Python学习—05函数

Python函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。我们已经知道Python提供了许多内建函数，比如print()。但我们也可以自己创建函数，这被叫做用户自定义函数。

定义一个函数

我们可以定义一个由自己想要功能的函数，以下是简单的规则：

  • 函数代码块以def关键词开头，后接函数标识符名称和圆括号()。
  • 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
  • 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
  • 函数内容以冒号起始，并且缩进。
  • Return[expression]结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

语法

  1. def functionname( parameters ):
  2.    "函数_文档字符串"
  3.    function_suite
  4.    return [expression]

默认情况下，参数值和参数名称是按函数声明中定义的的顺序匹配起来的。

实例

以下为一个简单的Python函数，它将一个字符串作为传入参数，再打印到标准显示设备上。

  1. def printme( str ):
  2.    "打印传入的字符串到标准显示设备上"
  3.    print str
  4.    return

函数调用

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。

Python里不用像C语言里需要先申明函数再使用。

如下实例调用了printme()函数：

  1. #!/usr/bin/python
  2. # -*- coding: UTF-8 -*-
  4. # 定义函数
  5. def printme( str ):
  6.    "打印任何传入的字符串"
  7.    print(str);
  8.    return;
  10. # 调用函数
  11. printme("我要调用用户自定义函数!");
  12. printme("再次调用同一函数");

以上实例输出结果：

  1. 我要调用用户自定义函数!
  2. 再次调用同一函数

参数

以下是调用函数时可使用的正式参数类型：

  • 必选参数：fun(name, age)
  • 默认参数：fun(name='yjc', age=18)
  • 可变参数：fun(*args)
  • 关键字参数：fun(name, age, **kw)
  • 命名关键字参数：fun(name, age, *, city)

必选参数

必选参数也称位置参数。必选参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用printme()函数，你必须传入一个参数，不然会出现语法错误：

  1. #!/usr/bin/python
  2. # -*- coding: UTF-8 -*-
  4. #可写函数说明
  5. def printme( str ):
  6.    "打印任何传入的字符串"
  7.    print(str);
  8.    return;
  10. #调用printme函数
  11. printme();

以上实例输出结果：

  1. Traceback (most recent call last):
  2.   File "test.py", line 11, in <module>
  3.     printme();
  4. TypeError: printme() takes exactly 1 argument (0 given)

默认参数

调用函数时，默认参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：

  1. #!/usr/bin/python
  2. # -*- coding: UTF-8 -*-
  4. def printinfo( name, age = 35 ):
  5.     "打印任何传入的字符串"
  6.     print ("Name: ", name);
  7.     print ("Age ", age);
  8.     return;
  10. # 调用printinfo函数
  11. printinfo( "miki" )
  12. printinfo( "miki", 50)
  14. # 当不按顺序提供部分默认参数时，需要把参数名写上:
  15. printinfo( name="miki", age=50 )

以上实例输出结果：

  1. Name:  miki
  2. Age  35
  3. Name:  miki
  4. Age  50
  5. Name:  miki
  6. Age  50

可变参数

在Python函数中，还可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。基本语法如下：

  1. def functionname(*var_args_tuple ):
  2.    "函数_文档字符串"
  3.    function_suite
  4.    return [expression]

加了星号（*）的变量名会存放所有未命名的变量参数。如下实例：

  1. #!/usr/bin/python
  2. # -*- coding: UTF-8 -*-
  4. def calc(*numbers):
  5.     sum = 0
  6.     for n in numbers:
  7.         sum = sum + n * n
  8.     return sum

在函数内部，参数numbers接收到的是一个tuple。调用该函数时，可以传入任意个参数，包括0个参数：

  1. >>> calc(1, 2)
  2. 5
  3. >>> calc()
  4. 0

如果已经有一个list或者tuple，要调用一个可变参数怎么办？Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去：

  1. >>> nums = [1, 2, 3]
  2. >>> calc(*nums)
  3. 14

*nums表示把nums这个list的所有元素作为可变参数传进去。

关键字参数

关键字参数允许我们在传入必选参数外，还可以接受关键字参数kw：

  1. def person(name, age, **kw):
  2.     print('name:', name, 'age:', age, 'other:', kw)

