当前位置：首页 > article >正文

各种数据类型的定义与常规计算

article 2024/10/24 1:58:38

Python 是一种动态类型的编程语言，这意味着在定义变量时，数据类型是隐式确定的，而不是显式声明的。不同的数据类型可以表示不同类型的数据，Python 提供了许多内置的数据类型，用于处理数字、文本、布尔值、容器等。下面详细介绍 Python 中不同数据类型的定义与表达方式。

一、各种数据类型的定义与常规计算

（一）整数（`int`）

定义：整数是没有小数部分的数值，可以是正数、负数或零。Python 支持任意大小的整数。
表达方式：
- 直接输入整数值，如 10、-5、0 等。

示例：

a = 100    # 正整数
b = -50    # 负整数
c = 0      # 零

（二）整数的操作

在 Python 中，int 类型用于表示整数，并且支持多种操作。Python 的整数类型支持任意大小的正整数和负整数，常用的操作包括算术运算、比较运算、位运算等。

以下是 Python 中整数（int）类型的所有常见操作及其示例。

1. 算术运算

Python 支持基本的算术运算，包括加法、减法、乘法、除法、整除、取余和幂运算。

1.1 加法（`+`）

a = 10
b = 5
result = a + b  # 结果是 15
print(result)

1.2 减法（`-`）

a = 10
b = 5
result = a - b  # 结果是 5
print(result)

1.3 乘法（`*`）

a = 10
b = 5
result = a * b  # 结果是 50
print(result)

1.4 除法（`/`）

注意，Python 中的除法运算总是返回浮点数。

a = 10
b = 3
result = a / b  # 结果是 3.3333333333333335
print(result)

1.5 整除（`//`）

整除运算返回商的整数部分（向下取整）。

a = 10
b = 3
result = a // b  # 结果是 3
print(result)

1.6 取余（`%`）

取余运算返回除法的余数。

a = 10
b = 3
result = a % b  # 结果是 1
print(result)

1.7 幂运算（`**`）

计算 a 的 b 次幂。

a = 2
b = 3
result = a ** b  # 结果是 8
print(result)

1.8 绝对值（`abs()`）

返回整数的绝对值。

a = -10
result = abs(a)  # 结果是 10
print(result)

2. 比较运算

整数支持常见的比较运算符，比较的结果是布尔值 True 或 False。

2.1 等于（`==`）

a = 5
b = 5
result = a == b  # 结果是 True
print(result)

2.2 不等于（`!=`）

a = 5
b = 3
result = a != b  # 结果是 True
print(result)

2.3 大于（`>`）

a = 5
b = 3
result = a > b  # 结果是 True
print(result)

2.4 小于（`<`）

a = 5
b = 8
result = a < b  # 结果是 True
print(result)

2.5 大于等于（`>=`）

a = 5
b = 5
result = a >= b  # 结果是 True
print(result)

2.6 小于等于（`<=`）

a = 5
b = 8
result = a <= b  # 结果是 True
print(result)

3. 位运算

位运算是直接对整数的二进制表示进行操作的运算。Python 提供了多种位运算操作符。

3.1 按位与（`&`）

对两个整数进行按位与操作，只有两个数字的二进制位都为 1 时，该位结果为 1，否则为 0。

a = 5  # 二进制: 101
b = 3  # 二进制: 011
result = a & b  # 结果是 1（二进制 001）
print(result)

3.2 按位或（`|`）

对两个整数进行按位或操作，只要两个数字的二进制位有一个为 1，该位结果为 1，否则为 0。

a = 5  # 二进制: 101
b = 3  # 二进制: 011
result = a | b  # 结果是 7（二进制 111）
print(result)

3.3 按位异或（`^`）

对两个整数进行按位异或操作，两个数字的二进制位相同时结果为 0，不同时结果为 1。

a = 5  # 二进制: 101
b = 3  # 二进制: 011
result = a ^ b  # 结果是 6（二进制 110）
print(result)

3.4 按位取反（`~`）

对整数的所有二进制位进行取反操作。

a = 5  # 二进制: 101
result = ~a  # 结果是 -6，二进制为 -1011
print(result)

3.5 左移（`<<`）

将二进制位向左移动，右边用 0 填充，相当于乘以 2 的 n 次方。

a = 5  # 二进制: 101
result = a << 1  # 结果是 10，二进制为 1010
print(result)

3.6 右移（`>>`）

将二进制位向右移动，左边用符号位填充，相当于除以 2 的 n 次方。

a = 5  # 二进制: 101
result = a >> 1  # 结果是 2，二进制为 10
print(result)

4. 内置函数

Python 为 int 类型提供了许多内置函数，帮助进行类型转换和数学运算。

4.1 `int()` 类型转换

将其他类型的值转换为整数。

# 浮点数转整数
result = int(3.99)  # 结果是 3
print(result)

# 字符串转整数
result = int("123")  # 结果是 123
print(result)

4.2 `pow()` 幂运算

计算 a 的 b 次方。

a = 2
b = 3
result = pow(a, b)  # 结果是 8
print(result)

4.3 `divmod()` 同时返回商和余数

a = 10
b = 3
result = divmod(a, b)  # 结果是 (3, 1)，3 是商，1 是余数
print(result)

4.4 `bin()`、`oct()` 和 `hex()` 进制转换

bin()：将整数转换为二进制字符串。
oct()：将整数转换为八进制字符串。
hex()：将整数转换为十六进制字符串。

a = 10

binary = bin(a)  # 结果是 '0b1010'
octal = oct(a)   # 结果是 '0o12'
hexadecimal = hex(a)  # 结果是 '0xa'

print(binary)
print(octal)
print(hexadecimal)

5. 类型检查

使用 isinstance() 函数来检查变量是否是整数类型。

a = 10
print(isinstance(a, int))  # 结果是 True

6. 进制表示

Python 支持不同进制的整数表示：

十进制：默认的数字表示方式，例如 123。
二进制：以 0b 或 0B 开头，例如 0b101 表示 5。
八进制：以 0o 或 0O 开头，例如 0o17 表示 15。
十六进制：以 0x 或 0X 开头，例如 0x1A 表示 26。

binary_num = 0b101  # 二进制
octal_num = 0o17    # 八进制
hex_num = 0x1A      # 十六进制

print(binary_num)  # 结果是 5
print(octal_num)   # 结果是 15
print(hex_num)     # 结果是 26

7. 数学运算

Python 的 math 模块提供了更多的数学操作。

import math

#

 计算平方根
result = math.sqrt(16)  # 结果是 4.0
print(result)

# 计算阶乘
result = math.factorial(5)  # 结果是 120
print(result)

# 计算对数（以 10 为底）
result = math.log10(100)  # 结果是 2.0
print(result)

总结

算术运算：Python 提供了常见的加法、减法、乘法、除法、幂运算等。
比较运算：可以比较两个整数的大小、相等性等。
位运算：直接操作整数的二进制位。
进制转换：可以在二进制、八进制和十六进制之间自由转换。
内置函数：提供了 int()、abs()、divmod() 等函数帮助处理整数。

（三）、浮点数（`float`）

定义：浮点数是带有小数部分的数值，通常用于表示实数。Python 中的浮点数遵循 IEEE 754 标准。
表达方式：
- 直接输入带小数点的数值，如 3.14、-2.5、0.0 等。
- 科学计数法，如 1.23e4 表示 1.23 × 10^4。

示例：

x = 3.14    # 浮点数
y = -0.001  # 负的浮点数
z = 1.23e4  # 科学计数法，表示 12300.0

（四）、浮点数（`float`）的运算与各种操作示例

浮点数（float）是 Python 中用于表示带有小数的实数类型。Python 的浮点数基于 IEEE 754 双精度标准，通常精确到 15 位小数。浮点数支持基本的算术运算、比较运算、类型转换以及各种内置函数。下面我们详细介绍浮点数的各种运算和操作示例。

1. 基本算术运算

1.1 加法（`+`）

a = 3.14
b = 2.5
result = a + b  # 结果是 5.64
print(result)

1.2 减法（`-`）

a = 3.14
b = 2.5
result = a - b  # 结果是 0.64
print(result)

1.3 乘法（`*`）

a = 3.14
b = 2.5
result = a * b  # 结果是 7.85
print(result)

1.4 除法（`/`）

a = 3.14
b = 2.0
result = a / b  # 结果是 1.57
print(result)

1.5 取余（`%`）

a = 5.5
b = 2.0
result = a % b  # 结果是 1.5
print(result)

1.6 幂运算（`**`）

a = 2.0
b = 3.0
result = a ** b  # 结果是 8.0
print(result)

1.7 整除（`//`）

整除运算返回商的整数部分（向下取整）。

a = 5.5
b = 2.0
result = a // b  # 结果是 2.0
print(result)

2. 浮点数的比较运算

比较运算符返回布尔值 True 或 False。

2.1 等于（`==`）

a = 3.14
b = 3.14
result = a == b  # 结果是 True
print(result)

2.2 不等于（`!=`）

a = 3.14
b = 2.5
result = a != b  # 结果是 True
print(result)

2.3 大于（`>`）

a = 3.14
b = 2.5
result = a > b  # 结果是 True
print(result)

2.4 小于（`<`）

a = 3.14
b = 2.5
result = a < b  # 结果是 False
print(result)

2.5 大于等于（`>=`）

a = 3.14
b = 3.14
result = a >= b  # 结果是 True
print(result)

2.6 小于等于（`<=`）

a = 3.14
b = 3.14
result = a <= b  # 结果是 True
print(result)

3. 浮点数类型转换

3.1 `int()`：浮点数转整数

将浮点数转换为整数时，小数部分被舍弃（向下取整）。

