标准数据类型
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、创建空字典使用 { }。