目录

一、特殊语法

1.1 高阶函数

1.2 函数嵌套

1.3 装饰器

二、常用的模块

2.1 time模块

2.1.1 时间的表示方式

2.1.2 time 的使用方式

2.2 datetime 模块

2.2.1 datetime 模块总览

2.2.2 date 类

2.2.3 time 类

2.2.4 datetime 类

2.2.5 timedelta 类

2.3 random 模块

2.4 目录和文件操作—os,os.path

2.4.1 目录操作

2.4.2 读写操作

2.5 struct 模块

2.5.1 `struct` 模块介绍

2.5.2 `struct` 模块的应用

2.5.3 struct 中的格式化字符串

2.5.4 struct 使用例子

---

一、特殊语法

1.1 高阶函数

        Python确实支持函数式编程，并提供了一些内置的高阶函数，这些函数可以接受其他函数作为参数，从而使代码更加简洁和功能强大。以下是您提到的几个函数及其用法：

### `filter`
        `filter`函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器，其中包含所有符合条件的元素。

# 定义一个函数，用于判断一个数是否为偶数
def is_even(n):
    return n % 2 == 0

# 使用filter函数过滤列表中的偶数
numbers = [1, 2, 3, 4, 5, 6]
even_numbers = filter(is_even, numbers)

# 转换为列表
even_numbers_list = list(even_numbers)
print(even_numbers_list)  # 输出: [2, 4, 6]

### `map`
        `map`函数用于对序列中的每个元素应用一个函数，返回一个包含所有结果的迭代器。

# 定义一个函数，用于计算一个数的平方
def square(n):
    return n * n

# 使用map函数计算列表中每个数的平方
numbers = [1, 2, 3, 4, 5]
squared_numbers = map(square, numbers)

# 转换为列表
squared_numbers_list = list(squared_numbers)
print(squared_numbers_list)  # 输出: [1, 4, 9, 16, 25]

### `reduce`
        `reduce`函数用于对序列中的元素进行累积计算，返回一个单一的值。需要注意的是，`reduce`函数在Python 3中被移到了`functools`模块中。

from functools import reduce

# 定义一个函数，用于计算两个数的乘积
def multiply(x, y):
    return x * y

# 使用reduce函数计算列表中所有数的乘积
numbers = [1, 2, 3, 4, 5]
product = reduce(multiply, numbers)

print(product)  # 输出: 120

        这些函数都是高阶函数，因为它们接受其他函数作为参数。通过使用这些函数，你可以编写更简洁、更功能化的代码，同时减少循环和临时变量的使用。

1.2 函数嵌套

        Python中有一个特殊的语法，虽然不常见，但在某些情况下确实有用，那就是嵌套函数。嵌套函数是指一个函数定义在另一个函数内部。外层函数返回内层函数，即返回的是函数本身。

以下是您提供的代码的修改版本：

def outer(factor):
    def inner(number):
        return number * factor
    return inner

在这个例子中：

1. `outer` 是一个外部函数，它接受一个参数 `factor`。
2. `inner` 是一个内部函数，它定义在 `outer` 内部，并接受一个参数 `number`。
3. `inner` 函数返回 `number` 乘以 `factor` 的结果。
4. `outer` 函数返回 `inner` 函数本身。

        需要注意的是，返回的 `inner` 函数可以访问其定义所在的作用域，即它携带了定义时的环境信息。这种现象被称为闭包。

        闭包允许函数记住并访问其定义时所在的作用域中的变量，即使这个函数在其定义的作用域之外被调用。这是Python中一个强大且灵活的特性，常用于需要函数携带状态信息的场景。

1.3 装饰器

        Python中的装饰器（Decorator）是一种用于修改函数或方法行为的高级功能。装饰器本质上是一个函数，它接受一个函数作为参数，并返回一个新的函数。装饰器通常用于在不修改原函数代码的情况下，添加日志记录、性能计时、权限检查等功能。

装饰器使用`@`符号来应用，语法如下：

