目录

一：定义函数

二：函数参数

函数定义详解：函数参数

默认值参数

关键字参数 

可变长度参数 *name 和 **name

使用特殊参数 * 和 / 限制函数传参数方式

函数注解

文档字符串

三：递归调用函数

四：Lambda 表达式

五：Python 全局变量和局部变量

全局变量

global 关键词

局部变量

一：定义函数

        函数是一个功能模块的封装，函数可以让写好的功能模块可以更容易重复使用。

        示例：

# 使用 def 关键词定义函数
def get_name_and_age():
    """获取姓名和年龄并输出"""
    name = input("姓名：")
    age = input("年龄：")
    print(f"姓名：{name}，年龄{age}")


# 调用函数
get_name_and_age()

        定义 函数使用关键字 def，后跟函数名与括号内的形参列表。函数语句从下一行开始，并且必须缩进。

        函数内的第一条语句是字符串时，该字符串就是文档字符串 （docstring），

二：函数参数

函数定义详解：函数参数

        参数是使用者提供给函数的数据值，值可以是多种类型。

        示例：

# 定义一个函数计算指定数字自身的乘方
def my_pow(n: int):
    calc = 1
    for _ in range(n):
        calc *= n 
    
    return calc


print(my_pow(3)) # 输出27
print(my_pow(5)) # 输出3125

        函数的返回值

        Python 使用 return 关键词返回数据供给调用后的逻辑使用，返回值可以多种类型，甚至是一个函数（function）或者类（class）。

        形参和实参数

        函数定义时的参数称为 “形参”，调用是传入的实际参数称为 “实参”

默认值参数

        为参数指定默认值是非常有用的方式。调用函数时，可以使用比定义时更少的参数，例如：        （有默认值的参数成为可选参数，没有默认值的参数称为必选参数）    

# 声明一个函数，并为性别设置默认值
def input_you_info(name: str, age: int, sex: str = "男"):
    return (
        f"name: {name}\n"
        f"age: {age} 岁\n"
        f"sex: {sex} 性"
    )

# 省略性别调用函数
print(input_you_info("小明", 18))
"""
输出：
name: 小明
age: 18 岁
sex: 男 性
"""

        （警告：默认值只初始化一次。当默认值是列表、字典、Class实例等可变对象时，会产生与预期不同的结果。）

        示例，下面定义的的函数会累积每次调用时传递的参数：

def f(a, L=[]):
    L.append(a)
    return L

print(f(1))
# 输出 [1]
print(f(2))
# 输出 [1, 2]
print(f(3))
# 输出 [1, 2, 3]

        不想在每次调用之间共享默认值时，应该使用如下方式编写函数：

def f(a, L = None):
    if L is None:
        L = []
    L.append(a)
    return L


r = f(1)
print(r)  # 输出 [1]
r = f(2, r)
print(r)  # 输出 [1, 2]
r = f(3, r)
print(r)  # 输出 [1, 2, 3]

r = f(1)
print(r)  # 输出 [1]

关键字参数 

        Python 还支持 name=value 的形式穿参数调用函数。好处是可以函数定义的参数顺序当使用

      （关键字参数时，所有的参数都必须 name=value 的方式传入，否则会收到 “SyntaxError: positional argument follows keyword argument” 的错误）

        示例：

def input_you_info(name: str, age: int, sex: str = "男"):
    return (
        f"name: {name}\n"
        f"age: {age} 岁\n"
        f"sex: {sex} 性"
    )


print(input_you_info(sex="女", age=20, name="小红"))

"""
输出：
name: 小红
age: 20 岁
sex: 女 性
"""

可变长度参数 *name 和 **name

   *name参数， *name需要声明在参数列表的最后位置。

def variable_length(name: str, *features: list[str]):
    print(name, "的特长是：")
    for f in features:
        print(f)

variable_length("小明", "跑步", "潜水", "画画")
"""
输出：
小明 的特长是：
跑步
潜水
画画
"""

        当最后一个形参为 **name 形式时，函数可以接受一个字典形式的参数（详见 映射类型 — dict），该字典包含与函数中已定义形参对应之外的所有关键字参数。

   **name 需要放在形参列表的的最后位置（*name 之后）

        示例：

def variable_length_and_dict(name: str, *features: list[str], **grades):
    print(name, "的特长是：")
    for f in features:
        if grades.get(f) is not None:
            print(f"{f}: {grades[f]}")


# variable_length_and_dict("小明", "跑步", "潜水", "画画", 跑步=80, 潜水=100, 画画=60)

"""
输出：
小明 的特长是：
跑步: 80
潜水: 100
画画: 60
"""

使用特殊参数 * 和 / 限制函数传参数方式

        示例：

def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
      -----------    ----------     ----------
        |             |                  |
        |        允许位置和关键词参数   |
        |                                - 仅限关键词参数
         -- 仅限使用位置传参

        / 和 * 是可选的。这些符号表明形参如何把参数值传递给函数：位置、位置或关键字、关键字。关键字形参也叫作命名形参。

位置或关键字参数

        函数定义中未使用 / 和 * 时，参数可以按位置或关键字传递给函数。

仅位置参数

        此处再介绍一些细节，特定形参可以标记为 仅限位置。仅限位置 时，形参的顺序很重要，且这些形参不能用关键字传递。仅限位置形参应放在 / （正斜杠）前。/ 用于在逻辑上分割仅限位置形参与其它形参。如果函数定义中没有 /，则表示没有仅限位置形参。

   / 后可以是 位置或关键字 或 仅限关键字 形参。

