有时可能需要定义一个可以接受可变数量参数的函数。可以使用 *args 和 **kwargs 来实现。

*args: 非关键字可变长度参数**kwargs: 关键字可变长度参数

def greet(*names):

"""该函数用于向 names 元组中的所有人打招呼"""

for name in names:

print("你好, " + name)

greet("Alice", "Bob", "Charlie")

2. Python 内置函数

Python 提供了许多内置函数，你可以直接使用。以下是一些最常用的内置函数：

2.1 字符串处理函数

len(): 返回字符串的长度。str(): 将对象转换为字符串。format(): 格式化字符串。

示例：

s = "你好, 世界!"

print(len(s)) # 输出: 9

print(str(123)) # 输出: '123'

print("我今年 {} 岁".format(25)) # 输出: 我今年 25 岁

2.2 数学函数

abs(): 返回一个数的绝对值。min(): 返回所有输入值中的最小值。max(): 返回所有输入值中的最大值。

示例：

print(abs(-5)) # 输出: 5

print(min(1, 2, 3)) # 输出: 1

print(max(1, 2, 3)) # 输出: 3

2.3 类型转换函数

int(): 将值转换为整数。float(): 将值转换为浮点数。bool(): 将值转换为布尔值。list(): 将序列转换为列表。

示例：

print(int('10')) # 输出: 10

print(float('10.5')) # 输出: 10.5

print(bool(0)) # 输出: False

print(list("abc")) # 输出: ['a', 'b', 'c']

2.4 输入和输出函数

input(): 从用户读取一行输入。print(): 将指定消息输出到控制台。

示例：

name = input("请输入你的名字: ")

print("你好, " + name)

2.5 文件处理函数

open(): 打开一个文件并返回文件对象。read(): 读取文件内容。write(): 向文件写入内容。close(): 关闭文件。

示例：

f = open("test.txt", "w")

f.write("你好, 世界!")

f.close()

f = open("test.txt", "r")

print(f.read())

f.close()

这一部分在之后文件操作会详细讲解

3. 匿名函数（Lambda 函数）

在 Python 中，可以使用 lambda 关键字创建小型匿名函数。Lambda 函数通常用于需要一个简单函数的场景，特别是在高阶函数中使用。

3.1 什么是 Lambda 函数？

Lambda 函数是没有名字的函数。它的定义比较简单，通常只用于简单的表达式中。其语法为：

lambda 参数1, 参数2, ... : 表达式

示例：

# 一个简单的 lambda 函数

add = lambda x, y: x + y

print(add(5, 3)) # 输出: 8

在上面的例子中，lambda x, y: x + y 定义了一个匿名函数，并将其赋值给 add 变量。之后，add(5, 3) 调用了这个 lambda 函数，返回结果 8。

3.2 Lambda 函数的应用

Lambda 函数通常用于需要短小函数的场景，如排序、过滤等。

# 使用 lambda 函数对列表进行排序

points = [(1, 2), (3, 4), (5, 0)]

points.sort(key=lambda point: point[1])

print(points) # 输出: [(5, 0), (1, 2), (3, 4)]

在这个例子中，lambda point: point[1] 用于指定排序的键，即每个元组的第二个元素。

4. 高阶函数

高阶函数是指能够接收其他函数作为参数，或者将函数作为返回值的函数。在 Python 中，常见的高阶函数包括 map()、filter() 和 reduce()。

4.1 map() 函数

map() 函数用于将一个函数应用到一个序列（如列表）中的每个元素，并返回一个包含结果的新序列。

# 使用 map() 将每个数字乘以 2

numbers = [1, 2, 3, 4]

doubled = list(map(lambda x: x * 2, numbers))

print(doubled) # 输出: [2, 4, 6, 8]

4.2 filter() 函数

filter() 函数用于过滤序列，保留满足条件的元素。它接收一个函数和一个序列，并返回一个包含函数返回 True 的元素的新序列。

# 使用 filter() 过滤出偶数

numbers = [1, 2, 3, 4, 5, 6]

evens = list(filter(lambda x: x % 2 == 0, numbers))

