跳转至

Python 数据类型语法总结

1.字符串

字符串是 Python 最常用的数据类型，用于表示文本，本质是不可变的字符序列（修改字符串会生成新字符串，原字符串不变）。下面按高频使用场景整理所有核心语法

1.1字符串的定义（创建）

用单引号、双引号、三引号包裹文本均可，三引号支持多行字符串。 

# 1. 单行字符串（单/双引号通用，嵌套时交替使用）
s1 = 'hello python'
s2 = "I'm a student"  # 内部含单引号，用双引号包裹更方便

# 2. 多行字符串（三单/三双引号）
s3 = '''第一行
第二行
第三行'''

# 3. 空字符串
s4 = ""

1.2字符串的核心操作

索引（取单个字符） 字符串是有序序列，下标从 0 开始，支持正向/反向索引： - 正向：0,1,2... - 反向：-1（最后一个）,-2（倒数第二个）... 

s = "python"
print(s[0])   # 输出：p（第一个字符）
print(s[-1])  # 输出：n（最后一个字符）

切片（取子字符串） 格式：字符串[起始索引:结束索引:步长] - 起始：包含，默认 0 - 结束：不包含，默认字符串长度 - 步长：默认 1，负数表示反向截取 

s = "abcdef"
print(s[1:4])   # 输出：bcd（索引1~3）
print(s[:3])    # 输出：abc（从头开始）
print(s[2:])    # 输出：cdef（到结尾结束）
print(s[::2])   # 输出：ace（步长2，隔一个取一个）
print(s[::-1])  # 输出：fedcba（反转字符串，最常用！）

拼接与重复 - 拼接：+ 连接两个字符串 - 重复：* 重复字符串多次 

a = "hello"
b = "world"
print(a + " " + b)  # 输出：hello world
print(a * 3)        # 输出：hellohellohello

长度与成员判断 - 长度：len(字符串) → 获取字符个数 - 成员：in / not in → 判断是否包含子串 

s = "python"
print(len(s))      # 输出：6
print("py" in s)   # 输出：True
print("ab" not in s) # 输出：True

1.3字符串格式化（输出/拼接文本）

3种常用方式，推荐 f-string（Python3.6+） 最简洁： 

name = "小明"
age = 18

# 1. f-string（首选）
print(f"姓名：{name}，年龄：{age}")

# 2. format() 方法
print("姓名：{}，年龄：{}".format(name, age))

# 3. % 占位符（旧语法）
print("姓名：%s，年龄：%d" % (name, age))

1.4字符串常用内置方法（高频）

查找与替换 

s = "hello python python"
s.find("python")    # 返回第一个匹配的起始索引：6，找不到返回-1
s.count("python")   # 统计子串出现次数：2
s.replace("python", "java")  # 替换所有子串：hello java java

大小写转换 

s = "Hello World"
s.upper()    # 转大写：HELLO WORLD
s.lower()    # 转小写：hello world
s.title()    # 每个单词首字母大写：Hello World

去除空白/指定字符 

s = "  hello  "
s.strip()   # 去除两端空白：hello
s.lstrip()  # 去除左端空白
s.rstrip()  # 去除右端空白

分割与拼接 

# 分割：按指定字符拆分为列表
s = "a,b,c"
s.split(",")  # 输出：['a','b','c']

# 拼接：用连接符将列表合并为字符串
lst = ['a','b','c']
"-".join(lst) # 输出：a-b-c

判断类型（返回 True/False） 

"123".isdigit()   # 是否全为数字：True
"abc".isalpha()   # 是否全为字母：True
"abc123".isalnum()# 是否全为字母/数字：True
"hello".islower() # 是否全小写：True
"HELLO".isupper() # 是否全大写：True

1.5转义字符（特殊符号）

用 \ 开头，表示无法直接输入的字符： 

# \n：换行  \t：制表符（空格）  \'：单引号  \"：双引号  \\：反斜杠
print("hello\nworld")  # 换行输出
print("I\'m fine")     # 输出：I'm fine

1.6原始字符串（取消转义）

字符串前加 r，所有 \ 都当作普通字符，常用于路径、正则： 