仅限关键字参数

        把形参标记为 仅限关键字，表明必须以关键字参数形式传递该形参，应在参数列表中第一个 仅限关键字 形参前添加 *。

        示例：

def standard_arg(arg):
    """对调用方式没有任何限制，可以按位置也可以按关键字传递参数"""
    print(arg)

def pos_only_arg(arg, /):
    """函数定义中有 /，仅限使用位置形参"""
    print(arg)

def kwd_only_arg(*, arg):
    """函数定义通过 * 表明仅限关键字参数"""
    print(arg)

def combined_example(pos_only, /, standard, *, kwd_only):
    """在同一个函数定义中，使用了全部三种调用惯例"""
    print(pos_only, standard, kwd_only)

函数注解

        函数注解 是可选的用户自定义函数类型的元数据完整信息。

        标注 以字典的形式存放在函数的 annotations 属性中，并且不会影响函数的任何其他部分。 形参标注的定义方式是在形参名后加冒号，后面跟一个表达式，该表达式会被求值为标注的值。 返回值标注的定义方式是加组合符号 ->，后面跟一个表达式，该标注位于形参列表和表示 def 语句结束的冒号之间。 下面的示例有一个必须的参数，一个可选的关键字参数以及返回值都带有相应的标注:

# 标注函数
def f(ham: str, eggs: str = 'eggs') -> str:
    return ham + ' and ' + eggs


print("Annotations:", f.__annotations__)
# 输出 Annotations: {'ham': , 'eggs': , 'return': }

        Python 语言中的标注并没有强制效果

        良好的编码习惯应该添加必要的标注         

文档字符串

        以下是文档字符串内容和格式的约定，同样适用于 Class。

        第一行应为对象用途的简短摘要。为保持简洁，不要在这里显式说明对象名或类型，因为可通过其他方式获取这些信息（除非该名称碰巧是描述函数操作的动词）。这一行应以大写字母开头，以句点结尾。

        文档字符串为多行时，第二行应为空白行，在视觉上将摘要与其余描述分开。后面的行可包含若干段落，描述对象的调用约定、副作用等。

        Python 解析器不会删除 Python 中多行字符串字面值的缩进，因此，文档处理工具应在必要时删除缩进。这项操作遵循以下约定：文档字符串第一行 之后 的第一个非空行决定了整个文档字符串的缩进量（第一行通常与字符串开头的引号相邻，其缩进在字符串中并不明显，因此，不能用第一行的缩进），然后，删除字符串中所有行开头处与此缩进“等价”的空白符。不能有比此缩进更少的行，但如果出现了缩进更少的行，应删除这些行的所有前导空白符。转化制表符后（通常为 8 个空格），应测试空白符的等效性。

        多行文档字符串的一个例子：

def my_function():
    """Do nothing, but document it.

    No, really, it doesn't do anything.
    """
    pass

print(my_function.__doc__)

三：递归调用函数

在函数内部调用自身 称为递归调用。

        （递归调用一定设置结束（不再继续调用）条件否则会收到 RecursionError 错误）

        示例:

counter = 0


def foo():
    global counter
    counter += 1
    print(counter)
    # 当 counter 小于 10时，继续调用 foo()
    if counter < 10:
        foo()

foo()

# 输出 1-10

        获取递归调用次数限制

import sys

print(sys.getrecursionlimit())
# 打印递归调用次数限制

四：Lambda 表达式

  lambda 关键字用于创建小巧的匿名函数。lambda a, b: a+b 函数返回两个参数的和。Lambda 函数可用于任何需要函数对象的地方。在语法上，匿名函数只能是单个表达式。在语义上，它只是常规函数定义的语法糖。与嵌套函数定义一样，lambda 函数可以引用包含作用域中的变量：

def make_incrementor(n):
    return lambda x: x + n


f = make_incrementor(42)
print(f(0))
# 42
print(f(1))
# 43

        上例用 lambda 表达式返回函数。还可以把匿名函数用作传递的实参：

pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
pairs.sort(key=lambda pair: pair[1])
print(pairs)
# [(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

五：Python 全局变量和局部变量

全局变量

函数内部只作引用的 Python 变量隐式视为全局变量。如果在函数内部任何位置为变量赋值，则除非明确声明为全局变量，否则均将其视为局部变量。

（已分配的变量要求加上 global 可以防止意外的副作用发生。另一方面，如果所有全局引用都要加上 global ，那处处都得用上 global 了。那么每次对内置函数或导入模块中的组件进行引用时，都得声明为全局变量。这种杂乱会破坏 global 声明用于警示副作用的有效性。）

        示例：

        （在foo函数中，x只被引用，变量隐式视为全局变量）

x = 10
def foo():
    print(x)

foo()
# 输出 10

        在函数内部任何位置为变量赋值，则除非明确声明为全局变量，否则均将其视为局部变量。

x = 10
def foo():
    x += 1 # 对 x 重新赋值，x 被视为局部变量
    print(x)


foo()
# 发生错误： UnboundLocalError: local variable 'x' referenced before assignment

global 关键词

        使用 global 关键词，显式的将变量声明为全局变量。

x = 10
def foobar():
    global x
    # 使用
    x += 1
    print(x)


foobar()
# 输出 11

局部变量

        在函数内 (适用于类的方法) 声明的变量是局部变量，在外部无法使用

def local_foo():
    local_variable = 10


print(local_variable)
# 如果使用在外部使用函数内声明的变量，会提示：NameError: name 'local_variable' is not defined