print(evens) # 输出: [2, 4, 6]

4.3 reduce() 函数

reduce() 函数用于对序列中的元素进行累积。它接收一个函数和一个序列，并返回一个单一的累积结果。需要注意，reduce() 函数在 Python 3 中被移到了 functools 模块中。

from functools import reduce

# 使用 reduce() 计算列表元素的乘积

numbers = [1, 2, 3, 4]

product = reduce(lambda x, y: x * y, numbers)

print(product) # 输出: 24

5. 递归函数

递归是指函数调用自身的编程技巧。递归可以用来解决许多编程问题，如计算阶乘、斐波那契数列等。

5.1 递归的基本概念

递归函数必须具备两个条件：

基本情况：定义一个最简单的情况，当满足这个情况时，函数将停止递归。递归情况：函数调用自身以简化问题的规模。

示例：阶乘

def factorial(n):

if n == 1: # 基本情况

return 1

else:

return n * factorial(n - 1) # 递归调用

print(factorial(5)) # 输出: 120

在这个例子中，factorial() 函数通过递归计算了 5!，即 5 * 4 * 3 * 2 * 1。

5.2 递归与迭代的对比

递归虽然优雅且易于理解，但在 Python 中，递归的深度是有限制的，过深的递归可能导致栈溢出。在某些情况下，递归可以被等效的迭代（如循环）所替代。

# 使用迭代计算阶乘

def factorial_iterative(n):

result = 1

for i in range(2, n + 1):

result *= i

return result

print(factorial_iterative(5)) # 输出: 120

在实际编程中，选择递归还是迭代取决于具体问题和性能需求。

6. 装饰器（Decorators）

装饰器是 Python 中的一种高级功能，它允许你在不修改函数代码的情况下增强或改变函数的行为。装饰器通常用于记录日志、权限验证、性能测试等场景。

6.1 什么是装饰器？

装饰器本质上是一个返回函数的高阶函数。它接收一个函数作为参数，并返回一个新的函数。

6.2 定义和使用装饰器

定义装饰器时，首先创建一个接收函数作为参数的函数。然后在内部定义一个包装函数，最后返回包装函数。

def my_decorator(func):

def wrapper():

print("Something is happening before the function is called.")

func()

print("Something is happening after the function is called.")

return wrapper

@my_decorator

def say_hello():

print("Hello!")

say_hello()

在这个例子中，@my_decorator 是装饰器语法糖，它等效于 say_hello = my_decorator(say_hello)。输出结果为：

Something is happening before the function is called.

Hello!

Something is happening after the function is called.

6.3 带参数的装饰器

装饰器还可以接受参数。这时，需要将装饰器再包装一层，使其成为一个接收参数的函数。

def repeat(n):

def decorator(func):

def wrapper(*args, **kwargs):

for _ in range(n):

func(*args, **kwargs)

return wrapper

return decorator

@repeat(3)

def say_hello():

print("Hello!")

say_hello()

在这个例子中，say_hello() 会被执行三次。

7. 生成器函数（Generator Functions）

生成器是使用 yield 关键字的特殊函数。生成器不返回一个单一值，而是返回一个生成器对象，可以迭代生成多个值。

7.1 什么是生成器？

生成器允许你在函数执行时暂停，并在下一次调用时恢复执行。这使得生成器特别适用于处理大数据流或需要延迟计算的场景。

7.2 定义生成器函数

生成器函数与普通函数的定义类似，只不过使用 yield 而不是 return 返回值。

def countdown(n):

while n > 0:

yield n

n -= 1

for i in countdown(5):

print(i)

输出结果为：

5

4

3

2

1

7.3 生成器的应用场景

生成器常用于以下场景：

处理大数据集：生成器按需生成数据，而不是一次性将所有数据加载到内存中。流式处理：生成器可以逐步生成数据，适合处理需要延迟计算的情况。

def fibonacci():

a, b = 0, 1

while True:

yield a

a, b = b, a + b

gen = fibonacci()

for _ in range(10):

print(next(gen))

输出前十个斐波那契数列：

0

1

1

2

3

5

8

13

21

34

