05数

## 概念

在 Python 中，“数” 是用于表示数量、大小的基础数据类型，主要分为**整数（int）**、**浮点数（float）**、**复数（complex）** 三大类，此外还有一种特殊的 “布尔值（bool）”（本质是整数的子类）。

## 整数（int）

整数是没有小数部分的数字，可以是正整数、负整数或零。在 Python 中，整数没有大小限制（无论多大或多小的整数都能表示）。

**特点与表示**

- 日常使用的 “整数” 默认是十进制（0-9 组成），例如：0、123、-456。

- 也支持其他进制表示（需加前缀）：

二进制（0 和 1 组成）：前缀 0b 或 0B，如 0b101（对应十进制 5）。

八进制（0-7 组成）：前缀 0o 或 0O，如 0o12（对应十进制 10）。

十六进制（0-9、a-f、A-F 组成）：前缀 0x 或 0X，如 0x1a（对应十进制 26）。

```python
a = 42          # 十进制正整数
b = -100        # 十进制负整数
c = 0           # 零
d = 0b1111      # 二进制，等于十进制15
e = 0o755       # 八进制，等于十进制493
f = 0xabc       # 十六进制，等于十进制2748
```

## 浮点数（float）

浮点数是带小数部分的数字，用于表示有精度要求的数值（如长度、重量、小数结果等）。

**特点与表示**

基本形式：直接包含小数点，如 3.14、-0.001、5.0（注意：5.0 是浮点数，不是整数）。

科学计数法：当数值极大或极小时，可用 e 或 E 表示（e 等价于 “×10 的 n 次方”），例如：

- 1.23e4 表示 1.23 × 10⁴ = 12300
- 5e-3 表示 5 × 10⁻³ = 0.005

注意：浮点数的精度问题，由于计算机存储方式的限制，浮点数可能存在**精度误差**（并非 Python 独有，所有编程语言都有类似问题）。例如：

```python
>>> print(0.1 + 0.2)
0.30000000000000004
# 输出：0.30000000000000004（而非0.3）
```

如果需要精确计算（如金融场景），可使用 Python 的 decimal 模块

## 复数（complex）

复数是由**实部**和**虚部**组成的数，形式为 a + bj（a 是实部，b 是虚部，j 或 J 表示虚数单位，即√-1）。

**特点与表示**

- 实部和虚部都可以是整数或浮点数，例如：3+4j、-2.5+1j、0-1j（可简写为 -1j）。

- 可通过 .real 获取实部，.imag 获取虚部：

```python
  >>> z = 3 + 4j
  >>> print(z.real)
  3.0
  >>> print(z.imag)
  4.0
  # 输出：3.0（实部，注意返回浮点数）
  # 输出：4.0（虚部，返回浮点数）
  
  ```

**应用场景：**复数主要用于科学计算、工程领域（如信号处理、电磁场分析等），日常开发中较少使用。

## 布尔值（bool）

布尔值是一种特殊的数值类型，只有两个取值：True（真）和 False（假），主要用于逻辑判断（如条件语句、循环控制）。

本质：布尔值是整数的子类：

- True 等价于整数 1
- False 等价于整数 0

```python
>>> print(True + 1)
2
>>> print(False * 5)
0
>>> a = 5
>>> b = 10
>>> print(a < b)
True
>>> print(a == b)
False
```

## 数值类型的转换

不同类型的数可以通过内置函数相互转换（转换规则与数学逻辑一致）：

- int(x)：将x转换为整数（去掉小数部分，或解析合法字符串）。
- float(x)：将x转换为浮点数。
- complex(x)：将x转换为复数（虚部为 0）；complex(x, y) 表示实部x、虚部y的复数。

```python
>>> print(int(3.9))
3
>>> print(int("123"))
123
>>> print(float(5))
5.0
>>> print(float("3.14"))
3.14
>>> print(complex(2))
(2+0j)
>>> print(complex(3, 4))
(3+4j)
```

