Task05：函数与Lambda表达式

水深无声 2023-06-10 08:26 42阅读 0赞

### Task05：函数与Lambda表达式 ###

*  函数
 *   *  介绍
     *  定义
     *  调用
     *  函数文档
     *  函数传递
     *  函数参数
     *   *  位置参数
         *  默认参数
         *  可变参数
         *  关键字参数
         *  命名关键字参数
         *  参数组合
     *  函数返回
     *  变量作用域
     *  内嵌函数
     *  闭包
     *  递归
 *  Lambda 表达式
 *   *  介绍
     *  语法
     *  实例
 *  参考资料

# 函数 #

## 介绍 ##

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。  
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

## 定义 ##

简单的规则：

*  函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
 *  任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
 *  函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
 *  函数内容以冒号起始，并且缩进。
 *  return \[表达式\] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

>>> def area(width, height):
        return width * height
    
    >>> area(3,4)
    12

## 调用 ##

定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。  
这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。

def f1(a,b):
        print(a*b)
    
    f1(8,9)
    f1([1,2,3],3)
    # 72
    # [1, 2, 3, 1, 2, 3, 1, 2, 3]

## 函数文档 ##

>>> def f1(a,b):
        "计算面积"
        print(a*b)
    
    >>> help(f1)
    Help on function f1 in module __main__:
    
    f1(a, b)
        计算面积
    
    >>>

## 函数传递 ##

**可更改(mutable)与不可更改(immutable)对象**  
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

*  不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5  
    被丢弃，不是改变a的值，相当于新生成了a。
 *  可变类型：变量赋值 la=\[1,2,3,4\] 后再赋值 la\[2\]=5 则是将 list la  
    的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

*  不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在  
    fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
 *  可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

==形参：==函数定影过程中的参数  
==形参：==实际传递进来的参数

## 函数参数 ##

Python 的函数具有非常灵活多样的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。从简到繁的参数形态如下：

*  位置参数 (positional argument)
 *  默认参数 (default argument)
 *  可变参数 (variable argument)
 *  关键字参数 (keyword argument)
 *  命名关键字参数 (name keyword argument)
 *  参数组合

### 位置参数 ###

位置参数 ，这些参数在调用函数 (call function) 时位置要固定。

### 默认参数 ###

默认参数 = 默认值，调用函数时，默认参数的值如果没有传入，则被认为是默认值。  
默认参数一定要放在位置参数 后面，不然程序会报错。

### 可变参数 ###

可变参数就是传入的参数个数是可变的，可以是 0, 1, 2 到任意个，是不定长的参数。

def functionname(arg1, arg2=v, *args):
        "函数_文档字符串"
        function_suite
        return [expression]

def printinfo( arg1, *vartuple ):
       "打印任何传入的参数"
       print ("输出: ")
       print (arg1)
       print (vartuple)
     
    # 调用printinfo 函数
    printinfo( 70, 60, 50 )
    
    #70
    #(60, 50)

### 关键字参数 ###

def functionname(arg1, arg2=v, *args, **kw):
        "函数_文档字符串"
        function_suite
        return [expression]

\*\*kw - 关键字参数，可以是从零个到任意个，自动组装成字典。

def printinfo( arg1, **vardict ):
       "打印任何传入的参数"
       print ("输出: ")
       print (arg1)
       print (vardict)
     
    # 调用printinfo 函数
    printinfo(1, a=2,b=3)
    
    #1
    #{'a': 2, 'b': 3}

「可变参数」和「关键字参数」的同异总结如下：

可变参数允许传入零个到任意个参数，它们在函数调用时自动组装为一个元组 (tuple)。

关键字参数允许传入零个到任意个参数，它们在函数内部自动组装为一个字典 (dict)。

### 命名关键字参数 ###

*  \*, nkw - 命名关键字参数，用户想要输入的关键字参数，定义方式是在nkw 前面加个分隔符 \*。
 *  如果要限制关键字参数的名字，就可以用「命名关键字参数」
 *  使用命名关键字参数时，要特别注意不能缺少参数名。

def functionname(arg1, arg2=v, *args, *, nkw, **kw):
        "函数_文档字符串"
        function_suite
        return [expression]