print(r"C:\Users\test")  # 输出：C:\Users\test（不会转义）

总结 1. 定义：单/双/三引号包裹，三引号支持多行； 2. 核心操作：索引取字符、切片取子串、+拼接、*重复、len()算长度； 3. 格式化：优先用 f-string，简洁高效； 4. 常用方法：查找、替换、分割、拼接、大小写转换、去空格； 5. 特性：不可变，修改字符串会生成新对象。

2.列表

列表是 Python 最常用、最灵活的序列数据类型，是有序、可变的容器，可存储任意数据类型（数字、字符串、列表、字典等），用方括号 [] 表示。以下是全场景核心知识点，覆盖基础到进阶：

2.1 列表核心特性

  1. 有序性：元素有固定顺序，可通过索引精准定位
  2. 可变性：支持增/删/改元素（区别于元组、字符串）
  3. 包容性：可存储混合数据类型（如 [1, "abc", True, [2,3]]）
  4. 重复性：允许包含重复元素
  5. 索引规则：正索引从 0 开始，负索引从 -1 开始（最后一个元素）

2.2 列表的创建（6种常用方式）

# 1. 空列表
lst1 = []
lst2 = list()

# 2. 直接赋值创建（最常用）
lst3 = [1, 2, 3, "Python", True]

# 3. range() 生成数字列表
lst4 = list(range(1, 6))  # [1,2,3,4,5]

# 4. 拆分字符串生成列表
lst5 = list("hello")      # ['h','e','l','l','o']

# 5. 列表推导式（高效生成）
lst6 = [x*2 for x in range(5)]  # [0,2,4,6,8]

# 6. 复制已有列表
lst7 = lst3.copy()

2.3 列表元素访问：索引 + 切片

2.3.1 索引访问（单个元素）

lst = [10, 20, 30, 40]
print(lst[0])   # 正索引：10（第一个元素）
print(lst[-1])  # 负索引：40（最后一个元素）

2.3.2 切片访问（多个元素） 语法：列表[起始索引:结束索引:步长] - 起始索引：默认 0 - 结束索引：不包含该位置元素 - 步长：默认 1，负数表示反向截取

lst = [1,2,3,4,5]
print(lst[1:4])   # [2,3,4] （索引1~3）
print(lst[:3])    # [1,2,3] （从头开始）
print(lst[2:])    # [3,4,5] （到结尾）
print(lst[::-1])  # [5,4,3,2,1] （反转列表）

2.4 核心操作：增、删、改、查

2.4.1增加元素

方法 作用 示例
append(x) 末尾添加单个元素 lst.append(6)
extend(iter) 末尾添加可迭代对象（列表/字符串） lst.extend([7,8])
insert(i,x) 指定索引 i 处插入元素 lst.insert(1, 99)
+ 运算符 拼接列表（生成新列表） lst + [10,20]

2.4.2删除元素

方法 作用 示例
del lst[i] 删除指定索引的元素 del lst[0]
pop(i) 删除并返回指定索引元素（默认删最后一个） lst.pop()
remove(x) 删除第一个匹配的元素x lst.remove(20)
clear() 清空列表（保留空列表） lst.clear()

2.4.3修改元素 直接通过索引赋值修改： 

lst = [1,2,3]
lst[1] = 99  # 把索引1的元素改为99 → [1,99,3]

2.4.4 查找元素 

lst = [10,20,30,20]
# 1. 判断元素是否存在
print(20 in lst)  # True

# 2. 查找元素第一次出现的索引
print(lst.index(20))  # 1

# 3. 统计元素出现次数
print(lst.count(20))  # 2

2.5 列表常用内置方法/函数

  1. 长度：len(lst) → 获取元素个数
  2. 排序：
  3. lst.sort()：原地升序排序（修改原列表）
  4. lst.sort(reverse=True)：原地降序排序
  5. sorted(lst)：返回新的排序列表（不修改原列表）
  6. 反转：lst.reverse() → 原地反转列表
  7. 复制：lst.copy() / lst[:] → 浅拷贝列表
  8. 最值/求和：max(lst)、min(lst)、sum(lst)（仅数值列表）

