变量与数据类型：数字、字符串、列表、字典（重点讲列表/字典）
18.16.1 引言：变量和数据类型是什么？用大白话讲
你可以把变量理解成“贴了标签的盒子”：
盒子的“标签”就是变量名，比如age、name；
盒子里的“东西”就是数据，比如25、"张三"。
而数据类型，就是盒子里东西的“种类”：
装数字的盒子：整数、浮点数；
装文字的盒子：字符串；
装一堆东西的盒子：列表（有序排列）、字典（键值对映射）。
今天咱们先快速过数字、字符串，重点啃列表和字典——这俩是Python里用得最多的“高级盒子”，搞定它们，80%的Python数据处理问题都能解决。
18.16.2 一、数字类型：整数与浮点数

1. 定义与基本运算
   数字类型分两种：
   整数（int）：没有小数的数，比如10、-5、0；
   浮点数（float）：带小数的数，比如3.14、-2.5、1.0。
   直接上代码，逐行讲解：
   python

	# 定义整数变量
	age = 25 # 把数字25放进叫age的盒子里
	print("age的数据类型：", type(age)) # type()查看数据类型，输出<class 'int'>
	
	# 定义浮点数变量
	height = 1.75
	print("height的数据类型：", type(height)) # 输出<class 'float'>
	
	# 基本运算：加减乘除、整除、取余
	a = 10
	b = 3
	print("加法：", a + b) # 13
	print("减法：", a - b) # 7
	print("乘法：", a * b) # 30
	print("除法：", a / b) # 3.3333333333333335（浮点数）
	print("整除：", a // b) # 3（只取整数部分）
	print("取余：", a % b) # 1（10除以3的余数是1）
	print("幂运算：", a ** b) # 1000（10的3次方）

2. 新手必踩坑：浮点数精度问题
   你可能会遇到这种“玄学”情况：
   python
   print(0.1 + 0.2) # 输出0.30000000000000004，不是0.3！
   原因：浮点数在计算机里是用二进制存储的，0.1和0.2转成二进制是无限循环小数，相加后就会有精度误差。
   解决方法：用decimal模块精确计算：
   python

	from decimal import Decimal
	a = Decimal("0.1")
	b = Decimal("0.2")
	print(a + b) # 输出0.3，完美解决！

18.16.3 二、字符串类型：处理文字的“万能盒子”

1. 定义字符串
   字符串就是用单引号、双引号或三引号括起来的文字：
   python

	# 单引号定义
	name = '张三'
	# 双引号定义（和单引号完全一样，适合字符串里有单引号的情况）
	sentence = "他说：'我今年25岁'"
	# 三引号定义（支持多行字符串，适合写大段文字）
	paragraph = '''这是一段
	多行的
	字符串'''

2. 常用操作：切片、拼接、方法
   python

	s = "Hello, Python!"
	
	# 1. 切片：按索引取字符（索引从0开始，负索引从-1开始）
	print(s[0:5]) # 取第0到第4个字符，输出"Hello"
	print(s[-7:-1]) # 取倒数第7到倒数第2个字符，输出"Python"
	print(s[:5]) # 省略开头，从第0个取到第4个，输出"Hello"
	print(s[7:]) # 省略结尾，从第7个取到最后，输出"Python!"
	
	# 2. 拼接：用+号连接字符串
	greeting = "你好，" + name + "！"
	print(greeting) # 输出"你好，张三！"
	
	# 3. 常用字符串方法（重点记这几个）
	print(s.upper()) # 转大写，输出"HELLO, PYTHON!"
	print(s.lower()) # 转小写，输出"hello, python!"
	print(s.split(",")) # 按逗号分割成列表，输出["Hello", " Python!"]
	print(s.replace("Python", "World")) # 替换字符串，输出"Hello, World!"

3. 拓展：f-string格式化（Python3.6+必备技能）
   这是Python最方便的字符串格式化方法，比format()简洁10倍：
   python

	name = "张三"
	age = 25
	height = 1.75
	# 用{}占位，直接把变量塞进去
	info = f"我叫{name}，今年{age}岁，身高{height:.2f}米"
	print(info) # 输出"我叫张三，今年25岁，身高1.75米"
	# {height:.2f}表示保留2位小数

18.16.4 三、重点：列表（List）——有序的“杂货铺盒子”

1. 什么是列表？
   列表就是把一堆东西按顺序放进一个盒子里，比如：
   购物清单：["苹果", "香蕉", "牛奶"]；
   成绩列表：[90, 85, 95, 88]；
   混合列表：["张三", 25, 1.75, True]（Python支持不同类型的数据放一起）。
   列表的3个核心特点：
   1.有序：每个元素都有固定的位置（索引）；
   2.可变：可以随时添加、删除、修改元素；
   3.可重复：允许有相同的元素，比如[1, 2, 2, 3]。
2. 常用操作：增删改查（代码逐行讲）
   python

	# 定义一个列表
	fruits = ["苹果", "香蕉", "橙子"]
	print("初始列表：", fruits) # 输出["苹果", "香蕉", "橙子"]
	
	# 1. 访问元素（按索引）
	print("第一个元素：", fruits[0]) # 输出"苹果"（索引从0开始）
	print("最后一个元素：", fruits[-1]) # 输出"橙子"（负索引从-1开始）
	
	# 2. 添加元素
	fruits.append("葡萄") # 在列表末尾添加"葡萄"
	print("append后：", fruits) # ["苹果", "香蕉", "橙子", "葡萄"]
	
	fruits.insert(1, "草莓") # 在索引1的位置插入"草莓"
	print("insert后：", fruits) # ["苹果", "草莓", "香蕉", "橙子", "葡萄"]
	
	fruits.extend(["西瓜", "芒果"]) # 把另一个列表的元素加进来
	print("extend后：", fruits) # ["苹果", "草莓", "香蕉", "橙子", "葡萄", "西瓜", "芒果"]
	
	# 3. 删除元素
	del fruits[2] # 删除索引2的元素（"香蕉"）
	print("del后：", fruits) # ["苹果", "草莓", "橙子", "葡萄", "西瓜", "芒果"]
	
	removed_fruit = fruits.pop() # 删除最后一个元素，并返回该元素
	print("pop删除的元素：", removed_fruit) # 输出"芒果"
	print("pop后：", fruits) # ["苹果", "草莓", "橙子", "葡萄", "西瓜"]
	
	fruits.remove("橙子") # 删除第一个出现的"橙子"
	print("remove后：", fruits) # ["苹果", "草莓", "葡萄", "西瓜"]
	
	# 4. 修改元素
	fruits[0] = "红苹果" # 把索引0的元素改成"红苹果"
	print("修改后：", fruits) # ["红苹果", "草莓", "葡萄", "西瓜"]
	
	# 5. 切片：取多个元素
	print("前2个元素：", fruits[:2]) # ["红苹果", "草莓"]
	print("中间2个元素：", fruits[1:3]) # ["草莓", "葡萄"]
	
	# 6. 排序（针对数字或字符串列表）
	numbers = [3, 1, 4, 2, 5]
	numbers.sort() # 原地排序（直接修改原列表）
	print("sort后：", numbers) # [1, 2, 3, 4, 5]
	
	sorted_numbers = sorted(numbers, reverse=True) # 生成新的排序后的列表（不修改原列表）
	print("sorted降序：", sorted_numbers) # [5, 4, 3, 2, 1]

3. 拓展：列表推导式（Python特色语法）
   用一行代码生成列表，比循环简洁10倍，比如：
   python

	# 生成1-10的平方列表
	squares = [x**2 for x in range(1, 11)]
	print(squares) # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
	
	# 生成1-10的偶数列表
	evens = [x for x in range(1, 11) if x % 2 == 0]
	print(evens) # [2, 4, 6, 8, 10]

逐行讲解：
x**2：要生成的元素（x的平方）；
for x in range(1,11)：遍历1到10的数字；
if x%2 ==0：过滤条件（只取偶数）。
4. 新手必踩坑：列表的深浅拷贝
如果直接用=赋值列表，会导致两个变量指向同一个“盒子”：
python

	a = [1, 2, [3, 4]]
	b = a # 不是复制，是给同一个盒子贴了新标签
	b[2][0] = 300
	print(a) # 输出[1, 2, [300, 4]]，a也被修改了！

解决方法：用copy()做浅拷贝，或deepcopy()做深拷贝：
python

	import copy
	a = [1, 2, [3, 4]]
	
	# 浅拷贝：只复制外层列表，内层列表还是共享
	b = a.copy()
	b[0] = 100
	print(a) # [1, 2, [3, 4]]（a的外层元素没被修改）
	b[2][0] = 300
	print(a) # [1, 2, [300, 4]]（a的内层元素被修改了）
	
	# 深拷贝：完全复制所有层级的元素
	c = copy.deepcopy(a)
	c[2][0] = 3
	print(a) # [1, 2, [300, 4]]（a完全没被修改）

18.16.5 四、重点：字典（Dict）——键值对的“映射盒子”

1. 什么是字典？
   字典就是“键-值”对的集合，比如：
   学生信息：{"name": "张三", "age": 25, "height": 1.75}；
   配置信息：{"theme": "dark", "font_size": 14}。
   字典的3个核心特点：
   1.键值对映射：通过“键”（比如name）找“值”（比如"张三"），类似查字典；
   2.键唯一且不可变：键不能重复，且必须是不可变类型（比如字符串、数字，不能是列表）；
   3.有序（Python3.7+）：3.7之前是无序的，3.7之后会保留插入顺序。
2. 常用操作：增删改查（代码逐行讲）
   python

	# 定义一个字典
	student = {
	"name": "张三",
	"age": 25,
	"height": 1.75,
	"is_student": True
	}
	print("初始字典：", student)
	
	# 1. 访问值（通过键）
	print("姓名：", student["name"]) # 输出"张三"
	# 用get()方法访问，避免键不存在报错
	print("性别：", student.get("gender", "未知")) # 键"gender"不存在，返回默认值"未知"
	
	# 2. 添加/修改键值对
	student["gender"] = "男" # 键不存在，添加新的键值对
	student["age"] = 26 # 键存在，修改对应的值
	print("添加/修改后：", student)
	
	# 3. 删除键值对
	del student["height"] # 删除键"height"
	print("del后：", student)
	
	removed_value = student.pop("is_student") # 删除键"is_student"，并返回值
	print("pop删除的值：", removed_value) # 输出True
	print("pop后：", student)
	
	# 4. 遍历字典
	print("
遍历键：")
	for key in student:
	print(key) # 输出name、age、gender
	
	print("
遍历值：")
	for value in student.values():
	print(value) # 输出张三、26、男
	
	print("
遍历键值对：")
	for key, value in student.items():
	print(f"{key}：{value}") # 输出name：张三、age：26、gender：男

3. 拓展：字典推导式
   和列表推导式类似，一行代码生成字典：
   python

	# 生成1-5的平方字典
	square_dict = {x: x**2 for x in range(1, 6)}
	print(square_dict) # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
	
	# 把两个列表转成字典
	keys = ["name", "age", "gender"]
	values = ["李四", 23, "女"]
	person = {k: v for k, v in zip(keys, values)}
	print(person) # {"name": "李四", "age": 23, "gender": "女"}

4. 拓展：defaultdict（解决键不存在的问题）
   普通字典如果访问不存在的键会报错，用collections.defaultdict可以指定默认值：
   python

	from collections import defaultdict
	
	# 定义默认值为列表的字典
	student_scores = defaultdict(list)
	student_scores["张三"].append(90)
	student_scores["张三"].append(85)
	student_scores["李四"].append(95)
	print(student_scores) # defaultdict(list, {'张三': [90, 85], '李四': [95]})
	# 不用判断键是否存在，直接append，非常适合分组统计

18.16.6 五、列表 vs 字典：什么时候用哪个？

举个例子：
存储班级学生的姓名：用列表["张三", "李四", "王五"]；
存储每个学生的成绩：用字典{"张三": 90, "李四": 85, "王五": 95}。
18.16.7 思考题
1.为什么Python的列表索引从0开始？（提示：和计算机内存存储有关）
2.列表的append()、insert()、extend()有什么区别？分别适用于什么场景？
3.字典的键为什么必须是不可变类型？列表为什么不能当键？
4.如何判断一个变量的数据类型？type()和isinstance()有什么区别？
5.用列表推导式生成1-20的奇数列表，用字典推导式生成学生姓名到成绩的映射（姓名从"学生1"到"学生5"，成绩随机生成60-100的整数）。

转载请注明出处：https://www.xin3721.com/pythonNew/python49616.html