python-函数相关

一.函数:

函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。

函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。

但你也可以自己创建函数,这被叫做用户自定义函数。

定义函数规则:

函数代码块以 def 关键词开头,后接函数标识符名称和圆括号 ()

任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数。

函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

函数内容以冒号起始,并且缩进。

return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None

函数定义示例:

 1 def 函数名(参数1,参数2):  2     '''
 3  这是一个解决什么问题的函数  4  :param 参数1: 参数1代表输入什么  5  :param 参数2: 参数2代表输入什么  6  :return: 返回什么东西  7     '''
 8  函数体  9  返回值 10     return 返回值

例如定义计算字符串长度的函数:

 1 def my_len(my_str):   #定义函数
 2     '''
 3  用于计算可变类型长度的函数  4  :param my_str: 用户输入的参数内容  5  :return:返回参数的长度  6     '''
 7     count = 0  8     for val in my_str:  9         count += 1
10     return count 11 a = my_len("hightgood") 12 print(a)       #输出值9

定义一个函数后,尽量不要用print,尽量return结果

自己是可以知道函数代码内部打印的是啥,自己可以随时修改,但是别人不知道

函数中的return:

《python-函数相关》

 1.返回None

有三种情况:

(1)无return的情况

(2)本来就return None

(3)return         #return空白

#无return
def my_print(parameter): print("Welcome",parameter) #return None
def my_print(parameter): return None #return
def my_print(parameter): return         #一般用于结束函数体

2.返回一个值

1 def my_len(my_str):   #定义函数
2     #计算可变类型值的长度
3     my_str = "goodnight"
4     count = 0 5     for val in my_str: 6         count += 1
7     return count       #count就是那个返回值

3.返回多个值

1 def my_print(): 2     return 11,22,33,[1,2,3] 3 a = my_print() 4 print(a) 5 #打印结果:(11, 22, 33, [1, 2, 3])

return后面的值用逗号隔开,然后以元组的形式返回

4.结束函数代码

1 def my_print(): 2     print('one') 3     return         #遇到return不继续函数下面的代码
4     print('two') 5 my_print()    #结果:one

5.补充:接收多个值

1 def my_print(): 2     return 1,2,3
3 a,b,c=my_print() 4 print(a,b,c)  #相当于用a接收1,b接收2,c接收3
5 def my_print(): 6     return [4,5,6] 7 a,b,c=my_print() 8 print(a,b,c)  #一个列表里有三个值,分别用abc去接收,相当于解包

函数的参数:

《python-函数相关》

1 def my_len(my_str):   #这里的my_str就是形参,形式参数,输入对象不确定,形参可以有多个,用逗号隔开
2     my_str = "goodnight"
3     count = 0 4     for val in my_str: 5         count += 1
6     return count 7 a = my_len("hightgood")    #这里的hightgood就是实参,实际参数,输入对象确定
8 print(a)

 函数参数详解:

《python-函数相关》

 1.位置参数:

1 def demo_1(a,b):   #位置参数 用户必须传入的参数,不传会报错
2     print(a,b) 3 demo_1(1,2)   #输出结果:1 2 按照位置传参 
4 demo_1(b=1,a=2) #输出结果:2 1 按照关键字传参
5 demo_1(1,b=2)  #输出结果:1 2 混用,但必须注意先按照位置传参,再按照关键字传参,不然会报错

2.默认参数:

1 def welcome(name,sex='man'):    #sex为默认参数
2     print('welcome %s,sex %s'%(name,sex)) 3 welcome('zrh')   #输出结果:welcome zrh,sex man
4 welcome('lml','women')  #输出结果:welcome lml,sex women
5 #默认参数如果不传参数,就用默认值,如果默认参数传入参数,就用传入值

默认参数的陷阱:

(1)

1 a = 18
2 def age(a1,a2=a): 3     print(a1,a2) 4 a = 20
5 age(10)  #输出结果:10 18

内部原理:

