一、函数
def 函数名(参数): ... 函数体 ... 返回值
函数的定义主要有如下要点：
- def：表示函数的关键字
- 函数名：函数的名称，日后根据函数名调用函数
- 函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
- 参数：为函数体提供数据
- 返回值：当函数执行完毕后，可以给调用者返回数据。
有参数实现
# def test(x):
# '''
# y=2*x+1
# :param x:整形数字
# :return: 返回计算结果
# '''
# y=2*x + 1
# return y
#
# a=test(3)
# print(a)
无参数实现
# def test():
# '''
# y=2*x+1
# :param x:整形数字
# :return: 返回计算结果
# '''
# x=3
# y=2*x + 1
# return y
#
# a=test()
# print(a)
函数的返回值
总结：
返回值数=0：返回None
返回值数=1：返回Object
返回值数>1：返回tuple
函数参数
# def test(x,y,z): #x=1,y=2,z=3
# print(x)
# print(y)
# print(z)
# 位置参数，必须一一对应，缺一不行，多一也不行
# test(1,2,3)
# 关键字参数，无须一一对应，缺一不行多一也不行
# test(y=1,x=3,z=2)
# 混合使用位置参数必须在关键字参数左边
# test(1,y=2,3) #报错
# test(1,3,y=2) #报错
# test(1,3,z=2)
# test(1,3,z=2,y=4) #报错，y 传入了多个值
默认参数：
# def handle(x,type='mysql'):
# print(x)
# print(type)
# handle('hello') #返回：hello mysql
# # handle('hello',type='sqlite') #返回：hello sqlite
# # handle('hello','sqlite')
动态参数：参数组：**字典 *列表
1）
# def test(x,*args):
# print(x)
# print(args)
# print(args[0][0])
# test(1)
# test(1,2,3,4,5,6)
# test(1,{'name':'alex'})
# test(1,['x','y','z']) #把列表当作一个整体传进去
# test(1,*['x','y','z']) #遍历列表
# test(1,*('x','y','z')) #遍历元祖
2）
# def test(x,**kwargs):
# print(x)
# print(kwargs)
# test(1,y=2,z=3)
# test(1,y=2,z=3,z=4) #会报错：一个参数不能传两个值，传值重复
3）
# def test(x,*args,**kwargs):
# print(x)
# print(args,args[-1])
# print(kwargs,kwargs.get('y'))
# # test(1,1,2,3,4,5,x=1,y=2,z=3) #报错
# # test(1,1,2,3,4,5,y=2,z=3)
# test(1,*[1,2,3],**{'y':1})
二、全局变量与局部变量
代码规范：全局变量变量名都大写，局部变量变量名都小写
全局变量顶头写
# 当全局变量与局部变量同名时：
# 在定义局部变量的子程序内，局部变量起作用;在其它地方全局变量起作用
name = 'lyj' def change_name(): print('我的名字',name) change_name()
返回：我的名字 lyj
name = 'lyj' def change_name(): name='甩了一比' print('我的名字',name) change_name() print(name)
返回：
我的名字 甩了一比
lyj
name = 'lyj' def change_name(): global name #引用全局变量，声明成全局变量了，其他函数的name也变成 甩了一比了
# global name ： global 用于将局部变量声明成全局变量
name = '甩了一比' print('我的名字', name) change_name() print(name)
返回：
我的名字 甩了一比
甩了一比
# 如果函数内部无 global 关键字，优先读取局部变量，只能读取全局变量，无法对全局变量重新赋值 name='adfga',
# 但是对于可变对象，可以对内部元素进行操作，name.append("afgadgs")
# 如果函数内部有 global 关键字，变量本质上就是全局的那个变量，可读取可赋值 name='adgc'
# 如果函数内部无 global 关键字,
# - 有声明局部变量
# name = ["Q","W"]
# def fuck():
# name = "R"
# print("fuck",name)
# fuck()
# - 无声明局部变量
# name = ["Q","W"]
# def fuck():
# name.append("T") #列表的方法都可以用
# print("fuck",name)
# fuck()
# 如果函数内部有 global 关键字,
# - 有声明局部变量
# name = ["Q","W"]
# def fuck():
# global name
# name = "R"
# print("fuck",name)
# fuck()
# 错误示例：
# name = ["Q","W"]
# def fuck():
# name = "R"
# global name #全局变量声明要往上提
# print("fuck",name)
# fuck()
# - 无声明局部变量
# name = ["Q","W"]
# def fuck():
# global name
# name = "Y"
# name.append("T") #列表的方法都可以用
# print("fuck",name)
# fuck()
关于 global 和 nonlocal 参考: https://www.cnblogs.com/z360519549/p/5172020.html
三、递归
#递归调用是函数嵌套调用的一种特殊形式，函数在调用时，直接或间接调用了自身，就是递归调用，在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。
递归的两个阶段：回溯，递推
回溯就是从外向里一层一层递归调用下去，
回溯阶段必须要有一个明确地结束条件，每进入下一次递归时，问题的规模都应该有所减少（否则，单纯地重复调用自身是毫无意义的）
递推就是从里向外一层一层结束递归
import time def calc(n): print(n) time.sleep(1) calc(n) calc(10)
递归例子：
import time person_list=['alex','wupeiqi','linhaifeng','zsc'] def ask_way(person_list): print('-'*60) if len(person_list) == 0: return '根本没人知道' person=person_list.pop(0) if person == 'linhaifeng': return '%s说:我知道,老男孩就在沙河汇德商厦,下地铁就是' %person print('hi 美男[%s],敢问路在何方' % person) print('%s回答道:我不知道,但念你慧眼识猪,你等着,我帮你问问%s...' % (person, person_list)) time.sleep(1) res=ask_way(person_list) print('%s问的结果是: %res' %(person,res)) return res res=ask_way(person_list) print(res)
返回结果：
D:Python35python3.exe D:/python_s3/day15/1.py ------------------------------------------------------------ hi 美男[alex],敢问路在何方 alex回答道:我不知道,但念你慧眼识猪,你等着,我帮你问问['wupeiqi', 'linhaifeng', 'zsc']... ------------------------------------------------------------ hi 美男[wupeiqi],敢问路在何方 wupeiqi回答道:我不知道,但念你慧眼识猪,你等着,我帮你问问['linhaifeng', 'zsc']... ------------------------------------------------------------ wupeiqi问的结果是: 'linhaifeng说:我知道,老男孩就在沙河汇德商厦,下地铁就是'es alex问的结果是: 'linhaifeng说:我知道,老男孩就在沙河汇德商厦,下地铁就是'es linhaifeng说:我知道,老男孩就在沙河汇德商厦,下地铁就是