基本数据类型
一、基本数据类型
Python 的基本数据类型可分为以下几类：
- 标量类型：数字（整数、浮点数、复数、布尔值）、字符串
- 容器类型：列表、元组、字典、集合
二、数据类型转换
Python 提供了内置函数用于数据类型转换，常见转换方式如下：
| 函数 | 功能说明 | 示例 |
|---|---|---|
int(x) |
将 x 转换为整数（忽略小数部分） |
int(3.8) → 3；int("100") → 100 |
float(x) |
将 x 转换为浮点数 |
float(5) → 5.0；float("3.14") → 3.14 |
str(x) |
将 x 转换为字符串 |
str(123) → "123"；str([1,2]) → "[1, 2]" |
list(x) |
将可迭代对象 x 转换为列表 |
list("abc") → ['a','b','c']；list((1,2)) → [1,2] |
tuple(x) |
将可迭代对象 x 转换为元组 |
tuple([1,2]) → (1,2)；tuple("hi") → ('h','i') |
dict(x) |
将键值对序列 x 转换为字典 |
dict([(1,'a'), (2,'b')]) → {1: 'a', 2: 'b'} |
set(x) |
将可迭代对象 x 转换为集合（去重） |
set([1,1,2]) → {1,2} |
bool(x) |
将 x 转换为布尔值（空/0 为 False） |
bool(0) → False；bool("a") → True |
三、详细数据类型说明
1. 数字（Numbers）
Python 数字类型包括整数（int）、浮点数（float）、复数（complex）和布尔值（bool，特殊的整数）。
创建
# 整数（无大小限制）
a = 100
b = -20
c = 0b1010 # 二进制（10）
d = 0o12 # 八进制（10）
e = 0x0a # 十六进制（10）
# 浮点数（带小数点）
f = 3.14
g = -0.001
h = 1.2e3 # 科学计数法（1200.0）
# 复数（实部+虚部j）
i = 3 + 4j
j = 5j # 纯虚数
# 布尔值（True=1，False=0）
k = True
l = False
访问
数字是不可变类型，直接通过变量名访问值：
print(a) # 100
print(f) # 3.14
常用操作与函数
- 算术运算符：
+、-、*、/（除法，返回浮点数）、//（整除）、%（取余）、**（幂运算）print(5 / 2) # 2.5 print(5 // 2) # 2 print(5 % 2) # 1 print(2 **3) # 8 - 内置函数：
abs(x)：返回绝对值round(x, n)：四舍五入，n为小数位数max(x1, x2, ...)/min(x1, x2, ...)：返回最大值/最小值pow(x, y)：返回x** y
print(abs(-3)) # 3 print(round(3.1415, 2)) # 3.14 print(max(1, 5, 3)) # 5
2. 字符串（String）
字符串是字符的有序序列，用单引号（'）、双引号（"）或三引号（'''/"""，支持多行）包裹。
创建
s1 = 'hello'
s2 = "world"
s3 = '''多行
字符串'''
s4 = "I'm a student" # 双引号内可包含单引号
s5 = 'He said "Hi"' # 单引号内可包含双引号
访问
- 索引：通过
[index]访问单个字符（索引从 0 开始，负数表示从末尾计数） - 切片：通过
[start:end:step]访问子串（左闭右开，step为步长）
s = "python"
print(s[0]) # 'p'（第一个字符）
print(s[-1]) # 'n'（最后一个字符）
print(s[1:4]) # 'yth'（索引1到3的字符）
print(s[::2]) # 'pto'（每隔一个字符取一次）
常用操作与方法
-
拼接：
+运算符或*重复print("hello" + " " + "world") # "hello world" print("a" * 3) # "aaa" -
成员判断：
in/not inprint("ll" in "hello") # True -
常用内置方法：
s.lower()/s.upper()：转换为小写/大写s.strip()：去除首尾空白字符s.split(sep)：按sep分割为列表s.join(iter)：用s拼接可迭代对象s.replace(old, new)：替换子串
s = " Hello World " print(s.strip()) # "Hello World" print(s.lower()) # " hello world " print("abc".join(["1", "2"])) # "1abc2" print(s.replace("World", "Python")) # " Hello Python " -
内置函数：
len(s)：返回字符串长度str.format()：格式化字符串（或用 f-字符串更简洁）
print(len("hello")) # 5 print(f"Name: {name}, Age: {age}") # f-字符串格式化
3. 列表（List）
列表是有序、可变的元素集合，元素可以是不同类型，用 [] 定义。
创建
l1 = [1, 2, 3]
l2 = ["a", 1, True] # 元素类型可混合
l3 = [] # 空列表
l4 = list(range(5)) # 从可迭代对象创建：[0,1,2,3,4]
访问
- 索引和切片：与字符串用法相同（支持修改）
l = [10, 20, 30, 40]
print(l[1]) # 20
print(l[-2:]) # [30, 40]
l[0] = 100 # 修改元素：[100, 20, 30, 40]
常用操作与方法
-
添加元素：
l.append(x)：在末尾添加xl.insert(i, x)：在索引i处插入xl.extend(iter)：合并另一个可迭代对象
l = [1, 2] l.append(3) # [1, 2, 3] l.insert(0, 0) # [0, 1, 2, 3] l.extend([4,5]) # [0, 1, 2, 3, 4, 5] -
删除元素：
l.pop(i)：删除索引i处的元素并返回（默认最后一个）l.remove(x)：删除第一个值为x的元素del l[i]：删除索引i处的元素
l = [1, 2, 3] l.pop() # 返回3，列表变为[1,2] l.remove(1) # 列表变为[2] -
其他常用方法：
l.sort()：排序（原地修改）l.reverse()：反转（原地修改）l.count(x)：统计x出现的次数
l = [3, 1, 2] l.sort() # [1, 2, 3] l.reverse() # [3, 2, 1] print(l.count(2)) # 1 -
内置函数：
len(l)：长度；max(l)/min(l)：最大/最小值sum(l)：求和（元素为数字）
print(len([1,2,3])) # 3 print(sum([1,2,3])) # 6
4. 元组（Tuple）
元组是有序、不可变的元素集合，用 () 定义（元素不可修改，适合存储固定数据）。
创建
t1 = (1, 2, 3)
t2 = ("a", 1) # 混合类型
t3 = () # 空元组
t4 = (5,) # 单元素元组（必须加逗号）
t5 = tuple([1,2]) # 从列表创建：(1,2)
访问
- 索引和切片：与列表相同（但不能修改元素）
t = (10, 20, 30)
print(t[1]) # 20
print(t[:2]) # (10, 20)
# t[0] = 100 # 错误：元组不可修改
常用操作与方法
-
不可变性：元组一旦创建，元素不能增删改，但可包含可变对象（如列表）
t = (1, [2, 3]) t[1].append(4) # 允许修改元组中的列表元素：(1, [2, 3, 4]) -
常用方法：
t.count(x)：统计x出现次数t.index(x)：返回x第一次出现的索引
t = (1, 2, 2, 3) print(t.count(2)) # 2 print(t.index(2)) # 1 -
内置函数：与列表相同（
len、max、min、sum等）
5. 字典（Dictionary）
字典是无序（Python 3.7+ 为有序）的键值对集合，用 {key: value} 定义，键唯一且不可变（如字符串、数字、元组）。
创建
d1 = {"name": "Alice", "age": 20}
d2 = {1: "one", (2,3): "two-three"} # 键为数字、元组
d3 = {} # 空字典
d4 = dict(name="Bob", age=18) # 用 dict() 函数创建
d5 = dict([("a", 1), ("b", 2)]) # 从键值对列表创建
访问
- 通过键访问：
d[key]或d.get(key, default)（不存在时返回default） - 获取所有键/值/键值对：
d.keys()、d.values()、d.items()
d = {"name": "Alice", "age": 20}
print(d["name"]) # "Alice"
print(d.get("gender", "unknown")) # "unknown"（键不存在）
print(d.keys()) # dict_keys(['name', 'age'])
print(d.items()) # dict_items([('name', 'Alice'), ('age', 20)])
常用操作与方法
-
添加/修改键值对：
d[key] = value（键存在则修改，不存在则添加）d = {"name": "Alice"} d["age"] = 20 # 添加：{"name": "Alice", "age": 20} d["name"] = "Bob" # 修改：{"name": "Bob", "age": 20} -
删除键值对：
d.pop(key)：删除键key并返回对应值del d[key]：删除键key
d = {"a": 1, "b": 2} d.pop("a") # 返回1，字典变为{"b": 2} del d["b"] # 字典变为{} -
其他常用方法：
d.clear()：清空字典d.copy()：复制字典（浅拷贝）
d = {"a": 1} d2 = d.copy() # d2 = {"a": 1} d.clear() # d 变为 {} -
内置函数：
len(d)返回键值对数量print(len({"a":1, "b":2})) # 2
6. 集合（Set）
集合是无序、不重复的元素集合，用 {} 或 set() 定义（空集合必须用 set()）。
创建
s1 = {1, 2, 3}
s2 = {1, 2, 2, 3} # 自动去重：{1, 2, 3}
s3 = set() # 空集合
s4 = set([1, 2, 3]) # 从列表创建：{1, 2, 3}
s5 = set("abc") # 从字符串创建：{'a', 'b', 'c'}
访问
- 集合无序，不能通过索引访问，可通过
in判断元素是否存在，或迭代遍历
s = {1, 2, 3}
print(2 in s) # True
for x in s:
print(x) # 输出1、2、3（顺序不确定）
常用操作与方法
-
添加/删除元素：
s.add(x)：添加元素x（已存在则忽略）s.remove(x)：删除元素x（不存在则报错）s.discard(x)：删除元素x（不存在则忽略）
s = {1, 2} s.add(3) # {1, 2, 3} s.remove(2) # {1, 3} s.discard(4) # 无变化 -
集合运算：
- 交集（
&或s1.intersection(s2)） - 并集（
|或s1.union(s2)） - 差集（
-或s1.difference(s2)） - 对称差集（
^或s1.symmetric_difference(s2)）：元素在其中一个集合但不在两个都有
s1 = {1, 2, 3} s2 = {3, 4, 5} print(s1 & s2) # {3}（交集） print(s1 | s2) # {1,2,3,4,5}（并集） print(s1 - s2) # {1,2}（差集） - 交集（
-
内置函数：
len(s)长度；max(s)/min(s)最大/最小值print(len({1,2,3})) # 3