一、函数是什么
定义：函数是指一组语句的集合通过一个名字（函数名）封装起来，想要执行这个函数，只需要调用函数名即可。
C中的函数叫function，java中的函数叫method，python中的函数用def做关键字。
二、使用函数的好处
1.提高代码的复用性
2.让代码更简洁、简化代码
3.代码可扩展
三、python中函数的定义
定义函数使用def关键字，后面是函数名，函数名不能重复
def sayHello(): #定义函数，函数名
print(‘hello‘) #函数体
#函数不调用是不会被执行的
sayHello() #调用函数
四、函数的参数
1、形参与实参
函数在调用的时候，可以传入参数，有形参和实参。形参就是函数接收的参数，而实参就是你实际传入的参数
形参：
只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。
实参：
可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。函数调用结束返回主调用函数后则不能再使用该形参变量。
def calc(a,b): #形参：形式参数
print(‘%s * %s = %s‘%(a,b,a*b))
calc(7,8) #实参：实际参数
2、函数的四种形参
(1) 位置参数
按照参数的位置来传参，calc这个函数中，a和b就是位置参数，是必传的，没有会报错
def calc(a,b): #位置参数，必填，不填会报错missing 2 required positional arguments
print(‘%s * %s = %s‘%(a,b,a*b))
calc(7,8)
有几个位置参数在调用的时候就要传几个，否则会报错，如果有多个位置参数的话，记不住哪个位置传哪个了，可以使用位置参数的名字来指定调用
def size(ength,width,height):
print(‘Size is %s‘%(ength * width * height))
size(height=7,ength=8,width=10)#关键字传参,参数过多可以使用未知参数的名字来指定调用
def op_mysql(host,port,username,passwd,charset,sql):
print(‘连接数据库‘)
#一一对应传参
op_mysql(‘192.168.1.1‘,3306,‘Amy‘,‘sfsd‘,‘utf-8‘,‘select * from user‘)
#不按顺序传参（关键字传参）
op_mysql(sql = ‘select * from user‘,
host = ‘192.168.1.1‘,
username = ‘Amy‘,
passwd = ‘sfsd‘,
charset = ‘utf-8‘,
port = ‘3306‘
)
#也可以将两种传参相结合
op_mysql(‘192.168.1.1‘,3306,
sql = ‘select * from user‘,
username = ‘Amy‘,
passwd = ‘sfsd‘,
charset = ‘utf-8‘,
)
(2) 默认参数
在定义形参的时候，给函数默认赋一个值，比如说数据库的端口这样的，默认给它一个值，这样就算你在调用的时候没传入这个参数，它也是有值的。
默认参数不是必填的，如果给默认参数传值，它就会使用你传入的值。如果使用默认值参数的话，必须放在位置参数后面定义。
def op_file(file_name,content=None): #content:默认值参数,它是非必填的
f = open(file_name, ‘a+‘, encoding=‘utf-8‘)
f.seek(0)
if content: #不为空代表写文件
f.write(content)
f.flush()
else: #为空代表读文件
all_user = f.read() #all_users是局部变量
return all_user #调用完函数之后，返回什么结果
f.close()
print(op_file(‘username‘))
(3) 非固定参数
位置参数和默认参数的参数个数都是固定的，如果一个函数参数是不固定的，以后也不知道会扩展成什么样，那么再用固定函数，后面程序就不好扩展了。这时候需要非固定参数。非固定参数有两种，可变参数和关键字参数。
(i) 可变参数
可变参数用*来接收，后面想传多少个参数就传多少个，如果位置参数、默认值参数、可变参数一起使用的的话，可变参数必须在位置参数和默认值参数后面。
a、非必填参数
b、它没有限制参数个数
b、它把传回来的参数放在元组里
def syz(name,*args): #参数组
# 位置参数、默认值参数、可变参数，可变参数会把后面多传的参数都放到args这个元组中
# args名字是随便写的，不过一般我们都写args
print(name,args)
syz(‘双鱼座‘) #双鱼座 (),非必填
syz(‘双鱼座‘,‘111‘) #双鱼座 (‘111‘,)
syz(‘asd‘,‘sdf‘,23224) #asd (‘sdf‘, 23224),没有限制参数个数
(ii) 关键字参数
关键字参数用**来接收，后面的参数也是不固定的，位置参数、默认值参数、可变参数，关键字参数一起使用的话，关键字参数必须在最后面。
a、非必填参数
b、它没有限制参数个数
c、它把传回来的参数放在字典里
d、使用关键字参数的话，调用的时候必须使用关键字传参
def syz(name,**kwargs): #关键字参数,必须有k-v，两个参数
# 位置参数、关键字参数，调用的时候会把传入的关键字参数放到kwargs这个字典中
print(name,kwargs)
syz(‘双鱼座‘) #非必填,双鱼座 {}
syz(‘双鱼座‘,‘111‘) #报错，必须有k-v，两个参数
syz(‘双鱼座‘,room = ‘111‘) #双鱼座 {‘room‘: ‘111‘}
syz(‘双鱼座‘,room = ‘111‘,addr = ‘北京‘) #没有限制参数个数,双鱼座 {‘addr‘: ‘北京‘, ‘room‘: ‘111‘}
五、函数的返回值
每个函数都有返回值，如果没有在函数里指定返回值，则默认返回None，函数可以有多个返回值，如果有多个返回值，会把返回值放到一个元组中，返回的是一个元组。
def calc(x,y):
res = x * y
return x,y,res
print(calc(2,3)) #多个返回值的函数，返回一个元组(2, 3, 6)
返回值作用：
1、把函数处理的结果返回回来，供后面的程序用。
2、结束函数，函数里面遇到return，函数会立即结束
def r():
for i in range(5):
if i == 3:
print(i)
return #只写一个return的话，就返回None
r() #3,遇到return函数立即结束
res = r()
print(res) #默认返回None
import string
def check(pwd):
if len(pwd) >5 and len(pwd) <12: #长度6-11
if set(pwd) & set(string.ascii_letters) and set(pwd) & set(string.digits):#必须包含字符和数字
print(‘密码合法‘)
else:
print(‘密码不合法‘)
else:
print(‘密码不合法‘)
res = check(‘ad1234‘) #调用函数，并把函数返回值赋给res
# 函数里面如果没有return的话，默认返回none，return不是必须写的
print(res)
六、局部变量和全局变量
常量：
一个不变的值，通常用大写字母定义
PORT = 3306 #常量 FLIENAME = ‘user.txt‘
局部变量：
函数里面定义的变量，都是局部变量，只能在函数里面用，出了函数之后就不能用了
name = ‘Lily‘ #全局变量
def sayName():
name = ‘Kate‘#局部变量
print(name) #kate
sayName()
print(name) #Lily
全局变量：
公共的变量，都可以用的变量。
在整个程序里面都生效的，在程序最前面定义的都是全局变量，全局变量如果要在函数中修改的话，需要加global关键字声明，如果是list、字典和集合的话，则不需要加global关键字，直接就可以修改
name = ‘Lily‘ #字符串全局变量
names = [] #list全局变量
def sayName():
global name #修改全局变量name，加global关键字
name = ‘Kate‘
names.append(name)#修改全局list变量，不用加global关键字
print(name) #kate
sayName()
print(name) #kate
print(names) #[‘Kate‘]
最好少用全局变量的原因：
(1) 不安全，因为所有人都可以改
(2) 全局变量它会一直占着内存
七、递归
函数自己调用自己。
在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
递归调用的意思就是，在这个函数内部自己调用自己，就有点循环的意思。
def test1():
num = int(input(‘please enter a number：‘))
if num%2==0:#判断输入的数字是不是偶数
return True #如果是偶数的话，程序就退出了，返回True
print(‘不是偶数请重新输入！‘)
return test1()#如果不是偶数的话继续调用自己，输入值
print(test1())#调用test
递归调用的特性：
1. 必须有一个明确的结束条件
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）
少用递归，递归最多递归999，递归的效率不高
i = 0
def test():
global i
i += 1
print(i)
test()
test() #循环999次后会报错，3.6版本以后不会报错
八、高阶函数
如果一个函数的参数是一个函数的话，那么这个函数就是一个高阶函数
def s_int(n):#把传入的参数类型转换成int类型
return int(n)
def add(x,y,z):#接收3个参数，x,y,z，z是一个函数
print(z(x)+z(y))#z是一个函数，把x和y的值传给z，然后用z函数的返回值把两个值相加
add(‘8‘,‘9‘,s_int)#调用，传入x和y的值，再把上面的那个定义好的函数传进去