@decorator_function
def my_function():
    pass

这等价于：

def my_function():
    pass

my_function = decorator_function(my_function)

以下是一个简单的装饰器示例，用于在函数调用前后打印消息：

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()

输出结果将是：

Something is happening before the function is called.
Hello!
Something is happening after the function is called.

### 带参数的装饰器

        如果需要装饰的函数带有参数，可以在装饰器内部定义的`wrapper`函数中使用`*args`和`**kwargs`来接收任意参数：

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Something is happening before the function is called.")
        result = func(*args, **kwargs)
        print("Something is happening after the function is called.")
        return result
    return wrapper

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

# 调用被装饰的函数
result = add(3, 5)
print(result)  # 输出: 8

### 装饰器本身带参数

        如果装饰器本身需要参数，可以创建一个返回装饰器的函数：

def repeat(num_times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(num_times=3)
def greet(name):
    print(f"Hello, {name}!")

# 调用被装饰的函数
greet("Alice")

输出结果将是：

Hello, Alice!
Hello, Alice!
Hello, Alice!

        装饰器是Python中非常强大和灵活的工具，广泛用于各种场景，如日志记录、性能监控、输入验证等。通过使用装饰器，可以保持代码的整洁和可维护性。

二、常用的模块

2.1 time模块

2.1.1 时间的表示方式

在Python中，时间的表示方式有多种，主要包括以下几种形式：

1. **时间戳**：一个表示从1970年1月1日午夜（UTC）开始经过的秒数的整数。
2. **格式化的时间字符串**：按照特定格式表示时间的字符串，例如"YYYY-MM-DD HH:MM:SS"。
3. **时间元组**：一个包含9个元素的元组，这些元素分别是：
   - 年（例如2023）
   - 月（1到12）
   - 日（1到31）
   - 小时（0到23）
   - 分钟（0到59）
   - 秒（0到59）
   - 一周中的第几天（0到6，0表示周一）
   - 一年中的第几天（1到366）
   - 是否为夏令时（0、1或-1）

        这些表示方式在Python的标准库中都有相应的处理方法，特别是在`time`和`datetime`模块中。通过这些模块，可以方便地进行时间的转换、格式化和计算。

2.1.2 time 的使用方式

        `time`模块中常用函数的整合列表及其功能描述：

1. **`time()`**:
   - **功能**: 获得当前时间戳。
   - **示例**: `current_timestamp = time.time()`

2. **`localtime()`**:
   - **功能**: 将时间戳转换为当前时区的时间元组信息。
   - **示例**: `local_time_tuple = time.localtime(current_timestamp)`

3. **`gmtime()`**:
   - **功能**: 将时间戳转换为标准时区（UTC）的时间元组信息。
   - **示例**: `utc_time_tuple = time.gmtime(current_timestamp)`

4. **`mktime()`**:
   - **功能**: 将时间元组信息转换为时间戳。
   - **示例**: `timestamp = time.mktime(local_time_tuple)`

5. **`sleep()`**:
   - **功能**: 使程序睡眠一段时间（以秒为单位）。
   - **示例**: `time.sleep(5)`  # 睡眠5秒

6. **`clock()`**:
   - **功能**: 在Python 3.8及之前的版本中，第一次调用返回当前时间戳，第二次调用返回距上次的差值。但在Python 3.8之后，`clock()`已被弃用，建议使用`time.perf_counter()`或`time.process_time()`。
   - **示例**: `start_time = time.perf_counter()`

7. **`ctime()`**:
   - **功能**: 将时间戳转换为可读的时间字符串。
   - **示例**: `time_string = time.ctime(current_timestamp)`

8. **`strftime()`**:
   - **功能**: 将时间元组格式化为字符串。
   - **示例**: `formatted_time_string = time.strftime("%Y-%m-%d %H:%M:%S", local_time_tuple)`

9. **`asctime()`**:
   - **功能**: 将时间元组转换为可读的时间字符串。
   - **示例**: `time_string = time.asctime(local_time_tuple)`

10. **`strptime()`**:
    - **功能**: 将时间字符串解析为时间元组。
    - **示例**: `parsed_time_tuple = time.strptime("2023-10-01 12:34:56", "%Y-%m-%d %H:%M:%S")`

        这些函数涵盖了时间戳、时间元组和时间字符串之间的转换，以及程序的睡眠和时间测量等功能。

有几个关键的函数和时间字符串的关系如下：

2.2 datetime 模块

2.2.1 datetime 模块总览

        `datetime`模块确实提供了比`time`模块更高级和更丰富的接口来处理日期和时间。以下是`datetime`模块中主要类的详细说明：

1. **`datetime.date`**:
   - **功能**: 表示一个日期（年、月、日）。
   - **示例**: `d = datetime.date(2023, 10, 1)`

2. **`datetime.time`**:
   - **功能**: 表示一个时间（时、分、秒、微秒），通常与`datetime.datetime`一起使用。
   - **示例**: `t = datetime.time(12, 34, 56)`

3. **`datetime.datetime`**:
   - **功能**: 表示一个具体的日期和时间。
   - **示例**: `dt = datetime.datetime(2023, 10, 1, 12, 34, 56)`

4. **`datetime.timedelta`**:
   - **功能**: 表示两个日期或时间之间的差异。
   - **示例**: `delta = datetime.timedelta(days=5, hours=3)`

5. **`datetime.tzinfo`**:
   - **功能**: 时区信息的抽象基类，通常不直接使用，而是通过子类（如`datetime.timezone`）来实现。
   - **示例**: `tz = datetime.timezone(datetime.timedelta(hours=8))`

        `datetime`模块确实提供了比`time`模块更多的接口和功能，特别是在处理日期和时间的组合、时区、以及日期和时间的运算方面。以下是一些`datetime`模块的常用操作示例：

- **获取当前日期和时间**:

  now = datetime.datetime.now()
  today = datetime.date.today()

- **格式化日期和时间**:

  formatted_date = dt.strftime("%Y-%m-%d %H:%M:%S")

- **解析字符串为日期和时间**:

parsed_date = datetime.datetime.strptime("2023-10-01 12:34:56", "%Y-%m-%d %H:%M:%S")

- **日期和时间的运算**:

  future_date = today + datetime.timedelta(days=7)

- **时区转换**:

  from datetime import datetime, timezone, timedelta
  utc_now = datetime.now(timezone.utc)
  local_now = utc_now.astimezone()

        `datetime`模块是Python中处理日期和时间的首选模块，提供了丰富的方法来处理各种日期和时间操作。

2.2.2 date 类

`        datetime.date`类是Python的`datetime`模块中用于表示日期的类。`date`类中的函数和方法的详细说明：

1. **`today()`**:
   - **功能**: 创建一个表示当前本地日期的`date`对象。
   - **示例**: `today_date = datetime.date.today()`

2. **构造函数**:
   - **功能**: 创建一个`date`对象，提供年、月、日。
   - **示例**: `d = datetime.date(2023, 10, 1)`

3. **`timetuple()`**:
   - **功能**: 返回日期对应的元组信息，类似于`time.localtime()`返回的结构。
   - **示例**: `time_tuple = d.timetuple()`

4. **`gmtime()`**:
   - **功能**: 这个方法在`date`类中并不存在。通常`gmtime()`是`time`模块中的函数，用于将时间戳转换为标准时区（UTC）的时间元组信息。

5. **`weekday()`**:
   - **功能**: 返回这个星期中的第几天，其中星期一为0，星期日为6。
   - **示例**: `day_of_week = d.weekday()`

6. **`isoweekday()`**:
   - **功能**: 返回星期几，其中星期一为1，星期日为7。
   - **示例**: `iso_day_of_week = d.isoweekday()`

7. **`isocalendar()`**:
   - **功能**: 返回一个包含年、周数和星期几的元组。
   - **示例**: `iso_calendar = d.isocalendar()`

8. **`isoformat()`**:
   - **功能**: 返回一个ISO 8601格式的时间字符串，格式为`YYYY-MM-DD`。
   - **示例**: `iso_date_string = d.isoformat()`

9. **`strftime()`**:
   - **功能**: 将日期格式化为字符串，使用指定的格式化字符串。
   - **示例**: `formatted_date_string = d.strftime("%Y-%m-%d")`

        这些方法和函数提供了对日期对象的各种操作和格式化选项。

2.2.3 time 类

        `datetime.time`类是Python的`datetime`模块中用于表示时间的类。`time`类中的函数和方法的详细说明：

1. **构造函数**:
   - **功能**: 创建一个`time`对象，提供时、分、秒和微秒（可选）。
   - **示例**: `t = datetime.time(12, 34, 56)`

2. **`replace()`**:
   - **功能**: 替换时间对象中的时、分、秒和微秒（可选），返回一个新的`time`对象。
   - **示例**: `new_time = t.replace(hour=13, minute=45)`

3. **`isoformat()`**:
   - **功能**: 返回一个ISO 8601格式的时间字符串，格式为`HH:MM:SS.mmmmmm`（如果指定了微秒）。
   - **示例**: `iso_time_string = t.isoformat()`

4. **`strftime()`**:
   - **功能**: 将时间格式化为字符串，使用指定的格式化字符串。
   - **示例**: `formatted_time_string = t.strftime("%H:%M:%S")`

这些方法和函数提供了对时间对象的各种操作和格式化选项。

2.2.4 datetime 类

        `datetime.datetime`类是Python的`datetime`模块中用于表示日期和时间的类。`datetime`类中的方法的详细说明：

1. **`now()`**:
   - **功能**: 创建一个表示当前本地日期和时间的`datetime`对象。
   - **示例**: `now_datetime = datetime.datetime.now()`

2. **`utcnow()`**:
   - **功能**: 创建一个表示当前UTC日期和时间的`datetime`对象。
   - **示例**: `utc_now_datetime = datetime.datetime.utcnow()`

3. **`date()`**:
   - **功能**: 获取`datetime`对象中的日期部分，返回一个`date`对象。
   - **示例**: `date_part = now_datetime.date()`

4. **`time()`**:
   - **功能**: 获取`datetime`对象中的时间部分，返回一个`time`对象。
   - **示例**: `time_part = now_datetime.time()`

5. **`replace()`**:
   - **功能**: 替换`datetime`对象中的年、月、日、时、分、秒和微秒（可选），返回一个新的`datetime`对象。
   - **示例**: `new_datetime = now_datetime.replace(year=2024, month=12)`

        这些方法和函数提供了对日期和时间对象的各种操作和提取选项。

2.2.5 timedelta 类

        `datetime.timedelta`类是Python的`datetime`模块中用于表示时间差的类。它可以用于在日期和时间上进行加减运算。以下是一些示例代码，展示了如何使用`timedelta`类进行时间计算：

from datetime import datetime, timedelta

# 获取当前日期和时间
dt = datetime.now()

# 日期减一天
dt1 = dt + timedelta(days=-1)  # 昨天
dt2 = dt - timedelta(days=1)   # 昨天
dt3 = dt + timedelta(days=1)   # 明天

# 计算时间差
delta_obj = dt3 - dt

# 打印时间差对象的类型和值
print(type(delta_obj), delta_obj)  # <class 'datetime.timedelta'> 1 day, 0:00:00

# 打印时间差的总天数和总秒数
print(delta_obj.days, delta_obj.total_seconds())  # 1 86400.0

        在这个示例中，我们使用了`timedelta`类来计算昨天的日期和明天的日期，并展示了如何计算两个日期之间的时间差。`timedelta`对象的`days`属性表示时间差的天数，`total_seconds()`方法返回时间差的总秒数。

2.3 random 模块

        `random`模块是Python标准库中用于生成伪随机数的模块。以下是您提到的`random`模块中的方法的详细说明：

1. **`random()`**:
   - **功能**: 生成一个范围在[0.0, 1.0)之间的随机浮点数。
   - **示例**: `random_float = random.random()`

2. **`randint(a, b)`**:
   - **功能**: 在一个范围[a, b]中生成一个随机的整数（包括a和b）。
   - **示例**: `random_int = random.randint(1, 10)`

3. **`randrange(start, stop[, step])`**:
   - **功能**: 在一个范围[start, stop)中生成一个随机的整数，可以指定步长。
   - **示例**: `random_int = random.randrange(0, 10, 2)`  # 生成0, 2, 4, 6, 8中的一个随机数

4. **`shuffle(seq)`**:
   - **功能**: 打乱一个序列（列表）中的元素顺序。
   - **示例**:
     ```python
     my_list = [1, 2, 3, 4, 5]
     random.shuffle(my_list)
     print(my_list)
     ```

        这些方法提供了生成随机数和操作序列的丰富功能。

2.4 目录和文件操作—os,os.path

2.4.1 目录操作

        Python的`os`和`os.path`模块，这些模块提供了与操作系统交互的功能，包括文件和目录操作。以下是您提到的函数的详细说明：

1. **`os.listdir(path)`**:
   - **功能**: 返回指定目录下的文件和目录名列表。
   - **示例**: `files_and_dirs = os.listdir('/path/to/directory')`

2. **`os.remove(path)`**:
   - **功能**: 删除一个文件。
   - **示例**: `os.remove('/path/to/file')`

3. **`os.path.isfile(path)`**:
   - **功能**: 判断指定路径是否是一个文件。
   - **示例**: `is_file = os.path.isfile('/path/to/file')`

4. **`os.path.isdir(path)`**:
   - **功能**: 判断指定路径是否是一个目录。
   - **示例**: `is_dir = os.path.isdir('/path/to/directory')`

5. **`os.path.splitext(path)`**:
   - **功能**: 将路径拆分为(root, ext)对，其中ext是文件扩展名。
   - **示例**: `root, ext = os.path.splitext('/path/to/file.txt')`

6. **`os.path.basename(path)`**:
   - **功能**: 获取路径中的文件名部分。
   - **示例**: `base_name = os.path.basename('/path/to/file.txt')`

7. **`os.path.exists(path)`**:
   - **功能**: 检测指定路径是否存在。
   - **示例**: `exists = os.path.exists('/path/to/file_or_directory')`

8. **`os.mkdir(path)`**:
   - **功能**: 创建一个目录。
   - **示例**: `os.mkdir('/path/to/new_directory')`

9. **`os.mknod(path)`**:
   - **功能**: 创建一个空文件。在某些操作系统上可能需要特定的权限。
   - **示例**: `os.mknod('/path/to/new_file')`

10. **`os.stat(path)`**:
    - **功能**: 获取文件的属性信息。
    - **示例**: `file_stats = os.stat('/path/to/file')`

11. **`os.chmod(path, mode)`**:
    - **功能**: 修改文件的权限。
    - **示例**: `os.chmod('/path/to/file', 0o755)`

        这些函数和方法提供了对文件和目录的基本操作，包括创建、删除、检查存在性、获取属性等。

2.4.2 读写操作

        在Python中，读写文件主要通过内置的`open`函数以及文件对象的方法来实现。以下是您提到的函数和方法的详细说明：

1. **`open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)`**:
   - **功能**: 打开文件，返回一个文件对象。
   - **示例**: `file_obj = open('example.txt', 'r')`

2. **`read(size=-1)`**:
   - **功能**: 读取文件内容，可以指定读取的字节数。
   - **示例**: `content = file_obj.read(1024)`

3. **`readline(size=-1)`**:
   - **功能**: 读取文件中的一行内容，可以指定读取的字节数。
   - **示例**: `line = file_obj.readline()`

4. **`readlines(hint=-1)`**:
   - **功能**: 读取文件中的所有行，返回一个列表，可以指定读取的总字节数。
   - **示例**: `lines = file_obj.readlines()`

5. **`write(s)`**:
   - **功能**: 将字符串写入文件。
   - **示例**: `file_obj.write('Hello, World!')`

6. **`writelines(lines)`**:
   - **功能**: 将一个序列（如列表）中的字符串写入文件，不会自动添加换行符。
   - **示例**: `file_obj.writelines(['Line1\n', 'Line2\n'])`

7. **`close()`**:
   - **功能**: 关闭文件对象，释放资源。
   - **示例**: `file_obj.close()`

8. **`tell()`**:
   - **功能**: 返回文件对象的当前位置。
   - **示例**: `position = file_obj.tell()`

9. **`next()`**:
   - **功能**: 返回文件的下一行。在Python 3中，通常使用迭代器来实现类似功能。
   - **示例**: `line = next(file_obj)`

10. **`seek(offset, whence=0)`**:
    - **功能**: 移动文件对象的指针到指定位置。
    - **示例**: `file_obj.seek(0)`  # 移动到文件开头

        这些函数和方法提供了对文件的基本操作，包括打开、读取、写入、关闭和移动文件指针等。

2.5 struct 模块

2.5.1 `struct` 模块介绍

        在 Python 这类高级编程语言中，并不支持像 C 或 C++ 那样直接对内存进行操作。然而，在某些场景下，我们可能需要按照特定的格式来组织 Python 中的内存数据，比如在网络通信中，数据往往需要按照特定的结构进行存储和传输。

以一个网络消息结构为例：

struct NETMSGINFO {
    int MSGTYPE;       // 消息类型
    int nMsgLen;       // 消息大小
    char szMsgBuff[1024]; // 消息内容
};
NETMSGINFO so = {1, 10, "hello world"};

        在 Python 中，我们无法直接创建这样的内存结构，但我们可以利用 `struct` 模块来模拟这种内存布局。`struct` 模块允许我们将 Python 数据打包成二进制数据，或者从二进制数据中解包出 Python 数据，从而实现类似 C 语言中结构体的功能。

        通过 `struct` 模块，我们可以定义一个类似于 `NETMSGINFO` 的结构，并对其进行打包和解包操作，以便在 Python 中处理这种特定格式的数据。

2.5.2 `struct` 模块的应用

        `struct` 模块在 Python 中扮演着桥梁的角色，它使得 Python 能够与 C 语言的结构体数据进行无缝交互。通过这一模块，Python 程序可以轻松地处理由 C/C++ 程序传输过来的数据。该模块提供了两个主要函数：`struct.pack(fmt, v1, v2, ...)` 用于将 Python 数据打包成字节流，而 `struct.unpack(fmt, string)` 则用于将字节流解包回 Python 数据。这两个函数均依赖于格式控制字符串来描述 C 语言结构体的布局并指导数据的转换过程。

以下是 `struct` 模块的基本使用示例：

**打包示例**

>>> from struct import pack
>>> packed_data = pack('hhl', 1, 2, 3)
>>> packed_data
b'\x00\x01\x00\x02\x00\x00\x00\x03'

        在这个例子中，`'hhl'` 是格式控制字符串，它指定了两个短整型（`h`）和一个长整型（`l`）的布局。`pack` 函数根据这个格式将整数 1、2 和 3 打包成字节流。

**解包示例**

>>> from struct import unpack
>>> unpacked_data = unpack('hhl', b'\x00\x01\x00\x02\x00\x00\x00\x03')
>>> unpacked_data
(1, 2, 3)

        在这个例子中，`unpack` 函数根据相同的格式控制字符串 `'hhl'` 将字节流解包回一个包含三个整数的元组。需要注意的是，字节流的长度必须与格式控制字符串所描述的数据长度完全一致。

        通过这些示例，我们可以看到 `struct` 模块如何帮助 Python 程序在处理二进制数据时达到与 C 语言相似的效率和灵活性。

2.5.3 struct 中的格式化字符串

        格式化字符串在 `struct` 模块中扮演着至关重要的角色，它们定义了数据在打包和解包过程中的具体布局。这些字符串由一系列格式字符组成，每个字符对应一种特定的数据类型，并且可以包含额外的控制字符来调整字节顺序、大小和对齐方式。

以下是一些常用的格式字符及其含义：

- `x`：跳过一个字节。
- `c`：一个字节的字符。
- `b`：一个字节的有符号整数。
- `B`：一个字节的无符号整数。
- `?`：布尔值。
- `h`：短整型（通常是两个字节）。
- `H`：无符号短整型。
- `i`：整型（通常是四个字节）。
- `I`：无符号整型。
- `l`：长整型（通常是四个字节）。
- `L`：无符号长整型。
- `q`：长长整型（通常是八个字节）。
- `Q`：无符号长长整型。
- `f`：单精度浮点数。
- `d`：双精度浮点数。
- `s`：字符串（例如 `10s` 表示一个 10 字节的字符串）。
- `p`：Pascal 字符串。
- `P`：指针。

除了这些基本的数据类型字符，格式化字符串还可以包含以下控制字符来影响数据的处理方式：

- `@`：使用本机字节顺序、大小和对齐方式（默认）。
- `=`：使用本机字节顺序，标准大小和对齐方式。
- `<`：小端字节顺序（低位在前）。
- `>`：大端字节顺序（高位在前）。
- `!`：网络字节顺序（大端）。

        例如，格式化字符串 `'<hhl'` 表示使用小端字节顺序，包含两个短整型和一个长整型。这样的设置确保了在不同平台间传输数据时的一致性。

        通过合理地组合这些格式字符和控制字符，开发者可以精确地控制数据的打包和解包过程，从而实现与 C 语言结构体相似的数据处理能力。

2.5.4 struct 使用例子

使用 `struct.pack()` 构建 C 结构体的二进制数据

假设我们有如下的 C 结构体定义：

struct NETMSGINFO {
    int MSGTYPE;       // 消息类型
    int nMsgLen;       // 消息大小
    char szMsgBuff[1024]; // 消息内容
};
struct NETMSGINFO nso = {1, 10, "hello"};

        在 Python 中，我们可以使用 `struct.pack()` 函数来构建这个结构体的二进制数据。以下是具体的实现方法：

import struct

# 使用固定长度的格式字符串
packed_string = struct.pack("ii1024s", 1, 10, b"hello")

# 或者使用动态长度的格式字符串
packed_string = struct.pack("ii%ds" % 1024, 1, 10, b"hello")

        在这段代码中，`"ii1024s"` 是一个格式字符串，其中 `i` 表示整型，`1024s` 表示一个 1024 字节的字符串。注意，字符串参数需要转换为字节类型（`b"hello"`），因为 `struct` 模块处理的是二进制数据。

        使用 `struct.unpack()` 解析 C 结构体的二进制数据

        假设我们已经有了一个打包好的二进制字符串 `packed_string`，我们可以使用 `struct.unpack()` 函数来解析这个字符串，并将其转换回 Python 数据结构。以下是具体的实现方法：

# 使用固定长度的格式字符串
msgtype, nlen, msgbuff = struct.unpack("ii1024s", packed_string)

# 打印解析结果
print(f"MSGTYPE: {msgtype}, nMsgLen: {nlen}, msgbuff: {msgbuff.decode('utf-8').strip('\x00')}")

        在这个例子中，`struct.unpack()` 函数返回一个元组，其中包含了按照格式字符串 `"ii1024s"` 解析出的各个字段。注意，`msgbuff` 是一个包含 1024 字节的字节数组，我们需要使用 `decode('utf-8')` 将其转换为字符串，并使用 `strip('\x00')` 去除末尾的空字符。

        通过这些步骤，我们可以在 Python 中模拟 C 语言结构体的打包和解包过程，从而实现对二进制数据的精确控制。