【Python】基础语法入门（四）

前言

在上一篇基础语法（三）中，我们掌握了函数的核心用法，解决了代码复用问题。但如果需要处理"批量数据"（如多个学生成绩、一系列坐标），仅用单个变量就会力不从心；如果想让数据在程序重启后不丢失，就需要把数据存储到文件中。这一篇，我们聚焦Python的核心数据结构（列表、元组、字典）和文件操作，解锁"批量存储数据"和"数据持久化"的关键能力，让程序能处理更复杂的场景。

---

一、列表与元组

当需要存储多个相关数据（如10个学生的成绩、5个坐标点）时，列表（list）和元组（tuple）是最常用的选择，它们都是"序列型数据结构"，按顺序存储元素，支持通过下标访问。

1.1 列表与元组的核心区别

我们可以用一个生动的比喻来理解：

• 列表：像"散装产品"------买回家后可以随时加、减、换辣条（元素可修改）。
• 元组：像"包装产品"------出厂后数量和内容固定，不能修改（元素不可变）。

特性	列表（list）	元组（tuple）
定义方式	用[]（如[1,2,3]）	用()（如(1,2,3)）
元素修改	支持（增、删、改元素）	不支持（创建后不可修改）
适用场景	数据需要动态调整（如批量录入成绩）	数据固定不变（如坐标、配置项）
语法灵活性	高（提供多个操作方法）	高（支持下标、切片等读操作）

1.2 列表

（1）创建列表

# 方式1：用[]创建（最常用）
alist = [1, 2, 3, 4]  # 整数列表
blist = [1, 'hello', True, 3.14]  # 支持不同类型元素（Python特色）

# 方式2：用list()函数创建
clist = list()  # 空列表
dlist = list(range(1, 6))  # 从其他可迭代对象创建，输出[1,2,3,4,5]

（2）访问元素

列表的元素按顺序排列，支持通过"下标"精准访问，通过"切片"批量获取连续元素：

• 下标：从0开始（如alist[0]是第一个元素），支持负数（alist[-1]是最后一个元素）；
• 切片：用[start:end:step]表示，左闭右开区间，step为步长（默认1）。

示例：下标与切片操作

alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(alist[0])    # 访问第一个元素，输出1
print(alist[-1])   # 访问最后一个元素，输出10
print(alist[1:4])  # 切片[1,4)，输出[2,3,4]
print(alist[::2])  # 步长2，取奇数元素，输出[1,3,5,7,9]
print(alist[::-1]) # 步长-1，反转列表，输出[10,9,8,...,1]

（3）修改列表

列表是可变的，提供丰富的方法修改元素：

alist = [1, 2, 3, 4]

# 1. 新增元素
alist.append(5)          # 尾插：在末尾添加元素，输出[1,2,3,4,5]
alist.insert(1, 'hello') # 插入：在下标1处添加元素，输出[1,'hello',2,3,4,5]
alist.extend([6,7])      # 扩展：合并另一个列表，输出[1,'hello',2,3,4,5,6,7]

# 2. 删除元素
alist.pop()              # 尾删：删除最后一个元素，输出[1,'hello',2,3,4,5,6]
alist.pop(1)             # 按下标删：删除下标1的元素，输出[1,2,3,4,5,6]
alist.remove(3)          # 按值删：删除第一个值为3的元素，输出[1,2,4,5,6]

# 3. 修改元素
alist[0] = 100           # 按下标修改，输出[100,2,4,5,6]

（4）遍历列表

遍历是"逐个取出元素处理"，常用三种方式：

alist = [1, 2, 3, 4]

# 方式1：直接遍历元素（最简洁）
for elem in alist:
    print(elem)  # 输出：1、2、3、4

# 方式2：按下标遍历（需要下标时用）
for i in range(len(alist)):
    print(f"下标{i}：{alist[i]}")  # 输出：下标0：1、下标1：2...

# 方式3：while循环遍历（手动控制下标）
i = 0
while i < len(alist):
    print(elem)
    i += 1

1.3 元组

元组的操作和列表类似，但不支持修改元素，核心用法集中在"读操作"：

# 1. 创建元组
atuple = (1, 2, 3, 4)  # 标准创建
btuple = (1,)           # 单个元素必须加逗号（否则会被视为整数）
ctuple = tuple([1,2,3]) # 从列表转换

# 2. 访问元素：下标与切片（和列表一致）
print(atuple[0])        # 输出1
print(atuple[1:3])      # 输出(2,3)
print(atuple[::-1])     # 输出(4,3,2,1)

# 3. 遍历元组（和列表一致）
for elem in atuple:
    print(elem)

# 4. 不可修改：以下操作会报错
atuple[0] = 100         # 报错：TypeError（元组元素不可修改）
atuple.append(5)        # 报错：AttributeError（元组无append方法）

1.4 为什么需要元组？

既然有了灵活的列表，为什么还要元组？核心优势有两个：

• 数据安全：传递数据时（如调用函数），元组不可修改，避免被意外篡改；
• 可作为字典键：字典的键要求是"不可变类型"，元组可以，列表不行。

---

二、字典

列表和元组按"顺序"存储数据，查找元素需要遍历（效率低）；而字典（dict）按"键值对"存储数据，通过"键"快速查找"值"，就像查字典------通过拼音（键）快速找到汉字（值），效率极高。

2.1 字典的核心概念

字典的每个元素是"键值对"，特点：

• 键（key）：唯一、不可变（如整数、字符串、元组）；
• 值（value）：可任意类型、可重复；
• 无序（Python3.7+后有序，但不依赖顺序查找）。

