python基础语法菜鸟教程,python的语法

　　Python基本语法02:函数2.1函数定义2.1.1函数概述2.1.2函数定义2.1.3参数和自变量2.1.4函数返回值2.2函数分类2.2.1内置函数2.2.2用户定义函数2.3函数参数2.3.1参数类型类2.3.2位置参数2.3.3默认参数2.3.4变长参数2.3.5关键字参数2.3.6命名关键字参数2.3.7参数组合2.4函数

　　提高代码的重用率：在编程中，有些代码具有相同的功能和操作，但它们的数据是不同的。在这种情况下，你可以把这个函数写成一个函数模块，当你想使用这个函数的时候，你只需要调用这个函数模块。

　　提高代码的可维护性：使用函数后，代码可以重用。当需要检查或修改某个功能时，只需要检查或修改该功能对应的功能。函数的修改可以使调用该函数的所有模块同时生效，大大提高了代码的可维护性。

　　内置函数：内置函数也叫内置函数，即已经被系统定义好，可以被开发者直接调用的函数。为了让开发者对固有函数和自定义函数有一个直观的认识，这里举一个简单的例子。

　　调用系统内置函数pow():

　　Pow(2，4)自定义函数func():

　　定义函数(a，b):

　　返回a ** b

　　上面代码中的Func(2，4)，首先调用Python语言的内置函数pow()求幂；

　　然后定义一个函数func()，它的作用是输出A的b次方；最后调用自定义函数func()，输出相应的结果。可见Python语言中函数的定义和使用是非常方便的。

　　2.1.2函数的定义在Python中，函数通常由函数名、参数列表和一系列语句组成。函数定义的一般格式如下：

　　定义函数名(参数列表):

　　职能机构，例如：

　　def hello():

　　打印(“你好”)

　　打印(世界！)虽然上面例子中定义的hello()函数不包含任何参数，但是函数名后面的一对括号是不能省略的。在实际应用中，稍微复杂的函数通常包含一个或多个参数。

　　下面的代码定义了一个函数area()来计算矩形区域，并定义了一个函数welcome()来打印欢迎信息。

　　#函数area()计算矩形面积

　　定义区域(宽度、高度):

　　返回宽度*高度

　　#输出中英文信息的功能

　　定义欢迎(姓名):

　　打印(“欢迎”，姓名)

　　#调用欢迎函数

　　欢迎(张三)

　　#调用面积函数

　　w=4

　　h=9

　　上面代码中的Print (with=，w， height=，h， namea=，area (w，h))首先定义了两个函数area()和welcome()，其中area()提供了两个参数width(宽度)和height(高度)，welcome()然后分别调用area()和welcome()函数，在控制台中输出相应的结果。结果如下：

　　欢迎张三

　　With=4 height=9 area=36下面的代码定义了一个没有操作的空函数nop()。

　　def nop():

　　在Python代码中，pass语句通常可以用作占位符，表示不执行任何操作。比如在项目初期，如果还没搞清楚函数的具体实现，可以先放一个pass语句，让代码运行成功。项目框架搭建完成后，会进行相应的具体实施。

　　一般来说，在Python语言中用特定函数定义函数需要满足以下规则：

　　代码块以def关键字开头，后面是函数标识符的名称和参数列表；任何参数和传入的参数都必须用括号括起来；函数的第一行语句可以选择性地使用文档字符串(即函数描述)；函数内容以冒号开头，严格统一缩进；所有函数都有返回值，默认情况下不返回任何值。2.1.3形参和实参在编程语言中，函数用形参定义，用实参调用。

　　形参，全称为“形参”，不是实变量，也叫虚变量。参数是定义函数名和函数体时使用的参数，其目的是在调用函数时接收传入的参数。参数，全称为“实际参数”，是调用函数时传递给函数的参数。参数可以是常量、变量、表达式、函数等。无论实参是什么样的量，在进行函数调用时都必须有一定的值，这样这些值才能传递给形参。形式参数和实际参数的作用是数据传输。调用函数时，实参将被赋给形参。必须注意，实参的数量和类型要与形参一一对应，实参必须有确定的值。参数的范围通常被限制在函数体内部，而实际参数的范围取决于实际设置。

　　以计算面积的函数为例：