2.6 列表遍历

普通遍历（仅元素） 

lst = [1,2,3]
for i in lst:
    print(i)

带索引遍历（enumerate） 

for idx, val in enumerate(lst):
    print(f"索引：{idx}，值：{val}")

2.7 列表推导式（重点：简洁生成列表）

语法：[表达式 for 变量 in 可迭代对象 if 条件] - 一行代码生成列表，比 for 循环更高效 - 支持条件过滤

# 示例1：生成1~5的平方
lst = [x**2 for x in range(1,6)]  # [1,4,9,16,25]

# 示例2：过滤偶数
lst = [x for x in range(10) if x % 2 == 0]  # [0,2,4,6,8]

2.8 嵌套列表（多维列表）

列表中嵌套列表，常用于二维数据（如矩阵）： 

# 二维列表
matrix = [[1,2], [3,4], [5,6]]
# 访问元素：先行索引，再列索引
print(matrix[1][0])  # 3

2.9 关键注意事项

  1. 列表是可变对象：直接赋值会共享内存（浅拷贝） 
    a = [1,2]
b = a  # b和a指向同一个列表
b.append(3)
print(a)  # [1,2,3]（a也被修改）
  2. 深拷贝：嵌套列表需用 copy.deepcopy() 完全复制
  3. 索引越界：访问不存在的索引会报错 IndexError

总结

  1. 列表核心：有序、可变、存任意类型，是Python最灵活容器
  2. 高频操作：索引/切片访问、增删改查、排序、推导式
  3. 效率技巧：列表推导式 > 普通for循环，append() 比 + 更高效

3.Python 字典（Dictionary）

字典是 Python 映射型数据类型，以键值对（key:value）存储数据，是无序（3.7+有序）、可变的容器，通过键（key）快速查找值，用花括号 {} 表示。以下是全场景核心知识点，覆盖基础到进阶：

3.1 字典核心特性

  1. 键值映射：每个值对应唯一键，通过键取值（类似查字典）
  2. 键的规则：键必须不可变（数字/字符串/元组），且唯一不重复；值可任意类型
  3. 可变性：支持增/删/改键值对
  4. 有序性：Python 3.7 及以上保留插入顺序，3.6 及以下无序
  5. 高效查找：通过键查找速度极快（远快于列表）

3.2 字典的创建（6种常用方式）

# 1. 空字典
dict1 = {}
dict2 = dict()

# 2. 直接赋值创建（最常用）
dict3 = {"name": "张三", "age": 20, "gender": "男"}

# 3. dict() 关键字创建
dict4 = dict(name="李四", age=21)

# 4. 双元素序列创建
dict5 = dict([("name", "王五"), ("age", 22)])

# 5. 字典推导式（高效生成）
dict6 = {x: x**2 for x in range(5)}  # {0:0,1:1,2:4,3:9,4:16}

# 6. fromkeys() 创建（键相同，值统一）
dict7 = dict.fromkeys(["a", "b"], 0)  # {"a":0, "b":0}

3.3 字典元素访问：

键 + get() + 遍历

  1. 键访问（单个值） 

    dic = {"name": "张三", "age": 20}
print(dic["name"])   # 张三（键不存在会报错）

  2. get() 方法（推荐，键不存在不报错） 

    print(dic.get("age"))       # 20
print(dic.get("gender", "未知"))  # 键不存在返回默认值：未知

  3. 访问所有键/值/键值对 

    dic = {"name": "张三", "age": 20}
print(dic.keys())    # 获取所有键：dict_keys(['name', 'age'])
print(dic.values())  # 获取所有值：dict_values(['张三', 20])
print(dic.items())   # 获取所有键值对：dict_items([('name','张三'), ('age',20)])

3.4 核心操作：增、删、改、查

1.增加键值对

方法 作用 示例
字典[新键] = 新值 新增键值对（键不存在则添加） dic["gender"] = "男"
update(dict) 批量添加/更新键值对 dic.update({"score":90, "class":1})

2.删除键值对

