百木园1.函数定义
函数就是将完成一件事情的步骤封装在一起并得到最终的结果；
函数名代表了这个函数要做的事情；
函数体是实现函数功能的流程；
添加一个函数也被叫做实现了一个方法或功能；
函数可以帮助我们重复使用一些操作步骤；
2.def
通过关键字def定义函数；
def name(args...):
print(\'\')
return 是将函数结果返回的关键字；
return只能在函数体中使用；
return支持返回所有python类型；
有返回值的函数可以直接赋值给一个变量；
def add(a, b):
c=a+b
return c # 出现retuen代表函数执行结束，后面有语句也不会执行了
def multiplication(a, b):
re = a * b
return re
print(\'test\')
result = multiplication(3, 4) # 函数返回值可以直接赋值给变量
print(result)
\'\'\'
12 return后的语句不会被执行
\'\'\'
def no_re():
print(\'无返回的函数\')
no_r = no_re()
print(no_r) # 函数无返回时，默认是None
\'\'\'
无返回的函数
None
\'\'\'
def test():
for i in range(4):
print(i)
if i == 2:
return i
t = test()
print(t)
\'\'\'
0
1
2
2
# return后循环结束，函数结束；只打印到2，且函数返回值2
\'\'\'
3.函数的参数
必传参数（位置参数），函数中定义的没有默认值的参数，在调用函数时若不传则会报错；
在定义函数时，参数后无等号和默认值；
且传参时，实际值的顺序与定义的参数顺序要一致；
def add(a, b)
默认参数，定义函数时，定义的参数有默认值，通过赋值语句给他一个值；
如果调用函数时，为默认参数传递了新值，函数会使用新传入的值；
def add(a, b=1)
def add(a, b, c=4):
return a+b+c
re = add(1, 2) # 使用c的默认值
print(re) # 7
re2 = add(1, 2, 5) # 使用c的新值
print(re2) # 8
# 注意，默认参数一定在位置参数之后，否则会报错
def add2(a, b=3, c):
return a+b+c
add2(1, 3, 2)
\'\'\'
File \"D:\\python_exercise\\test.py\", line 566
def add2(a, b=3, c):
^
SyntaxError: non-default argument follows default argument
\'\'\'不确定参数--可变参数，没有固定的参数名和数量（提前不知道要传的参数名和数量）；
def add(*args, **kwargs)
*args保存多余实参，保存为元组、**kwargs保存多余的带有变量名的实参，保存为字典；
def add(a, b, c=4, *args, **kwargs):
print(a)
print(b)
print(c)
print(args, type(args))
print(kwargs, type(kwargs))
add(1, 2, 3, 4, 5, d=3, e=4)
\'\'\'
1
2
3 # 3给了默认参数c，后面再有的剩余实际参数保存为元组了
(4, 5) <class \'tuple\'>
{\'d\': 3, \'e\': 4} <class \'dict\'>
# 后面就可以使用元组、字典的方法处理args和kwargs了
\'\'\'
def test(*args, **kwargs):
print(args)
print(kwargs)
test((2, 3), {\'name\': \'ll\', \'age\': 23})
\'\'\'
((2, 3), {\'name\': \'ll\', \'age\': 23})
{}
\'\'\'
# 可以发现*args是将多余实参都放到了元组中
# 如果就想对应传递元组和字典，可以在实参前加*和**
test(*(2, 3), **{\'name\': \'ll\', \'age\': 23})
\'\'\'
(2, 3)
{\'name\': \'ll\', \'age\': 23}
\'\'\'
def add3(a, b, c):
return a+b+c
tuple_test = (23, 45, 0)
re = add3(*tuple_test) # 此时也可以借助*tuple对实参进行解包
print(re) # 68参数的规则，
多参数一般添加顺序 ：def add(a, b=1, *args, **kwargs) 。
上面的例子可以看到python中函数参数没有定义类型，
其实在py3.7后可以为参数定义类型，但只是用于肉眼上的查看；
def person(name:str, age:int=33):
print(name, age)
def add(a: int, b: int, *args: int):
print(a, b, args)
add(1, 2, 4, \'rt\') # 1 2 (4, \'rt\')
# 虽然传递的参数不符合数据类型的要求，但可以正常执行，指定类型只是起提示功能且pycharm中也会有提示标注
4.全局变量和局部变量
python脚本最上层代码块的变量，就是全局变量；全局变量可以在函数中读取使用；
局部变量：只能在局部使用的变量，比如函数体内的变量只能在函数内使用；
name = \'ll\' # 定义一个全局变量
def test():
print(\'函数体内\'+name)
test() # 函数体内ll (函数体内可以直接使用全局变量)
def test2():
age = 13
print(age)
test2() # 13
print(age) # NameError: name \'age\' is not defined (局部变量只能在局部使用)
def test3():
name = \'tt\'
print(name)
test3() # tt
print(name) # ll (全局变量未被函数修改，函数只能使用全局变量，不能修改)可以使用global关键字，在函数内修改全局变量；（但在工作中不建议使用global对全局变量进行修改）
name = \'ll\' # 定义一个全局变量
def test():
global name
name = \'tt\'
test()
print(name) # tt当全局变量值是字典或列表时，函数内可以直接修改其值；
name_list = [\'ll\', \'tt\'] # 定义一个全局变量
def test():
name_list.append(\'rr\')
test()
print(name_list) # [\'ll\', \'tt\', \'rr\']
5.函数的递归
一个函数不停的将自己反复执行；
def test(a):
print(a)
return test(a) 通过返回值，直接执行函数自身，就可以达到递归的效果；
避免滥用递归，一定要设置满足后退出递归的条件，小心内存溢出；
能用递归解决的问题必须满足两个条件：
1.可以通过递归调用来缩小问题规模，且新问题与原问题有着相同的形式；
2.存在一种简单情形，使用该简单情形可退出递归；
count = 0
def test():
global count
count += 1
if count != 5:
print(\'继续执行函数\')
return test()
else:
print(\'执行结束\')
test()
\'\'\'
继续执行函数
继续执行函数
继续执行函数
继续执行函数
执行结束
\'\'\'两个经典的递归案例，阶乘和斐波那契数列；
\'\'\'
阶乘
n! = 1*2*3*...*n
f(n) = n * f(n-1)
且f(1)=1
\'\'\'
def test(n):
if n == 1:
return 1
return n * test(n-1)
re = test(6)
print(re) # 720
\'\'\'
斐波那契数列（黄金分割数列）
数列从0开始，数列前两项是0,1，第三项开始每一项是前两项的和
f(0) = 0
f(1) = 1
f(n) = f(n-1) + f(n-2)
\'\'\'
def fib(n):
if n == 0:
return 0
elif n == 1:
return 1
return fib(n-1) + fib(n-2)
# 求数列的第9项
re2 = fib(9)
print(re2) # 34
# 打印20项
for i in range(20):
if i == 19:
print(fib(i), end=\',\')
else:
print(fib(i), end=\',\')
# 0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181
6.匿名函数lambda
可以定义一个轻量化的函数，处理一些简单操作；
即用即删除，适合需要完成一项功能，但此功能只在此一处使用；
无参数lambda, f = lambda : value ; f()调用；lambda函数自带return关键字，此时返回值是value；
有参数lambda, f = lambda x,y: x*y ; f(3, 4)调用； 此时返回值是x*y的值12；
test = lambda: 34
print(test()) # 34
test2 = lambda x, y: x > y
re = test2(4, 6)
print(re) # False
test3 = lambda x, y=4: x + y
re = test3(4, 6)
print(re) # 10
# 此时可以再来看列表的sort(key)方法，key参数值就是函数、可以指定排序的参考值，此处就可以使用lambda函数的写法
name_list = [
{\'name\': \'ll\', \'age\': 34},
{\'name\': \'tt\', \'age\': 4},
{\'name\': \'rr\', \'age\': 24}
]
# 按照字典中age对应的值排序
name_list.sort(key=lambda x: x[\'age\'])
print(name_list) # [{\'name\': \'tt\', \'age\': 4}, {\'name\': \'rr\', \'age\': 24}, {\'name\': \'ll\', \'age\': 34}]
总结
来源：https://www.cnblogs.com/white-list/p/16841112.html
本站部分图文来源于网络，如有侵权请联系删除。