Python基础教程2/4（复合数据结构）

1. 字符串的使用

1.字符串运算符：简单操作字符串

1.1. 字符串拼接（+）

作用：像“粘胶带”一样，将两个火多个字符串合并成一个。

示例：

print("a"+"b") str1 = "你好" str2 = "小帅" print(str1 + str2)

注意：只能字符串和字符串拼接，不能直接和数字拼接（比如 "年龄" + 18 会报错，需要转换成字符串）。

1.2. 字符串重复（ * ）

作用：知道字符串重复的次数，快速生成重复内容。

示例：

# *字符串重复 print("哈哈" * 3) #输出3个哈哈 print(1) print("-" * 10) #生成分割线 print(2)

1.3. 成员运算符（in / not in）

作用：检查一个字符串（字串）是否包含在另一个字符串里，返回True或False

示例：

str = "Hello World" print("h" in str) #False print("H" in str) #True print("Hello" not in str) #False print("Hi" not in str) #True

2. 索引与切片：精准提取字符串内容

2.1. 索引（下标）：按位置取单个字符

作用：字符串里的每个字符都有固定的”位置编号“，通过编号能精准取出单个字符。

编号规则：

• 从左往右：从0开始（第一个字符是0，第二个是1，以此类推）；
• 从右往左：从-1开始（最好一个字符是-1，倒数第二个是-2，以此类推）。

#索引（下标） str = "Hello World" print("h" in str) #False print("H" in str) #True print("Hello" not in str) #False print("Hi" not in str) #True

2.2. 切片：截取字符串的一部分

作用：像”剪刀“一样，从字符串中截取一段内容，返回新字符串。

语法如下：

str[start:stop:step]

参数详解：

• start（可选）：起始索引（包含，默认从0开始）。
• stop（可选）：结束索引（不包含，默认到字符串末尾）。
• step（可选）：步长（截取间隔，默认1，负数表示从右往左截）。

示例：

#切片：字符串[起始索引:结束索引:步长] myString="hello world,hello xiaoshuai" #虽然可以省略，但是至少要写一个:，不然以为你写的是索引 print(myString[:]) #全部输出 hello world,hello xiaoshuai #指定起始索引 print(myString[2 :]) #llo world,hello xiaoshuai #指定结束索引（包前不包后） print(myString[:2]) #he #指定步长 #正数：从左往右 print(myString[::5]) #h dlaa #负数：从右往左 print(myString[::-8]) #ixdl print(myString[2:10:2]) #lowr print(myString[-2:-10:-2]) #ahoi

3. 转义字符：处理特殊格式的文字

3.1. 什么是转义字符？

转义字符以 \ 开头，用来表示不能直接输入的特殊符号（比如换行、制表符），相对于“文件的特殊指令”。

3.2. 常用转义符

示例：

# 制表符 \t print(" hello") print("\thello") # 换行 \n print("第一行\n第二行") print("第一行\n第二行", end="") # 单个反斜杠 print("D:\tools\Python") # D: ools\Python，虽然只是warning，但是路径还是有问题的 print("D:\\tools\\Python") # 引号 print("I don't like it") print('I don\'t like it') # 要转义，不能和界定符一样

3.3. 原始字符串（r""）：取消转义

作用：字符串前面加r，里面的\会被当做普通字符，不用手动转义（适合文件路径、正则表达）。

示例：

# 原始字符串 r print("D:\\tools\\Python") #普通字符串要处理反斜杠 print(r"D:\tools\Python") #原始字符串直接写反斜杠

4. 格式化字符串：优雅拼接变量和文字

4.1. 作用

把变量、数字或运算结果嵌入到字符串中，让输出更整齐（不用反复用+拼接，避免出错）。

4.2. 实现方式

Python提供了多种方式来实现格式化输出，包括旧式的%格式化、str.format() 以及较新的 f-strings (Python3.6及以上版本，推荐使用)。