这里name, age是必须的，kw可选，意味着第三个参数开始我们可以传入任意个数的关键字参数：

  1. >>> person('Bob', 35, city='Beijing')
  2. name: Bob age: 35 other: {'city': 'Beijing'}
  4. >>> person('Adam', 45, gender='M', job='Engineer')
  5. name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

这个例子里，关键字参数让我们保证能接收到name和age这两个参数，但是，如果提供更多的参数，我们也能收到。

实际上，关键字参数kw是个dict，如果我们已经准备好了dict，只需要在前面加**就可以转换为参数传入：

  1. param = {'gender': 'M', 'job': 'Engineer'}
  2. >>> person('Adam', 45, **param)
  3. name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

注关键字参数kw获得的dict是param的一份拷贝，对kw的改动不会影响到函数外的param。

命名关键字参数

如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：

  1. def person(name, age, *, city, job):
  2.     print(name, age, city, job)
  4. # 调用：
  5. person('yjc', 22, city='Beijing', job='IT')

输出：

  1. yjc 22 Beijing IT

和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错。如果调用时缺少参数名city和job，Python解释器把这4个参数均视为位置参数，但person()函数仅接受2个位置参数。

如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：

  1. def person(name, age, *args, city, job):
  2.     print(name, age, args, city, job)

命名关键字参数可以有缺省值，从而简化调用：

  1. def person(name, age, *, city='Beijing', job):
  2.     print(name, age, city, job)

由于命名关键字参数city具有默认值，调用时，可不传入city参数。

返回多个值

Python里函数可以返回多个值：

  1. def updPoint(x, y):
  2.     x+=5
  3.     y+=10
  4.     return x,y
  6. x,y = updPoint(1,2)
  7. print(x,y)

输出：

  1. 6 12

但其实这只是一种假象，Python函数返回的仍然是单一值：

  1. r = updPoint(1,2)
  2. print(r)

输出：

  1. (6, 12)

返回值是一个tuple！但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。

匿名函数

python 使用 lambda 来创建匿名函数。

lambda只是一个表达式，函数体比def简单很多。

lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

lambda函数拥有自己的名字空间，且不能访问自有参数列表之外或全局名字空间里的参数。

虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法
lambda函数的语法只包含一个语句，如下：

  1. lambda [arg1 [,arg2,.....argn]]:expression

如下实例：

  1. #!/usr/bin/python
  2. # -*- coding: UTF-8 -*-
  4. # 可写函数说明
  5. sum = lambda arg1, arg2: arg1 + arg2;
  7. # 调用sum函数
  8. print "相加后的值为 : ", sum( 10, 20 )
  9. print "相加后的值为 : ", sum( 20, 20 )

以上实例输出结果：

  1. 相加后的值为 :  30
  2. 相加后的值为 :  40

return语句

return语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，下例便告诉你怎么做：

  1. #!/usr/bin/python
  2. # -*- coding: UTF-8 -*-
  4. # 可写函数说明
  5. def sum( arg1, arg2 ):
  6.    # 返回2个参数的和."
  7.    total = arg1 + arg2
  8.    print("函数内 : ", total)
  9.    return total;
  11. # 调用sum函数
  12. total = sum( 10, 20 );
  13. print("函数外 : ", total )
  14. 以上实例输出结果：
  15. 函数内 :  30
  16. 函数外 :  30

变量作用域

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：

  • 全局变量
  • 局部变量

变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内（包括函数里面）访问。如下实例：

  1. #!/usr/bin/python
  2. # -*- coding: UTF-8 -*-
  4. total = 0; # 这是一个全局变量
  5. # 可写函数说明
  6. def sum( arg1, arg2 ):
  7.    #返回2个参数的和."
  8.    total = arg1 + arg2; # total在这里是局部变量.
  9.    print "函数内是局部变量 : ", total
  10.    return total;
  12. #调用sum函数
  13. sum( 10, 20 );
  14. print "函数外是全局变量 : ", total

以上实例输出结果：

  1. 函数内是局部变量 :  30
  2. 函数外是全局变量 :  0

但是如果在函数中定义的局部变量如果和全局变量同名，则它会隐藏该全局变量。例如：

  1. #!/usr/bin/python
  2. a = 10;
  4. def test():
  5.     print(a);
  6.     #a = 11;
  8. test();

