Python函数

函数

定义函数

• 函数的定义
  • 函数是将具有的独立功能的代码组织成为一个整体，使其具有特殊功能的代码集。使用函数可以加强代码的复用性，降低编程的难度，提高程序编写的效率。
  • 定义函数语法规则
    • 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
    • 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
    • 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
    • 函数内容以冒号 : 起始，并且缩进。
    • return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。
  • 语法格式：

  def <函数名>(<形式参数列表>):
  	<函数体>
  	return<返回值列表>
  

  
  • 代码演示：

    # 定义一个对两个数求和的数
    def add(x,y):
    	s=x+y
    	return s
    
    print(add(1, 1))
    
    # 执行结果：
    2
    

函数调用

• 函数的调用
  • 定义后的函数不能直接运行，需要经过“调用”方可运行。因此，在Python中函数必须“先定义，后调用”
  • 调用函数的基本格式

    <函数名>（<实际赋值参数列表>）
    

  • 代码演示：

    # 定义一个对两个数求和的数
    def add(x,y):
    	s=x+y
    	return s
    
    #调用对两个树求和的函数
    print(add(1, 1))
    
    # 执行结果：
    2
    

return语句

• 函数的返回值
  • Python 函数使用 return 语句返回“返回值”。所有函数都有返回值，如果没有 return 语句，会隐式地调用 return None 作为返回值。如果函数执行了 return 语句，函数会立刻返回，结束调用，return 之后的其他语句都不会被执行。
  • return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。
  • 代码演示：

    def multiply(x,y):
    	x*y   #函数没有返回值
    
    s=multiply(5,6)
    print(s)
    
    #执行结果：
    None
    

    def multiply(x,y):
    	return x*y   #函数没有返回值
    
    s=multiply(5,6)
    print(s)
    
    #执行结果：
    30
    	```
    

参数

• 实参和形参
  • Python 函数有两种类型的参数：实参和形参。在函数定义时的参数被称为形参，形参不是实际存在的变量，形参存在的目的是用来接受调用函数时传来的参数，在调用时将实参的值赋值给形参。因此，实参的个数与类型需与形参一一对应。函数调用时传入的参数被称为实参。实参可以是常量、变量、表达式、函数等，无论实参是何种类型，在函数调用时，它们都必须有确定的值，便于把值传递形参。
  • 代码演示：

    def test(name,age):
    	print('年龄',age)
    	print('姓名',name)
    
    test('lyd',20)
    
    # 执行结果：
    年龄 20
    姓名 lyd
    

• 位置参数
  • 位置参数是函数最常用的一种传参方式，调用函数时实参的数量与顺序必须和函数声明时形参的一样。
  • 代码演示：

    def test(a,b):
        print(a,b)
    
    test(3,4)
    
    #执行结果：
    3 4
    

• 默认值参数
  • 在定义函数时，给参数一个默认值，此时的参数被称为默认参数值。调用函数时，如果没有给参数赋值，调用的函数就会使用这个默认值。
  • 代码演示：

    def test(name,age=18):
    	print("my age is ",age)
    	print("my name is:",name)
    	
    test('lyd')
    
    # 执行结果：
    my age is  20
    my name is: lyd
    

  • 默认值参数的规则
    • 1.函数定义时若有默认参数和位置参数同时存在时，默认参数必须全部在位置参数的后面。
    • 2.函数有默认参数时，只要不传入实际参数，则使用默认参数值
    • 3.如果要更改默认参数值参数，又不想传入其他参数，而且该默认值参数值不是默认参数值参数中的第一个，则可以通过参数名对默认参数值参数赋值。
    • 4.如果不是默认值参数中的第一默认参数值，想要通过参数名更改参数值，则其他需要更改的默认参数都需要传入参数名更改参数，否则报错。
    • 5.通过传入名称更改默认参数值时。可以不按照函数定义时的默认参数值顺序传入。
• 关键字参数
  • 关键字参数传参是指调用函数时通过参数名传递值，与函数的定义无关。实参的顺序和形参的顺序可以不一致，只需明确传值相对应的参数即可
  • 代码演示：

    def test(a,b,c):
    	print(a,b,c)
    
    test(c=4,b=3,a=1)
    
    # 执行结果：
    1 3 4
    

• 可变参数
  • 在函数定义时，也可以设定可变参数，通过在参数前加星号（*）实现。可变参数在函数定义时主要有两种表现形式：*param和**param，前者表示可以接收多个位置参数收集的实参组成一个元组，后者表示可以接受多个关键字参数收集的实参名和值组成一个字典。
  • 代码演示：

    def test(b,*a,c):  # ‘*’代表接收所有
        r=0
        print(a)
        for i in a:
            r+=i
        print(r)
    
    test(1,2,3,4,5,c=6)
    
    # 执行结果：
    (2, 3, 4, 5)  # print(a)输出的结果
    14    #print(r)输出的结果
    

    def test(y,*x,**z):
        r=0
        print(x)
        print(y)
        for i in x:
            r+=i
        print(r)
        print(z)
    
    test(8,a=1,b=2,c=3,d=4,f=5)
    
    # 执行结果：
    ()           # print(x)  输出的结果
    8           # print(y)  输出的结果
    0            # print(r)  输出的结果
    {
             'a': 1, 'b': 2, 'c': 3, 'd': 4, 'f': 5}       # print(z) 输出的结果
    

• 组合参数
  • 在实际中，经常会遇到位置参数、关键字参数、默认参数和可变参数 4 中参数组合使用这是参数的使用顺序必须是位置参数、默认参数、可变参数和关键字参数
  • 代码演示：

    def test(a,b,c=1,*p,**k):
    	print('a=',a,'b=',b,'c=',c,'p=',p,'k=',k)
    
    test(3,4)
    test(3,4,5)
    test(3,4,5,'A','B')
    test(3,4,5,'AB',x=7,y=8)
    
    # 执行结果：
    a= 3 b= 4 c= 1 p= () k= {
             }
    a= 3 b= 4 c= 5 p= () k= {
             }
    a= 3 b= 4 c= 5 p= ('A', 'B') k= {
             }
    a= 3 b= 4 c= 5 p= ('AB',) k= {
             'x': 7, 'y': 8}
    

• 参数拆包
  • 参数的解包(拆包)
    • 传递实参时，可以在序列类型的参数前添加星号，这样他会自动将序列中的元素依次作为参数传递
  • 要求：序列中的元素个数必须和形参的个数一致

    def fn1(a,b,c):
        print(a, b, c)
    
    
    x = (1,2,3) # 元组数据
    y = [4,5,6] # 列表数据
    z = {
             'a':7, 'b':8, 'c':9} # 字典数据
    
    fn1(*x)  # 元组解包  *
    fn1(*y)  # 列表解包  *
    fn1(**z) # 字典解包  通过 **对字典进行解包
    
    # 输出为
    1 2 3
    4 5 6
    7 8 9
    

变量作用域

• 变量作用域是指在程序中能够对该变量进行操作的范围。根据作用域不同，变量分为全局变量和局部变量。全局变量指在函数之外定义的变量，在程序执行全过程有效。局部变量是指在函数内部使用的变量，仅在函数内部有效，当函数使用过后，变量从内存中释放。

  • 代码演示：

    a=1  # a是全局变量
    def calc():
        b=a+3   # b是局部变量
        print(b)
    calc()
    print(b)
    
    # 执行结果：
    4
    Traceback (most recent call last):
      File "D:/py/Example/13/CSDN/函数.py", line 79, in <module>
        print(b)
    NameError: name 'b' is not defined
    

    这段代码表示当函数执行完之后，其内部变量 b 将被释放。

    n=1
    def calc(a,b):
        n=b
        return a+b
    s=calc(5,4)
    print(s,n) # 测试n的值是否发生变化
    
    # 执行结果：
    9 1
    

  • 函数 calc() 内使用了变量n，且将参数b赋值给变量n，函数 calc()有自己的内存空间，n = b 实际上是重新生成的局部变量，此时函数没有将n看为全局变量n,当函数退出时，局部变量n被释放，全局变量的值没有改变。

  • 如果要在函数中使用全局变量，只需要在函数内部的变量前加上关键字 global。

  • 代码演示：

    m=1
    def calc(a,b):
        global m
        m=b
        return a+b
    s=calc(5,4)
    print(s,m)
    
    # 执行结果：
    9 4
    

匿名函数

• python 使用 lambda 来创建匿名函数。
• 所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
  • lambda 只是一个表达式，函数体比 def 简单很多。
  • lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
  • lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
  • 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
  • 语法格式：

    <函数名> = lambda <形式参数列表>: <表达式> 
    

  • 代码演示：

    sum = lambda arg1, arg2: arg1 + arg2
     
    # 调用sum函数
    print ("相加后的值为 : ", sum( 10, 20 ))
    print ("相加后的值为 : ", sum( 20, 20 ))
    
    #执行结果：
    相加后的值为 :  30
    相加后的值为 :  40