1.什么是函数函数就是具有某个具体功能的工具
2.为什么要用函数提供开发效率减少代码冗余提高程序的扩展性
3.定义一个函数def是定义函数的关键字，函数在定义的时候只检测函数体语法 不执行函数体代码
4.函数名: 函数名的命名规则与变量名一致5.调用函数的固定格式：            函数必须先定义在调用，定义之后可以在任何位置调用函数名+括号函数名只要遇到括号会立即执行函数体代码代码中遇到函数名加括号 优先级最高先去执行函数 再看下面的代码

1.len() 内置函数
2.如果没有len（）我们能不能自己定义一个类似的函数呢？s = 'hello'
def my_len():  # 自定义函数n = 0for i in s:n += 1print(n)res = my_len()
print(res)  # None#我们自己写的函数现在的问题问题1.没有返回值 只能固定的执行打印操作问题2.只能够固定的统计某一个容器类型的长度

#解决 问题1

1.所有的函数都有返回值,无论你写不写return，不写的情况下默认返回None2.只写return 或者return None并不是为了考虑返回值 而是为了结束函数的运行

# 函数内要想返回给调用者值 必须用关键字return
返回值有以下几种情况：
1.不写return
2.只写return
3.写return None (和只写return一样)
4.写return返回一个值
5.写return返回多个值

# 不写return:函数默认返回None
def func():print('hahaha') res = func() #开始调用
print(res)  #None

# 只写return: return除了可以返回值之外 还可以直接结束整个函数的运行函数返回的也是None(None就表示什么都没有)
def func():l = ['jason','egon','tank']while True:for i in l:if i == 'egon':  # 当i为egon的时候 直接结束函数运行# break  # 如果这里不写return，写break，那么只能结束for循环，回到while循环，继续执行下一次for循环，一直执行，死循环输出jasonreturn  #整个函数结束标志，结束函数# print('asdasdkljlsjadl')  # return会结束整个函数， 这一行代码永远都不会运行print(i)  #jason
res = func()
print(res)  #None

# 写return返回一个值:这个值可以是python任意数据类型
def func():return '123'
def func1():return [1,2,3]
def func5():return True
print(func(),func1(),func5())  #123 [1, 2, 3] True

# 返回多个值，默认元组形式 （函数不希望自己处理的结果被修改）
def func2():return [1,2,3],[1,2,3],[1,2,3]  # ([1, 2, 3], [1, 2, 3], [1, 2, 3])
res1 = func2()
print(res1)
#如果不想让return帮你做处理，自己手动加上你想返回的数据类型符号
def func4():return [[1,2,3,4],[1,2,3,4],[1,2,34]]
res = func4()
print(res)  #[[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 34]]

函数参数的两大类型形参:在函数的定义阶段 括号内写的变量名 叫做该函数的形式参数 简称 形参实参:在函数的调用阶段 括号内实际传入的值 叫做实际参数 简称 实参形参与实参的关系形参就相当于变量名,而实参就相当于变量的值函数调用传参的过程 就是给形参变量名赋值的过程注意:形参和实参的绑定关系只在函数的调用阶段有效,函数运行结束关系自动解除只在函数内部有效 函数外部无任何影响

#无参数s = 'hello'
l = [1.2,3,4]
def my_len():# 需要0个参数n = 0for i in s:n += 1return n  #返回n的值给函数

res = my_len () #调用函数
print(res)  #5#我能不能像len（）一样也能在括号内传递参数呢？
def my_len(args):  # 'args'为形参，相当于占位符，后面实参传入之后，形参的值即为实参的值print(args)n = 0for i in args:n += 1return n  #返回n给函数，即my_len()print(my_len('hello'))  #调用函数，将实参'hello'传递给形参‘args’
print(my_len('hello world'))
print(my_len([1,2,3,4,5]))print（args） # 直接报错  形参和实参的绑定关系只在函数内部有用，出了函数关系就不存在了hello
5
hello world
11
[1, 2, 3, 4, 5]
5