def printinfo(arg1, *, nkw, **kwargs):
        print(arg1)
        print(nkw)
        print(kwargs)
    
    
    printinfo(70, nkw=10, a=1, b=2)
    # 70
    # 10
    # {'a': 1, 'b': 2}
    
    printinfo(70, 10, a=1, b=2)
    # TypeError: printinfo() takes 1 positional argument but 2 were given

注：没有写参数名nwk，因此 10 被当成「位置参数」，而原函数只有 1 个位置函数，现在调用了 2 个，因此程序会报错。

### 参数组合 ###

在 Python 中定义函数，可以用位置参数、默认参数、可变参数、命名关键字参数和关键字参数，这 5 种参数中的 4 个都可以一起使用，但是注意，参数定义的顺序必须是：

*  位置参数、默认参数、可变参数和关键字参数。
 *  位置参数、默认参数、命名关键字参数和关键字参数。

要注意定义可变参数和关键字参数的语法：

*  \*args 是可变参数，args 接收的是一个 tuple
 *  \*\*kw 是关键字参数，kw 接收的是一个 dict

命名关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。  
**定义命名关键字参数不要忘了写分隔符 \*，否则定义的是位置参数**

警告：虽然可以组合多达 5 种参数，但不要同时使用太多的组合，否则函数很难懂。

## 函数返回 ##

return \[表达式\] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

## 变量作用域 ##

*  定义在函数内部的变量拥有局部作用域，该变量称为局部变量。
 *  定义在函数外部的变量拥有全局作用域，该变量称为全局变量。
 *  局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。
 *  当内部作用域想修改外部作用域的变量时，用到global
 *  不到万不得已不要使用全局变量，简洁的概括为：
    
    a) 代码可读性变差  
    b) 代码安全性降低

## 内嵌函数 ##

在嵌套的函数中，如果希望在内部函数修改外部函数的局部变量，应该使用nonlocal 关键字

>>> def Fun1():
    	 x = 5
    	def Fun2():
    		nonlocal x
    		x *= x
    		return x
    	return Fun2()
    
    >>> Fun1()
    25

## 闭包 ##

*  是函数式编程的一个重要的语法结构，是一种特殊的内嵌函数。
 *  如果在一个内部函数里对外层非全局作用域的变量进行引用，那么内部函数就被认为是闭包。
 *  通过闭包可以访问外层非全局作用域的变量，这个作用域称为 闭包作用域。

def outer():      #------别人家
        x = 10        #别人家里的东西
        def inner():   #内部函数------别人家的小孩
            print(x)   #外部函数的一个变量
        return inner   #------返回小孩
     
     
     
    f = outer()        #到别人家 “套近乎”别人的小孩，套出（返回）小孩f
    f()                #f小孩执行
     
     
     
    # 调用inner()函数的方法
     
    1、法一
    outer()()   
     
    2、法二
    f = outer()
    f()

def funX():
        x = 5
        def funY():
            nonlocal x
            x += 1
            return x
        return funY
    
    a = funX()
    print(a())
    print(a())
    print(a())
    # 6
    # 7
    # 8

怎么跟全局变量一样了？局部变量 x 不是应该在每次调用的时候都重新初始化了吗？！  
其实大家仔细看看就明白了，当 a = funX() 的时候，只要 a 变量没有被重新赋值，funX() 就没有被释放，也就是说局部变量 x 就没有被重新初始化。  
所以当全局变量不适用的时候，可以考虑使用闭包更稳定和安全。

## 递归 ##

如果一个函数在内部调用自身本身，这个函数就是递归函数。  
例子：求n！  
循环法：

n = 5
    for k in range(1, 5):
        n = n * k
    print(n)  # 120

递归法：

def factorial(n):
        if n == 1:
            return 1
        return n * fact(n - 1)
    
    
    print(factorial(5)) # 120

# Lambda 表达式 #

## 介绍 ##

python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

lambda 只是一个表达式，函数体比 def 简单很多。  
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。  
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。  
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

## 语法 ##

lambda [arg1 [,arg2,.....argn]]:expression

## 实例 ##

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

# 参考资料 #

*  LSGOGroup 老马的程序人生
 *  FishC.com
 *  Runoob.com
 *  https://www.cnblogs.com/clairedandan/p/10976678.html