python基础之---函数

阅读量：797 次

发布时间：2023-03-07

本文共 5014 字，大约阅读时间需要 16 分钟。

Python基础之—函数

函数是Python编程中的核心概念之一，它允许我们将代码封装起来，便于重复使用和调用。以下将从函数的基本用法、定义、调用、可变与不可变参数、匿名函数、内置函数、高阶函数、变量作用域等方面进行详细讲解。

一、基本用法

1. 概念

函数是可以重复执行的语句块，可以通过调用它来多次执行其内部的操作。它是面向过程编程的最小单位，通过将代码封装，提高了代码的可维护性和重用性。

2. 作用

封装：将一段代码独立成一个功能模块，便于管理和维护。

抽象：用户无需关心实现细节，只需知道结果。

代码的复用：多个地方需要同样的功能时，可以通过调用函数实现。

二、函数的定义

1. 基本语法

使用def语句定义一个函数。函数定义的基本格式如下：

def 函数名(参数名1, 参数名2, ...):
    # 函数体，执行功能逻辑
    return 返回值

例如：

def kn1():
    print("kn1")
kn1()  # 执行函数内部的代码

运行结果：

kn1

2. 参数与返回值

位置传参：按定义顺序传递参数。

返回值：使用return语句返回函数执行的结果。

例如：

def kn2(a, b):
    print(a + b)
kn2(1, 2)  # 传递两个参数

运行结果：

如果函数需要返回多个值，可以使用逗号分隔：

def kn3(a, b):
    return a + b
re = kn3(1, 2)
print(re)  # 输出：3

三、函数的调用

1. 基本用法

函数调用是通过函数名后面跟上小括号()实现的。例如：

kn1()  # 调用函数kn1，输出结果

函数调用可以参与表达式运算：

re = kn3(1, 2)  # 调用函数kn3，返回结果
print(re)  # 输出：3

2. 传参方式

位置传参

参数按定义顺序传递给函数。

def fn1(x1, x2):
    print("x1", x1)
    print("x2", x2)
fn1(1, 2)  # x1=1, x2=2

运行结果：

x1 1
x2 2

关键字传参

通过指定参数名称来传值，无需按顺序。

def fn3(x1, x2):
    print(x1, x2)
fn3(x2=1, x1=2)  # 可以不按顺序传入参数

运行结果：

2 1

参数默认值

函数定义时为某些参数指定默认值，默认值必须位于无默认值参数的后面。

def fn(a, b=1):
    print(a, b)
fn(1)  # 调用时只传a，b使用默认值1
fn(1, 2)  # 传两个参数

运行结果：

1 1
1 2

可变位置参数

使用*args接收任意数量的位置参数。

def fn(a, b, *args):
    print(a, b, args)
    for i in args:
        print(i)
fn(10, 20, 30, 41, 25, 52)  # 传递多个参数

运行结果：

10 20 (30, 41, 25, 52)
30
41
25
52

可变关键词参数

使用**kwargs接收任意数量的关键词参数。

def fn(a, b, **arges):
    print(a, b, arges)
    for i in arges:
        print(i)
fn(1, 2, name='张三', age=18)

运行结果：

1 2 {'name': '张三', 'age': 18}
张三
年龄

*参数

*本身不是一个参数，而是一个特殊用法，可以用于占位符或特殊语法。

def fn(a, b, *, c):
    print(a, b, c)
fn(1, 2, c=30)  # c是关键字参数

运行结果：

1 2 30

四、可变和不可变参数

1. 不可变类型

int, float, str, tuple, frozenset 等不可变类型。

传递时会进行值复制，函数内部修改不会影响原值。

示例：

def fn(a):
    a = 20
x = [1, 2, 3, 4, 5]
fn(x)  # x在函数外部仍保持原值
print(x)  # 输出：[1, 2, 3, 4, 5]

2. 可变类型

list, dict, set 等可变类型。

传递时会传递引用，函数内部修改会影响原值。

示例：

def fn2(arr):
    arr[0] = 20
x = [1, 2, 3, 4, 5]
fn2(x)  # x在函数外部也被修改
print(x)  # 输出：[20, 2, 3, 4, 5]

3. 操作可变数据

列表：使用lst.copy()或切片lst[:]创建副本。

字典：使用dict.copy()或copy.deepcopy()进行深拷贝。

元组：直接创建新元组即可。

示例：

def fn3(arr):
    arr = arr.copy()
    arr[0] = 100
x = [10, 20, 30]
fn3(x)
print(x)  # 输出：[20, 20, 30]

五、匿名函数

匿名函数（lambda）没有名字，通常用于需要临时的函数场景。语法格式为：

lambda arguments: expression

示例：

fn = lambda x, y: x + y
print(fn(10, 20))  # 输出：30