　　#函数area()计算矩形面积

　　定义区域(宽度、高度):

　　返回宽度*高度

　　#调用面积函数

　　w=4

　　h=9

　　Print (with=，w， height=，h， area=，area (w，h))在上面的代码中，函数area()定义处的宽度和高度是形参，函数外定义的变量w和h是实参。正如您所看到的，在参数w和h被传递到函数体之后，相应的值被分配给参数width和height。参数width和height的范围限于area()函数，而参数w和h的范围取决于外部调用的设置。

　　对于函数参数列表，默认情况下，函数调用的参数值与参数列表声明中定义的顺序一致。Python语言也允许函数调用中的参数顺序与声明中的不一致，即表示关键字的参数根据参数的指定来显示和赋值。

　　def func(x，y):

　　打印( x y=，x y)

　　打印( x*y=，x*y)

　　#等价于func(x=3，y=2)，也等价于func(3，2)

　　Func(y=2，x=3)在上面的代码中，Func()的形参在定义时的顺序是func(x，y)，而实际参数在调用时的顺序是func(y=1，x=2)。这是因为Python语言提供了关键字参数的机制，可以为开发者提供更大的灵活性。

　　2.1.4函数的返回值函数的返回值是函数执行后，系统根据函数的具体定义返回给外部调用方的值。在实际开发中，有时不仅要执行某个函数的功能，还要将该函数的执行结果作为其他函数或功能的计算单位。因此，函数的返回值非常有用。在Python中，当函数运行到return语句时，它被执行并返回结果。因此，复杂的逻辑可以通过函数内部的条件判断和循环设置来实现，并返回预期的结果。如果没有return语句，函数体中的所有语句执行后默认都不返回。#函数定义

　　def add(x，y):

　　打印( x y=，x y)

　　返回x y

　　#函数调用

　　结果=相加(y=1，x=2)

　　Print(result)以上代码中，定义的add()函数返回“x y”的运算结果。可以看到，调用这个函数后，这个函数的返回值被赋给变量result，最后输出变量result的值。

　　还应该注意，在Python中，函数也可以有多个返回值，比如：

　　#函数定义

　　def add(x，y):

　　打印( x y=，x y)

　　打印( x*y=，x*y)

　　返回x y，x * y

　　#函数调用

　　a，b=加法(y=1，x=2)

　　Print(a，b)在上面的代码中，定义的add()函数有连续的返回值，分别是“x y”和“x*y”。可以看到，调用这个函数后，这个函数的返回值分别赋给变量A和B，最后输出变量A和B的值。

　　注意：通信是

　　2.2函数的分类2.2.1内置函数Python语言中的内置函数称为内置函数。这些内置函数有效地封装了大多数常见的操作，可以直接调用，为开发提供了极大的便利。由于内置函数是Python语言中的内置函数，不需要导入任何函数库就可以直接调用。常用的内置函数如图所示。

　　在Python语言中，除了内置函数之外的其他类型的函数通常被称为第三方函数。

　　第三方函数一般是其他开发者或组织针对某些特定需求编写的，分享给大家的函数库。Python的强大功能源于其丰富的第三方函数库。无论是内置函数还是第三方函数，在Python语言中都可以非常方便地使用。要成功调用内置函数或第三方函数，首先需要知道的是函数的确切名称和参数列表信息。例如，绝对值的内置函数abs()有一个数值类型参数。下面的代码演示了内置函数abs()的调用过程和内置函数max()的调用。

　　abs(100)

　　abs(-10)

　　最大值(1，2)

　　Max(-2，0，4，1)从上面的代码可以看出，内置函数Max()可以同时返回多个值的最大值，而其他编程语言中的类似函数只能接收两个变量。Python语言内置函数的威力可见一斑。

　　Python语言中常用的内置函数还包括数据类型转换函数。下面的代码演示了常见类型转换函数的方法。

　　print(int(12 ):，int(12 ))

　　print(int(12.3):，int(12.3))

　　打印(浮点( 12.3 ):，浮点( 12.3 ))

　　print(str(1.23):，str(1.23))

　　print(str(10):，str(10))

　　print(bool(1):，bool(1))

　　打印( bool():，bool())输出结果：

　　int(12): 12