## 运算符分类

Python 运算符按功能分为 9 大类，核心常用的有：

- 算术运算符：处理数值计算；
- 比较与逻辑运算符：处理条件判断；
- 赋值运算符：简化变量赋值；
- 成员与身份运算符：判断元素归属和对象身份。

## 算术运算符（用于数值计算）

Python 支持多种算术运算符，可直接对数值进行计算：

| 运算符 | 功能                  | 示例                             |
| ------ | --------------------- | -------------------------------- |
| +      | 加法                  | 3 + 5 → 8                        |
| -      | 减法                  | 10 - 4 → 6                       |
| *      | 乘法                  | 2 * 7 → 14                       |
| /      | 除法（结果为浮点数）  | 7 / 2 → 3.5                      |
| //     | 取整除（向下取整）    | 7 // 2 → 3；-7//2 → -4           |
| %      | 取余数（模运算）      | 7 % 2 → 1；5 % 3 → 2             |
| **     | 幂运算（x 的 y 次方） | 2**3 → 8；9**0.5 → 3.0（开平方） |

注意：

- 除法（/） 永远返回浮点数（即使能整除，如 6/2=3.0）；
- 整除（//） 向下取整（如 10//3=3，-10//3=-4）；
- 取余（%） 结果的符号与除数一致（如 10%3=1，10%-3=-2）。

## 比较运算符（用于判断关系）

比较两个值的关系，返回布尔值 True（成立）或 False（不成立）。

| 运算符 | 描述               | 示例（a=10, b=3） | 结果  |
| ------ | ------------------ | ----------------- | ----- |
| ==     | 等于（值是否相等） | a == b            | False |
| !=     | 不等于             | a != b            | True  |
| >      | 大于               | a > b             | True  |
| <      | 小于               | a < b             | False |
| >=     | 大于等于           | a >= 10           | True  |
| <=     | 小于等于           | b <= 2            | False |

**注意**：

- == 是 “判断值相等”，而 = 是 “赋值”，二者完全不同（如 if a == 5 是判断，a = 5 是赋值）；
- 可连续比较（如 3 < 5 < 10 等价于 3 < 5 and 5 < 10，返回 True）。

## 逻辑运算符（用于逻辑判断）

组合多个条件，返回布尔值 True 或 False，常用于复杂条件判断。

| 运算符 | 描述           | 规则（A 和 B 为条件）             | 示例             | 结果 |
| ------ | -------------- | --------------------------------- | ---------------- | ---- |
| and    | 逻辑与（且）   | A 和 B 都为True，结果才为True     | 5 > 3 and 5 < 10 | True |
| or     | 逻辑或（或）   | A 或 B 有一个为True，结果就为True | 5 > 10 or 5 < 10 | True |
| not    | 逻辑非（取反） | 条件为True时结果为False，反之亦然 | not (5 > 10)     | True |

**短路特性**（提高效率）：

- and：若左边条件为False，直接返回False，不再判断右边（如 False and (1/0) 不报错，因右边不执行）；
- or：若左边条件为True，直接返回True，不再判断右边（如 True or (1/0) 不报错）。

## 赋值运算符（用于变量赋值）

将右边的值赋给左边的变量，支持简单赋值和复合赋值（简化运算 + 赋值）。

| 运算符 | 描述       | 示例（等价形式）     | 说明                               |
| ------ | ---------- | -------------------- | ---------------------------------- |
| =      | 基础赋值   | a = 10               | 将 10 赋给变量 a                   |
| +=     | 加法赋值   | a += 5 → a = a + 5   | 先加 5，再赋值给 a                 |
| -=     | 减法赋值   | a -= 5 → a = a - 5   | 先减 5，再赋值给 a                 |
| *=     | 乘法赋值   | a *= 5 → a = a * 5   | 先乘 5，再赋值给 a                 |
| /=     | 除法赋值   | a /= 5 → a = a / 5   | 先除 5，再赋值给 a（结果为浮点数） |
| //=    | 整除赋值   | a //= 5 → a = a // 5 | 先整除 5，再赋值给 a               |
| %=     | 取余赋值   | a %= 5 → a = a % 5   | 先取余 5，再赋值给 a               |
| **=    | 幂运算赋值 | a **=5 → a = a** 5   | 先求 a 的 5 次方，再赋值给 a       |