1.基本架构形式def 函数名(形参1,形参2...):'''函数的注释 用来描述该函数的作用以及各个形参的类型'''函数体代码1函数体代码2...return 函数的返回值2. 实例
def func(x,y): # 三个引号直接回车，自动跳出注释格式"""该函数的作用:param x: 对形参x的解释:param y: 对形参y的解释:return: 对函数返回值的解释"""print('hahaha')return 'heihei'
3.调出注释格式
print(help(func))  #查看函数的注释，没写注释输出None
print(help(len))  #千万不要加括号，加括号优先级最高直接调用函数了

1. 第一种直接按照位置传  一一对应
# 位置参数:在函数定义阶段按照位置从左往右依次书写的变量名 叫做函数位置形参
# 位置形参在调用的时候 必须为其传值
def my_max(x,y):print(x,y)  # 20 10if x > y:return xelse:return y
# res = my_max(1)  # 在调用函数的时候 少一个实参不行
# res = my_max(1,2,3)  # 在调用函数的时候 多一个实参也不行
res = my_max(20,10)
# 位置实参:在函数的调用阶段 传入的参数会按照位置一一对应给形参
print(res)  #202. 第二种指名道姓的传  >>>:关键字传参
my_max(y=20,x=10)
my_max(10,y=20)  # 位置和关键字混合使用
my_max(20,y=40)
my_max(20,y=40,x=30)

注意:在函数的调用阶段 位置参数和关键字参数可以混合使用
但是必须保证1.位置参数必须在关键字参数的前面(越短的越靠前,越长的越复杂的越靠后)2.同一个形参不能被多次赋值

1. 默认值参数: 在函数的定义阶段,形参(变量名)就已经被赋值了
2. 调用的时候可以不为默认值形参传值,默认使用定义阶段就已经绑定的值调用的时候如果给默认值形参传值 ,那么就使用你传的值
3. 默认值参数的应用场景当形参接收的到值比较单一的情况下 通常可以考虑用默认值形参
def register(username,age,gender='male'):print(username,age,gender)register('jason',18)  #开始调用
register('tank',28)
register('egon',84)
register('kevin',58)
register('xiaohou',17,'female')jason 18 male
tank 28 male
egon 84 male
kevin 58 male
xiaohou 17 female

def info(username,hobby,l=[]):l.append(hobby)print('%s 的爱好是 %s'%(username,l))
info('jason','study')
info('tank','生蚝')
info('kevin','喝腰子汤')
info('egon','女教练')jason 的爱好是 ['study']
tank 的爱好是 ['study', '生蚝']
kevin 的爱好是 ['study', '生蚝', '喝腰子汤']
egon 的爱好是 ['study', '生蚝', '喝腰子汤', '女教练']# 解决方法1 不使用默认列表，每次都传入新的空列表
def info(username,hobby,l=[]):l.append(hobby)print('%s 的爱好是 %s'%(username,l))
info('jason','study',[])
info('tank','生蚝',[])
info('kevin','喝腰子汤',[])
info('egon','女教练',[])jason 的爱好是 ['study']
tank 的爱好是 ['生蚝']
kevin 的爱好是 ['喝腰子汤']
egon 的爱好是 ['女教练']# 解决方法2 每次都给列表重新赋值
def info(username,hobby,l=None):if l == None:l = []l.append(hobby)print('%s 的爱好是 %s'%(username,l))
info('jason','study')
info('tank','生蚝')
info('kevin','喝腰子汤')
info('egon','女教练')jason 的爱好是 ['study']
tank 的爱好是 ['生蚝']
kevin 的爱好是 ['喝腰子汤']
egon 的爱好是 ['女教练']

m = 100
def my_max(x,y=m):print(x,y)
m = 222
my_max(111)  # 111  100  //而不是111 2221.函数在定义阶段 内部所使用的变量都已经初始化完毕了
不会因为调用的位置的变化 而影响到内部的值(暂时可忽略，但是很重要)2.函数无论在什么地方被调用都会跑到函数定义阶段去执行代码形参中用到的值都是往函数定义阶段代码往上找

