关于python:Python函数

函数

作用:最大化代码重用,最小化代码冗余,过程合成(不便保护)

一、函数的定义

  • 函数定义后不会被执行,只有被调用的函数才会被执行
  • 函数名称只能是由字母、数字、下划线组成,其不能以数字结尾
`# 格局:
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整除的元素

【腾讯云】轻量 2核2G4M,首年65元

阿里云限时活动-云数据库 RDS MySQL  1核2G配置 1.88/月 速抢

本文由乐趣区整理发布,转载请注明出处,谢谢。

您可能还喜欢...

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注

此站点使用Akismet来减少垃圾评论。了解我们如何处理您的评论数据