方法 作用 示例
del 字典[键] 删除指定键值对 del dic["age"]
pop(键) 删除并返回指定键的值 dic.pop("name")
popitem() 删除并返回最后插入的键值对 dic.popitem()
clear() 清空字典（保留空字典） dic.clear()

2.修改键值对

直接通过键赋值修改： 

dic = {"name": "张三", "age": 20}
dic["age"] = 21  # 把age的值改为21 → {"name":"张三","age":21}

3.查找元素

dic = {"name": "张三", "age": 20}
# 1. 判断键是否存在
print("name" in dic)  # True（默认判断键，不是值）

# 2. 判断值是否存在
print(20 in dic.values())  # True

3.5 字典常用内置方法/函数

  1. 长度：len(dic) → 获取键值对个数
  2. 复制：
  3. dic.copy() → 浅拷贝字典（不修改原字典）
  4. 默认值：
  5. setdefault(键, 默认值) → 键存在则返回值，不存在则添加并返回默认值
  6. 排序：
  7. sorted(dic) → 对键排序，返回键的列表

3.6 字典遍历

  1. 遍历键（默认） 

    dic = {"name": "张三", "age": 20}
for key in dic:
    print(key, dic[key])

  2. 遍历值 

    for val in dic.values():
    print(val)

  3. 遍历键值对（最常用） 

    for key, val in dic.items():
    print(f"键：{key}，值：{val}")

3.7 字典推导式（重点：简洁生成字典）

语法：{键表达式: 值表达式 for 变量 in 可迭代对象 if 条件} - 一行代码生成字典，比循环更高效 - 支持条件过滤

# 示例1：数字键值对
dic = {x: x+10 for x in range(3)}  # {0:10,1:11,2:12}

# 示例2：过滤大于2的键
dic = {x: x**2 for x in range(5) if x>2}  # {3:9,4:16}

3.8 嵌套字典（多维字典）

字典中嵌套字典，常用于复杂结构化数据： 

# 嵌套字典
student = {
    "name": "张三",
    "score": {"语文": 90, "数学": 95}
}
# 访问元素：先外层键，再内层键
print(student["score"]["数学"])  # 95

3.9 关键注意事项

  1. 键不可变：列表不能做键（[1,2] 不行），字符串/元组可以
  2. 键唯一：重复键会覆盖之前的值 
    dic = {"a":1, "a":2}  # 最终{"a":2}
  3. 访问不存在的键：直接用 dic["key"] 会报错 KeyError，推荐用 get()
  4. 字典是可变对象：直接赋值会共享内存，修改会影响原字典

总结

  1. 字典核心：键值对存储、键唯一不可变、查找高效
  2. 高频操作：键/get()取值、增删改键值对、items()遍历、推导式
  3. 实用技巧：get() 避免键报错，items() 遍历键值对最方便

4. Python 元组（Tuple）

元组是有序、不可变的序列类型，功能和列表几乎一样，但不能修改、删除、添加元素，用小括号 () 表示。

4.1 元组核心特性

  1. 有序性：元素按顺序存储，可通过索引访问
  2. 不可变性：创建后不能增/删/改（最核心特点）
  3. 包容性：可存任意数据类型
  4. 重复性：允许重复元素
  5. 安全性：数据不想被修改时用元组（如配置项）

4.2 元组的创建

# 1. 空元组
t1 = ()
t2 = tuple()

# 2. 直接创建（最常用）
t3 = (1, 2, 3, "Python")

# 3. 单个元素必须加逗号（重点！）
t4 = (10,)  # 不加逗号会变成数字 10

# 4. 可省略括号
t5 = 10, 20, 30

# 5. 其他类型转元组
t6 = tuple([1,2,3])  # 列表转元组

4.3 元组元素访问：索引 + 切片（和列表完全一样）

  1. 索引访问 
t = (10, 20, 30)
print(t[0])   # 10
print(t[-1])  # 30
  1. 切片访问 
t = (1,2,3,4,5)
print(t[1:4])  # (2,3,4)
print(t[::-1]) # (5,4,3,2,1)