可变长参数：
1.站在调用函数传递实参的角度：  实参的个数不固定的情况，也就意味形参也不固定
2.站在形参的角度： 可以用*和**来接收多余的(溢出的)位置参数和关键字参数

1.站在形参的角度 看 *
形参中的*会将多余的(溢出的)位置实参 统一用元组的形式处理 传递给*后面的形参名
def func(x,y,*z):print(x,y,z)  # z = (3, 4, 5, 6, 7, 8, 54, 43, 4, 5, 6, 6, 7, 8)
func(1,2,3,4,5,6,7,8,54,43,4,5,6,6,7,8,)def func(x,*z):print(x,z)
func(1,z=8)  #直接报错   /// *在形参中只能接收多余的位置实参 不能接收关键字实参

2.站在实参的角度 看 *
def func(x,y,z):print(x,y,z)
#l = [1,2,3] #想将123对应xyz怎么办？
#a,b,c = l
#func(a,b,c) #解压赋值虽然可以但是如果有成千上万个数，怎么办呢？
func(*[1,2,3])  #1 2 3    *会将列表打散成位置实参一一传入等价于func(1,2,3,4,5,6)
func(*(1,2,3))  #1 2 3    等价于func(1,2,3)*只能将列表 元组 集合 字符串 （字典不行）
*的内部你可以看成是for循环

1.站在形参的角度看 **
def func(x,y,**z):print(x,y,z)  # z = {'r': 1, 'a': 1, 'b': 2, 'c': 3}
func(x=1,y=2,r=1,a=1,b=2,c=3)
**会接收所有多余的关键字参数 并将关键字参数 转换成字典的形式 字典的key就是关键字的名字
字典的value就是关键字的名字指向的值  将字典交给**后面的变量名2.站在实参的角度看 **
def func(x,y,z):print(x,y,z)
d = {'x':1,'y':2,'z':333}
func(**d)  #  1 2 333   // 等价于func(x=1,y=2,z=333)
**会将字典拆封成 key = value的形式

1.形参中：        *在形参中能够接受多余的位置参数 组织成一个元祖赋值给*后面的变量名**在形参中能够接受多余的关键字参数 组织成一个字典赋值给**后面的变量名2.实参中：*:在实参中 *能够将列表 元祖 集合 字符串 打散成位置实参的形式传递给函数 (*就看成是for循环取值)**:在实参中 能将字典打散成key = value的形式 按照关键字参数传递给函数3.结合使用
# 需求 你写的函数 无论调用者按照正确传参的方式无论怎么传 你的函数都能够正常执行
# 注意python推荐形参*和**通用的写法
def func2(*args, **kwargs):print(args, kwargs)
func2(1, 2, 3, 4, 5, 6, x=1, y=2, z=3)
#(1, 2, 3, 4, 5, 6) {'x': 1, 'y': 2, 'z': 3}

空函数:可以快速帮助你构建项目框架 使项目架构清晰明了应用频率非常高购物车功能def register():passdef login():passdef shopping():passdef pay():pass

def func():print('from func')

def func(x,y,*args,**kwargs):pass

1.命名关键字参数:在函数定义阶段 写在*与**可变长参数之间的形参
2. 在给命名关键字参数传值的时候 只能用关键字为其传值
3.在定义阶段 给你感觉好像是z是默认值参数 放在了m这个位置参数的前面了 应该报错
4.其实z和m都是命名关键字参数 不是默认值参数和位置参数
def func(x,y=1,*args,z=3,m,**kwargs):print(x,y)  #1 2print(args)  # (1, 2, 3, 4, 5, 6, 7, 78, 8, 9, 0)print(z,m)  # 69 999print(kwargs)  # {'o': 666999, 'l': 999666}
func(1,2,1,2,3,4,5,6,7,78,8,9,0,z=69,m=999,o=666999,l = 999666)