python函数
函数说明文档：
【定义函数说明文档】
1
2
3
4
| def 函数名（形参）:
'''说明文档位置''''
代码
。。。。。。
|
【查看函数的说明文档】
help（函数名）
位置参数：在定义函数时，参数的名字和位置已被确认
1
2
3
4
| def abc(姓名,年龄,性别):
print(f'您的姓名是{姓名}，性别{性别}，年龄{年龄}岁')
abc('hockel','男',25)
|
函数名(‘hockel’,’男’,25）
关键字参数：传入实参是，明确形参变量名，参数之间**不存在先后顺序**
1
2
3
4
| def abc(姓名,年龄,性别):
print(f'您的姓名是{姓名}，性别{性别}，年龄{年龄}岁')
abc('hockel',性别='男',年龄=25)
|
函数调用时，通过‘键=值’的形式加以指定，清除参数的顺序问题。
注意：调用函数时，如有位置参数，位置参数必需在关键字参数的前面，否则报错
默认参数（缺省参数）：参数指定默认值，调用时不传入实参，就用 默认值。
1
2
3
4
5
| def abc(姓名,年龄,性别=‘男’):
print(f'您的姓名是{姓名}，性别{性别}，年龄{年龄}岁')
abc('hockel',25)
abc('joan',33,性别=‘女’)
|
可变参数（收集参数）：
1、位置可变参数（接受所有的位置参数，返回一个元组）
1
2
3
4
5
| def 函数名(*args):
print(args)
函数名（’hockel‘）
函数名（‘Joan’，20）
|
2、关键字可变参数（接受所有的关键字，返回一个字典）
1
2
3
4
| def 函数名(**kwargs):
print(kwargs)
函数名（姓名 = ‘hockel’，年龄=20，性别=‘男“）
|
1、局部变量：定义在函数内部的变量，即只在函数内部生效
1
2
3
4
5
6
| def 函数名():
a = 520
print(a)
函数名（）
print(a)
|
2、全局变量：定义在函数外部的变量。
1
2
3
4
5
6
7
| a = 520
def 函数名():
print(a)
函数名（）
print(a)
|
3、在函数内部修改全局变量（global）
切记：不要轻易修改全局变量，除非万不得已！
1
2
3
4
5
6
| a = 520
def 函数名（）：
global a #声明a 为全局变量
a = 1314
print(a)
函数名（）
|
多函数程序执行流程：一般在实际开发过程中，一个程序往往由多个函数组成，并且多个函数共享某些数据
多函数公用全局变量的流程、；
1、声明全局变量
2、定义两个函数
3、函数1修改全局变量，函数2访问全局变量
4、先调用函数1（函数1修改了全局变量），再调用函数2时就可以使用修改后的全局变量了
1
2
3
4
5
6
7
8
9
10
11
| a = 1314
def name1():
global a
a = 520
def name2():
print(a)
name1()
name2()
|
函数返回值：return
1
2
3
4
5
6
7
| def 函数名（a,b): #多个返回值写成 return a,b 返回是一个元组（a,b)
return a + b
变量名 = 函数名（520，1314）
print(变量名)
|
多函数返回值做参数传递：
1.定义函数1，return返回一个值
2、定义带形参的函数2，打印形参
3、将调用函数1的返回值，赋值给一个 变量。列如：变量名 = 函数名1（）
4、调用函数2，用刚才的变量做参数 列如：函数名2（变量名）
1
2
3
4
5
6
| def name1():
return 520
def name(a):
print(a)
b = name1()
name(b)
|
元组 拆包
1
2
3
4
5
6
| def 函数名():
retrun 520,1314
a,b = 函数名()
print(a)
print(b)
|
字典拆包
1
2
3
4
5
6
7
8
| c = {'姓名' : 'hockel','年龄'：20}
def name():
return c
a,b = name()
print(a,b)
print(c[a])
print(c[b])
|
什么是递归？递归背部自己调用自己，必需留有出口。（套娃）
实例：1+2+3+4+5…..+100
把它看成：100+99+98+….+1
1
2
3
4
5
6
7
| def 函数名(形参):
if 形参 == 1:
return 1
结果 = 形参 + 函数名(形参 - 1)
return 结果
变量名 = 函数名(100)
print(变量名)
|
遇到return：（1）返回值（2）退出当前函数
函数式编程是一种古老的编程模式，就是用函数来表示程序，用函数的组合来表达组合的思维方式
函数编程之lambda表达式
1、什么时候用lambda表达式？
当函数有一个返回值，且只有一句代码，可以用lambda简写
2、lambda语法
lambda 形参：表达式
注意
1，形参可以省略，函数的参数在lambda中也适用
2、lambda函数能接受任何数量的参数但只能返回一个表达式的值
函数与lambda表达式对比：
1
2
3
4
5
6
7
| def func():
return 520
print(func())
func = lambda:520
print(func())
print((lambda:520)())
|
1
2
3
4
5
6
| def func1(a,b):
return a + b
result = func1(520,1314)
print(result)
print((lambda a,b: a+b)(520,1314))
|
lambda参数形式：
1，无参数 lambda:520()
2，一个参数 (lambda a:a)(520)
3、默认参数 （lamda a,b,c = a + b+ c)(2,6)
4、可变位置参数 (lambda *args = args)(1,2,3) 返回一个元组
5、可变关键字参数 （lambda **kwargs = kwargs)(a=1,b=2)返回的只一个字典
带（判断）条件语句的lambda：
1
2
3
4
5
| def func(a,b):
return a if a>b else b
print(func(1,2))
(lambda a,b :a if a > b else b)(1,2)
|
列表中的字典数据排序：
1
2
3
| dict1 = [{'姓名' : 'hockel','年龄'：20}，{'姓名' : 'jack','年龄'：20} ，{'姓名' : 'tom','年龄'：20}]
dict1.sort(key= lambda x:x['姓名']，reverse = True)
print(dict1)
|
编程式编程之高阶函数
高阶函数：就是基于已有的函数定义新函数，以函数作为参数，返回也是函数
1
2
3
4
5
6
7
| def func(a,b):
return abs(a)+ abs(b)
result = func(-5,3)
def func1(a,b,c):
return c(a) + c(b)
result = func1(-5,3,abs)
|
函数式编程之内置高阶函数
1，filter(函数名，可迭代对象) 作用：过渡序列中不符合条件的元素
1
2
3
4
5
6
7
8
9
| list1 = [1,2,3,4,5,6,7,8,9,10]
def func(x):
return x % 2 == 0
result = filter(func,list1)
print(result)
print(list[result])
filter(lambda x :x % 2,range(1,11))
|
注
filter有两个参数，第一个参数可以是函数，也可以是None
当第一个参数是函数的时候，将第二个参数中每一个元素进行计算。
当第一个参数是none时，直接将第二个参数中True 的值赛选出来
2、.map(函数名，迭代对象)
作用：将可迭代对象的每一个元素作为函数的参数进行运算加工，直到可迭代序列每个元素都加工完毕。
计算列表元素中各个数字的2次方
1
2
3
4
5
6
7
8
| dict1 = [range(1,5)]
def func(x):
return x ** 2
result = map(func,dict1)
print(result)
print(list(result))
list(map( lambda x: x **2,dict1))
|
3、reduce(函数名（x,y),可迭代对象）
作用：函数中必需有连个参数，每个函数计算的结果继续和序列的写一个元素做累积计算
计算 下列数据之和
1
2
3
4
5
6
7
| import functools
list1 = [range(1,5)]
def func(a,b):
return a + b
result = functools.reduce(func,list1)
functools,reduce(lambda x, y : x + y , list1)
|