　　int(12.3): 12

　　浮动( 12.3): 12.3

　　str(1.23): 1.23

　　字符串(10): 10

　　布尔(1):真

　　Bool():False在上面的代码中，分别演示了内置函数int()、float()、str()和bool()的使用。其中，int()函数将传入参数转换为整数类型，float()函数将传入参数转换为浮点类型，str()函数将传入参数转换为字符串类型，bool()函数将传入参数转换为布尔类型。

　　在Python中，还可以给变量赋一个函数名，这相当于给函数一个“别名”，如下面的代码所示。

　　a=abs

　　Print(a(-1))这里注意，abs没有括号，所以加括号相当于调用一个函数。Python语言提供了很多内置函数。由于篇幅所限，这里不一一列举。内置函数功能强大。了解和掌握它们可以大大提高开发效率。

　　2.2.2自定义功能当内置功能不能满足要求时，开发者可以根据实际需要自定义功能。函数自定义后，开发者可以在其他代码中通过函数名调用。下面的代码演示了自定义函数printme()的定义和调用过程。

　　#自定义功能

　　定义打印时间(字符串):

　　功能：打印输入的字符串

　　打印(字符串)

　　#调用自定义函数

　　Printme(调用用户定义的函数！)

　　Printme(再次调用用户定义的函数！)输出结果：

　　调用自定义函数！

　　再次调用自定义函数！在上面的代码中，定义了一个函数printme()，并调用了两次来测试相应的函数。在实际开发中，涉及到大量的用户自定义函数。在自定义函数中，还可以调用内置函数或其他自定义函数。自定义函数和内置函数的定义方式是一样的，只是自定义函数是由开发人员定义的，而内置函数是由系统定义的。两者的叫法都一样。

　　在Python语言中，内置函数可以直接使用，第三方函数需要用import命令导入相应的库才能使用。对于自定义函数，它的定义和调用可以在同一个文件中，也可以在不同的文件中。

　　从测试导入你好

　　Hello()上面的代码演示了函数的定义和调用不在同一个文件中的情况。首先，定义hello()函数，并将其保存为test.py文件。然后用Python语言的导入指令“from test import hello”导入文件。可以调用hello()函数。导入时，应注意test是文件名，不包含。py扩展名。

　　2.3函数参数2.3.1参数类型函数参数分为可变类型和不可变类型，其调用结果不同。

　　(1)变量类型：类C引用传递，如列表、字典等。如果传递的参数是可变类型，函数内部传递参数的修改将影响外部变量。

　　(2)不可变类型：类C值传递，如整数、字符串、元组等。如果传递的参数是不可变类型的，那么在函数中修改传递的参数不会影响外部变量。

　　不可变类型参数的示例：

　　def change_int(a):

　　a=10

　　b=2

　　change_int(b)

　　Print(b) #结果为2在上面的例子中，有一个int类型的对象2，指向它的变量是B，当传递给change_int()函数时，变量B被value复制，A和B都指向同一个int对象。当a=10时，生成一个新的int value对象10，A指向它。

　　更详细的例子，打印出id为的变量的内存地址。可以看到函数内核之外的内存发生了变化，说明使用了不同的内存单元来存储不同的数据：

　　可变类型参数的示例：

　　def change_int(我的列表):

　　修改接收列表

　　我的列表追加([1，2，3])

　　Print(函数中的修改变量：，my_list)

　　我的列表=[10，20，30]

　　change_int(我的列表)

　　Print(函数外变量值：，my_list)调用函数时，如果传入的参数是变量类型，那么外部变量也会改变。在上面的例子中，传递到函数中的list对象和末尾添加了新内容的mylist对象使用相同的引用。

　　从下图的内存地址可以看出，变量的内存地址没有变化，表示使用的是同一个内存：

　　定义函数时，开发者确定参数的名称和位置，函数的接口定义就完成了。Python的函数定义非常简单，但是灵活性非常大。函数定义可能包含多个形参，因此函数调用也可能包含多个实参。有许多方法可以让函数传递参数。您可以使用位置参数，它要求传递参数和定义参数的顺序相同。您也可以使用关键字参数，每个参数都由一个变量名和值组成。2 . 3 . 2 Python语言在调用带有位置参数的函数时，必须将函数调用中的每个实参与函数对应的形参相关联。最简单的关联方式是基于论元的顺序，这叫做位置论元。下面的代码显示了学生信息的功能，它输出学生的姓名和年龄。