4.3. f-string

4.3.1. 基本使用

语法：字符串前加 f 或 F ，用 { } 包裹变量/表达式。

示例：

# 格式化字符串 name = "小明" age = 10 # 输出我的姓名：小明，我的年龄：10岁。 print("我的姓名：", name, "，我的年龄：", age, "岁。") # 可读性差 #在字符串前面加f/F，用{}括起来，将变量插入到字符串中 print(f"我的姓名：{name}，我的年龄：{age}岁。") # format格式化

4.3.2. 支持表达式

{ } 里面可以直接写算术运算，函数调用等，Python会自带计算结果。

示例：

# 支持表达式 n1 = 3 n2 = 4 print(f"{n1} + {n2} = {n1 + n2}") print(f"{n1}对应的类型：{type(n1)}")

4.3.3. 数字格式化

对于整数，可以设置其显示的最小宽度，并使用零或空格作为填充字符以达到这个宽度。

示例：

# 数字格式化 # 整数：可以设定最小宽度，并且补零 id = 3 print("你的学号:123") print(f"我的学号:{id:3}") # 设置最小宽度为3，如果id小于3，则前面补空格 print(f"我的学号:{id:03}") # 设置最小宽度为3，如果id小于3，则前面补0

对于浮点数，可以通过指定小数点后的位数来保留精度。

示例：

# 小数：设置精度 pi = 3.1415926 print(f"圆周率（保留10位小数）:{pi:.10f}") # 不够补零 print(f"圆周率（保留3位小数）:{pi:.2f}") # 四舍五入

4.3.4. 对齐与填充

语法：{变量:填充符+对齐方式+宽度}

对齐方式：

• >：右对齐
• <：左对齐
• ^：居中对齐

示例：

# 对齐与填充 name = "xiaoming" print(f"姓名：{name:20}") # 默认左对齐，宽度20，不足后面补空格 print(f"姓名：{name:<20}") # 左对齐，宽度20，不足后面补空格 print(f"姓名：{name:>20}") # 右对齐，宽度20，不足前面补空格 print(f"姓名：{name:^20}") # 居中对齐，宽度20，不足两边补空格 print(f"姓名：{name:-^20}") # 居中对齐，宽度20，不足两边补- print(f"姓名：{name:*>20}") # 右对齐，宽度20，不足前面补*

5. 字符串常用内建函数：高效处理文字

5.1. 查找类函数（找字符/统计次数）

示例：

# 字符串常见内建函数 # 查找类（find/index/count） name = "xiaoming" print(name.find("m")) print(name.index("mi")) print(name.count("xx")) # -1 print(name.index("x")) print(name.index("xx")) # ValueError: substring not found print(name.count("i")) print(name.count("xx"))

5.2. 修改类函数（改内容/分割/去空格）

示例：

# 修改类（replace / split / strip / lower / upper） name = "xiaoming" print(name.replace("i", "a")) # 替换所有 print(name.replace("i", "a", 1)) # 指定替换次数 str = "hello world\nhello xiaoming" # 默认使用空白（空格、\n、\t）分割，遇到这些字符旧分割 print(str.split()) # ['hello', 'world', 'hello', 'xiaoming'] print(str.split("\n")) # ['hello world', 'hello xiaoming'] print(str.split(" ", 1)) # 指定分割次数['hello', 'world\nhello xiaoming'] str = " hello python " print(str.strip()) # 去除字符串两端的空白 str = "xxxxpythonxxxx" print(str.strip("x")) str = "Hell,Python" print(str.lower()) print(str.upper())

5.3. 判断类函数（判断字符串属性）

示例：

# 判断类（startswith / endswith / isupper / islower） str = "hello python" print(str.startswith("hello")) print(str.startswith("ell")) print(str.endswith("python")) print(str.endswith("pytho")) print(str.isupper()) print(str.islower())

5.4. 编码解码（处理字符串/字节）

