标签：结果 用途 http ast 顺序 extra 错误 move 返回
为什么使用函数：减少重复代码、使程序变的可扩展使程序变得易维护
要调用一个函数，需要知道函数的名称和参数，比如求绝对值的函数abs，只有一个参数。可以直接从Python的官方网站查看文档：
http://docs.python.org/3/library/functions.html#abs
1 #定义一个函数 2 def func()： #使用def关键字定义函数 ，接函数名，括号内可以传递参数 3 print("hello world") #函数体 4 return #返回值：函数在执行过程中只要遇到return语句，就会停止执行并返回结果，如果未在函数中指定return,那这个函数的返回值为None 5 6 #调用函数 7 func()
函数可以返回多个值吗？答案是肯定的。
比如在游戏中经常需要从一个点移动到另一个点，给出坐标、位移和角度，就可以计算出新的新的坐标：
import math def move(x, y, step, angle=0): nx = x + step * math.cos(angle) ny = y - step * math.sin(angle) return nx, ny
定义函数的时候，我们把参数的名字和位置确定下来，函数的接口定义就完成了。对于函数的调用者来说，只需要知道如何传递正确的参数，以及函数将返回什么样的值就够了，函数内部的复杂逻辑被封装起来，调用者无需了解。
Python的函数定义非常简单，但灵活度却非常大。除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数，使得函数定义出来的接口，不但能处理复杂的参数，还可以简化调用者的代码。
1.形参与实参
形参变量：只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
1 def func(a,b): 2 res = a + b 3 print(res)
实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值
1 m = func(x,y)
2.默认参数
调用函数时，默认参数可有可无，非必须传递，其他可以赋值
用途：默认安装值，默认行为等
1 def func(a,b = 2): 2 res = a * b 3 print(res) 4 5 func(10) 6 #输出 20 7 func(10,5) 8 #输出 50
设置默认参数时，有几点要注意：
一是必选参数在前，默认参数在后，否则Python的解释器会报错（思考一下为什么默认参数不能放在必选参数前面）；
二是如何设置默认参数。
当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。
使用默认参数有什么好处？最大的好处是能降低调用函数的难度。
举个例子，我们写个一年级小学生注册的函数，可以把年龄和城市设为默认参数：
def enroll(name, gender, age=6, city=‘Beijing‘): print(‘name:‘, name) print(‘gender:‘, gender) print(‘age:‘, age) print(‘city:‘, city)
>>> enroll(‘Sarah‘, ‘F‘) name: Sarah gender: F age: 6 city: Beijing
3.关键字参数与位置参数
a.位置参数使用是一一对应的
b.正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可。关键字参数必须在位置参数之后
1 def func(a,b,c): 2 res = a * b *c 3 print(res) 4 5 func(a = 3,c= 5,b = 6) 6 #输出90
1 def func(a,b,c): 2 res = a * b *c 3 print(res) 4 5 func(3,c= 5,b = 6) 6 #输出90 7 8 func(c= 5,b = 6,3) #错误写法，报错 9 #SyntaxError: positional argument follows keyword argument
4.命名关键字参数与关键字参数
和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。
def(*args) 接收N个位置参数，转换为元组
1 def func(country,province,*args): 2 print(country,province,args) 3 4 func("China","Sichuan","Chengdu","JingJiang") 5 6 #输出： 7 >>>China Sichuan (‘Chengdu‘, ‘JingJiang‘)
如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：
def person(name, age, *args, city, job): print(name, age, args, city, job)
命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错：
>>> person(‘Jack‘, 24, ‘Beijing‘, ‘Engineer‘) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: person() takes 2 positional arguments but 4 were given
由于调用时缺少参数名city和job，Python解释器把这4个参数均视为位置参数，但person()函数仅接受2个位置参数。
命名关键字参数可以有缺省值，从而简化调用：
def person(name, age, *, city=‘Beijing‘, job): print(name, age, city, job)
由于命名关键字参数city具有默认值，调用时，可不传入city参数：
>>> person(‘Jack‘, 24, job=‘Engineer‘) Jack 24 Beijing Engineer
使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个*作为特殊分隔符。如果缺少*，Python解释器将无法识别位置参数和命名关键字参数：
def person(name, age, city, job): # 缺少 *，city和job被视为位置参数 pass
可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。请看示例：
def person(name, age, **kw): print(‘name:‘, name, ‘age:‘, age, ‘other:‘, kw)
关键字参数有什么用？它可以扩展函数的功能。比如，在person函数里，我们保证能接收到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。
和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去：
>>> extra = {‘city‘: ‘Beijing‘, ‘job‘: ‘Engineer‘}
>>> person(‘Jack‘, 24, **extra)
name: Jack age: 24 other: {‘city‘: ‘Beijing‘, ‘job‘: ‘Engineer‘}
*extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。
def（**kwargs） 把N个关键字参数转化为字典
1 def func(country,province,**kwargs): 2 print(country,province,kwargs) 3 4 func("China","Sichuan",city = "Chengdu", section = "JingJiang") 5 #输出 6 >>>China Sichuan {‘section‘: ‘JingJiang‘, ‘city‘: ‘Chengdu‘}
5.局部变量与全局变量
1 city = "Beijing" 2 3 def func(): 4 city = "Chengdu" 5 print(city) 6 7 func() 8 print(city) 9 #输出： 10 #Chengdu 11 #Beijing
可以使用 ：global 关键字再子程序内定义全局变量
1 city = "Beijing" 2 3 def func(): 4 global city 5 city = "Chengdu" 6 print(city) 7 8 func() 9 print(city) 10 #输出： 11 #Chengdu 12 #Chengdu
1.什么是递归函数：在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
举个例子，我们来计算阶乘n! = 1 x 2 x 3 x ... x n，用函数fact(n)表示，可以看出：
fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n
所以，fact(n)可以表示为n x fact(n-1)，只有n=1时需要特殊处理。
于是，fact(n)用递归的方式写出来就是：
def fact(n): if n==1: return 1 return n * fact(n - 1)
>>> fact(1) 1 >>> fact(5) 120 >>> fact(100) 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
2.递归函数的特性：
1)必须有一个明确的结束条件
2)每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3)递归效率不高，递归层次过多会导致栈溢出
1 def calc(n): 2 print(n) 3 if int(n/2) > 0: 4 return calc(int(n/2)) 5 print("===>",n) 6 calc(10) 7 #输出 8 #10 9 #5 10 #2 11 #1 12 #===> 1
递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。
使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。可以试试fact(1000)：
>>> fact(1000) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 4, in fact ... File "<stdin>", line 4, in fact RuntimeError: maximum recursion depth exceeded in comparison
解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。
尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。
上面的fact(n)函数由于return n * fact(n - 1)引入了乘法表达式，所以就不是尾递归了。要改成尾递归方式，需要多一点代码，主要是要把每一步的乘积传入到递归函数中：
def fact(n): return fact_iter(n, 1) def fact_iter(num, product): if num == 1: return product return fact_iter(num - 1, num * product)
可以看到，return fact_iter(num - 1, num * product)仅返回递归函数本身，num - 1和num * product在函数调用前就会被计算，不影响函数调用。
fact(5)对应的fact_iter(5, 1)的调用如下：
===> fact_iter(5, 1) ===> fact_iter(4, 5) ===> fact_iter(3, 20) ===> fact_iter(2, 60) ===> fact_iter(1, 120) ===> 120
尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出。
遗憾的是，大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出。
简单说，"函数式编程"是一种“编程范式”（programming paradigm），也就是如何编写程序的方法论。
主要思想是把运算过程尽量写成一系列嵌套的函数调用。
函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。
标签：结果 用途 http ast 顺序 extra 错误 move 返回
原文地址：https://www.cnblogs.com/dydxw/p/10577833.html