　　def describe_student(人名，学生年龄):

　　功能功能：显示学生信息

　　打印(“我的名字是”，人名)

　　打印(人名是学生年龄岁)

　　Describe_student(Jack ， 24 )输出：

　　我的名字是杰克

　　Jackis24yearold上述函数describe_student()的定义表明它需要两个参数：姓名和年龄。调用describe_student()函数时，需要依次提供姓名和年龄参数。调用该函数时，参数“Jack”存储在参数person_name中，而参数“24”存储在参数student_age中。

　　定义函数后，开发人员可以根据需要多次调用该函数。如果需要描述另一个学生，只需再次调用describe_student()即可，如下面的代码所示。

　　def describe_student(人名，学生年龄):

　　功能功能：显示学生的信息

　　打印(“我的名字是”，人名)

　　打印(人名是学生年龄岁)

　　describe_student(Jack ， 24 )

　　Describe_student(Bob ， 17 )结果：

　　我的名字是杰克

　　杰克24岁

　　我的名字是鲍勃

　　bobis 17岁调用函数是一种高效的开发方法。比如上面的例子，开发者只需要编写一次函数中描述学生的代码，以后需要描述新生的时候就可以调用这个函数并为其提供新生信息。即使描述了全校的学生，也只用一行调用函数的代码就可以实现所需的功能。

　　在函数中，可以根据需要使用任意数量的位置参数。Python会按顺序将函数调用中的实参与函数定义中相应的参数关联起来。但是，需要注意的是，在使用位置参数调用函数时，如果参数的顺序不正确，结果可能是意外的，如下面的代码所示。

　　def describe_student(人名，学生年龄):

　　功能功能：显示学生的信息

　　打印(“我的名字是”，人名)

　　打印(人名是学生年龄岁)

　　Describe_student(18 ， Jack )结果：

　　我的名字是18

　　18isJackyears在上面的函数调用中，开发者首先指定了姓名，然后指定了学生的年龄。因为参数“18”排在前面，所以该值将存储在形参person_name中；类似地，“jack”将存储在形参student_age中。在实际开发中，如果执行结果与预期不一致，请检查函数调用中实参的顺序是否与函数定义中形参的顺序一致。

　　2.3.3缺省参数在编写函数时，可以为每个参数指定一个缺省值。调用函数时，如果给参数提供了实参，Python语言会使用指定的实参值；否则，将使用参数的默认值。在为形参指定默认值后，可以在函数调用中省略相应的实参。使用默认值可以简化函数调用，并清楚地表明函数的典型用法。如果您按如下方式调用describe_student()函数，将会得到一个错误。

　　def describe_student(人名，学生年龄):

　　功能功能：显示学生的信息

　　打印(“我的名字是”，人名)

　　打印(人名是学生年龄岁)

　　Describe_student(Jack )提示一条错误消息：

　　回溯(最近一次呼叫):

　　模块中文件“D:/python_demo/demo_2.py”的第88行

　　描述_学生(杰克)

　　type:describe_student()missing 1必需的位置参数： student_age 在上面的代码中，错误信息非常明确，就是在调用函数describe _ student()时缺少了一个位置参数student _ age。这时，默认参数就派上用场了。

　　如果大部分学生都是18岁，开发人员可以将第二个参数student_age的默认值设置为18，这样当开发人员调用describe_student(Jack)时，就相当于调用describe_student(Jack，18)，如下面的代码所示。

　　def describe _ student(person _ name，student_age=18 ):

　　功能功能：显示学生信息

　　打印(“我的名字是”，人名)

　　打印(人名是学生年龄岁)

　　描述_学生(杰克)

　　Describe_student(Jack ， 18 )结果：

　　我的名字是杰克

　　杰克18岁

　　我的名字是杰克

　　jackis 18岁对于未满18岁的学生，必须明确引入student_age，如describe _ student (Herbie ，19)。从上面的例子可以看出，默认参数可以简化函数的调用。