• encode()：字符串转字节（比如网络传输、文件写入），默认UTF-8编码；
• decode()：字节转字符串（解码时编码要和解码时一致）。

示例：

str = "你好" bytes_data = str.encode() # 编码，默认utf-8 print(bytes_data) str = b'\xe4\xbd\xa0\xe5\xa5\xbd' # b开头表示字节数据 print(str.decode())

6. 核心总结

1. 字符串基础：用单/双/三引号界定，+ 拼接、* 重复、in 判断包含关系；
2. 索引切片：左数从 0 开始，右数从 -1 开始；切片 [start:stop:stop] ，包前不包后，步长负则反转；
3. 转义与原始字符串：\n 换行、\t 制表符；路径用 r"" 取消转义，避免多写反斜杠；
4. 格式化首选 f-string ：f"{变量}" 直接嵌入，支持运算、数字格式化和对齐，简洁高效；
5. 常用函数：查找用find / index / count、修改用 replace / split / strip、判断用startswith / endswith / islower / isupper，按需调用；
6. 关键提醒：字符串是”不可修改“的，函数操作后返回新字符串。

2. 列表及其常见操作

引言：在Python中，列表就像一个”万能储物筐“，能一次性装下多个不同类型的数据（比如数字、文字、甚至另一个列表），并且支持随时添加、修改、删除内容，是编程中最常用的数据结构之一。学会运用列表，能快速实现数据的批量管理与灵活调整，显著降低基础数据处理的难度，是入门Python必须掌握的核心技能。

1. 认识列表

1.1. 什么是列表

列表是有序的”数据集合“，用方括号 [ ] 包裹，元素直接用都好隔开，能存储数、字符串、小数等任意类型数据。

1.2. 格式

变量名 = [元素1, 元素2, 元素3, 元素4, ...]

示例：

# 定义列表 li = ['a', 'b', 'c'] # 输出列表及其类型 print(li, type(li))

1.3. 列表的索引与切片（和字符串用法一致）

1.3.1. 索引：按位置取单个元素

规则：左数从 0 开始，右数从 -1 开始，通过”列表名[编号]“取值。

示例：

# 定义列表 li = ['a', 'b', 'c'] print(li[0]) #输出： a（左数第一个） print(li[2]) #输出： c（左数第三个） print(li[-1]) #输出： c（右数第一个） print(li[5]) # IndexError: list index out of range

1.3.2. 切片：截取列表的一部分

语法：列表[start:stop:step] (默认从0开始， start 起始位置含、stop 结束位置不含、step 步长)。

示例：

li = [1, 2, 3, 4, 5] print(li[0:2]) print(li[:2]) print(li[::3]) print(li[::-3]) # 步长负数，从右边开始 print(li[1:8:2]) # 超出范围不会出错

1.4. 列表的特性：可修改

和字符串不同，列表的元素能直接修改，通过 列表名[索引] = 新值 实现。

示例：

li = ['a', 'b', 'c', 'd'] li[1] = '你好' print(li)

2. 列表嵌套：列表里装列表

列表嵌套就是一个列表里包含其它列表，像“储物筐里嵌套小储物筐”，适合存储多维数据（比如表格、矩阵）。

示例：

grades = [[90, 80], [80, 70], [70, 60]] # 表示3个同学的成绩，90,80表示第一个同学的90分80分 print(grades[0]) # grades的第一个元素（子列表） print(grades[0][0]) # 子列表中的第一个元素 print(grades[0][1]) # 子列表中的第二个元素 print(grades[1][0])

访问逻辑：先通过外层索引找到嵌套的小列表，再通过内层索引取小列表的元素。

3. 列表常见内建函数

3.1. 添加元素

示例：