优点

结构简单：适合短小的函数逻辑。

匿名性：只在一个地方使用，不需要被重复调用。

功能限制：只能包含一个表达式，无法包含多行语句。

六、内置函数

1. `all()` 和 `any()`

all()：如果可迭代对象中的所有元素都为True，返回True，否则返回False。

any()：如果可迭代对象中的任意元素为True，返回True，否则返回False。

示例：

x = [10, 20, 30, 0]
re = all(x)  # 输出：False
re = any(x)  # 输出：True

2. `sum()` 和 `sorted()`

sum()：返回可迭代对象中所有元素的总和。

sorted()：返回一个新列表，按升序排列元素。

示例：

x = [10, 20, 30, 0]
sorted_x = sorted(x)  # 输出：[0, 10, 20, 30]
sum_x = sum(x)  # 输出：60
print(sum_x / len(x))  # 输出：15.0

3. `reversed()` 和 `zip()`

reversed()：返回一个反向迭代器。

zip()：将多个可迭代对象打包成一个元组。

示例：

x = [10, 22, 65, 54]
re = reversed(x)
print(list(re))  # 输出：[54, 65, 22, 10]
y = [10, 20, 30, 40]
zip_xy = zip(x, y)
print(list(zip_xy))  # 输出：[(10, 10), (22, 20), (65, 30), (54, 40)]

4. `globals()` 和 `locals()`

globals()：返回当前模块的全局符号表。

locals()：返回当前函数的局部符号表。

示例：

x = 100
y = 200
def fn():
    x = 300
    y = 400
    print(globals())  # 输出：{'x': 100, 'y': 200}
    print(locals())  # 输出：{'x': 300, 'y': 400}
fn()

5. `filter()` 和 `map()`

filter()：从可迭代对象中筛选出满足条件的元素。

map()：将函数应用到可迭代对象的每个元素，返回结果的迭代器。

示例：

x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
filtered = filter(lambda x: x % 2 == 0, x)
print(list(filtered))  # 输出：[2, 4, 6, 8, 10]
mapped = map(lambda x: x ** 2, x)
print(list(mapped))  # 输出：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

6. `reduce()` 和 `copy()` 等工具函数

reduce()：将函数累积地应用到可迭代对象的元素上。

copy()：用于复制对象，避免副作用。

示例：

from functools import reduce
x = [1, 2, 3, 3, 4]
def fn(a, b):
    return a + b
re = reduce(fn, x)  # 输出：13

七、变量作用域

1. 作用域的定义

Python的作用域遵循LEGB规则（Local > Enclosing > Global > Built-in），即在函数内部先寻找变量，接着是外层函数，最后是全局变量和内建函数。

2. 作用域的操作

取值：在当前作用域中寻找，如果找不到则向外层作用域查询。

赋值：在当前作用域中创建变量，如果变量不存在则赋值。

示例：

a = 10
def fn():
    a = 20
    print(a)  # 输出：20
    print(globals())  # 输出：{'a': 10}
fn()

3. 全局变量

使用global关键字声明全局变量。

a = 10
def fn():
    global a
    print(a)  # 输出：10
    a = 20
fn()

4. 局部变量

函数内部定义的变量属于局部作用域。

def fn():
    a = 10
    print(a)  # 输出：10
fn()

八、递归函数

递归函数通过调用自身来解决问题。以下是递归函数的关键点：

递归终止条件：函数调用自身时必须有终止条件，否则会导致无限递归。

参数传递：递归函数通常需要额外的参数来记录递归深度和状态。

示例：

def fm():
    print("fm被调用了")
def fn(a):
    if a >= 5:
        return 5
    else:
        return fn(a + 1)
a = 1
re = fn(a)
print(re)  # 输出：5

九、递归函数的伪代码分析

伪代码分析是理解递归函数工作机制的有效方法。以下是fm2(a)函数的递归伪代码分析：

{
    fn2(a):
        if a <= 1:
            return 1
        else:
            return a * fn2(a - 1)
}

伪代码执行过程：

{
    fn2(5):
        if 5 <= 1？ 否
        返回 5 * fn2(4)
}
{
    fn2(4):
        if 4 <= 1？ 否
        返回 4 * fn2(3)
}
{
    fn2(3):
        if 3 <= 1？ 否
        返回 3 * fn2(2)
}
{
    fn2(2):
        if 2 <= 1？ 否
        返回 2 * fn2(1)
}
{
    fn2(1):
        if 1 <= 1？ 是
        返回 1
}
{
    fn2(2) → 2 * 1 = 2
}
{
    fn2(3) → 3 * 2 = 6
}
{
    fn2(4) → 4 * 6 = 24
}
{
    fn2(5) → 5 * 24 = 120
}