目 录
位置参数
默认值参数
可变长参数
一、函数的定义
函数定义的3中方式：
1、有参函数：定义时有参，调用时也要传入参数
def func(x,y): """求和""" n = x+y print(n) func(1,2) # 函数名+括号，函数的调用
2、无参函数：函数定义时无参，即调用时也无需传入参数
def func(): print('hello world!') func() # 函数名+括号，函数的调用
3、空函数：当你知道需要写个函数实现某个功能，但是还不知道如何去写的时候，可以先写一个空函数占位。
def func(): pass
知识点引入：自己制造的函数工具，存在的两个缺点。
# s = 'just do it' list = [1,2,3,4] def my_len(): count = 0 for i in s: count += 1 print(count) my_len() # 10
总结：我们制造的函数有两个缺点
1、没有返回值，只能单纯地打印
2、调用时只对指定的字符串s执行，没有其他参数。
引出函数的两个知识点：函数的返回值和函数的参数。
二、函数的返回值
函数要想返回给调用者值，就要用到关键字return。
对于关键字return有以下五种情况：
# 函数内要想返回给调用者值 必须用关键字return """ 不写return 只写return 写return None 写return返回一个值 写return返回多个值 """
1、不写return：函数默认返回一个None
def func(): n = '哈哈哈哈' #print(n) res = func() print(res) # None
2、只写return：只写return会返回None，同时return还可以结束函数体代码的执行
def func(): l = ['jason','tank','egon','sean'] while True: for i in l: if i == 'tank': #break # 会一直打印‘jason不是这个人’ return # 只返回一句，‘jason不是这个人！’ print('打印返回！') # 在return下这句话永远不会打印 print("%s不是这个人！"%i) res = func() print(res) # None
3、写return None：和上面只写return是一样的
4、写return 返回一个值：这个值可以是任意的数据类型
# return只返回一个值,这个值可以是任意的数据类型 def func(): return [1,2,3,4] res = func() print(res) # [1, 2, 3, 4]
5、写return返回多个值：return会将多个值以元组的形式返回给调用者
# return返回多个值,return会将多个值以元组的形式返回给调用者 def func(): return 1,2,3,4 res = func() print(res) # (1, 2, 3, 4) def func(): return 'a','b','c' res = func() print(res) # ('a', 'b', 'c')
注意一下两种情况：
1、为什么当return返回多个值时，结果是以元组的形式？函数不希望自己处理的值被修改
2、返回多个值，并且不想让return帮你做修改 ----自己手动加上你想要的数据类型。
def func(): return [[1,2],[1,2,3],[4,5,6]] # 手动加入列表类型 res = func() print(res) # [[1, 2], [1, 2, 3], [4, 5, 6]]
函数返回值总结：
1、所有的函数都有返回值，无论你写不写return，不写return的情况下默认返回None
2、有时候写return 或return None并不是为了考虑返回值，而是为了结束函数的运行，终止函数体代码的执行。
三、函数的参数
函数的参数两大类型分为：形参和实参。
个人理解：形参就像变量名，实参就像是变量名对应的值，当调用函数的时候就将实参赋值给形参。
形参：当函数定义时，括号内的变量名就是函数的形式参数，简称形参。
实参：当函数进行调用时，括号内实际传入的值就是函数的实际参数，简称实参。
注意：形参和实参的绑定关系只在函数调用阶段有效，当函数执行完毕后自动解除；只在函数内部有效，函数外部无影响。
函数的简易结构如下：
# 函数的简易结构： def func(形参1,形参2...): """ 注释：函数的作用，形参的作用""" 函数体代码1 函数体代码2 ... return 函数的返回值
1、位置参数
位置参数：在函数定义阶段，在括号内从左到右依次传入的变量名就是位置参数。
位置形参在调用时必须为其传值；
位置实参传入的值必须与位置形参的值一一对应。
def func(x,y): if x > y: return x return y res = func(23,12) # 位置实参传值时与形参一一对应 print(res) # 23
(由上引出)参数的传入有以下3种方式：
1、位置传参：位置实参和位置形参要注意一一对应。
2、关键字传参：
def func(x,y): if x > y: return x return y res = func(y=23,x=100) # 关键字传参 print(res) # 100
3、位置和关键字混合传参：
# 混合传参要注意的问题 def func(x,y): if x > y: return x return y # res = func(23,y=100) # 混合传参 100 # res = func(23,x=100) # 报错，位置参数x被重复赋值 res = finc(x=23,100) # 报错，位置参数要排在关键字参数的前面 print(res) # 100
关于混合传参的总结：
""" 注意:在函数的调用阶段 位置参数和关键字参数可以混合使用 但是必须保证 1.位置参数必须在关键字参数的前面(越短的越靠前,越长的越复杂的越靠后) 2.同一个形参不能被多次赋值 """
2、默认值参数
默认值参数：在函数定义阶段，括号内的形参就已经被赋值，这样的参数就是默认值参数
注意：1、函数调用时可以不用给默认值形参传值，默认值参数使用已经绑定好的值。
2、函数调用时如果给默认形参传值，默认参数句改变你赋给它的值。
3、在函数定义阶段，默认值形参必须放在位置形参的后面。
面试题坑点：
# 要求分别打印出每个人的姓名和爱好 def info(name,hobby,l=[]): # 默认值参数 l=[] l.append(hobby) print('%s 的爱好是：%s'%(name,l)) info('jason','study') info('tank','生蚝') info('kevin','喝腰子汤') info('egon','女教练') >>>:结果变成每个人‘爱好’的叠加 jason 的爱好是：['study'] tank 的爱好是：['study', '生蚝'] kevin 的爱好是：['study', '生蚝', '喝腰子汤'] egon 的爱好是：['study', '生蚝', '喝腰子汤', '女教练']
出错原因：
因为函数默认形参是列表 l = [] ,每一个name都会指向该列表 l ，当一个人的爱好添加进 l ，列表 l 发生改变之后所有name对应的 列表 l都会发生改变。
解决办法有以下两种：
# 解决方法 def info(name,hobby,l=None): # 将默认参数l设定为None if l == None: # 如果l== None，就将其赋值为空列表，再依次添加元素 l = [] l.append(hobby) print('%s 的爱好是：%s'%(name,l)) info('jason','study') info('tank','生蚝') info('kevin','喝腰子汤') info('egon','女教练') >>>: jason 的爱好是：['study'] tank 的爱好是：['生蚝'] kevin 的爱好是：['喝腰子汤'] egon 的爱好是：['女教练']
def info(name,hobby,l=[]): # 将l默认设定空列表 l.append(hobby) print('%s 的爱好是：%s'%(name,l)) info('jason','study',[]) # 为每一个函数传入实参空列表 info('tank','生蚝',[]) info('kevin','喝腰子汤',[]) info('egon','女教练',[]) >>>: jason 的爱好是：['study'] tank 的爱好是：['生蚝'] kevin 的爱好是：['喝腰子汤'] egon 的爱好是：['女教练']
3、可变长参数
可变长参数站在调用函数实参的角度来看，有时候实参传入的个数不固定，因此形参的个数也就不固定；
站在形参的角度来看：可以接收多余的（溢出的）位置参数和关键字参数。
站在形参的角度来，看 *
# 形参中的*会将多余的(溢出的)位置实参 统一用元组的形式处理 传递给*后面的形参名 def func(x,y,*z): print(x,y,z) func(1,2,3,4,5,6,7,8,9) # 1 2 (3, 4, 5, 6, 7, 8, 9)
站在实参的角度来，看 *
# 站在实参的角度 看 * def func(x,y,z): print(x,y,z) # l = [1,2,3] # a,b,c = l # func(a,b,c) # func(*[1,2,3,4,5,6]) # *会将列表打散成位置实参一一传入等价于func(1,2,3,4,5,6) func(*(1,2,3)) # 等价于func(1,2,3) def func(x,*z): print(x,z) func(1,*{1,2,3}) # *在形参中只能接收多余的位置实参 不能接收关键字实参 *只能将列表 元组 集合 字符串 *的内部你可以看成是for循环
站在形参的角度来，看 **
def func(x,y,**z): #将多余的关键字参数以字典的形式赋值给**后面的变量名 print(x,y,z) func(1,3, a=11,b=12,c=23) # 1 3 {'a': 11, 'b': 12, 'c': 23
站在实参的角度来，看 **
def func(x,y,z): print(x,y,z) # func(12,3,4) # func(x=1,y=2,z=3) # d = {'x':1,'y':2,'z':333} # func(x=1,y=2,z=3) # func(**d) # 等价于func(x=1,y=2,z=333) # **会将字典拆封成 key = value的形式
坑点：
# **:在实参中 能将字典打散成key = value的形式 按照关键字参数传递给函数 def func(x,y,z): print(x,y,z) #d = {'name':'jason','age':19,'hobby':'run'} # 报错，**是将字典打散按关键字传参 d = {'x'：'jason','y':19,'z':'run'} func(**d) # jason 19 run
总结：* 和 **
""" 总结 * 与 ** *在形参中能够接受多余的位置参数 组织成一个元祖赋值给*后面的变量名 **在形参中能够接受多余的关键字参数 组织成一个字典赋值给**后面的变量名 *:在实参中 *能够将列表 元祖 集合 字符串 打散成位置实参的形式传递给函数 (*就看成是for循环取值) **:在实参中 能将字典打散成key = value的形式 按照关键字参数传递给函数 """
需求：无论调用者按照正确的方式怎样传参，函数都可以正常运行
Python推荐的* 和 ** 的使用方式：
""" 注意python推荐形参*和**通用的写法 """ def func2(*args,**kwargs): print(args,kwargs) func2(1,2,3,4,5,6,x=1,y=2,z = 3)