函数与模块

函数的定义与调用

函数的定义

函数是组织代码的基本方式，便于重用和逻辑分离。

# 定义一个函数
def greet(name):
    print(f"Hello, {name}!")

# 调用函数
greet("Alice")  # 输出: Hello, Alice!

函数的参数与返回值

• 参数: 函数可以接受输入参数。
• 返回值: 函数可以通过 return 返回计算结果。

def add(a, b):
    return a + b

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

函数参数

位置参数与关键字参数

• 位置参数: 参数按顺序传递。
• 关键字参数: 可以在调用时指定参数名。

def multiply(a, b=2):  # b 有默认值
    return a * b

# 使用位置参数
print(multiply(5, 3))  # 输出: 15

# 使用关键字参数
print(multiply(b=4, a=3))  # 输出: 12

可变参数

• *args: 接受可变数量的位置参数，返回元组。
• **kwargs: 接受可变数量的关键字参数，返回字典。

def display(*args, **kwargs):
    print(args)  # 输出位置参数
    print(kwargs)  # 输出关键字参数

display(1, 2, 3, name="Alice", age=30)
# 输出: (1, 2, 3)
# 输出: {'name': 'Alice', 'age': 30}

匿名函数（lambda）

匿名函数是简洁的单行函数，通常用于简单的场景。

# 定义一个lambda函数
square = lambda x: x**2
print(square(5))  # 输出: 25

# 用于排序
my_list = [(1, 2), (3, 1), (5, 3)]
my_list.sort(key=lambda x: x[1])
print(my_list)  # 输出: [(3, 1), (1, 2), (5, 3)]

作用域与命名空间

• 局部作用域: 函数内部定义的变量，只在函数内部可见。
• 全局作用域: 函数外部定义的变量，在函数内外都可以访问。

x = 10  # 全局变量

def my_function():
    x = 5  # 局部变量
    print(x)  # 输出: 5

my_function()
print(x)  # 输出: 10

global 和 nonlocal 关键字

• global: 声明全局变量，允许在函数内部修改全局变量。
• nonlocal: 声明一个非局部变量，允许在嵌套函数中修改其父函数中的变量。

# 使用global
x = 10
def modify_global():
    global x
    x = 5

modify_global()
print(x)  # 输出: 5

# 使用nonlocal
def outer_function():
    x = 10
    def inner_function():
        nonlocal x
        x = 5
    inner_function()
    print(x)  # 输出: 5

outer_function()

模块与包

标准库的使用

Python 提供了丰富的标准库，以下是一些常用的标准库示例：

• math: 提供数学函数。

  import math
  print(math.sqrt(16))  # 输出: 4.0

• random: 生成随机数。

  import random
  print(random.randint(1, 10))  # 输出: 1-10之间的随机整数

• os: 提供与操作系统交互的功能。

  import os
  print(os.getcwd())  # 获取当前工作目录

自定义模块与导入

你可以将函数定义在单独的文件中，然后通过 import 导入使用。

1. 创建一个 my_module.py 文件：

   # my_module.py
   def greet(name):
       print(f"Hello, {name}!")

2. 在另一个文件中导入并使用该模块：

   import my_module
   my_module.greet("Alice")  # 输出: Hello, Alice!

你还可以使用 from ... import 导入特定函数：

from my_module import greet
greet("Bob")  # 输出: Hello, Bob!

常用内建函数

Python 提供了许多内建函数，常用于处理数据、转换类型等。以下是几个常用的函数：

• map(): 对可迭代对象的每个元素应用一个函数，并返回一个迭代器。

  numbers = [1, 2, 3, 4]
  squares = map(lambda x: x**2, numbers)
  print(list(squares))  # 输出: [1, 4, 9, 16]

• filter(): 过滤可迭代对象中的元素，返回一个满足条件的元素的迭代器。

  numbers = [1, 2, 3, 4]
  even_numbers = filter(lambda x: x % 2 == 0, numbers)
  print(list(even_numbers))  # 输出: [2, 4]

• reduce(): 对可迭代对象中的元素进行累积计算（需要 functools 模块）。

  from functools import reduce
  numbers = [1, 2, 3, 4]
  product = reduce(lambda x, y: x * y, numbers)
  print(product)  # 输出: 24

列表/字典推导式

列表推导式

简化代码的方式，用于生成列表。

# 生成1到5的平方列表
squares = [x**2 for x in range(1, 6)]
print(squares)  # 输出: [1, 4, 9, 16, 25]

# 带条件的推导式
evens = [x for x in range(10) if x % 2 == 0]
print(evens)  # 输出: [0, 2, 4, 6, 8]

字典推导式

可以简洁地生成字典。

# 生成1到5的平方字典
squares_dict = {x: x**2 for x in range(1, 6)}
print(squares_dict)  # 输出: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}