python中函数的分类及介绍_python函数介绍及使用

一：为什么要用函数？

1、减少代码量

2、保持一致性

3、易维护

二：函数的定义和使用

def test(参数):

...

函数体

...return 返回值

函数的定义：

def：表示函数的关键字

函数名：以后可以根据函数名调用函数，test可以作函数名

函数体：中间可以做一系列的运算

参数：为函数提供数据 ，参数有形参和实参 ，

形参不占用内存空间，调用时才会占用内存，在调用结束后，才会被释放。实参是给实参进行赋值

返回值（return）：当函数执行完毕后，可以给调用者返回数据。 多个返回元组形式，单个为原形式

def test(x): # x代表形参''' 3*x+1:param x:整形数字

:return:返回计算结果''' y = 3*x+1

returny

print(test) # 打印test的内存地址

p= test(4) # test()表示运行，函数名加小括号，要重新赋值变量

print(p)

位置参数：位置要一一对应，不能缺也不能多且不能给同一个形参赋予多个值（会报错）

关键字参数：位置无需固定，但是缺一不行多一也不行

位置参数必须在关键字参数的左边

def test(x,y,z):#x=1,y=2,z=3print(x)

print(y)

print(z)

# 位置参数，必须一一对应，缺一不行多一也不行

test(1,2,3)

# 关键字参数，无须一一对应，缺一不行多一也不行

test(y=1,x=3,z=4)

# 位置参数必须在关键字参数左边

test(1,y=2,3)#报错

test(1,3,y=2)#报错

test(1,3,z=2)

test(1,3,z=2,y=4)#报错

test(z=2,1,3)#报错

位置参数和关键字参数一起也不能给同一参数赋多个值(会报错)

不能缺也不能多

默认参数：如果之前给了一个值一个参数，再赋予这个值一个参数，则这个值原有的参数会被覆盖掉

def handle(x, type='mysql'):

print(x)

print(type)

handle('hello') # 调用handle函数，x赋值为hello，type有了默认参数

handle('hello', type='sqlite') # x赋值，type用关键字重新赋值

handle('hello', 'sqlite') # 用位置一一对应关系赋值，覆盖type原来的值

结果

hello

mysql

hello

sqlite

hello

sqlite

参数组（*args列表，**kwargs字典） 非固定长度参数　　*args是以元祖的形式表达

def test(x, *args):

print(x)

print(args)

test(1)　　　　　　　　　　　　　# 只传入x的值，*args默认为空，元组形式

test(1, 2, 3, 4, 5)　　　　　　　　 # 传入x的值后，位置关系对应后，2 3 4 5对应*args以元组形式表达

test(1, {"name": "alex"})　　　　# 传入x的值后，有一个字典，整体传入

test(1, ["x", "y", "z"])　　　# 传入x的值后，有一个列表，整体传入

test(1,*["x","y","z"])　 # 传入x的值后，列表前面加了个*，则表示遍历，逐一出现表达

test(1,*("x","y","z"))　　　　　　　　# 同上，注意表现形式

结果1()1(2, 3, 4, 5)1({'name': 'alex'},)1(['x', 'y', 'z'],)1('x', 'y', 'z')1('x', 'y', 'z')

**kwargs

def test(x, **kwargs):

print(x)

print(kwargs) 以字典的形式表达

test(1, y=2, z=3) #y，z为key 后面均为值

test(1,y=2,z=3,z=4) #会报错：一个参数不能传俩个值

结果

{'y': 2, 'z': 3}

*args，**kwargs同时存在

def test(x,*args,**kwargs):

print(x)

print(args,args[-1])

print(kwargs,kwargs.get('y'))

# test(1,1,2,1,1,11,1,x=1,y=2,z=3) #报错，x传了多个值

test(1, 1, 2, 1, 1, 11, 1, y=2, z=3) #1传给x，中间位置参数给*args，关键字参数给**kwargs

test(1,*[1,2,3],**{'y':1}) #1传给x，*[1,2,3]传给*args遍历传，**{'y':1}传给**kwargs

结果1(1, 2, 1, 1, 11, 1) 1{'y': 2, 'z': 3} 2

1(1, 2, 3) 3{'y': 1} 1

全局变量(大写)

定义：没有缩进的变量

局部变量(小写)

定义：子程序下定义的变量

name = 'lhf'# 这里就指全局变量

def change_name():

name= '帅了一比'# 这里就指局部变量

print('change_name', name)

change_name()

print(name)

结果

change_name 帅了一比

lhf

global声明是全局变量，

nolocal指定上一级变量

如果函数的内容无global关键字

- 声明局部变量

NAME = ["产品经理","廖波湿"]defqupengfei():

NAME= "自己"

print('我要搞', NAME)

qupengfei()

结果

我要搞 自己

优先读取局部变量，能读取全局变量，但无法对全局变量重新赋值，但是对于可变类型，可以对内部元素进行操作

如果函数中有glabal关键字，变量本质上就是全局的那个变量，可读取可赋值

递归函数

自己调用自己的函数，则为递归

特性：必须有一个明确的结束条件 ，每次进入深一层递归时，问题规模都应有所减少。

defcalc(n):print(n)if int(n / 2) ==0:return n #当上面的条件成立后一个真值，返回到函数

res = calc(int(n / 2))print(n,res)return res #返回res的值，要将真值一层一层传递回去

calc(10)

当使用一些简单的函数的时候我们可以用匿名函数lambda

例一：

defcalc(x):return x+1res=calc(10)print(res) #输出结果

print(calc) #输出calc这个函数的内存地址

print(lambda x:x+1)#输出lambda这个表达式的内存地址

func = lambda x:x+1#x代表形参，x+1为返回值

print(func(10)) #给lambda表达式传入值，输出结果

"""结果

11

11

at 0x000001F6D84897B8>

11"""

例二：、

name = "alex"

defchange_name(x):return name+"_sb"res=change_name(name)print(res)

func= lambda x:x+"_sb"res=func(name)print(res)

其中函数式编程 ：就是函数接收的参数是一个函数名

高阶函数

1、把函数当作一个参数传给另一个函数

2、返回值中包含参数

defbar():print('from bar')deffoo():print('from foo')returnbar

n=foo()

n()

返回值中包含函数