在了解函数之前，我们先想象一个这样的场景：
如果现在len方法不能用了，我们要如何用代码计算‘kilobitten’这个字符串的长度？
str1 = 'kilobitten' length = 0 for i in str1: length += 1 print(length) # 10
此时又有一个需求，要计算另一个字符串的长，“New Centry”，我们该怎么做呢？如法炮制
str1 = 'kilobitten' length = 0 for i in str1: length += 1 print(length) # 10
str2 = 'The New Centry' length2 = 0 for j in str2: length2 += 1 print(length2) # 14
不难发现，虽然这样可以满足需求，但是造成了代码冗余
并且对比len方法来说，这种实现方式的代码可读性较差
str1 = 'kilobitten' str2 = 'The New Centry' print(len(str1)) # 10 print(len(str2)) # 14
这时候，我们就希望能有个方法能像len那样，可以直接使用，来计算长度。
于是，就引入了函数的概念。
函数
函数，就是具有某个具体功能的工具
为什么要有函数？
提供开发效率
减少代码冗余
提高程序的扩展性
定义一个函数
'def' 是定义函数的关键字
函数名：函数名的命名规则和变量名一致
1.不能以关键字命名（**重要**）
2.函数名也应该做到见名知意
需要注意的是：
函数在定义的时候只检测函数体语法 不执行函数体代码
1 s = 'kilobitten' 2 3 def my_len(): # 自定义函数 # 在定义函数时，以下4行代码并不执行 4 n = 0 5 for i in s: 6 n += 1 7 print(n) # 10
res = my_len() print(res) # None
调用函数的固定格式
函数名+括号
函数名只要遇到括号会立即执行函数体代码
代码中遇到函数名加括号 优先级最高
先去执行函数 再看下面的代码
我们自己写的函数现在的问题
1.没有返回值 只能固定的执行打印操作
2.只能够固定的统计某一个容器类型的长度
返回值
上面我们自己写的代码，虽然可以正确运行但不能像len方法那样有返回值。
函数内要想返回给调用者值 必须用关键字return
关于return有五种情况
1.不写return
# 不写return:函数默认返回None def func(): print('hahaha') # hahaha res = func() print(res) # None
2.只写return
# 只写return:return除了可以返回值之外 还可以直接结束整个函数的运行 # 只写return 返回的也是None(None就表示什么都没有) def func(): l = ['jason','egon','tank'] while True: for i in l: if i == 'egon': # 当i为egon的时候 直接结束函数运行 # 下面的return相当于break return # print('asdasdkljlsjadl') # 这一行代码拥有都不会运行 print(i) # jason res = func() print(res) # None
3.写return None
# 写return None:跟上面的只写return是一样的 def func(): return None res = func() print(res) # None
4.写return返回一个值
# 写return返回一个值:这个值可以是python任意数据类型 def func(): return '123' # 123 def func1(): return [1,2,3] # [1,2,3] def func2(): return {'name':'jason'} # {'name': 'jason'} def func3(): return (1,) # (1,) def func4(): return {1,2,3,4,5} # {1, 2, 3, 4, 5} def func5(): return True # True print(func(),func1(),func2(),func3(),func4(),func5()) # 123 [1, 2, 3] {'name': 'jason'} (1,) {1, 2, 3, 4, 5} True
5.写return返回多个值
# 写return返回多个值:return会自动将多个值以元组的形式返回给调用者 ''' 1.为什么组织成元组返回 函数不希望自己处理的结果被修改 2.如何不返回元祖 ''' def func(): return 1, 2, 3, 4 res0 = func() print(res0) # 返回的是(1, 2, 3, 4) def func1(): return 'a', 'b', 'c' res = func1() print(res) # 返回的是 ('a', 'b', 'c') 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) def func3(): return {'name': 'jason'}, {'username': 'tank'}, { 'user_name': 'egon'} # ({'name': 'jason'}, {'username': 'tank'}, {'user_name': 'egon'}) res2 = func3() print(res2) # 返回多个值 并且不想让return帮你做处理 自己手动加上你想返回的数据类型符号 def func4(): return [[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 34]] res = func4() print(res)
# 1.所有的函数都有返回值,无论你写不写return
python中所有的函数都有返回值 不写的情况下默认返回None
# 2.光写return 或者return None并不是为了考虑返回值 而是为了结束函数的运行
函数的参数概要
函数参数的两大类型
形参：在函数的定义阶段 括号内写的变量名 叫做该函数的形式参数 简称 形参
实参：在函数的调用阶段 括号内实际传入的值 叫做实际参数 简称 实参
形参和实参的关系
形参就相当于变量名，而实参就相当于变量的值
函数调用传参的过程，就是给形参变量名赋值的过程
注：形参和实参的绑定关系只在函数的调用阶段有效，函数运行结束关系自动解除
只在函数内部有效，函数外部无影响
函数的简易结构
def 函数名（形参1，形参2...） ''' 函数的注释 描述该函数的作用
以及各个形参的类型 ''' 函数体代码1 函数体代码2 ......... return 函数的返回值
def func(x,y): """ 该函数的作用 :param x: 对形参x的解释 :param y: 对形参y的解释 :return: 对函数返回值的解释 """ print('hahaha') return 'heihei' # print(help(func)) # print(help(len)) # 通过这种形式 去查看相关函数的注释
位置参数
位置参数:在函数定义阶段按照位置从左往右依次书写的变量名 叫做函数位置形参
位置形参在调用的时候 必须为其传值
def my_max(x,y): print(x,y) if x > y: return x else: return y # res = my_max(1) # 在调用函数的时候 少一个实参不行 # res = my_max(1,2,3) # 在调用函数的时候 多一个实参也不行 # res = my_max(20,10) # 这样才可以 # 位置实参:在函数的调用阶段 传入的参数会按照位置一一对应给形参 # print(res)
传参方法
# 第一种直接按照位置传 一一对应
# 第二种指名道姓的传 >>>:关键字传参
# my_max(y=20,x=10) # my_max(10,y=20) # 位置和关键字混合使用
#注意:在函数的调用阶段 位置参数和关键字参数可以混合使用
但是必须保证
1.位置参数必须在关键字参数的前面(越短的越靠前,越长的越复杂的越靠后)
2.同一个形参不能被多次赋值
默认值参数
默认值参数:在函数的定义阶段,形参(变量名)就已经被赋值了
在调用的时候可以不为默认值形参传值,默认使用定义阶段就已经绑定的值
在调用的时候如果可以给默认值形参传值 传了那么就使用你传的值
在定义阶段 默认值形参必须放在位置形参的后面
def my_max(x,y=100): if x > y: return x return y # res = my_max(200) res1 = my_max(200,1000) res2 = my_max(y=200,x=1000) print(res2)
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') # 默认值参数的应用场景 # 当形参接收的到值比较单一的情况下 通常可以考虑用默认值形参
重要坑点1
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','女教练') # 解决方法1 info('jason','study',[]) info('tank','生蚝',[]) info('kevin','喝腰子汤',[]) info('egon','女教练',[]) # 解决方法2 info('jason','study') info('tank','生蚝') info('kevin','喝腰子汤') info('egon','女教练')
重要坑点2
m = 100 def my_max(x,y=m): print(x,y) m = 222 my_max(111) # 111 100 # 因为一开始 m已经指向了100 # 然后m=100 赋值给y # 再把m指向222 已经和y无关了
# 函数在定义阶段 内部所使用的变量都已经初始化完毕了 # 不会因为调用的位置的变化 而影响到内部的值(暂时可忽略) # 函数无论在什么地方被调用 # 都会跑到函数定义阶段去执行代码 # 形参中用到的值都是往函数定义阶段代码往上找
可变长实参
站在调用函数传递实参的角度 实参的个数不固定的情况
也就意味形参也不固定
站在形参的角度 可以用*和**来接收多余的(溢出的)位置参数和关键字参数
*
站在形参的角度 看 *
形参中的*会将多余的(溢出的)位置实参 统一用元组的形式处理 传递给*后面的形参名
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,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) # z = {'z': 1, 'a': 1, 'b': 2, 'c': 3} func(x=1,y=2,z=1,a=1,b=2,c=3)
# **会接收所有多余的关键字参数 并将关键字参数 转换成字典的形式
字典的key就是关键字的名字
# 字典的value就是关键字的名字指向的值 将字典交给**后面的变量名
站在实参的角度看 **
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的形式
总结
* 与 **
*在形参中能够接受多余的位置参数 组织成一个元祖赋值给*后面的变量名
**在形参中能够接受多余的关键字参数 组织成一个字典赋值给**后面的变量名
*:在实参中 *能够将列表 元祖 集合 字符串 打散成位置实参的形式传递给函数
(*就看成是for循环取值)
**:在实参中 能将字典打散成key = value的形式 按照关键字参数传递给函数
现提出一个需求：
你写的函数 无论调用者按照正确传参的方式无论怎么传
你的函数都能够正常执行
def func1(*x,**y): print(x,y) func1(1,2,3,4,5,6,x=1,y=2,z = 3) # (1, 2, 3, 4, 5, 6) {'x': 1, 'y': 2, 'z': 3}
# 注意python推荐形参*和**通用的写法
def func2(*args,**kwargs): print(args,kwargs) func2(1,2,3,4,5,6,x=1,y=2,z = 3)
补充：
# 命名关键字参数:在函数定义阶段 写在*与**可变长参数之间的形参
# 在给命名关键字参数传值的时候 只能用关键字为其传值
# 在定义阶段 给你感觉好像是z是默认值参数 放在了m这个位置参数的前面了 应该报错
# 其实z和m都是命名关键字参数 不是默认值参数和位置参数
def func(x,y=1,*args,z=3,m,**kwargs): print(x,y) print(args) print(z,m) print(kwargs) func(1,2,1,2,3,4,5,6,7,78,8,9,0,z=69,m=999,o=666999,l = 999666)