a = 3.99
result = int(a)  # 结果是 3
print(result)

3.2 `float()`：将其他类型转换为浮点数

将整数或字符串转换为浮点数。

# 整数转浮点数
a = 5
result = float(a)  # 结果是 5.0
print(result)

# 字符串转浮点数
s = "3.14"
result = float(s)  # 结果是 3.14
print(result)

3.3 `round()`：四舍五入

round() 函数用于对浮点数进行四舍五入，可以指定小数位数。

a = 3.14159
result = round(a, 2)  # 结果是 3.14
print(result)

result = round(a)  # 不指定小数位数时，结果是 3
print(result)

4. 浮点数与精度问题

浮点数在计算中由于底层表示方式（IEEE 754）可能出现精度问题。例如，以下计算结果并不是精确的：

a = 0.1 + 0.2
print(a)  # 输出: 0.30000000000000004

可以使用 decimal 模块来处理高精度的浮点运算。

使用 `decimal` 模块避免浮点数精度问题：

from decimal import Decimal

a = Decimal('0.1') + Decimal('0.2')
print(a)  # 结果是 0.3

5. 常用的数学函数（使用 `math` 模块）

Python 提供了 math 模块，包含许多数学函数用于处理浮点数运算。

5.1 计算平方根

import math

a = 9.0
result = math.sqrt(a)  # 结果是 3.0
print(result)

5.2 计算指数（`e^x`）

a = 1.0
result = math.exp(a)  # 结果是 e 的 1 次方
print(result)

5.3 计算对数

a = 10.0
result = math.log(a)  # 结果是自然对数 ln(10)
print(result)

result = math.log10(a)  # 结果是以 10 为底的对数 log10(10)
print(result)

5.4 向上取整和向下取整

a = 3.14

# 向上取整
result = math.ceil(a)  # 结果是 4
print(result)

# 向下取整
result = math.floor(a)  # 结果是 3
print(result)

5.5 计算三角函数

a = math.pi / 2  # π/2 弧度

# 计算正弦值
result = math.sin(a)  # 结果是 1.0
print(result)

# 计算余弦值
result = math.cos(a)  # 结果是 0.0
print(result)

6. 浮点数精度与格式化输出

6.1 `format()` 函数

可以使用 format() 函数来指定浮点数的格式，控制小数点后的位数。

a = 3.14159
result = format(a, ".2f")  # 保留两位小数，结果是 '3.14'
print(result)

6.2 使用 f-字符串格式化输出

a = 3.14159
print(f"{a:.2f}")  # 保留两位小数，输出: 3.14

7. 浮点数的特殊值

浮点数有一些特殊值，包括正无穷大、负无穷大和 NaN（不是一个数字）。

7.1 正无穷大和负无穷大

import math

# 正无穷大
pos_inf = float('inf')
print(pos_inf)  # 输出: inf

# 负无穷大
neg_inf = float('-inf')
print(neg_inf)  # 输出: -inf

# 检查是否为无穷大
print(math.isinf(pos_inf))  # 输出: True

7.2 `NaN`（Not a Number）

NaN 表示 “不是一个数字”，常在浮点数计算无效时产生。

nan_value = float('nan')
print(nan_value)  # 输出: nan

# 检查是否为 NaN
print(math.isnan(nan_value))  # 输出: True

8. 浮点数的类型检查

使用 isinstance() 检查变量是否为浮点数类型。

a = 3.14
print(isinstance(a, float))  # 输出: True

总结

算术运算：支持加减乘除、幂运算、整除、取余等基本运算。
比较运算：可以比较两个浮点数的大小。
类型转换：可以通过 int()、float() 等函数进行类型转换。
**精度控制

**：可以使用 round() 函数或 format()、f-字符串 进行格式化输出。

数学函数：math 模块提供了许多常用的数学运算函数。
特殊值：float 类型支持正无穷大、负无穷大和 NaN。

浮点数在 Python 中可以进行广泛的运算和操作，但需要注意浮点数的精度问题。在某些情况下，可以使用 decimal 模块处理高精度计算。

（五）、复数（`complex`）

定义：复数由实部和虚部组成，形式为 a + bj，其中 a 是实部，b 是虚部，j 表示虚数单位。
表达方式：
- 复数的表达方式使用 j 或 J 表示虚数单位，如 3 + 4j。

示例：

c = 2 + 3j   # 实部为 2，虚部为 3
d = -1j      # 仅有虚部，等同于 0 - 1j

（六）、浮点数（`float`）运算

1. 基本算术运算

1.1 加法（`+`）

a = 3.14
b = 2.5
result = a + b  # 结果是 5.64
print(result)

1.2 减法（`-`）

a = 3.14
b = 2.5
result = a - b  # 结果是 0.64
print(result)

1.3 乘法（`*`）

a = 3.14
b = 2.5
result = a * b  # 结果是 7.85
print(result)

1.4 除法（`/`）

a = 3.14
b = 2.0
result = a / b  # 结果是 1.57
print(result)

1.5 取余（`%`）

a = 5.5
b = 2.0
result = a % b  # 结果是 1.5
print(result)

1.6 幂运算（`**`）

a = 2.0
b = 3.0
result = a ** b  # 结果是 8.0
print(result)

1.7 整除（`//`）

整除运算返回商的整数部分（向下取整）。

a = 5.5
b = 2.0
result = a // b  # 结果是 2.0
print(result)

2. 浮点数的比较运算

比较运算符返回布尔值 True 或 False。

2.1 等于（`==`）

a = 3.14
b = 3.14
result = a == b  # 结果是 True
print(result)

2.2 不等于（`!=`）

a = 3.14
b = 2.5
result = a != b  # 结果是 True
print(result)

2.3 大于（`>`）

a = 3.14
b = 2.5
result = a > b  # 结果是 True
print(result)

2.4 小于（`<`）

a = 3.14
b = 2.5
result = a < b  # 结果是 False
print(result)

2.5 大于等于（`>=`）

a = 3.14
b = 3.14
result = a >= b  # 结果是 True
print(result)

2.6 小于等于（`<=`）

a = 3.14
b = 3.14
result = a <= b  # 结果是 True
print(result)

3. 浮点数类型转换

3.1 `int()`：浮点数转整数

将浮点数转换为整数时，小数部分被舍弃（向下取整）。

a = 3.99
result = int(a)  # 结果是 3
print(result)

3.2 `float()`：将其他类型转换为浮点数

将整数或字符串转换为浮点数。

# 整数转浮点数
a = 5
result = float(a)  # 结果是 5.0
print(result)

# 字符串转浮点数
s = "3.14"
result = float(s)  # 结果是 3.14
print(result)

3.3 `round()`：四舍五入

round() 函数用于对浮点数进行四舍五入，可以指定小数位数。

a = 3.14159
result = round(a, 2)  # 结果是 3.14
print(result)

result = round(a)  # 不指定小数位数时，结果是 3
print(result)

4. 浮点数与精度问题

浮点数在计算中由于底层表示方式（IEEE 754）可能出现精度问题。例如，以下计算结果并不是精确的：

a = 0.1 + 0.2
print(a)  # 输出: 0.30000000000000004

可以使用 decimal 模块来处理高精度的浮点运算。

使用 `decimal` 模块避免浮点数精度问题：

from decimal import Decimal

a = Decimal('0.1') + Decimal('0.2')
print(a)  # 结果是 0.3

5. 常用的数学函数（使用 `math` 模块）

Python 提供了 math 模块，包含许多数学函数用于处理浮点数运算。

5.1 计算平方根

import math

a = 9.0
result = math.sqrt(a)  # 结果是 3.0
print(result)

5.2 计算指数（`e^x`）

a = 1.0
result = math.exp(a)  # 结果是 e 的 1 次方
print(result)

5.3 计算对数

a = 10.0
result = math.log(a)  # 结果是自然对数 ln(10)
print(result)

result = math.log10(a)  # 结果是以 10 为底的对数 log10(10)
print(result)

5.4 向上取整和向下取整

a = 3.14

# 向上取整
result = math.ceil(a)  # 结果是 4
print(result)

# 向下取整
result = math.floor(a)  # 结果是 3
print(result)

5.5 计算三角函数

a = math.pi / 2  # π/2 弧度

# 计算正弦值
result = math.sin(a)  # 结果是 1.0
print(result)

# 计算余弦值
result = math.cos(a)  # 结果是 0.0
print(result)

6. 浮点数精度与格式化输出

6.1 `format()` 函数

可以使用 format() 函数来指定浮点数的格式，控制小数点后的位数。

a = 3.14159
result = format(a, ".2f")  # 保留两位小数，结果是 '3.14'
print(result)

6.2 使用 f-字符串格式化输出

a = 3.14159
print(f"{a:.2f}")  # 保留两位小数，输出: 3.14

7. 浮点数的特殊值

浮点数有一些特殊值，包括正无穷大、负无穷大和 NaN（不是一个数字）。

7.1 正无穷大和负无穷大

import math

# 正无穷大
pos_inf = float('inf')
print(pos_inf)  # 输出: inf

# 负无穷大
neg_inf = float('-inf')
print(neg_inf)  # 输出: -inf

# 检查是否为无穷大
print(math.isinf(pos_inf))  # 输出: True

7.2 `NaN`（Not a Number）

NaN 表示 “不是一个数字”，常在浮点数计算无效时产生。

nan_value = float('nan')
print(nan_value)  # 输出: nan

# 检查是否为 NaN
print(math.isnan(nan_value))  # 输出: True

8. 浮点数的类型检查

使用 isinstance() 检查变量是否为浮点数类型。

a = 3.14
print(isinstance(a, float))  # 输出: True

总结

