函数
作用：最大化代码重用，最小化代码冗余，过程合成（不便保护）
一、函数的定义
- 函数定义后不会被执行，只有被调用的函数才会被执行
- 函数名称只能是由字母、数字、下划线组成，其不能以数字结尾
`# 格局：def 函数名(形参,....): # 可不设置形式参数 函数体 # 例1：加法函数def add(a,b): c = a+b print("加法后果：",c) # 拓展：print(add) 输入后果为办法 add函数的贮存空间地位 # 例2：减法函数def sub(a,b): c = a-b print("减法后果：",c)` 二、函数的调用
`# 格局：函数名(输出理论参数值....)# 例：调用加法函数add(2,1)` 三、函数的返回（return)
`# 格局:def 函数名(): 函数体 return "返回值"# 例:def add(a,b): c = a+b print(c) return c # 返回值，哪个调用就给哪个返回csum = add(1,2) # 调用函数print("sum = " , sum)` 智汇代理申请https://www.kaifx.cn/broker/thinkmarkets.html留神：
- 当函数执行到return的时候，就会马上终止函数执行
- 函数中能够呈现多个return，但有且只有一个return会被执行
- return 前面能够不跟值，return 独自应用等价于return None
四、变量作用域
- 作用域范畴：Built_in > Global > Enclousure > Local
- 作用范畴采纳就近准则
1.python内置函数变量Built_in：
`def len(): print("我本人定义的办法") len("abcdef") # 输入后果报错，并不是执行python的内置函数len()计算长度# 本人定义的len()函数笼罩python的内置函数len()` 2.全局变量Global：
- 在函数内部定义的变量，全局指的是该变量在以后python文件范畴内是可见的，全局变量能够被以后python文件内所有函数间接应用。
- 局部变量的优先级大于全局变量(变量就近准则)
`# 例：a = 10 # 全局变量，全局变量作用域是所有中央c = 20def test1(): a=20 # 函数局部变量只能在本人的函数内应用 print(a)test1() # 输入后果 ： 20 print(a) # 输入后果 ： 10` 3.封装变量Enclousure：
`def func1(): x=100 def nested1(): x=99 print(x) nested1() print(x) func1()#输入后果：# 99# 100# 批改封装变量：nonlocaldef func2(): x=100 def nested2(): nonlocal x x=99 print(x) nested2() print(x) func()#输入后果：# 99# 99` 4.局部变量Local：
- 在函数外部定义的变量，该变量只能在定义的函数外部应用
- 全局变量可能同时作用于函数内外，如果想要在函数外部给一个定义在函数外的变量赋值，那么这个变量就不能是部分的，其作用域必须为全局的，能够通过global来定义。
- 函数内定义全局变量： global 命令
`a=1def test1(): global a # 定义函数内的全局变量， a=10 # 函数内全局变量定义格局：先定义，再赋值，不可写成一行，否则报错 print(a) #调用函数后，全局变量能力起作用print(a)test1() print("在函数外调用test1函数的全局变量："，a) # 输入后果：在函数外调用test1函数的全局变量：10#输入后果：#1在这里插入代码片#10#10` - 一个变量已在函数外定义，如果在函数内须要为这个变量赋值，并要将这个赋值后果反映到函数外，能够在函数内用global申明这个变量，将其定义为全局变量。
- 在函数外部间接将一个变量申明为全局变量，在函数外没有申明，在调用这个函数之后，将减少为新的全局变量。
五、参数
`def func(a,b,c): # 形参a、b、c print(a,b,c)func(1,2,3) # 实参1、2、3` 1. 必备参数（地位匹配）
必备参数须以正确的程序传入函数。调用时的数量必须和申明时的一样
`def sub(a,b): c = a-b print("减法后果：",c)sub(1,2) # 按形参程序传值 a=1 b=2 输入后果：-1`
2. 关键字参数
- 关键字参数和函数调用关系严密，函数调用应用关键字参数来确定传入的参数值。
应用关键字参数容许函数调用时参数的程序与申明时不统一，因为 Python 解释器可能用参数名匹配参数值
`def sub(a,b): c =a-b print(c)sub(b=2,a=1) # 输入后果：-1 #b=2,a=1 关键字参数#关键字传值与程序无关`- 留神：调用函数时既传递地位参数又传递关键字参数时，地位参数要在关键字参数后面如： add(200,300,400,num5=100)
3. 默认参数（调用时省略传值）
- 调用函数时，默认参数的值如果没有传入，则被认为是默认值
格局：
`def 函数名(... , ... , 形参名=默认值): 函数体`- 留神：默认值参数必须呈现在函数参数列表最右端，且任何一个默认参数左边不能有非默认参数
例：
`def func2(a,b=2,c=3): print(a,b,c)func(1) #输入后果：1 2 3func(1,2) #输入后果：1 2 3func(1,c=5) #输入后果：1 2 5`
默认值参数必须呈现在函数参数列表的最右端，如果某一个地位的形参设置了默认参数，那么该地位之后的所有参数都必须设置为默认参数
4. 不定长参数（定义函数时，定义可接管多实参数据的形参）
须要一个函数能解决比当初申明时更多的参数。这些参数叫做不定长参数
定义一个能够接管任意数量参数的函数时需应用不定长参数： *args与 **kwargs
4.1 *args
*args用来接管多个实参并将其放在一个元组中；*args示意多参数传值，*号为要害格局，前面名称可随便改`# 例1：# 定义计算2门学科求均匀问题的办法def avg(score1,score2): return(score1+score2)/2# 定义计算n门学科求均匀问题的办法def avg(*scores): #定义形参时，形参前加*号，示意可接管任意数量实参并将其置于一个元组中 return sum(scores)/len(scores) # 应用该形参时后面不须要加*号result = avg(98.2,88.1,70,65)print(result) # 输入80.325scores=(88,89,90)result2 = avg(*scores) # scores变量前必须加*解包，示意将元组各个元素分离出来，不然报错print(result2)# 例2：def test1(*args): # 形参格局为：* + 形参名 print(args) # 输入多个参数的元组数据类型# 调用函数，不能关键字传值：test1(1,2,3,"xzh",18) # 输入元组数据类型： (1,2,3,"xzh",18)`
4.2 **kwargs
**kwargs接管相似要害参数一样显示赋值模式的多个实参并将其放入字典中**kwargs示意多参数传值，**号为要害格局，前面名称可随便改`# 例1：def display(**employee): print(employee) emp={'name':'Tom','age':22,'job':'dev'}display(name='Tom', age=22, job='dev') #输入后果：{name:'Tom'，age:22, job:'dev'}display(**emp) #输入后果：{'job':'dev','name':'Tom','age':22} 必须加**解包# 例2：def test2(**kwargs): # 形参格局为：** + 形参名 print(kwargs) # 输入多个参数的字典数据类型# 调用函数,只能关键字传值：test2(name="Tom" , age=18 ,height=188.8)# 输入字典数据类型：{"name" : "Tom" , "age" : 18 , "height" : 188.8}`
总结：
- 单个*号示意应用元组传值，以元组模式传入的实参数不定
- **号示意应用字典传值，以字典模式传入的实参数不定
5、一般参数和不定长数参的混合应用
`# 例：def test3(a,b,*args): print("输入a和b：" ,a,b) print("输入可变长度参数：" , args)# 调用函数：test3(1,2,3,4)# 输入后果：输入a和b：1 2输入可变长度参数：（3,4）` 六、lambda表达式（匿名函数）
次要用于编写简略逻辑的函数
- lambda表达式能够用来申明匿名函数，即没有函数名字的长期应用的小函数。
- lambda是一种以表达式模式生成函数的办法，和def语句相似用于创立一个函数。
- def罕用来设计性能简单的一般性函数，而lambda用于简略的函数，以适应更灵便的利用，也被称为函数性能速写。
- lambda定义的函数没有函数名，生成的是一个表达式模式的无名函数，表达式的后果是lambda的返回值。
- lambda函数要传递给一个变量才可应用。
根本格局：
`lambda 参数1，…，参数n : 函数体 # 例： add = lambda a,b,c:a+b+c add(1,2,3)# 若不需传参f=lambda :pritn('hello')f()` 例：
`def hello(name): prtin(name) def add(x,y): return x+y f= lambda name: print(name) # 等价于没有函数名的hello()函数 f2=lambda x,y : x+y # 等价于没有函数名的add()函数 f('Tom') # 输入后果：打印出Tom print(f2(5,3)) # 输入后果：8` 七、函数的委托(函数别名)
`def add(x,y): return x+ya = add # 把函数当作对象传递给变量时留神不要加(),因为“函数名后+()”示意调用该函数print(a(2,3)) # 该委托函数执行办法：a()，也就是a()相当于add()这个函数#输入后果：5def hello_chinese(name): print('你好',name) hello = hello_chinesehello('Tom')hello = lanbda name:pritn('こんにちは', name)hello('Tom')` * 17八、将函数作为另一函数的参数进行传递
`#例1def hello_chinese(name): print('您好：', name)def hello_english(name): print('Hello', name) def hello_japanese(name): print('こんにちは', name) def hello(action,name): action(name) hello(hello_chinese,"Tom")hello(lambda name : print('!',name),"Tom")#例2l = list(range(1,21))def add(x): return x+5#将列表l中所有元素加5result = list(map(add,l))result = list(lambda x:x=5,l)` 九、理论利用
例：实现抉择不同语言打招呼
`# def hello_chinese(name):# print('您好：', name)# def hello_english(name):# print('Hello', name) # 高级写法 # while True:# name = input("请输出名称：n")# if name == 'stop':# break# language = input('请抉择语言：n c=> 中文版n e=>英文版n j=>日文版n')# # if language == 'c':# hello_chinese(name)# elif language == 'e':# hello_english(name)# elif language == 'j':# (lambda name: print('こんにちは', name))(name)# 中级写法 # while True:# name = input("请输出名称：n")# if name == 'stop':# break# language = input('请抉择语言：n c=> 中文版n e=>英文版n j=>日文版n')# # if language == 'c':# action = hello_chinese# elif language == 'e':# action = hello_english# elif language == 'j':# action = lambda name: print('こんにちは', name)# action(name) # 实现抉择不同语言换对应的函数#大神级写法def hello_chinese(name): print('您好：', name)def hello_english(name): print('Hello', name) def hello_japanese(name): print('こんにちは', name) operation{ 'e':hello_english, 'c':hello_chinese, 'j':hello_japanese, 'r':lambda name : print('!',name)} while True: name = input("请输出名称：n") if name == 'stop': break language = input('请抉择语言：n c=>中文版n e=>英文版n j=>日文版n r=>俄语版n') #operation.get(language)(name) #若找不到key值则返回None,相当于None(name)会报错 operation.get(language,hello_chinese)(name) # 设默认值为hello_chinese 避免报错` 十、函数的高级工具
1、map()函数
格局：
`map(函数，可迭代的对象)# map()返回的后果是一个map类型` * 1* 2- map()函数，顾名思义，用于映射，把一个序列的每一个元素映射到函数中，而后返回一个迭代对象。
例：
`l = list(range(1,21)) # 生成1到20的列表lresult = []# 将列表l中所有偶数放入列表result中#办法1：应用循环for n in l: if n % 2 == 0: result.append(n)pritn(result)#办法2：应用推导（理论开发过程中倡议应用推导）result = [x for x in l if x % 2 == 0]pritn(result)#将列表l中所有元素加5#办法1：应用循环for n in l: result.append(n+5)pritn(result)#办法2：应用推导result =[x+5 for x in l]#办法3：map()def add(x): return x+5result = list(map(add,l))#或写成如下：result = list(map(lambda n:n+5, l))` 2、filter()函数
格局：
`filter(函数，可迭代对象)` * 1- filter()函数，顾名思义，用于过滤，把一个序列的每个元素映射到函数中，返回后果为True的元素。
例：
l = list(range(1,11))def even_number(x): return x%2 == 0res = list(filter(even_number,l))# 或写成res = list(filter(lambda x: x % 2== 0, l)) # 只留下能被2整除的元素