2.2 字典的核心操作

（1）创建字典

# 方式1：用{}创建（最常用）
student = {
    'id': 1,
    'name': 'zhangsan',
    'score': 90
}

# 方式2：用dict()函数创建
student2 = dict(id=2, name='lisi', score=85)

# 方式3：空字典
empty_dict = {}
empty_dict2 = dict()

（2）访问与修改元素：通过键操作

字典的所有操作围绕"键"展开，比列表更简洁：

student = {'id': 1, 'name': 'zhangsan', 'score': 90}

# 1. 访问值：通过键（key不存在会报错）
print(student['name'])  # 输出：zhangsan
print(student.get('score'))  # 用get方法，key不存在返回None（更安全）

# 2. 新增键值对（key不存在时）
student['age'] = 20  # 新增age字段，字典变为{'id':1, 'name':'zhangsan', 'score':90, 'age':20}

# 3. 修改值（key已存在时）
student['score'] = 95  # 修改score为95

# 4. 删除键值对
student.pop('age')  # 通过key删除，字典变回原来的样子

（3）遍历字典

student = {'id': 1, 'name': 'zhangsan', 'score': 95}

# 方式1：遍历所有key（默认）
for key in student:
    print(f"{key}：{student[key]}")  # 输出：id：1、name：zhangsan、score：95

# 方式2：遍历所有key-value对（用items()，最常用）
for key, value in student.items():
    print(f"{key}：{value}")

# 方式3：单独遍历key或value
print(student.keys())    # 获取所有key：dict_keys(['id', 'name', 'score'])
print(student.values())  # 获取所有value：dict_values([1, 'zhangsan', 95])

（4）合法的key类型

字典的key必须是"可哈希类型"（不可变类型），以下类型可作为key：

• 整数、浮点数、字符串、布尔值、元组；
• 列表、字典等可变类型不能作为key（会报错）。

---

三、文件操作

变量存储的数据在程序重启、电脑关机后会丢失，而文件操作能将数据存储到硬盘中，实现"持久化"------比如保存用户信息、成绩记录、日志等。

3.1 文件操作的核心流程

无论读写文件，都遵循"打开→操作→关闭"的流程：

• 打开：用open()函数打开文件，获取文件对象；
• 操作：读文件（read()、readlines()）或写文件（write()）；
• 关闭：用close()方法关闭文件（必须执行，否则会占用资源）。

3.2 打开文件：open()函数的关键参数

# 语法：open(文件路径, 打开方式, encoding='编码格式')
f = open('d:/test.txt', 'r', encoding='utf8')

• 文件路径：绝对路径（如d:/test.txt）或相对路径（如./test.txt），新手推荐绝对路径；
• 打开方式：
  • r：只读（默认，文件不存在会报错）；
  • w：只写（文件不存在则创建，存在则清空原有内容）；
  • a：追加写（文件不存在则创建，存在则在末尾添加内容）；
• encoding：编码格式（读取中文文件时需指定utf8或gbk，避免乱码）。

3.3 读文件：三种常用方式

# 方式1：读取全部内容（适合小文件）
with open('d:/test.txt', 'r', encoding='utf8') as f:
    content = f.read()  # 读取所有内容为字符串
    print(content)

# 方式2：逐行读取（适合大文件，节省内存）
with open('d:/test.txt', 'r', encoding='utf8') as f:
    for line in f:
        print(line.strip())  # strip()去除换行符和空格

# 方式3：读取所有行到列表（适合需要批量处理行数据）
with open('d:/test.txt', 'r', encoding='utf8') as f:
    lines = f.readlines()  # 每行为列表的一个元素
    print(lines)

3.4 写文件：两种常用方式

# 方式1：覆盖写（w模式）
with open('d:/test.txt', 'w', encoding='utf8') as f:
    f.write('hello python\n')  # 写字符串，\n表示换行
    f.write('你好，Python')

# 方式2：追加写（a模式）
with open('d:/test.txt', 'a', encoding='utf8') as f:
    f.write('\n这是追加的内容')

3.5 关键技巧：用with语句自动关闭文件

手动调用close()容易忘记，推荐用with语句------代码块执行完毕后，会自动关闭文件，安全又简洁：

# 无需手动写f.close()，with会自动处理
with open('d:/test.txt', 'r', encoding='utf8') as f:
    content = f.read()
    print(content)

3.6 中文乱码问题：编码格式匹配

读取中文文件时，若出现乱码或UnicodeDecodeError，原因是"文件编码与代码指定的编码不匹配"：

• 解决方案：用记事本打开文件→"文件"→"另存为"，查看文件编码（如UTF-8、ANSI=GBK）；
• 在open()函数中指定对应的encoding（如encoding='utf8'或encoding='gbk'）。

---

这一篇我们掌握了三种核心结构和文件操作，这些知识点是Python开发的"核心工具集"，比如用"列表+字典"存储多个用户信息，用"文件操作"保存数据，再结合之前的函数、循环，就能写出实用的小项目（如学生成绩管理系统、日志分析工具）。

至此，我们已梳理完Python基础语法（四）的核心内容了。最后我们在文末来进行一个投个票，告诉我你对哪部分内容最感兴趣、收获最大，也欢迎在评论区聊聊你的学习感受。后续我们还将深入探索库的使用，敬请关注 , 谢谢！

以上就是本期博客的全部内容了，感谢各位的阅读以及关注。如有内容存在疏漏或不足之处，恳请各位技术大佬不吝赐教、多多指正。