4.4 核心操作：只能查，不能增删改

  1. 不可修改（报错） 
t = (1,2,3)
# t[0] = 100 → 报错！元组不可变
  1. 查找元素 
t = (10,20,20,30)
print(20 in t)        # True
print(t.index(20))    # 第一次出现的索引：1
print(t.count(20))    # 出现次数：2

4.5 常用内置函数

  1. 长度：len(t)
  2. 最值/求和：max(t)、min(t)、sum(t)
  3. 排序：sorted(t) → 返回列表（元组本身不能变）
  4. 拼接：t1 + t2 → 生成新元组

4.6 元组遍历

t = ("a", "b", "c")
for i in t:
    print(i)

4.7 元组 vs 列表

特性 列表 list 元组 tuple
符号 [] ()
可变性 可变 不可变
增删改 支持 不支持
速度 较慢 更快
用途 频繁修改 固定数据

3.8 关键注意事项

  1. 单个元素必须加逗号：(10) 是数字，(10,) 才是元组
  2. 元组内的可变对象可以修改 
    t = ([1,2], 3)
t[0].append(4)  # 可以修改列表 → ([1,2,4], 3)
  3. 函数多返回值默认是元组

5. Python 集合（Set）

集合是无序、不重复、可变的容器，自动去重，主要用于去重、关系测试（交集/并集/差集），用花括号 {} 表示。

5.1 集合核心特性

  1. 无序性：没有索引，不能用 [0] 取值
  2. 唯一性：自动去重，无重复元素
  3. 可变性：可增删元素（frozenset 不可变）
  4. 高效查找：判断元素是否存在极快
  5. 元素要求：必须是不可变类型（数字/字符串/元组）

5.2 集合的创建（4种方式）

# 1. 空集合（必须用 set()，{} 是空字典）
s1 = set()

# 2. 直接创建
s2 = {1, 2, 2, 3}  # 自动去重 → {1,2,3}

# 3. 列表/字符串转集合（最常用：去重）
s3 = set([1,2,2,3])
s4 = set("hello")  # {'h','e','l','o'}

# 4. 不可变集合
s5 = frozenset([1,2,3])

5.3 集合元素访问

不能用索引！只能遍历或判断存在 

s = {10,20,30}
print(10 in s)  # True

5.4 核心操作：增、删、查（无改）

  1. 增加元素 

    s = {1,2}
s.add(3)        # 添加单个 → {1,2,3}
s.update([4,5]) # 批量添加 → {1,2,3,4,5}

  2. 删除元素 

    s = {1,2,3}
s.remove(2)    # 删除指定元素，不存在则报错
s.discard(99)  # 安全删除，不存在不报错
s.pop()        # 随机删除一个
s.clear()      # 清空

  3. 查找 

    s = {1,2,3}
print(2 in s)  # True

5.5 集合高级功能：数学运算（重点）

a = {1,2,3}
b = {3,4,5}

# 1. 并集（合并，去重）
print(a | b)  # {1,2,3,4,5}

# 2. 交集（共同拥有）
print(a & b)  # {3}

# 3. 差集（a有b没有）
print(a - b)  # {1,2}

# 4. 对称差集（互相没有的）
print(a ^ b)  # {1,2,4,5}

5.6 常用内置函数

  1. 长度：len(s)
  2. 最值：max(s)、min(s)
  3. 清空：s.clear()
  4. 复制：s.copy()

5.7 合遍历

s = {"a", "b", "c"}
for i in s:
    print(i)

5.8 关键注意事项

  1. 空集合必须写 set()，{} 是字典
  2. 无索引、无顺序、不能切片
  3. 自动去重：列表快速去重神器 
    lst = [1,2,2,3,3,3]
lst = list(set(lst))  # [1,2,3]
  4. 集合元素必须不可变，不能存列表/字典

数据类型终极对比

类型 符号 有序 可变 重复 核心用途
列表 [] 是 是 允许 频繁修改的数据
元组 () 是 否 允许 固定不变的数据
字典 {} 3.7+ 是 键唯一 键值映射、快速查找
集合 {} 否 是 不允许 去重、交集并集