《python-函数相关》

 (2)

专门针对可变数据类型

 1 def demo(a = []):  2     a.append(1)  3     print(a)  4 demo() #输出结果:[1]
 5 demo() #输出结果:[1] [1]
 6 demo() #输出结果:[1] [1] [1]
 7 def demo_1(a = []):  8     a.append(1)  9     print(a) 10 demo_1([]) #输出结果:[1]
11 demo_1([]) #输出结果:[1]
12 demo_1([]) #输出结果:[1]

因为可变类型改变不是在内存中开辟一个新空间,而是在原来的基础上做修改,而10–12行是开辟了三块新内存

3.动态参数:

定义动态参数

1 def demo(*agrs):  #按位置输入的动态参数,组成一个元组
2     pass
3 def demo_1(**kwargs): #按关键字传入的参数,组成一个字典
4     pass

站在函数定义的角度:*做聚合作用,将一个一个的参数组合成一个元组(**则是字典)

站在函数调用的角度:*做打散用,将一个列表或元组打散成多个参数(**则是关键字形式)

 1 #函数定义角度:
 2 def demo(*agrs):  #按位置输入的动态参数
 3     print(agrs)  4 demo(1,2,3,4,5)  #输出结果(1, 2, 3, 4, 5)
 5 def demo_1(**kwargs): #按关键字传入的参数,组成一个字典
 6     print(kwargs)  7 demo_1(a=1,b=2,c=3)  #输出结果{'a': 1, 'b': 2, 'c': 3}
 8 #函数调用角度:
 9 val = [1,2,3,4] 10 val2 = {'a':1,'b':2} 11 demo(*val)  #将val打散成 1 2 3 4,然后传入函数
12 demo_1(**val2) #将val2打散成 a=1 b=2,然后传入函数

解释一下为什么在混用的传参中有必须先按位置传参,再按关键数传参:

1 def demo(*agrs,**kwargs):  #*agrs和**kwargs的位置是python固定死的
2     #所以必须先是按照位置传参的*agrs,再是按照关键字传参的**keagrs
3     print(agrs) 4     print(kwargs) 5 demo(1,2,3,4,a = 1,b = 2) 6 # 输出结果:
7 # (1, 2, 3, 4)
8 # {'a': 1, 'b': 2}

第3行对应第7行的输出结果

第4行对应第8行的输出结果

定义多个不同类型参数时的顺序:

1 def demo(位置参数1,位置参数2,*args,默认参数=x,**kwargs): 2     pass
3 #以后职业生涯用到多种参数时必须这么写

格式及原理:

《python-函数相关》

 情况总结:

1 def demo(*args,**kwargs):  #接收参数个数不确定的时候用动态传参,用到的时候再用
2     pass
3 def demo_1(a,b,c):    #位置参数,几个参数必须都要传入几个值,最常用
4     pass
5 def demo_2(a,b=10):   #默认参数,当参数信息大量形同时用到
6     pass

函数的嵌套:

 1 #函数的嵌套调用
 2 def demo_1():  3     print(123)  4 def demo_2():  5  demo_1()  6     print(456)  7 demo_2()  8 # 输出结果:
 9 # 123
10 # 456
11 
12 #函数嵌套定义
13 def demo_1(): 14     print(123) 15     def demo_2(): 16         print(456) 17  demo_2() 18 demo_1() 19 # 输出结果:
20 # 123
21 # 456

注意:内存读函数的时候先读定义函数名(不能里面的函数体),后面遇到调用此函数的时候,再返回读函数的函数体。

在函数外调整内部嵌套函数内容的方法:

1 def case(x,y,z): 2     def new_case(a,b,c): 3         print('content',a,b,c) 4  new_case(x,y,z) 5 case(1,2,3) 6 #输出结果 content 1 2 3

进阶:

《python-函数相关》

 

 ①表示代码运行顺序

*args 和 **kwargs 只是函数定义参数的方式,和混合传参不是一回事哦

点赞