算术运算：支持加减乘除、幂运算、整除、取余等基本运算。
比较运算：可以比较两个浮点数的大小。
类型转换：可以通过 int()、float() 等函数进行类型转换。
**精度控制

**：可以使用 round() 函数或 format()、f-字符串 进行格式化输出。

数学函数：math 模块提供了许多常用的数学运算函数。
特殊值：float 类型支持正无穷大、负无穷大和 NaN。

浮点数在 Python 中可以进行广泛的运算和操作，但需要注意浮点数的精度问题。在某些情况下，可以使用 decimal 模块处理高精度计算。

（七）、字符串（`str`）

定义：字符串是由一系列字符组成的文本数据。它可以包含字母、数字、符号等。字符串是不可变的，也就是说字符串一旦创建，就不能修改。
表达方式：
- 使用单引号 '' 或双引号 "" 包围文本，如 'hello' 或 "hello"。
- 使用三重引号 ''' 或 """ 定义多行字符串。

示例：

name = "Alice"           # 双引号字符串
greeting = 'Hello!'      # 单引号字符串
multiline = '''This is
a multiline
string.'''               # 多行字符串

（八）、字符串（`str`）之间的各种操作示例

Python 中的字符串（str）是常用的数据类型之一，字符串支持多种操作，例如拼接、切片、格式化、查找、替换等。下面介绍 Python 字符串的各种操作及其示例。

1. 字符串创建与基本操作

1.1 创建字符串

# 使用单引号或双引号创建字符串
str1 = 'Hello'
str2 = "World"

# 多行字符串
str3 = '''This is
a multi-line
string.'''
print(str3)

1.2 访问字符串中的字符（索引）

字符串可以使用索引访问其中的单个字符，索引从 0 开始。负索引从右向左计数，-1 表示最后一个字符。

s = "Python"
print(s[0])    # 输出: P
print(s[-1])   # 输出: n

1.3 字符串切片

通过切片操作从字符串中提取部分子字符串，格式为 str[start:end]，start 是起始索引，end 是结束索引（不包括 end）。

s = "Hello, World"
print(s[0:5])  # 输出: Hello
print(s[7:])   # 输出: World
print(s[:5])   # 输出: Hello
print(s[-5:])  # 输出: World

2. 字符串拼接与重复

2.1 字符串拼接（使用 `+`）

可以使用 + 运算符拼接两个或多个字符串。

s1 = "Hello"
s2 = "World"
result = s1 + " " + s2
print(result)  # 输出: Hello World

2.2 字符串重复（使用 `*`）

可以使用 * 运算符重复一个字符串。

s = "Hi"
result = s * 3
print(result)  # 输出: HiHiHi

3. 字符串查找与替换

3.1 查找子字符串

find()：返回子字符串第一次出现的索引，如果找不到返回 -1。
rfind()：返回子字符串最后一次出现的索引。
index()：类似于 find()，但如果找不到会抛出异常。

s = "Hello, World"
print(s.find("World"))  # 输出: 7
print(s.find("Python"))  # 输出: -1
print(s.index("World"))  # 输出: 7

3.2 替换子字符串

replace(old, new)：将字符串中的 old 替换为 new，返回一个新的字符串。

s = "Hello, World"
result = s.replace("World", "Python")
print(result)  # 输出: Hello, Python

4. 字符串格式化

4.1 使用 `%` 运算符进行格式化

name = "Alice"
age = 25
formatted_str = "My name is %s and I am %d years old." % (name, age)
print(formatted_str)  # 输出: My name is Alice and I am 25 years old.

4.2 使用 `str.format()` 方法

name = "Alice"
age = 25
formatted_str = "My name is {} and I am {} years old.".format(name, age)
print(formatted_str)  # 输出: My name is Alice and I am 25 years old.

4.3 使用 f-string（推荐）

Python 3.6 及以上版本支持 f-string，可以在字符串中嵌入表达式。

name = "Alice"
age = 25
formatted_str = f"My name is {name} and I am {age} years old."
print(formatted_str)  # 输出: My name is Alice and I am 25 years old.

5. 字符串大小写转换

upper()：将字符串转换为大写。
lower()：将字符串转换为小写。
capitalize()：将字符串的第一个字符转换为大写，其他字符转换为小写。
title()：将每个单词的首字母转换为大写。
swapcase()：将大写字母转换为小写，小写字母转换为大写。

s = "hello, World"
print(s.upper())      # 输出: HELLO, WORLD
print(s.lower())      # 输出: hello, world
print(s.capitalize()) # 输出: Hello, world
print(s.title())      # 输出: Hello, World
print(s.swapcase())   # 输出: HELLO, wORLD

6. 字符串分割与连接

6.1 分割字符串（`split()`）

split()：将字符串按照指定的分隔符拆分为列表，默认按空格分割。

s = "Hello World Python"
words = s.split()
print(words)  # 输出: ['Hello', 'World', 'Python']

s = "apple,banana,orange"
fruits = s.split(",")
print(fruits)  # 输出: ['apple', 'banana', 'orange']

6.2 连接字符串（`join()`）

join()：将列表中的元素连接成一个字符串，使用指定的分隔符。

fruits = ["apple", "banana", "orange"]
result = ", ".join(fruits)
print(result)  # 输出: apple, banana, orange

7. 去除空白字符

strip()：去除字符串首尾的空白字符（包括空格、换行符等）。
lstrip()：去除字符串左边的空白字符。
rstrip()：去除字符串右边的空白字符。

s = "  Hello, World  "
print(s.strip())   # 输出: Hello, World
print(s.lstrip())  # 输出: Hello, World  
print(s.rstrip())  # 输出:   Hello, World

8. 字符串判断操作

startswith(sub)：判断字符串是否以 sub 开头。
endswith(sub)：判断字符串是否以 sub 结尾。
isalnum()：判断字符串是否只包含字母和数字。
isalpha()：判断字符串是否只包含字母。
isdigit()：判断字符串是否只包含数字。
isspace()：判断字符串是否只包含空白字符。

s = "Hello123"
print(s.startswith("Hello"))  # 输出: True
print(s.endswith("123"))      # 输出: True
print(s.isalnum())            # 输出: True
print(s.isalpha())            # 输出: False
print(s.isdigit())            # 输出: False
print("   ".isspace())        # 输出: True

9. 字符串的长度与遍历

9.1 获取字符串长度（`len()`）

s = "Hello, World"
length = len(s)
print(length)  # 输出: 12

9.2 遍历字符串

s = "Python"
for char in s:
    print(char)
# 输出:
# P
# y
# t
# h
# o
# n

10. 字符串反转

使用切片方法可以轻松反转字符串。

s = "Python"
reversed_str = s[::-1]
print(reversed_str)  # 输出: nohtyP

11. 字符串转义字符

在字符串中，某些字符可能具有特殊意义，可以使用反斜杠 \ 进行转义。

\'：单引号
\"：双引号
\\：反斜杠
\n：换行符
\t：制表符

s = "He said, \"Hello, World!\""
print(s)  # 输出: He said, "Hello, World!"

12. 字符串编码与解码

字符串可以编码为字节数据，也可以将字节数据解码为字符串。

12.1 编码为字节

encode()：将字符串编码为指定编码的字节数据，默认编码为 utf-8。

s = "Hello"
byte_data = s.encode("utf-8")
print(byte_data)  # 输出: b'Hello'

12.2 解码为字符串

decode()：将字节数据解码为字符串。

byte_data = b'Hello'
s = byte_data.decode("utf-8")
print(s)  # 输出: Hello

总结

字符串的创建与访问：可以使用索引访问单个字符，使用切片提取子字符串。
拼接与重复：使用 + 进行拼接，使用 * 进行重复。
**查

找与替换**：find()、replace() 用于查找和替换子字符串。

字符串格式化：可以使用 %、str.format() 或 f-字符串进行格式化。
大小写转换：upper()、lower()、title() 等用于大小写转换。
分割与连接：split() 和 join() 用于拆分和连接字符串。
字符串判断：startswith()、endswith()、isalnum() 等函数用于判断字符串的特性。

通过掌握这些字符串操作，能够处理文本、格式化输出、以及进行各种字符串操作。

（八）、布尔值（`bool`）

定义：布尔类型表示逻辑值，有两个取值：True（真）和 False（假）。
表达方式：
- 使用 True 或 False 关键字直接表示布尔值。

示例：

is_active = True   # 真
is_valid = False   # 假

（九）、布尔值（`bool`）各种操作示例

在 Python 中，布尔值（bool）表示两个值：True 和 False。布尔值主要用于条件判断和逻辑运算。Python 的 bool 类型是 int 的子类，其中 True 相当于 1，False 相当于 0。布尔值可以与其他数据类型进行多种操作，例如算术运算、逻辑运算、比较操作等。

以下是布尔值的各种操作及其示例：

1. 布尔值定义与基本操作

1.1 布尔值定义

a = True
b = False

print(a)  # 输出: True
print(b)  # 输出: False

1.2 布尔值与整数的关系

布尔值 True 相当于整数 1，False 相当于整数 0，所以布尔值可以参与算术运算。

print(int(True))   # 输出: 1
print(int(False))  # 输出: 0

# 布尔值参与加法运算
print(True + 1)  # 输出: 2
print(False + 1)  # 输出: 1

2. 逻辑运算

Python 支持常见的逻辑运算符 and、or、not，用于处理逻辑判断。

2.1 `and` 运算

and 运算符在两个操作数都为 True 时，结果为 True，否则为 False。

print(True and True)   # 输出: True
print(True and False)  # 输出: False
print(False and False) # 输出: False

2.2 `or` 运算

or 运算符在至少一个操作数为 True 时，结果为 True，否则为 False。

print(True or True)   # 输出: True
print(True or False)  # 输出: True
print(False or False) # 输出: False

2.3 `not` 运算

not 运算符用于取反，True 变为 False，False 变为 True。

print(not True)   # 输出: False
print(not False)  # 输出: True

3. 比较运算

布尔值可以通过比较运算符返回 True 或 False。常见的比较运算符包括 ==、!=、>、<、>=、<= 等。

print(True == 1)  # 输出: True
print(False == 0)  # 输出: True
print(True != False)  # 输出: True
print(True > False)   # 输出: True
print(False < True)   # 输出: True

4. 布尔值与其他类型的转换

4.1 使用 `bool()` 函数进行类型转换

bool() 函数可以将其他类型转换为布尔值，以下情况会转换为 False：

数值 0（包括 0.0）
空字符串 ""
空列表、空元组、空字典、空集合
None

其他所有值都会转换为 True。

# 数字转换为布尔值
print(bool(0))    # 输出: False
print(bool(1))    # 输出: True
print(bool(-1))   # 输出: True

# 字符串转换为布尔值
print(bool(""))   # 输出: False （空字符串）
print(bool("Python"))  # 输出: True

# 列表转换为布尔值
print(bool([]))   # 输出: False （空列表）
print(bool([1, 2, 3]))  # 输出: True

# None 转换为布尔值
print(bool(None))  # 输出: False

4.2 布尔值转整数

布尔值可以通过 int() 转换为整数，True 转换为 1，False 转换为 0。

print(int(True))   # 输出: 1
print(int(False))  # 输出: 0

5. 短路运算

Python 中的逻辑运算符支持短路运算。

5.1 `and` 短路运算

and 运算中，如果第一个操作数为 False，则不会计算第二个操作数，因为结果已经确定为 False。

print(False and 1 / 0)  # 输出: False，不会抛出除零异常

5.2 `or` 短路运算

or 运算中，如果第一个操作数为 True，则不会计算第二个操作数，因为结果已经确定为 True。

print(True or 1 / 0)  # 输出: True，不会抛出除零异常

6. 布尔值在条件判断中的使用

布尔值在 if、while 等条件语句中应用广泛。

6.1 `if` 条件判断

if True:
    print("条件为真")  # 输出: 条件为真

if False:
    print("条件为假")  # 不会输出

6.2 `while` 循环

count = 0
while count < 3:
    print(count)  # 输出: 0 1 2
    count += 1

7. 布尔值与容器类型

空容器类型（如空列表、空字符串、空字典等）会被视为 False，非空容器类型被视为 True。

# 空列表
print(bool([]))  # 输出: False

# 非空列表
print(bool([1, 2, 3]))  # 输出: True

# 空字符串
print(bool(""))  # 输出: False

# 非空字符串
print(bool("hello"))  # 输出: True

8. `all()` 和 `any()` 函数

all(iterable)：如果迭代对象中的所有元素都为 True，返回 True，否则返回 False。
any(iterable)：如果迭代对象中的任意一个元素为 True，返回 True，否则返回 False。

# all() 示例
print(all([True, True, True]))  # 输出: True
print(all([True, False, True]))  # 输出: False

# any() 示例
print(any([False, False, True]))  # 输出: True
print(any([False, False, False])) # 输出: False

9. 布尔值与 `None`

在布尔上下文中，None 被视为 False。

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

10. 布尔值的优先级

not 的优先级高于 and 和 or，即先执行 not，再执行 and 或 or。
and 的优先级高于 or，即 and 会在 or 之前执行。

示例：

print(True or False and False)  # 输出: True （先执行 and，再执行 or）
print(not True or False)        # 输出: False （先执行 not，再执行 or）

11. 布尔值作为函数返回值

布尔值经常作为函数的返回值，用于表示某些条件是否成立。

def is_even(n):
    return n % 2 == 0

print(is_even(4))  # 输出: True
print(is_even(5))  # 输出: False

总结

布尔值的定义：True 和 False 是 Python 中的布尔值。
逻辑运算：and、or 和 not 是 Python 的主要逻辑运算符。
布尔值的类型转换：bool() 可以将其他类型转换为布尔值，int() 可以将布尔值转换为整数。
短路运算：逻辑运算符支持短路操作，避免不必要的计算。
all() 和 any()：all() 检查所有元素是否为真，any() 检查是否有任意元素为真。
布尔值在条件语句中的应用：布尔值广泛用于控制流程，如 if 和 while 语句中。

通过掌握这些操作，可以在条件判断、逻辑运算、循环控制等场景中灵活使用布尔值。

（十）、列表（`list`）

定义：列表是有序的、可变的序列数据类型，可以包含任意类型的元素（整数、浮点数、字符串等）。列表可以动态修改，添加、删除或更改其元素。
表达方式：
- 使用方括号 [] 定义列表，元素之间用逗号分隔，如 [1, 2, 3]。

示例：

my_list = [1, 2, 3, 4]             # 包含整数的列表
mixed_list = [1, "Alice", 3.14]    # 包含不同类型元素的列表

＃＃　（十一）＊＊列表（list）的各种操作的示例＊＊

Python 中的列表（list）是最常用的序列数据类型之一。列表是有序的、可变的，并且可以包含任意类型的元素（如整数、浮点数、字符串，甚至嵌套列表）。列表支持多种操作，包括添加、删除、修改、查询、切片等。

以下是 Python 列表的各种操作示例。

1. 创建列表

1.1 创建空列表

empty_list = []
print(empty_list)  # 输出: []

1.2 创建包含元素的列表

num_list = [1, 2, 3, 4]
mixed_list = [1, "Python", 3.14, True]
nested_list = [[1, 2], [3, 4]]  # 嵌套列表
print(num_list)   # 输出: [1, 2, 3, 4]
print(mixed_list) # 输出: [1, 'Python', 3.14, True]
print(nested_list) # 输出: [[1, 2], [3, 4]]

2. 访问列表元素

2.1 通过索引访问

列表的索引从 0 开始，负索引用于从右向左访问。

lst = ["Python", "Java", "C++"]
print(lst[0])   # 输出: Python
print(lst[-1])  # 输出: C++

2.2 修改列表元素

可以通过索引修改列表中的元素。

lst = [10, 20, 30]
lst[1] = 50
print(lst)  # 输出: [10, 50, 30]

2.3 列表切片

使用切片操作可以访问列表的子序列，格式为 list[start:end]，start 是起始索引，end 是结束索引（不包括 end）。

lst = [0, 1, 2, 3, 4, 5]
print(lst[1:4])  # 输出: [1, 2, 3]
print(lst[:3])   # 输出: [0, 1, 2]
print(lst[3:])   # 输出: [3, 4, 5]
print(lst[::2])  # 输出: [0, 2, 4]（步长为 2）

3. 添加元素

3.1 `append()`：在列表末尾添加元素

lst = [1, 2, 3]
lst.append(4)
print(lst)  # 输出: [1, 2, 3, 4]

3.2 `insert()`：在指定位置插入元素

lst = [1, 2, 3]
lst.insert(1, "Python")
print(lst)  # 输出: [1, 'Python', 2, 3]

3.3 `extend()`：合并另一个列表（扩展列表）

lst = [1, 2, 3]
lst.extend([4, 5])
print(lst)  # 输出: [1, 2, 3, 4, 5]

4. 删除元素

4.1 `remove()`：移除列表中第一次出现的指定元素

lst = [1, 2, 3, 2]
lst.remove(2)
print(lst)  # 输出: [1, 3, 2]

4.2 `pop()`：移除并返回指定位置的元素，默认是最后一个

lst = [1, 2, 3]
removed_element = lst.pop()
print(removed_element)  # 输出: 3
print(lst)  # 输出: [1, 2]

4.3 `del` 关键字：删除指定位置的元素

lst = [1, 2, 3]
del lst[1]
print(lst)  # 输出: [1, 3]

4.4 `clear()`：清空列表

lst = [1, 2, 3]
lst.clear()
print(lst)  # 输出: []

5. 查找与统计

5.1 `index()`：查找元素第一次出现的索引

lst = [1, 2, 3, 2]
index_of_2 = lst.index(2)
print(index_of_2)  # 输出: 1

5.2 `count()`：统计元素在列表中出现的次数

lst = [1, 2, 2, 3]
count_of_2 = lst.count(2)
print(count_of_2)  # 输出: 2

6. 列表排序与反转

6.1 `sort()`：对列表进行排序

默认从小到大排序，使用 reverse=True 参数可以从大到小排序。

lst = [3, 1, 4, 1, 5]
lst.sort()
print(lst)  # 输出: [1, 1, 3, 4, 5]

lst.sort(reverse=True)
print(lst)  # 输出: [5, 4, 3, 1, 1]

6.2 `reverse()`：反转列表中的元素顺序

lst = [1, 2, 3]
lst.reverse()
print(lst)  # 输出: [3, 2, 1]

7. 列表遍历

7.1 使用 `for` 循环遍历列表

lst = [1, 2, 3]
for item in lst:
    print(item)
# 输出:
# 1
# 2
# 3

7.2 使用 `enumerate()` 获取索引和值

lst = ['a', 'b', 'c']
for index, value in enumerate(lst):
    print(f"Index: {index}, Value: {value}")
# 输出:
# Index: 0, Value: a
# Index: 1, Value: b
# Index: 2, Value: c

8. 列表推导式

列表推导式用于简洁地生成列表。

# 生成一个包含 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]

9. 嵌套列表操作

嵌套列表是列表中的元素本身也是列表。

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# 访问嵌套列表中的元素
print(matrix[0][1])  # 输出: 2

# 遍历嵌套列表
for row in matrix:
    for element in row:
        print(element, end=" ")
    print()
# 输出:
# 1 2 3
# 4 5 6
# 7 8 9

10. 列表的浅复制与深复制

10.1 浅复制（`copy()` 或者使用 `[:]`）

浅复制会创建一个新的列表，但列表中的元素仍然是原来的引用。

lst = [1, 2, [3, 4]]
copy_lst = lst.copy()
copy_lst[2][0] = 100
print(lst)       # 输出: [1, 2, [100, 4]]，嵌套列表也被修改
print(copy_lst)  # 输出: [1, 2, [100, 4]]

10.2 深复制（`deepcopy()`）

深复制会创建一个全新的列表，包括其中的嵌套列表。

import copy
lst = [1, 2, [3, 4]]
deep_copy_lst = copy.deepcopy(lst)
deep_copy_lst[2][0] = 100
print(lst)           # 输出: [1, 2, [3, 4]]，原列表未被修改
print(deep_copy_lst) # 输出: [1, 2, [100, 4]]

11. 检查列表是否为空

通过检查列表的长度或直接使用 if 语句判断列表是否为空。

lst = []
if not lst:
    print("列表为空")  # 输出: 列表为空

12. 列表的合并与复制

12.1 合并列表

可以使用 + 运算符合并两个列表。

lst1

 = [1, 2, 3]
lst2 = [4, 5, 6]
merged_lst = lst1 + lst2
print(merged_lst)  # 输出: [1, 2, 3, 4, 5, 6]

12.2 复制列表

使用 * 运算符可以将列表中的元素复制多次。

lst = [1, 2, 3]
duplicated_lst = lst * 2
print(duplicated_lst)  # 输出: [1, 2, 3, 1, 2, 3]

总结

创建与访问：可以通过索引或切片访问列表中的元素。
增删改查：使用 append()、insert()、remove()、pop() 等方法添加、删除、修改元素。
排序与反转：使用 sort() 和 reverse() 对列表进行排序和反转。
遍历：可以使用 for 循环和 enumerate() 遍历列表。
嵌套列表：支持嵌套列表，可以通过多重索引访问元素。
复制：使用 copy() 进行浅复制，使用 deepcopy() 进行深复制。

通过掌握这些操作，可以灵活地处理 Python 列表并应对各种编程场景。

（十二）、元组（`tuple`）

定义：元组是有序的、不可变的序列数据类型。一旦定义，元组中的元素不能被修改。元组的创建方式与列表类似，但使用圆括号 ()。
表达方式：
- 使用圆括号 () 定义元组，元素之间用逗号分隔，如 (1, 2, 3)。

示例：

my_tuple = (1, 2, 3)              # 包含整数的元组
empty_tuple = ()                  # 空元组
single_tuple = (1,)               # 单元素元组，必须带逗号

＃＃　（十三）　＊＊元组（tuple）的各种操作示例＊＊

在 Python 中，tuple（元组）是一个有序且不可变的序列类型。元组与列表类似，但元组中的元素是不可更改的。一旦定义了元组，它的内容就不能被修改或删除。元组的不可变性使它在某些情况下更安全和高效。元组可以包含任意类型的元素，支持多种操作，如索引、切片、连接等。

以下是 Python 中元组的各种操作及其示例：

1. 创建元组

1.1 创建空元组

empty_tuple = ()
print(empty_tuple)  # 输出: ()

1.2 创建包含元素的元组

t = (1, 2, 3)
print(t)  # 输出: (1, 2, 3)

1.3 创建单元素元组

为了创建包含单个元素的元组，必须在元素后加上一个逗号。

single_tuple = (1,)
print(single_tuple)  # 输出: (1,)

1.4 创建不使用括号的元组（自动打包）

Python 支持自动打包多个值为元组，无需显式使用括号。

t = 1, 2, 3
print(t)  # 输出: (1, 2, 3)

2. 访问元组中的元素

2.1 通过索引访问

元组支持索引操作，索引从 0 开始，负索引从右向左计数。

t = (10, 20, 30, 40)
print(t[0])    # 输出: 10
print(t[-1])   # 输出: 40

2.2 元组切片

可以通过切片操作访问元组中的子元组，切片格式为 tuple[start:end]，不包括 end 位置的元素。

t = (0, 1, 2, 3, 4, 5)
print(t[1:4])   # 输出: (1, 2, 3)
print(t[:3])    # 输出: (0, 1, 2)
print(t[3:])    # 输出: (3, 4, 5)
print(t[::2])   # 输出: (0, 2, 4)  # 选择步长为 2

3. 遍历元组

3.1 使用 `for` 循环遍历元组

t = ('a', 'b', 'c')
for item in t:
    print(item)
# 输出:
# a
# b
# c

3.2 使用 `enumerate()` 获取索引和值

t = ('apple', 'banana', 'cherry')
for index, value in enumerate(t):
    print(f"Index: {index}, Value: {value}")
# 输出:
# Index: 0, Value: apple
# Index: 1, Value: banana
# Index: 2, Value: cherry

4. 元组的不可变性

元组是不可变的，意味着你无法直接修改其中的元素。如果尝试修改元组的内容，会抛出错误。

t = (1, 2, 3)
# t[0] = 100  # 这会导致 TypeError: 'tuple' object does not support item assignment

尽管元组本身不可变，但如果元组中的元素是可变类型（如列表），该元素的内容是可以修改的。

t = (1, [2, 3], 4)
t[1][0] = 100  # 修改元组中的列表
print(t)  # 输出: (1, [100, 3], 4)

5. 连接与重复元组

5.1 元组连接（使用 `+` 运算符）

可以通过 + 运算符将两个元组合并为一个新元组。

t1 = (1, 2)
t2 = (3, 4)
t3 = t1 + t2
print(t3)  # 输出: (1, 2, 3, 4)

5.2 元组重复（使用 `*` 运算符）

可以通过 * 运算符将元组中的元素重复多次。

t = (1, 2)
t2 = t * 3
print(t2)  # 输出: (1, 2, 1, 2, 1, 2)

6. 检查元组中的元素

6.1 检查某个元素是否在元组中（`in`）

t = (10, 20, 30)
print(20 in t)    # 输出: True
print(40 in t)    # 输出: False

6.2 获取元素的数量（`len()`）

t = (1, 2, 3, 4)
print(len(t))  # 输出: 4

6.3 统计元素出现的次数（`count()`）

t = (1, 2, 2, 3, 2)
print(t.count(2))  # 输出: 3

6.4 查找元素的索引（`index()`）

返回元素在元组中第一次出现的索引。

t = (1, 2, 3, 2, 4)
print(t.index(2))  # 输出: 1

7. 元组的解包

7.1 元组解包

元组解包允许将元组的元素赋值给多个变量。

t = (1, 2, 3)
a, b, c = t
print(a)  # 输出: 1
print(b)  # 输出: 2
print(c)  # 输出: 3

7.2 使用 `*` 捕获多余的值

t = (1, 2, 3, 4, 5)
a, b, *rest = t
print(a)     # 输出: 1
print(b)     # 输出: 2
print(rest)  # 输出: [3, 4, 5]

8. 嵌套元组

元组可以包含其他元组（嵌套元组）。

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

9. 转换为元组

9.1 将列表转换为元组

lst = [1, 2, 3]
t = tuple(lst)
print(t)  # 输出: (1, 2, 3)

9.2 将字符串转换为元组

s = "hello"
t = tuple(s)
print(t)  # 输出: ('h', 'e', 'l', 'l', 'o')

9.3 将字典的键、值或项转换为元组

d = {'a': 1, 'b': 2, 'c': 3}
keys_tuple = tuple(d.keys())
values_tuple = tuple(d.values())
items_tuple = tuple(d.items())
print(keys_tuple)   # 输出: ('a', 'b', 'c')
print(values_tuple) # 输出: (1, 2, 3)
print(items_tuple)  # 输出: (('a', 1), ('b', 2), ('c', 3))

10. 元组的比较

元组支持比较操作，会依次比较每个元素。

t1 = (1, 2, 3)
t2 = (1, 2, 4)
print(t1 < t2)   # 输出: True
print(t1 == t2)  # 输出: False

11. 元组作为字典的键

由于元组是不可变的，可以作为字典的键，而列表不能。

d = {(1, 2): "point1", (3, 4): "point2"}
print(d[(1, 2)])  # 输出: point1

12. 元组的浅复制与深复制

由于元组是不可变的，因此浅复制和深复制的区别只在元组中包含可变类型（如列表）时才有影响。

12.1 浅复制

t = (1, [2, 3], 4)
t_copy = t
t[1][0] = 100
print(t)       # 输出: (1, [100, 3], 4)
print(t_copy) 

 # 输出: (1, [100, 3], 4)

12.2 深复制

使用 copy.deepcopy() 来深复制元组。

import copy
t = (1, [2, 3], 4)
t_deep_copy = copy.deepcopy(t)
t[1][0] = 100
print(t)             # 输出: (1, [100, 3], 4)
print(t_deep_copy)   # 输出: (1, [2, 3], 4)

总结

元组是不可变的：一旦定义，元组中的元素不能被修改。
元组支持基本操作：包括索引、切片、遍历、连接、重复等操作。
元组解包：可以通过解包将元组中的元素赋值给多个变量。
元组可以作为字典的键：由于元组不可变，可以用作字典的键。
类型转换：可以将列表、字符串等转换为元组。

元组因其不可变性而在某些需要保证数据不被修改的场景中非常有用。通过掌握元组的操作，可以灵活地处理和存储多种数据类型。

（十三）、字典（`dict`）

定义：字典是无序的键值对集合。每个键必须是唯一的，不可变的（例如字符串、数字），而值可以是任意类型。字典使用键来访问对应的值。
表达方式：
- 使用大括号 {} 定义字典，键值对之间用冒号 : 分隔，键值对之间用逗号分隔，如 {"key": "value"}。

示例：

my_dict = {"name": "Alice", "age": 30}  # 包含两个键值对
empty_dict = {}                         # 空字典

＃＃　（十四）、字典（dict）的各种操作示例

Python 中的字典（dict）是一种无序的、可变的、键值对（key-value）存储数据的结构。字典的键必须是不可变的（如字符串、数字、元组），值可以是任意类型。字典是 Python 中非常常用的数据结构之一，广泛应用于需要快速查找、添加和删除元素的场景。

以下是 Python 字典的各种操作及其示例：

1. 创建字典

1.1 创建空字典

empty_dict = {}
print(empty_dict)  # 输出: {}

1.2 创建有元素的字典

person = {
    "name": "Alice",
    "age": 25,
    "city": "New York"
}
print(person)  # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York'}

1.3 使用 `dict()` 函数创建字典

person = dict(name="Alice", age=25, city="New York")
print(person)  # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York'}

2. 访问字典中的元素

2.1 使用键访问值

person = {"name": "Alice", "age": 25}
print(person["name"])  # 输出: Alice
print(person["age"])   # 输出: 25

2.2 使用 `get()` 方法访问值

get() 方法允许指定键不存在时返回一个默认值，避免抛出 KeyError。

person = {"name": "Alice", "age": 25}
print(person.get("name"))     # 输出: Alice
print(person.get("gender", "Not Specified"))  # 输出: Not Specified

3. 修改字典中的元素

可以通过键修改字典中的值。如果键不存在，会自动添加该键值对。

person = {"name": "Alice", "age": 25}
person["age"] = 30  # 修改 age
print(person)       # 输出: {'name': 'Alice', 'age': 30}

person["city"] = "New York"  # 添加新键值对
print(person)  # 输出: {'name': 'Alice', 'age': 30, 'city': 'New York'}

4. 删除字典中的元素

4.1 使用 `del` 关键字删除元素

person = {"name": "Alice", "age": 25, "city": "New York"}
del person["age"]
print(person)  # 输出: {'name': 'Alice', 'city': 'New York'}

4.2 使用 `pop()` 方法删除元素并返回其值

person = {"name": "Alice", "age": 25}
age = person.pop("age")
print(age)     # 输出: 25
print(person)  # 输出: {'name': 'Alice'}

4.3 使用 `popitem()` 删除并返回最后一个键值对

person = {"name": "Alice", "age": 25}
last_item = person.popitem()
print(last_item)  # 输出: ('age', 25)
print(person)     # 输出: {'name': 'Alice'}

4.4 使用 `clear()` 清空字典

person = {"name": "Alice", "age": 25}
person.clear()
print(person)  # 输出: {}

5. 字典的遍历

5.1 遍历字典的键

person = {"name": "Alice", "age": 25}
for key in person:
    print(key)
# 输出:
# name
# age

5.2 遍历字典的值

person = {"name": "Alice", "age": 25}
for value in person.values():
    print(value)
# 输出:
# Alice
# 25

5.3 遍历字典的键值对

使用 items() 方法可以同时获取键和值。

person = {"name": "Alice", "age": 25}
for key, value in person.items():
    print(f"{key}: {value}")
# 输出:
# name: Alice
# age: 25

6. 字典的常用方法

6.1 `keys()`：返回所有键

person = {"name": "Alice", "age": 25}
keys = person.keys()
print(keys)  # 输出: dict_keys(['name', 'age'])

6.2 `values()`：返回所有值

person = {"name": "Alice", "age": 25}
values = person.values()
print(values)  # 输出: dict_values(['Alice', 25])

6.3 `items()`：返回所有键值对

person = {"name": "Alice", "age": 25}
items = person.items()
print(items)  # 输出: dict_items([('name', 'Alice'), ('age', 25)])

6.4 `update()`：合并字典

update() 方法可以用一个字典更新另一个字典。

person = {"name": "Alice", "age": 25}
person.update({"city": "New York", "age": 30})
print(person)  # 输出: {'name': 'Alice', 'age': 30, 'city': 'New York'}

6.5 `setdefault()`：获取指定键的值，如果键不存在则插入键并设为默认值

person = {"name": "Alice"}
city = person.setdefault("city", "Unknown")
print(city)  # 输出: Unknown
print(person)  # 输出: {'name': 'Alice', 'city': 'Unknown'}

7. 字典的长度

使用 len() 可以获取字典中键值对的数量。

person = {"name": "Alice", "age": 25}
print(len(person))  # 输出: 2

8. 字典的键必须是不可变对象

字典的键必须是不可变的，如字符串、数字、元组。列表等可变对象不能作为字典的键。

# 字符串、整数、元组作为键
valid_dict = {
    "name": "Alice",
    1: "one",
    (1, 2): "tuple"
}
print(valid_dict)

# 列表作为键会报错
# invalid_dict = {[1, 2]: "list"}  # 会抛出 TypeError

9. 字典的浅复制与深复制

9.1 浅复制（使用 `copy()`）

浅复制会复制字典本身，但不会复制嵌套的可变对象。

person = {"name": "Alice", "info": {"age": 25, "city": "New York"}}
person_copy = person.copy()
person_copy["info"]["age"] = 30
print(person)       # 输出: {'name': 'Alice', 'info': {'age': 30, 'city': 'New York'}}
print(person_copy)  # 输出: {'name': 'Alice', 'info': {'age': 30, 'city': 'New York'}}

9.2 深复制（使用 `copy.deepcopy()`）

深复制会复制字典以及字典中所有嵌套的对象。

import copy
person = {"name": "Alice", "info": {"age": 25, "city": "New York"}}
person_deep_copy = copy.deepcopy(person)
person_deep_copy["info"]["age"] = 30
print(person)            # 输出: {'name': 'Alice', 'info': {'age': 25, 'city': 'New York'}}
print(person_deep_copy)  # 输出: {'name': 'Alice', 'info': {'age': 30, 'city': 'New York'}}

10. 字典推导式

字典推导式允许使用简洁的语法创建字典。

10.1 创建简单字典

squares = {x: x**2 for x in range(1, 6)}
print(squares)  # 输出: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

10.2 条件推导

even_squares = {x: x**2 for x in range(1, 6) if x % 2 == 0}
print(even_squares)  # 输出: {2: 4, 4: 16}

11. 合并字典

从 Python 3.9 开始，字典可以使用 | 运算符进行合并。

dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4

}
merged_dict = dict1 | dict2
print(merged_dict)  # 输出: {'a': 1, 'b': 3, 'c': 4}

12. 字典的比较

字典可以使用比较运算符进行相等性判断。

dict1 = {"a": 1, "b": 2}
dict2 = {"b": 2, "a": 1}
print(dict1 == dict2)  # 输出: True （顺序无关）

总结

字典的创建与访问：可以通过键访问或修改值，使用 get() 方法可以避免 KeyError。
添加与删除：可以使用 del、pop()、clear() 等方法删除字典中的元素。
遍历字典：可以遍历字典的键、值或键值对。
常用方法：字典支持 keys()、values()、items()、update()、setdefault() 等方法。
复制与推导：可以通过浅复制、深复制及推导式创建字典。
键的不可变性：字典的键必须是不可变对象，如字符串、元组等。

通过掌握这些操作，可以灵活处理 Python 中的字典结构，完成高效的数据存储和查询。

（十四）集合（`set`）

定义：集合是无序的、不可重复的元素集合。集合可以用于去重操作，也可以进行集合的交集、并集、差集等运算。
表达方式：
- 使用大括号 {} 定义集合，集合中的元素不能重复，如 {1, 2, 3}。

示例：

my_set = {1, 2, 3, 4}           # 包含整数的集合
empty_set = set()                # 创建空集合，不能用 {}，因为 {} 创建的是空字典

（十五）集合（`set`）的各种操作示例

Python 中的集合（set）是一种无序、元素唯一的数据结构。集合支持集合运算，如并集、交集、差集等，同时可以高效地进行去重和元素查找操作。Python 提供两种集合类型：set（可变集合）和 frozenset（不可变集合）。

下面是 Python 中集合（set）的各种操作示例：

1. 创建集合

1.1 创建空集合

注意：要创建一个空集合，必须使用 set()，因为 {} 默认创建的是空字典。

empty_set = set()
print(empty_set)  # 输出: set()

1.2 创建包含元素的集合

numbers = {1, 2, 3, 4, 5}
print(numbers)  # 输出: {1, 2, 3, 4, 5}

1.3 使用 `set()` 函数将其他数据类型转换为集合

# 从列表创建集合
list_data = [1, 2, 2, 3, 4]
set_from_list = set(list_data)
print(set_from_list)  # 输出: {1, 2, 3, 4}

# 从字符串创建集合（注意字符串会被拆分为字符）
set_from_string = set("hello")
print(set_from_string)  # 输出: {'o', 'h', 'e', 'l'}

2. 集合中的元素

集合中的元素是无序的、唯一的，因此重复的元素会被自动去除。

my_set = {1, 2, 2, 3, 4}
print(my_set)  # 输出: {1, 2, 3, 4}

3. 添加与删除元素

3.1 `add()`：向集合中添加元素

my_set = {1, 2, 3}
my_set.add(4)
print(my_set)  # 输出: {1, 2, 3, 4}

3.2 `update()`：向集合中添加多个元素

update() 可以添加其他可迭代对象中的元素到集合中。

my_set = {1, 2}
my_set.update([3, 4, 5])
print(my_set)  # 输出: {1, 2, 3, 4, 5}

3.3 `remove()` 和 `discard()`：从集合中删除元素

remove()：删除指定元素，如果元素不存在，会抛出 KeyError。
discard()：删除指定元素，如果元素不存在，不会抛出异常。

my_set = {1, 2, 3}
my_set.remove(2)
print(my_set)  # 输出: {1, 3}

my_set.discard(4)  # 不抛出异常，集合保持不变
print(my_set)  # 输出: {1, 3}

3.4 `pop()`：删除并返回集合中的一个任意元素

集合是无序的，pop() 会随机删除并返回一个元素。如果集合为空，会抛出 KeyError。

my_set = {1, 2, 3}
removed_element = my_set.pop()
print(removed_element)  # 输出: 1 或 2 或 3（随机）
print(my_set)  # 剩下的元素

3.5 `clear()`：清空集合

my_set = {1, 2, 3}
my_set.clear()
print(my_set)  # 输出: set()

4. 集合运算

4.1 并集（`union()` 或 `|`）

并集返回两个集合中的所有元素，不包括重复元素。

set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1.union(set2)
print(union_set)  # 输出: {1, 2, 3, 4, 5}

# 使用 | 运算符
union_set = set1 | set2
print(union_set)  # 输出: {1, 2, 3, 4, 5}

4.2 交集（`intersection()` 或 `&`）

交集返回两个集合中都包含的元素。

set1 = {1, 2, 3}
set2 = {2, 3, 4}
intersection_set = set1.intersection(set2)
print(intersection_set)  # 输出: {2, 3}

# 使用 & 运算符
intersection_set = set1 & set2
print(intersection_set)  # 输出: {2, 3}

4.3 差集（`difference()` 或 `-`）

差集返回存在于第一个集合但不存在于第二个集合的元素。

set1 = {1, 2, 3}
set2 = {2, 3, 4}
difference_set = set1.difference(set2)
print(difference_set)  # 输出: {1}

# 使用 - 运算符
difference_set = set1 - set2
print(difference_set)  # 输出: {1}

4.4 对称差集（`symmetric_difference()` 或 `^`）

对称差集返回两个集合中不重复的元素，即存在于其中一个集合，但不同时存在于两个集合的元素。

set1 = {1, 2, 3}
set2 = {2, 3, 4}
sym_diff_set = set1.symmetric_difference(set2)
print(sym_diff_set)  # 输出: {1, 4}

# 使用 ^ 运算符
sym_diff_set = set1 ^ set2
print(sym_diff_set)  # 输出: {1, 4}

5. 集合的比较

5.1 子集（`issubset()` 或 `<=`）

判断一个集合是否是另一个集合的子集。

set1 = {1, 2}
set2 = {1, 2, 3}
print(set1.issubset(set2))  # 输出: True

# 使用 <= 运算符
print(set1 <= set2)  # 输出: True

5.2 超集（`issuperset()` 或 `>=`）

判断一个集合是否是另一个集合的超集。

set1 = {1, 2, 3}
set2 = {1, 2}
print(set1.issuperset(set2))  # 输出: True

# 使用 >= 运算符
print(set1 >= set2)  # 输出: True

5.3 判断两个集合是否相交（`isdisjoint()`）

isdisjoint() 判断两个集合是否没有交集。如果没有交集，返回 True，否则返回 False。

set1 = {1, 2, 3}
set2 = {4, 5, 6}
print(set1.isdisjoint(set2))  # 输出: True

6. 集合的遍历

可以使用 for 循环遍历集合中的元素。

my_set = {1, 2, 3}
for item in my_set:
    print(item)
# 输出:
# 1
# 2
# 3

7. 集合的常用操作

7.1 获取集合的长度（`len()`）

my_set = {1, 2, 3}
print(len(my_set))  # 输出: 3

7.2 检查元素是否在集合中（`in` 和 `not in`）

my_set = {1, 2, 3}
print(2 in my_set)     # 输出: True
print(4 not in my_set) # 输出: True

8. 集合的复制

8.1 使用 `copy()` 复制集合

my_set = {1, 2, 3}
copy_set = my_set.copy()
print(copy_set)  # 输出: {1, 2, 3}

9. 不可变集合 `frozenset`

frozenset 是不可变的集合，无法修改、添加或删除元素。frozenset 适用于需要不可变性要求的场景。

9.1 创建 `frozenset`

immutable_set = frozenset([1, 2, 3, 4])
print(immutable_set)  # 输出: frozenset({1, 2, 3, 4})

frozenset 支持与 set 类似的操作，如并集、交集、差集等，但不支持修改操作（如 add()、remove() 等）。

10. 集合推导式

集合推导式用于通过简单的表达式快速生成集合。

10.1 创建简单集合

squared

_set = {x**2 for x in range(1, 6)}
print(squared_set)  # 输出: {1, 4, 9, 16, 25}

10.2 条件推导

even_set = {x for x in range(10) if x % 2 == 0}
print(even_set)  # 输出: {0, 2, 4, 6, 8}

总结

创建与操作：可以通过 set() 函数或直接用大括号创建集合。集合支持基本的添加、删除和清空操作。
集合运算：集合支持并集、交集、差集、对称差集等常见的集合运算。
遍历与长度：可以使用 for 循环遍历集合，使用 len() 获取集合的大小。
集合推导式：可以使用集合推导式快速创建集合。
frozenset：是一种不可变的集合，适合用于不可修改的数据场景。

通过掌握这些操作，可以灵活使用集合处理唯一性要求的数据或进行集合运算。

（十六）、 None 类型

定义：None 是 Python 中表示“无”或“空”的特殊类型。它常用于表示缺少值、空值或函数没有返回值。
表达方式：
- 使用关键字 None 表示。

示例：

a = None   # a 的值是 None

（十七）、 None 类型的各种操作示例

在 Python 中，None 是一个特殊的常量，表示 “没有值” 或 “空值”。它是一个独立的类型，称为 NoneType，并且常用于表示默认值、未定义状态、或者函数没有返回值的情况。None 通常用于标识空对象或占位符。

以下是 None 类型的各种操作及其示例：

1. `None` 的基本定义与使用

1.1 定义 `None`

None 是 Python 中的单例对象，表示 “什么都没有”。

x = None
print(x)  # 输出: None

1.2 检查变量是否为 `None`

使用 is 操作符来检查变量是否等于 None，而不是使用 ==。

x = None
print(x is None)  # 输出: True

# 避免使用 '==' 进行判断，因为 'is' 是用于检查对象标识符的
print(x == None)  # 输出: True, 但不推荐

2. `None` 与布尔上下文

在布尔上下文中，None 被视为 False。

x = None
if not x:
    print("x is None or evaluates to False")  # 输出: x is None or evaluates to False

None 在 if 语句或布尔运算中等价于 False，因此可以直接用于条件判断。

3. `None` 与函数

3.1 函数默认返回 `None`

如果函数没有显式返回值，默认返回 None。

def example():
    pass

result = example()
print(result)  # 输出: None

3.2 显式返回 `None`

函数可以显式返回 None，以表示某种特殊情况或未定义状态。

def example():
    return None

result = example()
print(result)  # 输出: None

4. `None` 作为默认参数值

None 常用于函数的默认参数值，表示参数可选。如果参数未传递，使用 None 作为占位符，并在函数内部检查它。

def process(data=None):
    if data is None:
        print("No data provided")
    else:
        print(f"Processing {data}")

process()  # 输出: No data provided
process([1, 2, 3])  # 输出: Processing [1, 2, 3]

5. `None` 与列表、字典等可变对象

None 可以作为列表、字典等可变对象的元素，表示这些位置没有值。

5.1 `None` 在列表中

lst = [1, None, 2, None, 3]
print(lst)  # 输出: [1, None, 2, None, 3]

5.2 `None` 在字典中

d = {'key1': None, 'key2': 2}
print(d)  # 输出: {'key1': None, 'key2': 2}

# 检查字典键的值是否为 None
if d['key1'] is None:
    print("key1 has no value")  # 输出: key1 has no value

6. `None` 与类型检查

可以使用 type() 函数来检查对象是否为 NoneType 类型。

x = None
print(type(x))  # 输出: <class 'NoneType'>

7. 赋值与覆盖 `None`

可以将变量设置为 None 来表示其没有被赋值或重置其值。

x = 42
x = None  # 重置变量 x
print(x)  # 输出: None

8. `None` 在类中的使用

None 常用于类的属性初始化，表示该属性尚未被赋值或可延迟赋值。

class Person:
    def __init__(self, name=None, age=None):
        self.name = name
        self.age = age

p = Person()
print(p.name)  # 输出: None
print(p.age)   # 输出: None

9. `None` 与逻辑运算

在逻辑运算中，None 会被视为 False。

9.1 使用 `and` 和 `or` 运算符

x = None
y = 10

# `and`：因为 x 为 None，相当于 False，结果为 None
result = x and y
print(result)  # 输出: None

# `or`：因为 x 为 None，相当于 False，结果为 y
result = x or y
print(result)  # 输出: 10

10. `None` 的短路行为

在逻辑运算中，None 会触发短路行为。

10.1 `and` 短路

None 在 and 运算中等同于 False，后续表达式不会被执行。

x = None
y = 1 / 0  # 会导致 ZeroDivisionError，但由于短路行为不会被执行

result = x and y  # 不会抛出异常
print(result)  # 输出: None

10.2 `or` 短路

在 or 运算中，如果第一个表达式为 None，继续评估第二个表达式。

x = None
y = 10

result = x or y  # 因为 x 为 None，返回 y
print(result)  # 输出: 10

11. `None` 与可迭代对象

None 不能直接用于迭代。

x = None

# 尝试遍历 None 会导致 TypeError
# for item in x:
#     print(item)  # 会抛出 TypeError: 'NoneType' object is not iterable

12. `None` 与比较运算

None 可以参与比较运算，但通常不会与其他类型进行比较。对于同类型的 None 比较是安全的。

x = None
y = None

# 比较两个 None
print(x == y)  # 输出: True
print(x is y)  # 输出: True

13. `None` 在数据结构中的应用

在一些复杂的数据结构中，None 常被用作占位符，表示尚未赋值或空状态。

13.1 `None` 在链表中作为终止节点

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None  # None 表示链表的终止

node1 = Node(1)
node2 = Node(2)
node1.next = node2  # node1 指向 node2
print(node1.next)  # 输出: <__main__.Node object at ...>
print(node2.next)  # 输出: None

总结

None 的基本特性：None 是一个特殊的对象，表示 “无值” 或 “空值”。
None 在逻辑运算中被视为 False，并且可以用于短路操作。
None 常用于表示函数的默认参数值或未赋值的变量。
使用 is 来检查 None，不要使用 ==。
None 在数据结构中常用于表示占位符或终止节点。

通过掌握 None 的用法，可以更好地处理空值、默认值、占位符等编程场景。

（十八）、字节（`bytes`）

定义：字节是表示二进制数据的不可变序列，常用于处理文件、网络传输等需要处理原始二进制数据的场景。
表达方式：
- 使用 b'' 或 b"" 表示字节序列。

示例：

byte_data = b"hello"   # 字节类型

（十九）、字节数组（`bytearray`）

定义：字节数组是可变的字节序列，允许修改其内容。
表达方式：
- 使用 bytearray() 函数创建字节数组。

示例：

byte_array = bytearray(b"hello")  # 字节数组类型
byte_array[0] = 100               # 修改第一个字节

数据类型之间的相互转换

Python 提供了许多内置函数，可以用于不同数据类型之间的转换：

示例：

# 数字和字符串的转换
n = 10
s = str(n)            # 将整数转换为字符串，结果是 "10"
m = int(s)            # 将字符串转换为整数，结果是 10

# 列表和元组的转换
lst = [1, 2, 3]
tup = tuple(lst)      # 列表转元组，结果是 (1, 2, 3)
lst2 = list(tup)      # 元组转列表，结果是 [1, 2, 3]

# 列表和集合的转换
lst = [1, 2, 2, 3]
set1 = set(lst)       # 列表转集合，去除重复元素，结果是 {1, 2, 3}
lst3 = list(set1)     # 集合转列表，结果是 [1, 2, 3]

# 字符串和列表的转换
s = "hello"
lst4 = list(s)        # 字符串转列表，结果是 ['h', 'e', 'l', 'l', 'o']
s2 = ''.join(lst4)    # 列表转字符串，结果是 "hello"

总结

数值类型：包括整数、浮点数、复数，表示各种数值。
序列类型：包括字符串、列表、元组，表示有序的数据集合。
字典和集合：字典是键值对集合，集合是无序的、不可重复的元素集合。
None 类型：表示空值或无值。

查看全文

http://www.kler.cn/news/362363.html

Java工具类--截至2024常用http工具类分享

spring boot 集成 dynamic-datasource-spring-boot-starter

C++数据类型转换

长短期记忆网络（Long Short-Term Memory，LSTM）

【Excel】兵来将挡01-删除多余的空白行（一行全部取底色后删除表格外多余的带底色空白格）

10.22 MySQL

京东北京 java 中级: 哪些情况下的对象会被垃圾回收机制处理掉? 哪些对象可以被看做是 GC Roots 呢？对象不可达，一定会被垃圾收集器回收么？

leetcode hot100【LeetCode 49. 字母异位词分组】java实现

理解多线程中的上下文切换：原理解析与Java模拟实现

2024入门测参考答案（c语言版）

C#学习笔记（五）

如何将logism电路转为verilog（一）

【JavaScript】Javascript基础Day02：运算符、分支、循环

从新手到高手：map和set的使用技巧全攻略（C++）

自由学习记录（14）

‌竞赛报名网站毕设计算机毕业设计基于SpringBootSSM框架

第二十七篇：传输层讲解，TCP系列一

内核提供的通用I2C设备驱动I2C-dev.c分析：file_ops篇

10. 异常处理器

【某农业大学计算机网络实验报告】实验二交换机的自学习算法

Python小程序 - 替换文件内容

Redis Search系列 - 第四讲支持中文

003：Context Capture10.16安装教程

Linux中如何理解一切皆文件

【YOLO模型】（1）--YOLO是什么

Android 13 SPRD 如何临时修改 Android 系统版本

一、各种数据类型的定义与常规计算

（一） 整数（int）

示例：

（二）整数的操作

1. 算术运算

1.1 加法（+）

1.2 减法（-）

1.3 乘法（*）

1.4 除法（/）

1.5 整除（//）

1.6 取余（%）

1.7 幂运算（**）

1.8 绝对值（abs()）

2. 比较运算

2.1 等于（==）

2.2 不等于（!=）

2.3 大于（>）

2.4 小于（<）

2.5 大于等于（>=）

2.6 小于等于（<=）

3. 位运算

3.1 按位与（&）

3.2 按位或（|）

3.3 按位异或（^）

3.4 按位取反（~）

3.5 左移（<<）

3.6 右移（>>）

4. 内置函数

4.1 int() 类型转换

4.2 pow() 幂运算

4.3 divmod() 同时返回商和余数

4.4 bin()、oct() 和 hex() 进制转换

5. 类型检查

6. 进制表示

7. 数学运算

总结

（三）、 浮点数（float）

示例：

（四）、浮点数（float）的运算与各种操作示例

1. 基本算术运算

1.1 加法（+）

1.2 减法（-）

1.3 乘法（*）

1.4 除法（/）

1.5 取余（%）

1.6 幂运算（**）

1.7 整除（//）

2. 浮点数的比较运算

2.1 等于（==）

2.2 不等于（!=）

2.3 大于（>）

2.4 小于（<）

2.5 大于等于（>=）

2.6 小于等于（<=）

3. 浮点数类型转换

3.1 int()：浮点数转整数

3.2 float()：将其他类型转换为浮点数

3.3 round()：四舍五入

4. 浮点数与精度问题

使用 decimal 模块避免浮点数精度问题：

5. 常用的数学函数（使用 math 模块）

5.1 计算平方根

5.2 计算指数（e^x）

5.3 计算对数

5.4 向上取整和向下取整

5.5 计算三角函数

6. 浮点数精度与格式化输出

6.1 format() 函数

6.2 使用 f-字符串格式化输出

7. 浮点数的特殊值

7.1 正无穷大和负无穷大

7.2 NaN（Not a Number）

8. 浮点数的类型检查

总结

（五）、 复数（complex）

示例：

（六）、浮点数（float）运算

1. 基本算术运算

1.1 加法（+）

1.2 减法（-）

（一）整数（`int`）

1.1 加法（`+`）

1.2 减法（`-`）

1.3 乘法（`*`）

1.4 除法（`/`）

1.5 整除（`//`）

1.6 取余（`%`）

1.7 幂运算（`**`）

1.8 绝对值（`abs()`）

2.1 等于（`==`）

2.2 不等于（`!=`）

2.3 大于（`>`）

2.4 小于（`<`）

2.5 大于等于（`>=`）

2.6 小于等于（`<=`）

3.1 按位与（`&`）

3.2 按位或（`|`）

3.3 按位异或（`^`）

3.4 按位取反（`~`）

3.5 左移（`<<`）

3.6 右移（`>>`）

4.1 `int()` 类型转换

4.2 `pow()` 幂运算

4.3 `divmod()` 同时返回商和余数

4.4 `bin()`、`oct()` 和 `hex()` 进制转换

（三）、浮点数（`float`）

（四）、浮点数（`float`）的运算与各种操作示例

1.1 加法（`+`）

1.2 减法（`-`）

1.3 乘法（`*`）

1.4 除法（`/`）

1.5 取余（`%`）

1.6 幂运算（`**`）

1.7 整除（`//`）

2.1 等于（`==`）

2.2 不等于（`!=`）

2.3 大于（`>`）

2.4 小于（`<`）

2.5 大于等于（`>=`）

2.6 小于等于（`<=`）

3.1 `int()`：浮点数转整数

3.2 `float()`：将其他类型转换为浮点数

3.3 `round()`：四舍五入

使用 `decimal` 模块避免浮点数精度问题：

5. 常用的数学函数（使用 `math` 模块）

5.2 计算指数（`e^x`）

6.1 `format()` 函数

7.2 `NaN`（Not a Number）

（五）、复数（`complex`）

（六）、浮点数（`float`）运算

1.1 加法（`+`）

1.2 减法（`-`）

1.3 乘法（`*`）

1.4 除法（`/`）

1.5 取余（`%`）

1.6 幂运算（`**`）

1.7 整除（`//`）

2.1 等于（`==`）

2.2 不等于（`!=`）

2.3 大于（`>`）

2.4 小于（`<`）

2.5 大于等于（`>=`）

2.6 小于等于（`<=`）

3.1 `int()`：浮点数转整数

3.2 `float()`：将其他类型转换为浮点数

3.3 `round()`：四舍五入

使用 `decimal` 模块避免浮点数精度问题：

5. 常用的数学函数（使用 `math` 模块）

5.2 计算指数（`e^x`）

6.1 `format()` 函数

7.2 `NaN`（Not a Number）

（七）、字符串（`str`）

（八）、字符串（`str`）之间的各种操作示例

2.1 字符串拼接（使用 `+`）

2.2 字符串重复（使用 `*`）

4.1 使用 `%` 运算符进行格式化

4.2 使用 `str.format()` 方法

6.1 分割字符串（`split()`）

6.2 连接字符串（`join()`）

9.1 获取字符串长度（`len()`）