grades = [100, 90, 80, 70, 60] grades.append(59) print(grades) # 在末尾追加元素 # grades.extend(90)#TypeError: 'int' object is not iterable 只能放可迭代对象 # 将可迭代对象拆分成一个个元素，并追加到列表中 grades.extend("123") # [100, 90, 80, 70, 60, 59, '1', '2', '3'] grades.extend([90, 80]) # [100, 90, 80, 70, 60, 59, '1', '2', '3', 90, 80] grades.insert(1, 33) print(grades)

3.2. 查找元素

示例：

li = [1, 2, 3, 2, 5, 2, 5, 8, 9, 10] print(li.index(2)) print(li.count(2)) print(li.count(20))

3.4. 排序与反转

示例：

li = [3, 1, 4, 1, 5, 8, 2] li.reverse() li.sort() li.sort(reverse=True) print(li)

4. 核心总结

1. 列表本质：有序的“万能储物筐”，用 [ ] 定义，元素间用逗号分隔，支持任意数据类型。
2. 核心操作：
   1. 访问：索引（取单个）、切片（取部分），规则和字符串一致；
   2. 修改：直接修改 列表[索引] = 新值 修改元素；
   3. 嵌套：列表里装列表，通过“外层索引 + 内层索引”访问嵌套元素。

3.常用函数

• 添加：append( )（加1个）、extend( ) （加多个）、insert( ) （指定位置加）；
• 查找：index( ) （找索引）、count( ) （统计次数）；
• 删除：remover( ) （删除第一个匹配值）；
• 排序：sort( ) （升/降序）、reverse( ) （反转）。

4. 关键提醒：列表是“可修改”的，操作后直接改变原列表；函数操作时注意不存在的元素会报错（如index( )、remover( ) ）。

3. 元组及其常见操作

引言：元组是Python中和列表很像的“数据集合”，但核心区别是创建后不能修改——适合存储不需要改动的数据（比如一周的天数、坐标值）。学会合理使用元组，能清晰划分可变与不可变数据的存储逻辑，提升代码的规范性。

1. 认识元组

1.1. 什么是元组

元组是有序的、不可修改的“数据容器”，用圆括号（）包裹，元素之间用逗号隔开，能存整数、字符串、小数等任意类型数据。

1.2. 格式

变量名 = (元素1、元素2、元素3、 ...)

示例：

# 定义元组 tuple tup = (1, 2, 3, 4, 5) print(tup) # 注意：如果元组中只要一个元素，末尾必须加逗号，否则将不是元组 tup = (1) # type:int tup = (1,)

1.3. 元组的索引与切片（和列表、字符串用法一致）

1.3.1. 索引：按位置取单个元素

规则：左数从0开始，右数从-1开始，通过 元组名[索引] 取值。

示例：

tup = (1, 2, 3, 4, 5) print(tup[0]) # 输出1（索引从0开始） print(tup[-2]) # 输出4（索引从-1开始，-1表示倒数第一个元素）

1.3.2. 切片：截取元组的一部分

语法：元组[start:stop:step] （start含、stop不含、step步长）

示例：

tup = (1, 2, 3, 4, 5) print(tup[1:4]) # 输出(2, 3, 4) print(tup[::-1]) # 输出(5, 4, 3, 2, 1) print(tup[::2]) # 输出(1, 3, 5)

1.4. 元组的核心特性：不可修改

这是元组和列表最大的区别——元组创建后，不能添加、删除和直接修改元素。

示例：

tup = (1, 2, 3, 4, 5) tup[1] = 6 # TypeError: 'tuple' object does not support item assignment

2. 元组常见操作

2.1. 成员判断（ in /not in ）

作用：判断某个元素是否在元组中，返回 True 或 False。

示例：

nums = (1, 2, 3, 4, 5) print(1 in nums) print(22 in nums) print(0 not in nums)

2.2. 查找索引

作用：查找元素第一次出现的索引，没找到会报错。

示例：

nums = (11, 22, 33, 44, 55) print(nums.index(22)) # 1 print(nums.index(33)) # 2 # print(nums.index(6)) # ValueError: 6 is not in list

