共计 6382 个字符,预计需要花费 16 分钟才能阅读完成。
函数
作用:最大化代码重用,最小化代码冗余,过程合成(不便保护)
一、函数的定义
- 函数定义后不会被执行,只有被调用的函数才会被执行
- 函数名称只能是由字母、数字、下划线组成,其不能以数字结尾
`# 格局: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 # 返回值,哪个调用就给哪个返回 c
sum = 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 = 20
def 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
# 批改封装变量:nonlocal
def func2():
x=100
def nested2():
nonlocal x
x=99
print(x)
nested2()
print(x)
func()
#输入后果:# 99
# 99`
4. 局部变量 Local:
- 在函数外部定义的变量,该变量只能在定义的函数外部应用
- 全局变量可能同时作用于函数内外,如果想要在函数外部给一个定义在函数外的变量赋值,那么这个变量就不能是部分的,其作用域必须为全局的,能够通过 global 来定义。
- 函数内定义全局变量:global 命令
`a=1
def 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 3 func(1,2) #输入后果:1 2 3 func(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.325 scores=(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+y
a = add # 把函数当作对象传递给变量时留神不要加(), 因为“函数名后 +()”示意调用该函数
print(a(2,3)) # 该委托函数执行办法:a(),也就是 a()相当于 add()这个函数
#输入后果:5
def hello_chinese(name):
print('你好',name)
hello = hello_chinese
hello('Tom')
hello = lanbda name:pritn('こんにちは', name)
hello('Tom')`
* 17
八、将函数作为另一函数的参数进行传递
`# 例 1
def 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")
#例 2
l = list(range(1,21))
def add(x):
return x+5
#将列表 l 中所有元素加 5
result = 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 的列表 l
result = []
# 将列表 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+5
result = 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 == 0
res = list(filter(even_number,l))
# 或写成
res = list(filter(lambda x: x % 2== 0, l)) # 只留下能被 2 整除的元素
正文完