python——函数
1.介绍：
在过去的十年间，大家广为熟知的编程方法无非两种：面向对象和面向过程，其实，无论哪种，都是一种编程的规范或者是如何编程的方法论。而如今，一种更为古老的编程方式：函数式编程，以其不保存状态，不修改变量等特性重新进入人们的视野。下面我们就来依次了解这一传统的编程理念，让我们从基本的函数概念开始。
2.函数定义：
初中数学函数定义：一般的，在一个变化过程中，如果有两个变量x和y，并且对于x的每一个确定的值，y都有唯一确定的值与其对应，那么我们就把x称为自变量，把y称为因变量，y是x的函数。自变量x的取值范围叫做这个函数的定义域，编程语言中函数定义：函数是逻辑结构化和过程化的一种编程方法。
函数定义规范
def 函数名(arg1,arg2,arg3):
"描述信息"
函数体
return 1
查看函数注释：
|
1
2
3
4
|
def foo(): 'foo function' print("from the foo")print(foo.__doc__) |
输出结果：
|
1
|
foo function |
2.1 定义无参函数
|
1
2
|
def foo(): print("from the foo") |
2.2 定义有参函数
|
1
2
3
|
def bar(x,y): res=x+y return res |
2.3 定义空函数
|
1
2
|
def auth(): pass |
2.4有参与无参的区别及其应用场景
这个功能需要外部传值，就是有参函数，否则，就是无参函数
3、调用函数：
3.1 调用无参、有参和空函数
|
1
2
3
4
5
6
|
调用无参函数：（定义无参，调用也无参） foo() 调用有参函数：（定义有参，调用也必须有参） res=bar(1,2) 调用空函数： auth() |
4、语句和表达式形式调用函数
|
1
2
3
4
|
语句形式调用：foo()表达式形式调用: (此时函数有返回值)res=bar(1,2)*10 bar(bar(1,2),3) #函数调用作为另一个函数的参数 |
5、函数返回值return
（1）函数返回值可以是任意类型数据
（2）无参函数通常没有返回值，有参函数通常有返回值
（3）函数没有return返回值但会返回None
没有return---> None
|
1
2
3
4
|
def foo(): print("from the foo")res=foo()print(res) |
输出结果：
|
1
2
|
from the fooNone |
（4）返回多个值会作为元组类型返回
|
1
2
|
return 1---->1 return 1,2,3 -----> (1,2,3) |
|
1
2
3
4
5
|
def my_max(x,y): res=x if x>y else y return resres1=my_max(1,2)print(res1) |
输出结果：
|
1
|
2 |
|
1
2
3
4
|
def bar(x,y): return 1,2,3,4,5,[1,2],{"a":2},{1,2,3}res1=bar(1,2)print(res1) |
输出结果：
|
1
|
(1, 2, 3, 4, 5, [1, 2], {'a': 2}, {1, 2, 3}) |
（5）接收返回值：
单个返回值：res=bar(1,2)
多个返回值：res=bar(1,2) res是元组类型
多个返回值：a,b,c=bar(1,2) a,b,c分别接收返回值
|
1
2
3
4
5
6
|
def bar(x,y): return 1,2,3a,b,c=bar(1,2)print(a)print(b)print(c) |
输出结果：
|
1
2
3
|
123 |
（6）函数只会执行一个return，就结束函数并返回值，无论写多少return
小知识：解压变量
6、有参函数的参数
python是弱类型语言，参数的类型不需要指定类型，但是会有不合法的数据类型，python不能限制，只能注释提醒
例：X,y没有指定数据类型，所以什么类型都行。使用灵活，但是乱用会报错。可以使用注释信息提醒
|
1
2
3
4
5
6
|
def my_max(x,y): res=x if x>y else y return resprint(my_max(1,2))print(my_max('a','b'))print(my_max('a',1)) |
输出结果：
2
b
TypeError: unorderable types: str() > int() #报错
6.0函数写注释方法
方法1：
|
1
2
3
4
|
def my_max(x,y): """x->int,y->int,res->int,cal max value""" res=x if x>y else y return res |
方法2：
|
1
2
3
4
|
def my_min(x:int,y:int)->int: print(x if x<y else y)my_min(1,2)print(my_min.__annotations__) |
输出结果：
|
1
2
|
1{'y': <class 'int'>, 'x': <class 'int'>, 'return': <class 'int'>} |
__annotations__用显示出函数的注释信息
6.1 形参和实参的概念
形参与实参的定义
|
1
2
3
4
5
|
def foo(x,y): # 在函数定义阶段，括号内定义的参数-->形式参数（本质就是变量名） print(x) print(y) foo(1,2) ##在函数调用阶段，括号内定义的参数-->实际参数（本质就是变量值，实参必须有一个确定的值） # 形参和实参的绑定关系在定义时没有生效，在调用时生效，形参被赋值实参的值，函数结束时解除绑定 |
实参要保证是不可变的类型：字符，数字，元组，如果是可变的类型，形参也可以修改实参。因此需要注意：不要在函数内动用全局变量，函数的功能就与函数有关，不要动全局变量。
实参的值为不可变类型时： 形参不能改变实参的值
|
1
2
3
4
5
6
|
def bar(x): print(x) x=3x=1bar(x)print(x) |
输出结果：
|
1
2
|
11 |
实参的值为可变类型时： 形参可以改变实参的值
|
1
2
3
4
5
|
def bar(x): x.append(4)x=[1,2,3]bar(x)print(x) |
输出结果：
|
1
|
[1, 2, 3, 4] |
6.2 实参的角度分析：书写三种方式
（1）位置实参
按照位置传值，按照位置写就是位置实参
|
1
2
3
4
|
def foo(x,y): print("x=",x,",y=",y)foo(1,2)foo(2,1) |
输出结果：
|
1
2
|
x= 1 ,y= 2x= 2 ,y= 1 |
（2）关键字实参
按照关键字传值：关键字实参
什么等于什么 就是关键字传值
|
1
2
3
4
|
def foo(x,y): print("x=",x,",y=",y)foo(x=1,y=2)foo(y=2,x=1) |
输出结果为：
|
1
2
|
x= 1 ,y= 2x= 1 ,y= 2 |
（3）位置实参和关键字实参混着用
1 位置参数必须在关键字参数之前。 按位置传值必须在按关键字传值的前面
|
1
2
3
|
def foo(x,y): print("x=",x,",y=",y)foo(1,y=2) |
输出结果：
|
1
|
x= 1 ,y= 2 |
|
1
2
3
|
def foo(x,y): print("x=",x,",y=",y)foo(y=2,1) |
输出结果：
|
1
|
SyntaxError: positional argument follows keyword argument #报错 |
2 对于一个形参只能赋值一次，不能重复赋值
|
1
2
3
|
def foo(x,y): print("x=",x,",y=",y)foo(1,x=1,y=2) |
输出结果：
|
1
|
TypeError: foo() got multiple values for argument 'x' #报错 |
6.3 形参的角度分析
（1）位置形参
必须传值的参数，传值时多或少都不行
|
1
2
3
|
def foo(x,y): print("x=",x,",y=",y)foo(1,2,3) |
输出结果：
|
1
|
TypeError: foo() takes 2 positional arguments but 3 were given #报错 |
（2）默认形参
1 常用的，变化比较小的值设为形参的默认值
2 形参设置默认形参时，必须放到形参中位置形参的后面
3 默认形参在函数定义的时候就已经被赋值了
4 在函数定义阶段，python只是会检查函数的语法是否错误；
在函数调用阶段，python才会输出执行函数代码的错误
5 默认形参也可以传值，也可以不传
1 常用的，变化比较小的值设为参数的默认值
|
1
2
3
|
def foo(x,y=1): print("x=",x,"y=",y)foo(1) |
输出结果：
|
1
|
x= 1 y= 1 |
Python自带许多有默认形参的函数
2 形参设置默认参数时，必须放到形参中位置参数的后面
可以这样理解：函数名相当于变量名，函数的代码相当于变量的值，定义函数相当给函数名与函数代码绑定，
引用函数名，就是引用函数代码
在函数定义阶段，函数绑定到一堆代码，python只是会检查函数的语法是否错误；
在函数调用阶段，python才会输出执行函数代码的错误
3 形参默认参数在函数定义的时候就可以被赋值了
|
1
2
3
4
5
|
x='male'def register(sex=x): print(sex)x=Noneregister() |
输出结果为：
|
1
|
male |
4 默认参数是可变类型时
|
1
2
3
4
5
6
7
|
x=[]def register(name,name_list=x): name_list.append(name)register("wen")register("yan")register("jie")print(x) |
输出结果：
|
1
|
['wen', 'yan', 'jie'] |
（3）形参:*args
1 功能：将实参那边的位置参数传值多余的值都接收，成元组类型
2 也是属于位置参数，但要放在其他位置参数的后面
形参参数排序：1 其他位置参数 2 *args 3 默认参数
一般*args和默认参数不要一起用
3 *args可以看做是无穷的位置参数，根据实参的数量而变化
4 * 的功能就相当于将形参名打散成多个，接收实参过来的值
*也可以用在实参里，将值打散分成多个传给形参
对以后装饰器有用
1 功能：将实参那边的位置参数传值多余的值都接收，成元组类型
|
1
2
3
4
|
def foo(x,*args): print(x) print(args)foo(1,2,3,4,5,6,7,8,'a','b') |
输出结果：
|
1
2
|
1(2, 3, 4, 5, 6, 7, 8, 'a', 'b') |
2 形参参数排序：1 其他位置参数 2 *args 3 默认参数 。 一般*args和默认参数不要一起用
|
1
2
3
4
5
|
def foo(x,y=1,*args): print("x=",x) print("y=",y) print("args=",args)foo(1,2,3,4,5) |
输出结果：
|
1
2
3
|
x= 1y= 2args= (3, 4, 5) |
|
1
2
3
4
5
|
def foo(x,*args,y=1): print("x=",x) print("y=",y) print("args=",args)foo(1,2,3,4,5) |
输出结果：
|
1
2
3
|
x= 1y= 1args= (2, 3, 4, 5) |
3 *的概念
* 的功能就相当于将形参名打散成多个，接收实参过来的值
*也可以用在实参里，将值打散分成多个传给形参
例：将args分成多个形参接收实参过来的值
|
1
2
3
|
*args=1,2,3args=(1,2,3)*(1,2,3)=1,2,3 |
从形参角度：
|
1
2
3
|
def foo(*args): print(args)foo(1,2,3) |
输出结果：
|
1
|
(1, 2, 3) |
从实参角度：将实参的元组打散分别传给形参
|
1
2
3
4
5
|
def bar(x,y,z): print(x) print(y) print(z)bar(*(1,2,3)) |
输出结果：
|
1
2
3
|
123 |
*功能的再一例子：
|
1
2
3
4
5
6
|
def my_sum(nums): res=0 for i in nums: res+=i return resprint(my_sum((1,2,3,4,5))) |
|
1
2
3
4
5
6
|
def my_sum(*nums): #比上面例子多一个*号 res=0 for i in nums: res+=i return resprint(my_sum(1,2,3,4,5)) #比上面例子少一对括号 |
（3）形参:**kwargs
接收关键字参数
1 功能：将实参那边的多余的关键字传值变成字典类型，赋值给kwargs
2 混着用的位置：在形参角度看，**kwargs位于*args之后
3 **的概念
* 的功能就相当于将形参名打散成多个对（默认参数，即x=1），接收实参过来的值
* 也可以用在实参里，将字典打散分成多个关键字参数（即x=1）传给形参
4 *args和**kwargs联用
1 将实参那边的关键字传值多余的变成字典类型，赋值给kwargs
|
1
2
3
4
|
def foo(x,**kwargs): print(x) print(kwargs)foo(1,y=2,a=3,b=4) |
输出结果：
|
1
2
|
1{'a': 3, 'y': 2, 'b': 4} |
使用**kwargs报错的例子：
|
1
2
3
4
|
def foo(x,**kwargs): print(x) print(kwargs)foo(1,2,3,4) |
输出结果：
|
1
|
TypeError: foo() takes 1 positional argument but 4 were given #报错 |
2 **的概念
* 的功能就相当于将形参名打散成多个对（默认参数，即x=1），接收实参过来的值
* 也可以用在实参里，将字典打散分成多个关键字参数（即x=1）传给形参
从形参的角度：
|
1
2
3
|
def foo(**kwargs): print(kwargs)foo(x=1,y=2,z=3) |
输出结果：
|
1
|
{'z': 3, 'x': 1, 'y': 2} |
从实参角度：
|
1
2
3
4
5
6
|
def foo(x,y,z=1): print(x) print(y) print(z)foo(**{'x':1,'y':2,'z':3}) #相当于 foo(x=1,y=2,z=3)输出结果为： |
输出结果：
|
1
2
3
|
123 |
3 在形参角度，**kwargs位于*args之后
|
1
2
3
4
5
|
def foo(x,*args,**kwargs): print(x) print(args) print(kwargs)foo(1,y=1,z=2) |
输出结果：
|
1
2
3
|
1(){'y': 1, 'z': 2} |
再例：
|
1
2
3
4
5
|
def foo(x,*args,**kwargs): print(x) print(args) print(kwargs)foo(1,2,3,4,5,6,a=7,y=1,z=2) |
输出结果：
|
1
2
3
|
1(2, 3, 4, 5, 6){'y': 1, 'a': 7, 'z': 2} |
4 *args和**kwargs联用的好处：灵活
调用auth函数参数输入灵活，实参是关键字参数和位置参数都可以，实参输入位置参数的时候注意位置
|
1
2
3
4
5
6
7
8
9
10
|
def auth(name,password,sex='female'): print(name) print(password) print(sex)def foo(*args,**kwargs): print("from foo") auth(*args,**kwargs)foo('yuan','123')foo('wen','123',sex='male')foo(name='wen',password='123',sex='male') |
5 *args和**kwargs联用实现执行函数的计时问题
计时功能：
|
1
2
3
4
5
6
7
8
9
10
|
import timedef auth(name,password,sex='male'): time.sleep(1) print(name,password,sex)def timmer(*args,**kwargs): start_time=time.time() auth(*args,**kwargs) stop_time=time.time() print('run time is %s' %(stop_time-start_time))timmer(name=1,password=123,sex='female') |
输出结果：
|
1
2
|
1 123 femalerun time is 1.0004379749298096 |