2.3. 统计次数（ count(value) ）

作用：统计元素在元组中出现的次数，没有找到返回0。

示例：

tup = (1, 2, 2, 3, 3, 3, 5) print(tup.count(3)) # 3 print(tup.count(1)) # 1 print(tup.count(9)) # 0 不存在

3. 元组vs列表：核心区别

4. 核心总结

1. 元组本质：有序、不可修改的“固定数据筐”，用 ( ) 定义，单元素必须加逗号。
2. 核心操作：

   1. 访问：索引（取单个元素）、切片（取部分元素），规则和列表、字符串一致

   2. 查询：in/not in判断存在、index( ) 找索引、count( )统计次数

3. 关键区别：和列表比，元组不可修改，适合存储不需要改动的数据，操作更简单。
4. 实用技巧：如果数据创建后不会变（比如周一到周日、经纬度），优先用元组，更安全高效。

4. 字典及其常见操作

引言：字典是Python中最灵活的“键值对数据容器”，就像现实中的字典——通过“关键字（键）”快速找到对应的“解释（值）”，不用像列表那样按顺序查找。它适配各类关联数据存储，如账号与密码、城市与区号等。学会运用字典，能限制提升关联数据的查询效率，规范数据存储逻辑。

1. 认识字典

1.1. 什么是字典

字典是存储“键值对 (key: value) ”的有序数据结构，每个“键 (key) ”是唯一的标识，对应一个“值 (value) ”，值可以是任意类型数据 （数字、字符串、列表等）。

1.2. 格式

变量名 = {键1:值1,键2:值2,键3:值3, ...}

示例：

# 定义字典 info = {"name": "张三", "age": 18, "sex": "男", "爱好": ["吃", "喝", "玩"]} # 输出 {'name': '张三', 'age': 18, 'sex': '男', '爱好': ['吃', '喝', '玩']} <class 'dict'> print(info, type(info))

注意：

• 键（key）必须唯一，不能重复（比如不能有两个“name”键，会覆盖前面的）；
• 值（value）可以重复，也可以是任意类型（包括列表、字典）。

2. 字典常用操作

2.1. 查找元素：根据“键”找“值”（最常用）

有两种方式，推荐用 get( )，避免报错。

2.1.1.1. 方式1：dict[key] （直接通过键取值）

语法：字典名[键]，找到键则返回对应值，没找到则报错。

示例：

info = {"name": "张三", "age": 18, "sex": "男", "爱好": ["吃", "喝", "玩"]} print(info["name"]) print(info["姓名"]) # 错误

2.1.1. 方式2：get(key, default)（安全取值）

语法 字典名.get(键，默认值)，找到键返回对应值，没有找到返回默认值（默认值可以省略，省略后返回None）。

示例：

# 定义字典 info = {"name": "张三", "age": 18, "sex": "男", "爱好": ["吃", "喝", "玩"]} print(info.get("name")) print(info.get("年龄")) print(info.get("年龄", "无此字段"))

2.2. 添加/修改元素：一个语法搞定两种操作

核心语法：字典名[键] = 值

• 如果键已经存在：修改改键对应的value；
• 如果键不存在：添加一个新的键值对。

示例：

# 定义字典 info = {"name": "小帅", "age": 18} info["age"] = 6 print(info) info["tel"] = 137731234567 print(info)

2.3. 删除元素

2.3.1. 方式1：pop(key, default) （删除指定键值对）

语法：字典名.pop(键，默认值)，删除指定键对应的键值对，返回被删除的value；键不存在就返回默认值（无默认值则报错）

示例：

# 定义字典 info = {"name": "小帅", "age": 18} # 删除存在的键 print(info.pop("age")) # 先找到对应的值，然后把键值对删除 # 删除不存在的键 #print(info.pop("sex")) # 没有默认值，则返回KeyError print(info.pop("sex", "没有此键"))