## 成员运算符（判断元素是否在序列中）

判断某个元素是否属于一个 “可迭代对象”（如列表、字符串、字典等），返回布尔值。

| 运算符 | 描述           | 示例               | 结果 |
| ------ | -------------- | ------------------ | ---- |
| in     | 元素在序列中   | "a" in ["a", "b"]  | True |
| not in | 元素不在序列中 | 3 not in (1, 2, 4) | True |

**注意**：

- 对字典使用时，判断的是 “键（key）” 是否存在，而非值（value）：

```python
>>> person = {"name": "张三", "age": 30}
>>> print("name" in person)
True	# True（判断键"name"是否存在）
>>> print("张三" in person)
False	# False（不判断值）
```

## 身份运算符（判断对象是否为同一个）

判断两个变量是否指向 “同一个内存地址的对象”（即是否为同一个实例），返回布尔值。

| 运算符 | 描述           | 示例                             | 结果 |
| ------ | -------------- | -------------------------------- | ---- |
| is     | 是同一个对象   | a = [1,2]; b = a; a is b         | True |
| is not | 不是同一个对象 | a = [1,2]; b = [1,2]; a is not b | True |

**区别 is 与 ==**：

- == 比较的是 “值是否相等”；
- is 比较的是 “身份是否相同”（内存地址是否一致）。

```python
>>> a = [1, 2]
>>> b = [1, 2]
>>> print(a == b)
True	# True（值相等）
>>> print(a is b)
False	# False（不是同一个对象，内存地址不同）
```

对 None 的判断推荐用 is（如 if x is None）。

## 位运算符（对二进制位操作）

直接对整数的二进制位进行运算（较少用于日常开发，多用于底层或性能优化）。

| 运算符 | 描述                       | 示例（a=6 → 0110，b=3 → 0011） | 结果（二进制→十进制） |          |      |
| ------ | -------------------------- | ------------------------------ | --------------------- | -------- | ---- |
| &      | 按位与（都为 1 则为 1）    | a & b → 0010                   | 2                     |          |      |
|        |                            | 按位或（有 1 则为 1）          | a                     | b → 0111 | 7    |
| ^      | 按位异或（不同则为 1）     | a ^ b → 0101                   | 5                     |          |      |
| ~      | 按位取反（0 变 1，1 变 0） | ~a → 1001（补码）              | -7                    |          |      |
| <<     | 左移（二进制位左移 n 位）  | a << 1 → 1100                  | 12                    |          |      |
| >>     | 右移（二进制位右移 n 位）  | a >> 1 → 0011                  | 3                     |          |      |

## 元运算符（条件表达式）

简化 if-else 逻辑，一行代码实现 “条件成立返回 A，否则返回 B”。

语法：

```python
结果 = A if 条件 else B
```

例如：
```python
age = 18
status = "成年" if age >= 18 else "未成年"
print(status)  # 输出：成年
```

## 运算符优先级（执行顺序）

当多个运算符同时出现时，按以下优先级执行（从高到低），可通过 () 强制改变顺序：

1. 幂运算 **
2. 正负号 +x、-x
3. 位运算符 ~
4. 乘除、取余 *、/、//、%
5. 加减 +、-
6. 位运算符 <<、>>
7. 位运算符 &
8. 位运算符 ^、|
9. 比较运算符 ==、!=、>、< 等
10. 身份运算符 is、is not
11. 成员运算符 in、not in
12. 逻辑非 not
13. 逻辑与 and
14. 逻辑或 or