　　注意，在设置默认参数时，必需的参数排在最前面，默认的参数排在最后，否则Python解释器会报告错误。使用默认参数最大的好处是可以降低调用函数的难度。要写一个学生注册函数，需要传入两个参数，姓名和性别。

　　定义注册(姓名，性别):

　　注册学生信息

　　打印(姓名：，姓名)

　　打印(性别：，性别)

　　姓名：杰克

　　性别：Fdef注册(姓名，性别，年龄=18 ，城市=北京):

　　注册学生信息

　　打印(姓名：，姓名)

　　打印(性别：，性别)

　　打印(“年龄：”，年龄)

　　打印(“城市：”，城市)

　　打印(- * 70)

　　姓名：莎拉

　　性别：女

　　年龄：18岁

　　城市：北京

　　姓名：莎拉

　　性别：男

　　年龄：17岁

　　城市默认参数：北京降低了函数调用的难度，一旦需要更复杂的调用，可以通过更多的参数来实现。无论是简单调用还是复杂调用，只需要定义一个函数；当有多个默认参数时，可以在调用时按顺序提供默认参数。

　　默认参数非常有用，但是在使用它的时候要记住。默认参数必须指向不可变的对象，否则会发生错误，如下面的代码所示。

　　def test_add(a=[]):

　　a.append(“结束”)

　　返回a