8. 闭包（Closures）

闭包是指函数内部定义的函数，该内部函数可以访问外部函数的变量，即使外部函数已经返回。

8.1 闭包的定义

闭包允许你在函数外部保留对局部变量的访问。这在需要延长局部变量的生命周期时非常有用。

def outer_func(x):

def inner_func(y):

return x + y

return inner_func

add_five = outer_func(5)

print(add_five(10)) # 输出: 15

在这个例子中，inner_func 是一个闭包，它记住了 outer_func 的参数 x。

8.2 闭包的使用场景

闭包常用于以下场景：

封装：闭包可以隐藏数据，只暴露必要的接口。回调函数：闭包可以保存函数状态，在异步回调中非常有用。

def make_counter():

count = 0

def counter():

nonlocal count

count += 1

return count

return counter

counter = make_counter()

print(counter()) # 输出: 1

print(counter()) # 输出: 2

print(counter()) # 输出: 3

在这个例子中，count 变量被 counter 函数所捕获，每次调用 counter() 时，count 变量都会被保留和更新。

9. 异步函数（Asynchronous Functions）

Python 中的异步编程可以通过 async 和 await 关键字实现，使得我们可以编写非阻塞的代码，特别适合 I/O 密集型任务，如网络请求、文件操作等。

9.1 异步函数的基础

异步函数通过 async def 关键字定义，并且可以使用 await 来暂停执行，直到 await 后的操作完成。

import asyncio

async def say_hello():

print("Hello...")

await asyncio.sleep(1)

print("...World!")

# 运行异步函数

asyncio.run(say_hello())

输出：

Hello...

...World!

9.2 使用 await 关键字

await 关键字用于挂起异步函数的执行，等待某个耗时操作完成。

async def fetch_data():

print("Fetching data...")

await asyncio.sleep(2)

print("Data fetched!")

async def main():

await fetch_data()

print("Done!")

asyncio.run(main())

在这个例子中，await asyncio.sleep(2) 模拟了一个耗时操作，如网络请求或文件读取。

9.3 异步编程的应用场景

异步编程在以下场景中特别有用：

I/O 操作：如文件读取、网络请求、数据库查询等。并发任务：异步函数可以并发执行，充分利用 CPU 资源。

async def fetch_data(index):

print(f"Fetching data { index}...")

await asyncio.sleep(2)

print(f"Data { index} fetched!")

async def main():

tasks = [fetch_data(i) for i in range(5)]

await asyncio.gather(*tasks)

print("All data fetched!")

asyncio.run(main())

在这个例子中，asyncio.gather 用于并发执行多个异步任务。

10. 函数进阶知识

10.1 函数注解

Python 支持在函数定义时添加注解，以说明参数和返回值的预期类型。注解本身并不会影响函数行为，但可以用于文档生成或类型检查工具。

def greet(name: str) -> str:

return "Hello, " + name

print(greet("Alice")) # 输出: Hello, Alice

在这个例子中，name: str 表示 name 参数应为字符串类型，-> str 表示函数返回字符串。

10.2 可变参数函数

Python 支持定义可变参数的函数，允许传递任意数量的参数。

*args: 接收多个非关键字参数，作为一个元组传递给函数。**kwargs: 接收多个关键字参数，作为一个字典传递给函数。

10.2.1 *args

*args 用于接收多个非关键字参数。这些参数会被打包成一个元组传递给函数。*args 允许函数接收任意数量的位置参数。

示例代码：

def my_func(*args):

for arg in args:

print(arg)

my_func(1, 2, 3)

# 输出:

# 1

# 2

# 3

10.2.2. **kwargs

**kwargs 用于接收多个关键字参数，这些参数会被打包成一个字典传递给函数。**kwargs 允许函数接收任意数量的关键字参数。

示例代码：

def my_func(**kwargs):

for key, value in kwargs.items():

print(f"{ key} = { value}")

my_func(name="Alice", age=30)code>

# 输出:

# name = Alice

# age = 30

通过使用 *args 和 **kwargs，你可以编写更加灵活的函数，适应多种参数传递方式。

10.3 函数的柯里化