2.3.2. 方式2：clear( ) （清空所有元素）

语法：字典名.clear()，删除字典中所有键值对，变成空字典

示例：

# 定义字典 info = {"name": "小帅", "age": 18} info.clear() print(info) # 输出{} （空字典）

2.4. 其它实用操作：获取所有键、值、键值对

示例：

info = {"name": "小帅", "age": 18} print(info.keys()) # 返回：dict_keys(['name', 'age']) print(info.values()) # 返回：dict_values(['小帅', 18]) print(info.items()) # 返回：dict_items([('name', '小帅'), ('age', 18)])

实用场景：配合循环遍历字典（后续学循环可直接用）

3. 核心总结

1. 字典本质：有序的“键值对容器”，用 {key : value }定义，键唯一且不可变，值可任意。
2. 核心操作：
3. • 查找：优先用 get(key, default)，安全不报错；dict[key] 找不到会报错；
   • 增改：字段名[键] = 值，键存在则改，不存在则加；
   • 删除：pop(key) 删除指定键值对，clear( )清空字典；
   • 遍历：keys( )取所有键、values( )取所有值，items( )取所有键值对。
4. 关键优势：通过键快速查找值，不用遍历，比列表查询效率高，适合存储关联数据。
5. 实用技巧：存储用户信息、配置参数、映射关系时，优先用字典，逻辑更清晰。

5. 集合及其常见操作

引言：集合是Python中特殊的“数据容器”，核心特点是无序+元素唯一——能自动去掉重复数据，还能快速左交集、并集等集合运算，适合去重、数据对比等场景。学会运用集合，能高效解决重复数据处理问题，简化数据对比逻辑。

1. 认识集合

1.1. 什么是集合

集合是存储唯一、无序元素的数据结构，用大括号 { } 包裹，元素之间用逗号隔开，它就像一个“去重篮子”，不管往里放多少重复数据，最终只会保留一个。

1.2. 格式

变量名 = {元素1,元素2,元素3, ...}

实例：

# 定义集合 s = {'a', 'b', 'c', 'a'} print(s) # 输出：{'a', 'b', 'c'}也可以输出：{'c', 'b', 'a'} 无序 data = {} # 空字典 print(data, type(data)) data = set() # 空集合 print(data, type(data))

关键规则：

• 元素唯一：集合中不会有重复元素，重复数据会被字典过滤。
• 元素无序：集合没有索引，不能像列表、元组那样按位置访问元素。
• 元素类型限制：只能存不可变类型（数字、字符串、元组），不能存列表、字典等可变类型

2. 集合常用内建函数

2.1. 添加元素

示例：

s = {'a', 'b', 'c'} s.add('d') s.add('c') print(s) s.update("fgh") # 将字符串拆分成多个字符，再逐一添加到集合 s.update([1, 2, 3]) # 将列表拆分成多个元素，再逐一添加到集合 print(s)

2.2. 删除元素

示例：

s = {1, 2, 3} s.remove(2) # s.remove(4) #报错 print(s) s.discard(3) s.discard(4) #不存在，不报错 print(s) s.clear() print(s)

2.3. 集合运算：快速对比两个集合（实战高频）

集合最强大的功能是运算，比如找两个集合的共同元素、合并元素等，直接用运算即可

示例：

s1 = {1, 2, 3, 4, 5} s2 = {3, 4, 5, 6, 7} s3 = {4, 5, 6} print("交集（共同元素）：", s1 & s2) print("交集（共同元素）：", s1.intersection(s2)) print("并集（所有元素）：", s1 | s2) print("并集（所有元素）：", s1.union(s2)) print("交集（共同元素）：", s1 & s2 & s3) print("交集（共同元素）：", s1.intersection(s2).intersection(s3)) print("交集（共同元素）：", s1.intersection(s2, s3))

3. 核心总结

