标准数据类型
Python3 中常见的数据类型有：
- Number（数字）
- String（字符串）
- bool（布尔类型）
- List（列表）
- Tuple（元组）
- Set（集合）
- Dictionary（字典）
Python3 的六个标准数据类型中：
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
Number（数字）
Python 3 支持以下几种数字类型：
1. 整数（int）
特点：
表示任意大小的整数，无长度限制，支持正负数和零
可以用十进制、二进制（0b 前缀）、八进制（0o 前缀）或十六进制（0x 前缀）表示
x = 100 # 十进制
y = -256 # 负数
z = 0 # 零
bin_num = 0b1010 # 二进制（等于十进制 10）
oct_num = 0o12 # 八进制（等于十进制 10）
hex_num = 0xA # 十六进制（等于十进制 10）
print(bin_num == oct_num == hex_num) # 输出: True
2. 浮点数（float）
特点：
表示带有小数点的数值，也可以用科学计数法（e 或 E 表示 10 的幂）表示
浮点数的精度有限，可能存在舍入误差
a = 3.14 # 标准写法
b = -0.005 # 负数
c = 2.5e3 # 科学计数法（2.5 × 10³ = 2500.0）
d = 1.23e-4 # 科学计数法（1.23 × 10⁻⁴ = 0.000123）
# 浮点数精度问题
print(0.1 + 0.2) # 输出: 0.30000000000000004（舍入误差）
3. 复数（complex）
特点：
由实部和虚部组成，虚部以 j 或 J 结尾
可以使用 complex(real, imag) 函数创建，或直接用 a+bj 表示
z1 = 3 + 4j # 实部 3，虚部 4
z2 = complex(1, -2) # 实部 1，虚部 -2
z3 = 2j # 实部 0，虚部 2
# 访问实部和虚部
print(z1.real) # 输出: 3.0
print(z1.imag) # 输出: 4.0
# 复数运算
print(z1 + z2) # 输出: (4+2j)
4. 布尔类型（bool）
特点：
布尔类型是特殊的整数类型，True 等价于 1，False 等价于 0
常用于条件判断和逻辑运算
x = True
y = False
print(int(x)) # 输出: 1
print(int(y)) # 输出: 0
print(3 > 2) # 输出: True
print(3 + True) # 输出: 4（3 + 1）
String（字符串）
1. 基础定义
用 ‘单引号’、“双引号” 或 ‘’‘三引号’‘’ 包裹文本
三引号支持多行字符串
s1 = 'Hello'
s2 = """多行
字符串"""
2. 不可变性
不能直接修改字符串，操作会生成新字符串
s = "Hi"
s = s + "!" # 创建新字符串 "Hi!"
3. 索引与切片
索引：从 0 开始，负数表示从后往前
s = "Python"
print(s[0]) # 'P'
print(s[-1]) # 'n'
切片：[开始:结束:步长]（结束位置不包含）
print(s[0:2]) # 'Py'
print(s[::-1]) # 反转：'nohtyP'
4. 常用操作
| 操作 | 示例 | 结果 |
|---|---|---|
| 拼接 | “a” + “b” | “ab” |
| 重复 | “a” | “aaa” |
| 成员判断 | “e” in “hello” | True |
| 长度 | len(“abc”) | 3 |
5. 常用方法
| 方法 | 作用 | 示例 |
|---|---|---|
| upper() | 转大写 | “hi”.upper() → “HI” |
| lower() | 转小写 | “HI”.lower() → “hi” |
| strip() | 去除首尾空白 | " a ".strip() → “a” |
| replace(a,b) | 替换子串 | “hi”.replace(“h”, “H”) → “Hi” |
| split(sep) | 按分隔符分割成列表 | “a,b,c”.split(“,”) → [“a”,“b”,“c”] |
| join(lst) | 用字符串连接列表元素 | “-”.join([“a”,“b”]) → “a-b” |
| find(sub) | 查找子串位置（不存在返回 -1） | “hi”.find(“i”) → 1 |
| count(sub) | 统计子串出现次数 | “hi”.count(“h”) → 1 |
List（列表）
List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
1. 基础定义
用 [] 定义，元素用逗号分隔，可包含不同类型。
lst = [1, "apple", True]
2. 特点
可变：可修改、添加、删除元素。
有序：元素有固定位置（索引）。
可重复：允许存在相同元素。
3. 索引与切片
索引：从 0 开始，负数表示从后往前。
lst = [10, 20, 30]
print(lst[0]) # 10
print(lst[-1]) # 30
切片：[开始:结束:步长]（结束位置不包含）。
print(lst[1:3]) # [20, 30]
print(lst[::-1]) # 反转：[30, 20, 10]
4. 常用操作
| 操作 | 示例 | 结果 |
|---|---|---|
| 拼接 | [1,2] + [3] | [1, 2, 3] |
| 重复 | [1] * 3 | [1, 1, 1] |
| 成员判断 | 2 in [1,2,3] | True |
| 长度 | len([1,2,3]) | 3 |
注意：
1、列表写在方括号之间，元素用逗号隔开。
2、和字符串一样，列表可以被索引和切片。
3、列表可以使用 + 操作符进行拼接。
4、列表中的元素是可以改变的。
Tuple（元组）
元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开
1. 基础定义
用 () 定义，元素用逗号分隔，可包含不同类型。
t = (1, "apple", True)
特殊情况：单元素元组需加逗号。
single = (1,) # 必须加逗号！
2. 特点
不可变：创建后不能修改（增删改元素）。
有序：元素有固定位置（索引）。
可重复：允许存在相同元素。
3. 索引与切片
索引：从 0 开始，负数表示从后往前。
t = (10, 20, 30)
print(t[0]) # 10
print(t[-1]) # 30
切片：[开始:结束:步长]（结束位置不包含）。
print(t[1:3]) # (20, 30)
print(t[::-1]) # 反转：(30, 20, 10)
4. 常用操作
| 操作 | 示例 | 结果 |
|---|---|---|
| 拼接 | (1,2) + (3,) | (1, 2, 3) |
| 重复 | (1,) * 3 | |
| 成员判断 | 2 in (1,2,3) | True |
| 长度 | len((1,2,3)) | 3 |
5. 常用方法
| 方法 | 作用 | 示例 |
|---|---|---|
| count(x) | 统计 x 出现的次数 | (1,2,2).count(2) → 2 |
| index(x) | 返回第一个 x 的索引 | (1,2,3).index(2) → 1 |
6. 元组的不可变性
不能修改元素，但可以重新赋值整个元组：
t = (1, 2)
#t[0] = 100 ❌ 报错！
t = (100, 2) ✅ 允许！
注意：
1、与字符串一样，元组的元素不能修改。
2、元组也可以被索引和切片，方法一样。
3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
4、元组也可以使用 + 操作符进行拼接。
Set（集合）
Python 中的集合（Set）是一种无序、可变的数据类型，用于存储唯一的元素。
集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。
在 Python 中，集合使用大括号 {} 表示，元素之间用逗号 , 分隔。
另外，也可以使用 set() 函数创建集合。
注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
parame = {value01,value02,…}
或者
set(value)
#!/usr/bin/python3
sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}
print(sites) # 输出集合，重复的元素被自动去掉
# 成员测试
if 'Runoob' in sites :
print('Runoob 在集合中')
else :
print('Runoob 不在集合中')
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b) # a 和 b 的差集
print(a | b) # a 和 b 的并集
print(a & b) # a 和 b 的交集
print(a ^ b) # a 和 b 中不同时存在的元素
1. 基础定义
用 {} 或 set() 定义，元素必须唯一且不可变（如数字、字符串、元组）。
s = {1, 2, 3} # 直接创建集合
s = set([1, 2, 2, 3]) # 从列表创建（自动去重）→ {1, 2, 3}
空集合必须用 set()，因为 {} 表示空字典。
2. 特点
无序：不支持索引和切片。
元素唯一：自动去重。
可变：可以添加 / 删除元素。
3. 基本操作
| 操作 | 示例 | 结果 |
|---|---|---|
| 添加元素 | s.add(4) | {1, 2, 3, 4} |
| 添加多个元素 | s.update([4, 5]) | {1, 2, 3, 4, 5} |
| 删除元素 | s.remove(3) {1, 2} | （不存在则报错） |
| 安全删除 | s.discard(3) | 不存在不报错 |
| 随机删除 | s.pop() | 随机删除并返回一个元素 |
| 清空集合 | s.clear() | set() |
Dictionary（字典）
字典（dictionary）是Python中另一个非常有用的内置数据类型。
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。
1. 基础定义
用 {} 定义，由 键值对（key: value） 组成，键必须唯一。
d = {
"name": "Alice",
"age": 25,
"hobbies": ["reading", "coding"]
}
2. 特点
无序：3.7+ 版本后保留插入顺序，但不支持索引。
键不可变：键必须是不可变类型（如字符串、数字、元组）。
值可变：值可以是任意类型。
3. 访问值
通过键获取值，键不存在时会报错。
print(d["name"]) # "Alice"
print(d["city"]) ❌ 报错：KeyError
安全方法：使用 get()，不存在时返回默认值。
print(d.get("city", "Unknown")) # "Unknown"
注意：
1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。
3、创建空字典使用 { }。