输出：10
如果把上面代码的注释去掉，运行会报错：UnboundLocalError: local variable ‘a’ referenced before assignment。这点非常值得注意。

如果要给全局变量在一个函数里赋值，必须使用global语句。
global VarName表达式会告诉Python， VarName是一个全局变量，这样Python就不会在局部命名空间里寻找这个变量了。
例如，我们在全局命名空间里定义一个变量money。我们再在函数内给变量money赋值，然后Python会假定money是一个局部变量。然而，我们并没有在访问前声明一个局部变量money，结果就是会出现一个UnboundLocalError的错误。取消global语句的注释就能解决这个问题。

  1. #!/usr/bin/python
  2. # -*- coding: UTF-8 -*-
  4. Money = 2000
  5. def AddMoney():
  6.    # 想改正代码就取消以下注释:
  7.    # global Money
  8.    Money = Money + 1
  10. print Money
  11. AddMoney()
  12. print Money

在这里我对比c、php、js进行说明：

  • php里函数外定义的变量在函数内部是不可见的。如果想使用或者修改函数外的变量，需要函数内使用global语句。
  • pyhon里函数外定义的变量在函数内部是可见的，但是不能修改。且函数里存在和函数外变量同名，函数外变量不可用。如果想修改函数外的变量，需要函数内使用global语句。
  • c语言里函数外定义的变量在函数内部是可见可修改的。但函数内部定义的变量(含同名)作用域是局部的。
  • js语言里函数外定义的变量在函数内部是可见可修改的。但函数内部定义的变量(含同名)作用域是局部的。另外js变量在函数内部还有变量提升的特性。

按值传递参数和按引用传递参数

和其他语言不一样，传递参数的时候，python不允许程序员选择采用传值还是传引用。

Python参数传递采用的肯定是“传对象引用”的方式。实际上，这种方式相当于传值和传引用的一种综合。

如果函数收到的是一个可变对象（比如字典或者列表）的引用，就能修改对象的原始值——相当于通过“传引用”来传递对象。如果函数收到的是一个不可变对象（比如数字、字符或者元组）的引用，就不能直接修改原始对象——相当于通过“传值’来传递对象。

例如：

  1. #!/usr/bin/python
  2. # -*- coding: UTF-8 -*-
  4. # 可写函数说明
  5. def changeme( mylist ):
  6.    "修改传入的列表"
  7.    mylist.append([1,2,3,4]);
  8.    print("函数内取值: ", mylist)
  9.    return
  11. # 调用changeme函数
  12. mylist = [10,20,30];
  13. changeme( mylist );
  14. print("函数外取值: ", mylist)
  16. # 不可变对象
  17. def changeFixed(age):
  18.     age += 5
  19.     print(age)
  20. age = 10;
  21. changeFixed(age);
  22. print(age)

输出结果如下：

  1. 函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
  2. 函数外取值:  [10, 20, 30, [1, 2, 3, 4]]
  4. 15
  5. 10

有时候，我们并不想函数修改了原列表，有没有办法呢？有的。既然列表互相赋值是地址引用，引入新的变量名也是不行的，那么，可以复制一个列表出来，这样内存里用的就不是同一个地址，也就不会改变原数组了：

  1. def changeme( mylist ):
  2.    "修改传入的列表"
  3.    mylist.append([1,2,3,4]);
  4.    print("函数内取值: ", mylist)
  5.    return
  7. # 调用changeme函数
  8. mylist = [10,20,30];
  9. # tmp = mylist; # 这样还是引用同一地址，达不到不修改原列表目的
  10. tmp = mylist[:] # 将原列表复制一份，地址将不再是相同的
  11. changeme( tmp );
  12. print("函数外取值: ", mylist)

输出：

  1. 函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
  2. 函数外取值:  [10, 20, 30]

这里使用了切片相关知识，后续会详细讲解。

空函数

如果想定义一个什么事也不做的空函数，可以用pass语句：

  1. def nop():
  2.     pass

常用系统函数

参考：
1、Python 函数
http://www.runoob.com/python/python-functions.html
2、函数的参数
http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431752945034eb82ac80a3e64b9bb4929b16eeed1eb9000

作者： 飞鸿影
版权：本作品采用「署名-非商业性使用-相同方式共享 4.0 国际」许可协议进行许可。
出处：https://www.cnblogs.com/52fhy/p/6254553.html