1. 集合本质：唯一、无序的“去重数据筐”，用 { } 定义，空集合必须用set( )。
2. 核心特性：自动去重、无索引（不能按位置访问）、支持集合运算。
3. 常用操作：

• • 增：add( ) 加单个元素、update( ) 加多个元素；
  • 删：discard( ) 、remove( )（报错）、clear( )清空；
  • 运算：& 交集、| 并集。

1. 实用技巧：去重优先用集合（列表转集合再转会列表），数据对比用集合运算，高效又简介。

示例：

# 去重 li = [1, 1, 2, 3, 5, 5, 5, 6, 7, 9] li = set(li) li = list(li) print(li)

6. 数据类型总结

引言：数据类型是Python处理数据的“基础模板”——不同类型的数据（比如数字、文字、列表）又不同的用法和规则。本小节把Python常用数据类型、公共操作、类型转换整合在一起，帮大家理清每种类型的特点和适用场景，零基础也能快速区分、灵活运用。数据类型分类Python数据类型主要份“基本数据类型”（单个数据）和“复合数据类型”（多个数据的集合），核心特点和用法如下。基本数据类型

复合数据结构

公共操作&公共方法不管是基本类型还是复合结构，很多操作是通用的，掌握这些能少记忆很多知识点。

示例：

# 字符串 print("he" in "hello") # 列表 print(1 in [11, 22, 33]) # 元组 print(1 in (11, 22, 33)) # 字典 print("a" in {"a": 1, "b": 2}) # 默认判断键名 print(1 in {"a": 1, "b": 2}.values()) # 判断值 # 集合 print(1 in {1, 2, 3}) # len() print(len("hello")) # 统计字符个数 print(len([1, 2, 3])) # 统计元素个数 print(len((1, 2, 3))) # 统计元素个数 print(len({1, 2, 3})) # 统计元素个数 print(len({"a": 1, "b": 2})) # 统计键值对 # del data = 1 del data # print( data) #报错 data = [3, 4, 5] del data[0] print(data) # sum max min print(sum([1, 2, 3])) print(max((1, 2, 3))) print(min((1, 2, 3)))

3. 类型转换：不同类型之间的“转换工具”

当需要用一种类型的方法处理另一种类型数据时，用以下函数转换（核心原则：能转则转，不能转则报错）。

示例：

# int print(int(1.6)) print(int("123")) # float print(float(33)) print(float("1.23")) # bool # 非零非空即为True # "" [] {} () set() ==> False print(bool(-1)) # true print(bool(0)) # false print(bool(" ")) # true # str data = (1, 2, 3) data = str(data) print(data, type(data)) # 虽然输出是元组，但是str()函数会自动将元组转换成字符串 # eval(str): str -> int,float,tuple,list,dict,set 去除引号 s = eval(input("请输入：")) print(s, type(s)) # 输入小数就转小数，输入列表就转列表 # list tuple set print(list("This is an apple")) # 拆分字符串，放入列表中 print(tuple("This is an apple")) print(set("This is an apple")) # dict print(dict([("name", "张三"), ("age", 18)])) # 列表/元组包含键值对

4. 核心总结

1. 类型选择：

• • 单个数据：数字用 int / float，文件用 str，判断用 bool，无数据用 None;
  • 多个数据：需要修改用 list，固定不变用 tuple，键值关联用 dict，去重/对比用 set。

1. 通用技巧：in 判断存在，len( )算长度、del 删除、sum( ) / max( ) / min( )处理数值，这些操作通用且高频。
2. 类型转换：用对应函数即可，重点记住str( )（万能转文字）、int( ) / float( )（文字转数字）、set( )（去重）。
3. 关键区别：

• • 可修改vs不可修改：list / dict / set 可修改，str / tuple不可修改；
  • 有序vs无序：str / list / tuple / dict 有序，set 无序；
  • 唯一vs重复：dict 键唯一、set 元素唯一，其它类型（除None）支持重复。