　　print(test_add([1，2，3])

　　print(test_add([a ， b ， c]))

　　print(test_add())

　　打印(test_add())结果：

　　[1，2，3，结束]

　　[a ， b ， c ， END]

　　[结束]

　　[END ， END]

　　[END ， END ， END]从上面的代码中可以看出，默认的参数是一个空的list []，但是函数test_add()好像每次都是在添加最后一个 END 之后才“记住”这个列表。这是因为在Python中，定义函数时，会计算默认参数h的值，即[]。因为默认参数h也是一个变量，所以它指向对象[]。每次调用这个函数时，如果h的内容发生变化，那么下次调用时默认参数的内容也会发生变化，函数定义时不再是[]。

　　开发人员还可以使用不可变对象None来解决错误问题，如下面的代码所示。

　　def test _ add(H=无):

　　如果H不存在：

　　H=[]

　　H.append(“结束”)

　　返回H

　　print(test_add())

　　打印(test_add())结果：

　　[结束]

　　[END]一旦创建了str、None等类似的不可变对象，其内部数据就无法修改，从而减少了修改数据带来的错误。

　　另外，因为对象是不变的，多线程环境下同时读取对象不需要加锁，同时读取是没有问题的。开发人员写程序的时候，如果能设计出不可变的对象，尽量设计成不可变的。

　　2.3.4变长参数在Python语言中，函数也可以定义变长参数，也叫可变参数。给定一组数A，B，C …，请计算A B C …要定义该函数，必须确定输入参数。开发人员可以将A、B、C …作为列表或元组传入。

　　定义计算(数字):

　　总和=0

　　对于数字中的n:

　　总和=总和

　　返回总和

　　Print(calc([1，2，3])#结果是6

　　Print(calc([1，2，3，4])#结果是10。对于上面定义的sum函数，调用时需要组装一个列表或者元组；第一；在Python语言中，可以在函数参数前加“*”，将其定义为不定参数；可以看出，变长参数的使用使得calc()函数的定义和调用变得简洁。例子如下：

　　定义计算(*数字):

　　总和=0

　　对于数字中的n:

　　总和=总和

　　返回总和

　　打印(calc(1，2，3，4))

　　打印(calc())

　　数字=[1，2，3]

　　打印(计算(*数字))结果：

　　62.3.5关键字参数关键字实参是传递参数时使用“名称-值”对的方式，名称和值在实参中是关联的。

　　关键字实参使得开发者无需考虑函数调用中实参的顺序，明确指出函数调用中每个值的用途。

　　关键字具有扩展功能的作用。

　　2.3.6命名关键字参数如果要限制关键字参数的名称，可以使用命名关键字参数。与关键字参数**kw不同的是，如果没有变量参数，则命名的关键字参数必须用“”标记，作为特殊分隔符。如果缺少" "，Python语言解释器将无法识别位置参数和命名关键字参数。例如，如果只接收年龄和城市作为关键参数，它可以采用以下形式。

　　定义注册(姓名，性别，*，年龄，城市):

　　打印(姓名、性别、年龄、城市)

　　Enroll (jack ， m ，年龄= 18 ，城市=北京)输出：

　　Jack M 18 Beijingdef enroll(姓名，性别，*年级，年龄，城市):

　　打印(姓名、性别、年龄、城市)

　　结果注册(杰克， M ， 18 ，北京)报告了一个错误：

　　回溯(最近一次呼叫):

　　模块中第119行的文件“D:/python _ spider/python _ demo/demo _ 2 . py”

　　TypeError: enroll()缺少两个必需的仅关键字参数：“age”和“city”def enroll(name，gender，*，age=“18”，city):

　　打印(姓名、性别、年龄、城市)

　　Enroll (Jack ， M ，city= Beijing) #结果是：Jack M 18北京注：

　　*表示可变长度参数。

　　* *表示不确定长度的关键字参数。

　　2.3.7参数组合用Python语言定义函数，开发者可以组合使用这些参数(必选参数、默认参数、变量参数、关键字参数和命名关键字参数)。请注意，参数定义是有序的。定义的顺序必须是：必选参数、默认参数、变量参数、命名关键字参数、关键字参数。例如，如果您想要定义一个包含上述几个参数的函数，如下面的代码所示。

　　def func(a，b，c=0，*args，**kw):

　　打印( a=，a， b=，b， c=，c， args=，args， kw=，kw)

　　print(func(1，2))

　　#输出结果：a=1 b=2 c=0 args=() kw={}

　　print(func(1，2，c=3))

　　#输出结果：a=1 b=2 c=3 args=() kw={}

　　print(func(1，2，3， a ， b ))

　　#输出结果：a=1 b=2 c=3 args=(a ， b) kw={}

　　print(func(1，2，3， a ， b ，x=4))

　　#输出结果：a=1b=2c=3args=(a ， b) kw={x: 4}

　　args=(1，2，3，4)

　　kw={x: 5}

　　print(func(*args，**kw))

　　#输出结果：A=1b=2c=3args=(4，)KW={x: 5} 2.4函数式编程是一种编程范式，是对数学的一种抽象。它将计算描述为表达式求值。函数式编程中的“函数”不是指计算机中的函数，而是数学中的函数，即自变量的映射。函数编程的一个特点是允许函数本身作为参数传入另一个函数，也允许返回一个函数。Python语言为函数式编程提供了部分支持。因为允许变量，所以Python不是纯粹的函数式编程语言。2.4.1接受函数作为参数或返回函数作为结果的高阶函数称为高阶函数。例如，要根据单词的长度对单词进行排序，只需将len函数传递给key参数。

　　水果=[草莓，无花果，苹果，樱桃，覆盆子，香蕉]

　　打印(已排序(水果，key=len))

　　#输出结果如下：

　　# [无花果，苹果，樱桃，香蕉，覆盆子，草莓]水果=[草莓，无花果，苹果，樱桃，覆盆子，香蕉]

　　定义反转(单词):

　　返回单词[:-1]

　　Print(reverse(testing)) #结果是：gnitset

　　打印(已分类(水果，关键字=反转))

　　#输出结果如下：

　　# [香蕉，苹果，无花果，覆盆子，草莓，浆果]注意，上面例子中列表中的单词没有变化，开发人员只是用反拼作为排序条件，所以各种浆果都列在一起。在函数式编程范例中，最著名的高阶函数是map、filter、reduce和apply。其中，apply函数在Python2.3中被标记为过时，在Python3中已被移除。

　　2.4.2匿名函数称为匿名函数，即不再以def语句的标准形式定义的函数。Python经常使用lambda创建匿名函数。Lambda只是一个表达式，它的函数体比def定义的要简单。lambda函数的语法如下。

　　[arg 1[，arg2]，argn]]:表达式示例：

　　sum=lambda arg1，arg2: arg1 arg2

　　Print(sum(1，2)) #结果为：3在上面的代码中，第一行定义了一个lambda函数，执行两个数的求和运算，并将lambda函数命名为sum。会议代码通过sum()函数实现调用lambda函数的功能。

　　转载请联系作者取得转载授权，否则将追究法律责任。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

相关文章阅读