Python3: 函数

柔光的暖阳◎ 2021-09-21 22:34 335阅读 0赞

本文链接: [https://blog.csdn.net/xietansheng/article/details/115557381][https_blog.csdn.net_xietansheng_article_details_115557381]

[Python3 学习笔记（目录）][Python3]

# 1. 函数的定义与调用 #

使用`def`关键字定义函数，函数定义格式：

# 通常函数代码块前后 空两行 作为函数分隔
    
    
    def 函数名(参数列表):
        """ 函数体第一行字符串为函数说明（可选） """
        函数体代码块
        ...
        函数体代码块
        # 使用 return 返回值, 如果没有 return 值, 则函数结果默认返回 None
        return 函数返回值
    
    
    函数名()           # 函数调用

实例：

#!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    
    
    def fun():
        print("Call Function")
    
    
    def add(a, b) -> int:
        """ 返回 a + b 的值 """
        c = a + b
        return c
    
    
    fun()                   # 输出 "Call Function", 函数返回的是 None
    print(add(2, 3))        # 输出 5, 函数返回的是 5

# 2. 函数的标准注释 #

函数的标准注释，可以通过`pydoc`工具导出生成标准的 Python API 文档。

def fun(name="", age=0):
        """ 一个函数的注释说明（下面要空一行） :param name: 函数第一个参数的说明 :param age: 函数第二个参数的说明 :return: 函数返回值的说明 """
        s = str(name) + ", " + str(age)
        return s

上面函数的注释，通过 IDE 解析出来的效果如下图:  
![fun-doc.png][]

通过打印函数对象的`__doc__`属性也可以输如函数的注释:

>>> print(fun.__doc__)
    
        一个函数的注释说明（下面要空一行）
    
        :param name: 函数第一个参数的说明
        :param age:  函数第二个参数的说明
        :return:     函数返回值的说明

# 3. 类型注解 #

## 3.1 类型注解的使用 ##

Python 是动态语言，变量可以指向任意类型的对象，变量不区分类型。Python3 中给变量增加了类型注解，类型注解仅仅是对变量的注释，不影响代码运行。使用类型注解可以提高代码的可读性，方便知道变量、参数、函数返回值的具体类型。

代码示例:

def add(a: int, b: int) -> int:
        c = a + b
        return c
    
    
    print(add(20, 30))      # 输出: 50
    
    # 通过函数对象的 __annotations__ 属性可以获取函数声明的类型注解
    # 输出: {'a': <class 'int'>, 'b': <class 'int'>, 'return': <class 'int'>}
    print(add.__annotations__)
    
    # 定义变量时也可以添加类型注解
    s: str = None

上面示例中用类型注解声明函数`fun`的参数`a`和`b`为`int`类型, 返回类型为`int`类型（类型注解的类型可以是任何类型）。

## 3.2 校验类型注解代码 ##

类型注解仅仅是注释，不参与代码运行，因此就算给被类型注解声明过的变量赋值其他类型的值也可以（例如给注解为整形的变量赋值字符串）。Python 提供了一个用于测试代码中类型注解正确性的模块`mypy`。

安装`mypy`：

pip install mypy

安装完成后，在`pip`命令文件所在目录将生成一个`mypy`命令文件。

`mypy`使用示例：

def add(a: int, b: int) -> int:
        c: int = a + b
        return c
    
    
    print(add(3.14, 30))

把上面代码保存为文件：`demo.py`

上面代码直接运行时没有错误，在控制台执行`mypy`命令检查类型注解：

$ mypy demo.py
    demo.py:6: error: Argument 1 to "add" has incompatible type "float"; expected "int"

意思说 demo.py 文件中的第 6 行有错误，add 函数的参数 1 传了不兼容的类型 float，预期的类型为 int。如果有多个类型错误将输出多行。

`mypy`可以同时检查多个文件，还可以检查`module`和`package`，具体使用说明执行命令`mypy --help`查看。

# 4. 参数传递的是引用 #

**调用函数时所有参数对象传递的都是对象的引用**，实例：

def fun1(i):
        """ 不可变对象传递 """
        i = 5               # 函数体内的本地变量 i 指向新的对象（与外部变量无关）
        print(i)            # 输出 5
    
    
    def fun2(lt):
        """ 可变对象传递 """
        # 改变变量 lt 指向的列表的第 0 个元素指向的对象
        # 此处的 lt 和 外部的 lt 指向的是同一个对象, 所以改变此处的 lt[0] 即改变了外部的 lt[0]
        lt[0] = "world"
        print(lt[0])        # 输出 "world"
    
    
    i = 3
    fun1(i)
    print(i)                # 输出 3
    
    lt = ["hello"]
    fun2(lt)
    print(lt[0])            # 输出 "world"

# 5. 参数默认值 与 关键字参数 #

函数的参数可以添加默认值：

def fun(a, b=2):        # 有默认值的参数必须放在后面
        c = a * b
        return c
    
    
    fun(5)          # 5 传给 a, b 有默认值, 可以不传, 结果为 10

函数调用的参数传递一般是按参数顺序逐个传递，但也可以手动指定参数的传递顺序：

def fun(a, b):
        print(a + ", " + b)
    
    
    fun(b="12", a="34")     # 把"12"传给参数b, 把"34"传给参数a, 结果输出 "34, 12"

# 6. 不定长参数 #

使用`*`声明函数的不定长参数，格式：

def fun([args,] *var_tuple):
        """ 不定长参数必须放在最后, 单个 * 的不定长参数（位置参数）以元组的形式导入 """
        pass
    
    
    def fun([args,] **var_dict):
        """ 不定长参数必须放在最后, 两个 * 的不定长参数（关键字参数）以字典的形式导入 ** 的不定长参数, 以 key=value 的形式传递 """
        pass
    
    def fun([args,] *args, **kwargs):
        """ 两种不定长参数可以一起使用, 使该函数的参数通用化（可以接收任何参数）。 args 表示 位置参数, 有顺序要求, 以元组的形式导入; kwargs 表示 关键字参数, 无顺序要求, 以 key=value 的形式传递, 并以字典的形式导入。 位置参数 必须放在 关键字参数 的前面。 """
        pass

实例：

def fun1(a, b, *tup):
        # tup 是一个元组
        print(tup)
    
    
    def fun2(a, b, **dt):
        # dt 是一个字典
        print(dt)
    
    
    def fun3(*tup, **dt):
        # 通用函数 tup 是一个元组, dt 是一个字典
        print(tup)
        print(dt)
    
    
    fun1(2, 3, "Hello", 25, True)                   # 输出 ('Hello', 25, True)
    fun2(2, 3, name="World", age=25)                # 输出 {'name': 'World', 'age': 25}
    fun3(10, True, "Hello", name="World", age=25)   # 输出 (10, True, 'Hello')
                                                    # {'name': 'World', 'age': 25}

# 7. 变量作用域 #

Python 中的作用域可分为 4 种：

*  L（Local）局部作用域
 *  E（Enclosing）闭包函数外的函数中
 *  G（Global）全局作用域
 *  B（Built-in）内置变量作用域（内置函数所在模块的范围内）

代码中需要引用变量时，以 L -> E -> G -> B 的顺序查找变量。

g = 0                       # 全局作用域
    print(g)                    # 输出 0
    
    def outer():
        e = 1                   # 局部作用域（闭包函数外的函数中）
        print(g, e)             # 输出 0 1
        def inner():
            l = 2               # 局部作用域
            print(g, e, l)      # 输出 0 1 2

# 8. 全局变量 与 局部变量 #

Python 中的变量在自己的作用域内才能被访问，如果在新的作用域内变量被重新声明，则改变量将作为新的局部变量，与外部的是不同的两个变量。

a = 0               # 全局变量
    
    def fun():          # 函数代码块引入新的作用域
        # a 在新的作用域内被重新声明为局部变量, 此处的 a 与外部的 a 是两个不同的变量
        a = 1
        print(a)        # 输出 1
    
    
    fun()
    print(a)            # 此处的 a 为全局变量, 输出 0

# 9. global 与 nonlocal 关键字 #

全局变量在新的作用域内被重新赋值时，如果希望作为全局变量继续使用，可以使用`global`关键字声明：

a = 0
    
    def fun():          # 引入新的作用域
        # 使用 global 关键字声明该函数作用域内访问(读和写)的变量 a 是全局变量
        # 即在新作用域内不重新声明变量 a, 继续使用全局作用域中声明的变量 a
        global a
        print(a)        # 输出 0
        a = 1
    
    fun()
    print(a)            # 全局变量 a 的值在 fun() 函数内被改变, 输出 1

如果要修改的变量在闭包函数外的函数中（即作用域嵌套），则可以使用`nonlocal`关键字声明：

def outer():            # 引入新的作用域
        a = 0               # 局部变量（相对于 outer 函数）
        
        def inner():        # 引入新的作用域
            # 使用 nonlocal 关键字声明变量 a 非本地变量, 即在新作用域
            # 内不重新声明变量 a, 继续使用上层函数作用域中的声明的变量 a
            nonlocal a
            a = 1
        
        inner()
        
        print(a)            # a 在 inner() 函数内被改变, 输出 1
    
    
    outer()

# 10. 匿名函数 #

Python 中支持使用 lambada 表达式来创建匿名函数。

匿名函数不需要使用 def 关键字声明，只是一个 lambda 表达式。lambada 的主体是一个表达式，而不是一个代码块，封装的逻辑有限。

语法格式：

lambda [arg1, [, arg2, ...]]: 表达式

实例：

sum = lambda a, b: a + b
    
    print(sum(2, 3))    # 输出 5

# 11. 内置函数 #

Python 官网内置函数列表: [https://docs.python.org/zh-cn/3/library/functions.html][https_docs.python.org_zh-cn_3_library_functions.html]

下面列出的内置函数可以在代码中直接调用：

#
    # 数学函数
    #
    abs(x)              # 返回数字的绝对值
    min(*args)          # 返回序列中元素的最小值
    max(*args)          # 返回序列中元素的最大值
    sum(seq[, start])   # 对序列进行求和
    round(x, n=0)       # 对数字 x 四舍五入保留 n 为小数, 默认n=0表示取整
    pow(x, y[, z])      # 计算 x 的 y 次方, 如果 z 存在, 则结果为 pow(x, y) % z
    divmod(x, y)        # 返回 x 除以 y 的 商和余数组成的元祖, 即: (x//y, x%y)
    
    
    #
    # 类型函数
    #
    int(...)            # 创建 整数 对象
    float(...)          # 创建 浮点 对象
    complex(...)        # 创建 复数 对象
    bool(...)           # 创建 布尔 对象
    str(...)            # 创建 字符串 对象
    tuple(...)          # 创建 元祖 对象
    set(...)            # 创建 集合 对象
    list(...)           # 创建 列表 对象
    dict(...)           # 创建 字典 对象
    
    
    #
    # 进制转换
    #
    bin(i)          # 把整数转换为二进制字符串
    oct(i)          # 把整数转换为八进制字符串
    hex(i)          # 把整数转换为十六进制字符串
    
    
    #
    # 字符 与 Unicode 之间的转换
    #
    chr(i)          # Unicode整数值 对应的 字符
    ord(c)          # 字符 转换为 Unicode整数值
    ascii(obj)      # 返回对象的 ASCII 字符串形式, 把非 ASCII 字符使用 \u 编码
    
    
    #
    # 序列操作
    #
    len(seq)                                    # 计算序列的长度
    range(start, stop[, step])                  # 返回一个可迭代对象（一般用于 for 循环）
    
    sorted(iterable, key=None, reverse=False)   # 排序可迭代对象, 返回排序后新的列表
    reversed(iterable)                          # 反转可迭代对象, 返回迭代顺序反转后的一个迭代器
    slice(start, stop[, step])                  # 返回一个切片对象, 用于截取序列, 
                                                # 例如: listobj[slice(start, stop[, step])]
    
    all(iterable)               # 判断可迭代对象的所有元素是否都为 True, 除了 0, "", None, False 外, 其他都算 True
    any(iterable)               # 判断可迭代对象的所有元素是否都为 False, 除了 0, "", None, False 外, 其他都算 True
    filter(function, iterable)  # 根据判断函数过滤序列, 返回一个被过滤后的新的可迭代对象
    enumerate(seq, [start=0])   # 将序列元素的索引和数据组合为一个元素, 返回可迭代对象, 一般用于 for 循环,
                                # 例如 list(enumerate(seq, n)) 返回 [(start, seq[0], (start+1, seq[1]), ...)]
    
    frozenset([iterable])       # 返回一个冻结的集合（不能添加和修改元素）
    map(function, iterable)     # 根据提供的函数(有1个参数用于接收序列元素)对可迭代对象做映射,
                                # 把序列的元素作为参数逐一调用函数, 函数的所有返回值组成新的可迭代序列返回。
    zip([iterable, ...])        # 打包多个序列的元素, 把索引相同的元素组成元祖, 返回以元祖作为元素的迭代器,
                                # 例如: a=[1, 2]; b=[3, 4]; list(zip(a, b)) 的结果为 [(1, 3), (2, 4)]
    
    
    #
    # 字节序列函数
    #
    bytearray([source[, encoding[, errors]]])   # 返回一个元素可变的字节数组
    bytes([source[, encoding[, errors]]])       # 返回一个元素不可变的字节数组
    
    
    #
    # 对象/类型操作
    #
    setattr(obj, name, value)           # 设置对象属性的值
    getattr(obj, name[, default])       # 获取对象属性的值
    hasattr(obj, name)                  # 判断对象是否有指定的属性
    delattr(obj, name)                  # 删除对象的指定属性
    
    iter(obj)                           # 生成迭代器
    next(iterable[, default])           # 返回迭代器的下一个值, 没有更多则返回 default, 
                                        # 如果没传 default 将抛出 StopIteration 异常
    
    id(obj)                             # 返回对象的内存地址
    hash(obj)                           # 获取对象的哈希值
    type(obj)                           # 返回对象的类型
    isinstance(obj, class)              # 判断对象是否是指定的类型
    issubclass(sub_class, super_class)  # 判断 sub_class 是否为 super_class 的子类
    
    super()                             # 方法被重写后, 调用父类的方法, 例如: super().method()
    object()                            # object 是所有类的超类
    
    @classmethod    # 放在类方法声明处, 声明该方法为类的方法（第1个参数cls为类本身）, 可以直接 类名.方法名() 调用
    @staticmethod   # 放在类方法声明处, 声明该方法为类的静态方法（可以无参数）, 可以直接 类名.方法名() 调用
    
    
    #
    # 控制台输入与输出
    #
    input([prompt)      # 等待用户输入, 从控制台读取用户输入的一行
    print(*objs, sep=' ', end='\n', file=sys.stdout)    # 输出内容到控制台
    
    
    #
    # 动态执行表达式/代码（把字符串解析为 Python 代码）
    #
    eval(expression[, globals[, locals]])   # expression 为字符串, 返回表达式结果
    exec(object[, globals[, locals]])       # object 为字符串或 code 对象, 无返回
    
    compile(source, filename, mode[, flags[, dont_inherit]])    # 动态把字符串/源码文件编译为字节码对象 code, 
                                                                # 然后使用 exec(code) 执行
    
    
    #
    # 帮助相关
    #
    help([obj])     # 查看对象的帮助文档, 如果对象是类名, 将列出类API文档,
                    # 如果不传参数, 则进入 help 的交互式模式
    
    dir([obj])      # 返回 对象/类型 的属性、方法列表, 如果对象有 __dir__() 方法, 则调用该方法,
                    # 如果对象不包含 __dir__() 方法, 则最大限度手机参数的信息;
                    # 如果不传参数, 则返回 当前范围内 的 变量、方法 和 定义的类型 组成的列表。 
    
    vars(obj)       # 返回对象的 属性:属性值 组成的字典
    
    globals()       # 以 属性:属性值 组成的字典类型返回当前位置的所有 全局变量
    locals()        # 以 属性:属性值 组成的字典类型返回当前位置的所有 局部变量
    
    callable(obj)   # 判断对象是否可调用, 如果返回 True, obj 仍然可能调用失败, 但如果返回 False, obj 绝对不能调用,
                    # 如果 obj 是函数、方法、lambda 函式、 类以及实现了 __call__() 方法的类实例, 它都返回 True。
    
    
    #
    # 其他
    #
    open(file, mode='r')                        # 打开文件
    memoryview(obj)                             # 返回对象的内存查看器, 结果可切片访问内存中的内容
    repr(obj)                                   # 把对象转化为供解释器读取的字符串形式
    property([fget[, fset[, fdel[, doc]]]])     # 在新式类中返回属性值
    
    __import__(name)                            # 动态加载类和函数, 
                                                # 列如 __import__('aa') 表示动态加载 aa.py 模块

[https_blog.csdn.net_xietansheng_article_details_115557381]: https://blog.csdn.net/xietansheng/article/details/115557381
[Python3]: https://blog.csdn.net/xietansheng/article/details/109266600
[fun-doc.png]: /images/20210920/1316568676554c32b30ecb539fe55f7e.png
[https_docs.python.org_zh-cn_3_library_functions.html]: https://docs.python.org/zh-cn/3/library/functions.html