Day 28 元组和OS模块

元组

在 Python 中，元组（Tuple） 是一种不可变、有序、可包含任意数据类型 的序列结构，也是最基础的数据类型之一。它和列表（List）语法相似（用圆括号 () 包裹），但核心区别是「不可变」------ 这让元组在数据安全、哈希（如字典键）、性能等场景中更有优势。

一、元组的核心特性

特性	说明
不可变性	一旦创建，元组内的元素不能被修改、添加、删除（但如果元素是可变类型如列表，其内部可修改）
有序性	元素按插入顺序排列，支持索引、切片（和列表 / 字符串一致）
异构性	可包含不同类型的元素（如数字、字符串、列表、元组等）
可哈希	仅当元组内所有元素都是不可变类型时，元组可作为字典的键、集合的元素（列表不行）
轻量级	内存占用比列表小，遍历 / 访问速度略快

二、元组的基本用法

1. 创建元组

复制代码

# 1. 基础创建（圆括号可选，但推荐加，避免歧义）
t1 = (1, 2, 3)  # 标准写法
t2 = 4, 5, 6    # 省略圆括号（Python 允许，称为"元组解包"语法）

# 2. 空元组
t_empty = ()

# 3. 单元素元组（必须加逗号，否则会被识别为普通变量）
t_single = (7,)  # 正确：元组（长度1）
t_error = (7)    # 错误：实际是整数 7

# 4. 嵌套元组（元组内包含元组/其他类型）
t_nested = (1, "hello", [8,9], (10, 11))

2. 访问元组元素（和列表完全一致）

元组支持索引（从 0 开始）、切片（左闭右开）、遍历：

复制代码

t = (10, 20, 30, 40, 50)

# 索引访问
print(t[0])   # 10（第一个元素）
print(t[-1])  # 50（最后一个元素）

# 切片
print(t[1:4]) # (20, 30, 40)（索引1到3）
print(t[:3])  # (10, 20, 30)（前3个元素）

# 遍历
for num in t:
    print(num)  # 依次打印 10,20,30,40,50

3. 元组的不可变性（核心）

元组创建后，不能修改元素、添加元素、删除元素，否则会报错：

复制代码

t = (1, 2, 3)
t[0] = 100  # 报错：TypeError: 'tuple' object does not support item assignment
t.append(4) # 报错：tuple 没有 append 方法
del t[1]    # 报错：tuple 不支持删除元素

# 例外：元组内的可变元素（如列表），其内部可修改
t = (1, [2, 3], 4)
t[1][0] = 200  # 合法！元组本身的结构没改，只是内部列表的元素改了
print(t)       # (1, [200, 3], 4)

4. 元组的常用操作（仅读操作）

元组没有修改类方法（如 append/pop），但支持以下只读操作：

复制代码

t = (1, 2, 3, 2, 4)

# 1. 长度
print(len(t))  # 5

# 2. 元素计数
print(t.count(2))  # 2（数字2出现2次）

# 3. 查找元素索引（返回第一个匹配项）
print(t.index(3))  # 2（数字3在索引2的位置）

# 4. 拼接（生成新元组，原元组不变）
t_new = t + (5, 6)
print(t_new)  # (1, 2, 3, 2, 4, 5, 6)

# 5. 重复（生成新元组）
t_repeat = t * 2
print(t_repeat)  # (1, 2, 3, 2, 4, 1, 2, 3, 2, 4)

可迭代对象

在 Python 中，可迭代对象（Iterable） 是指「能够依次返回其内部每个元素的对象」，是遍历（如 for 循环）、解包、推导式等操作的核心基础。简单来说：只要一个对象能被 for ... in ... 遍历，它就是可迭代对象。

一、常见的可迭代对象

Python 中绝大多数常用数据结构都是可迭代对象，核心包括：

类型	示例	备注
序列类型	列表 `[1,2,3]`、元组 `(1,2,3)`、字符串 `"abc"`	有序，支持索引 / 切片，最基础的可迭代对象
集合 / 字典	集合 `{1,2,3}`、字典 `{"a":1, "b":2}`	字典默认迭代「键」，可通过 `.values()`/`.items()` 迭代值 / 键值对
文件对象	`open("file.txt")`	逐行读取文件内容，本质是迭代每行
生成器 / 生成器表达式	`(x*2 for x in range(5))`	惰性生成元素，节省内存
第三方库对象	pandas 的 `Series`/`DataFrame`、numpy 数组	适配了 Python 迭代协议，可直接 `for` 遍历
自定义可迭代对象	实现 `__iter__()` 的类实例	按需自定义迭代逻辑

OS模块

os 模块是 Python 内置的核心模块，用于与操作系统交互 ，封装了跨平台的文件 / 目录操作、路径处理、系统信息获取等功能。无论是遍历文件、创建目录，还是拼接文件路径，os 模块都是处理文件系统的首选工具。

一、OS 模块核心功能分类

1. 路径处理（最常用）

路径是文件 / 目录的唯一标识，os.path 子模块提供了路径解析、拼接、验证等工具，解决跨平台路径问题。

函数	功能	示例
`os.path.join()`	拼接路径（自动适配分隔符）	`os.path.join("/kaggle/input", "titanic", "train.csv")` → `/kaggle/input/titanic/train.csv`
`os.path.abspath()`	获取绝对路径	`os.path.abspath("data.txt")` → `/home/user/data.txt`（Linux）
`os.path.basename()`	获取路径中的文件名（含后缀）	`os.path.basename("/a/b/c.txt")` → `c.txt`
`os.path.dirname()`	获取路径中的目录名	`os.path.dirname("/a/b/c.txt")` → `/a/b`
`os.path.exists()`	判断路径是否存在（文件 / 目录）	`os.path.exists("/kaggle/input/titanic")` → `True`
`os.path.isfile()`	判断是否是文件	`os.path.isfile("/kaggle/input/titanic/train.csv")` → `True`
`os.path.isdir()`	判断是否是目录	`os.path.isdir("/kaggle/input")` → `True`
`os.path.splitext()`	分割文件名和后缀	`os.path.splitext("train.csv")` → `("train", ".csv")`

实战示例：

复制代码

import os

# 拼接路径（跨平台友好）
base_dir = "/kaggle/input"
data_dir = "titanic"
file_name = "train.csv"
full_path = os.path.join(base_dir, data_dir, file_name)
print("完整路径：", full_path)  # /kaggle/input/titanic/train.csv

# 解析路径
print("文件名：", os.path.basename(full_path))  # train.csv
print("目录名：", os.path.dirname(full_path))   # /kaggle/input/titanic
print("文件名+后缀分割：", os.path.splitext(full_path))  # ('/kaggle/input/titanic/train', '.csv')

# 验证路径
print("路径是否存在：", os.path.exists(full_path))  # True
print("是否是文件：", os.path.isfile(full_path))    # True

2. 目录操作

用于创建、删除、切换目录，是批量处理文件的基础。

函数	功能	示例
`os.getcwd()`	获取当前工作目录（CWD）	`os.getcwd()` → `/kaggle/working`（Kaggle 环境）
`os.chdir()`	切换工作目录	`os.chdir("/kaggle/input")`（切换到输入目录）
`os.mkdir()`	创建单个目录（父目录不存在则报错）	`os.mkdir("new_dir")`（创建 new_dir 目录）
`os.makedirs()`	递归创建多级目录（父目录不存在则自动创建）	`os.makedirs("a/b/c")`（创建 a → b → c 多级目录）
`os.rmdir()`	删除空目录（非空则报错）	`os.rmdir("new_dir")`（删除空的 new_dir）
`os.removedirs()`	递归删除空目录（从子到父，遇到非空则停止）	`os.removedirs("a/b/c")`（删除 c → b → a，若都为空）
`os.listdir()`	列出目录下的所有文件 / 子目录（返回列表）	`os.listdir("/kaggle/input")` → `["titanic"]`

实战示例：

复制代码

import os

# 查看当前工作目录
print("当前工作目录：", os.getcwd())  # 如 /kaggle/working

# 创建多级目录
os.makedirs("data/train", exist_ok=True)  # exist_ok=True：目录已存在时不报错
print("是否创建成功：", os.path.isdir("data/train"))  # True

# 列出目录内容
print("data 目录下的内容：", os.listdir("data"))  # ['train']

# 删除空目录
os.rmdir("data/train")
os.removedirs("data")  # 递归删除空的 data 目录

3. 文件遍历（核心：os.walk ()）

os.walk() 是递归遍历目录的核心函数，它会逐层遍历目录，返回三元组 (当前目录路径, 子目录列表, 文件列表)。

核心逻辑

复制代码

import os

# 遍历 /kaggle/input 目录下的所有文件
for dirname, subdirs, filenames in os.walk("/kaggle/input"):
    # dirname：当前遍历的目录路径
    # subdirs：当前目录下的子目录列表
    # filenames：当前目录下的文件列表
    print(f"当前目录：{dirname}")
    print(f"子目录：{subdirs}")
    print(f"文件：{filenames}")
    # 拼接每个文件的完整路径
    for filename in filenames:
        file_path = os.path.join(dirname, filename)
        print(f"完整文件路径：{file_path}")

实战场景（遍历并读取所有 CSV 文件）：

复制代码

import os
import pandas as pd

# 遍历指定目录，读取所有 CSV 文件
csv_data = {}
for dirname, _, filenames in os.walk("/kaggle/input"):
    for filename in filenames:
        if filename.endswith(".csv"):  # 筛选 CSV 文件
            file_path = os.path.join(dirname, filename)
            csv_data[filename] = pd.read_csv(file_path)  # 读取并存储

# 查看读取的文件
print("读取的 CSV 文件：", list(csv_data.keys()))  # ['train.csv', 'test.csv', ...]

2. 代码的遍历流程

复制代码

/kaggle/input/
└── titanic/
    ├── train.csv
    ├── test.csv
    └── gender_submission.csv

遍历步骤：

os.walk('/kaggle/input')先进入/kaggle/input目录：
- dirname = '/kaggle/input'；
- 子目录列表 = ['titanic']（代码中用_忽略）；
- filenames = []（/kaggle/input下没有直接的文件，只有子目录titanic）。
然后递归进入子目录/kaggle/input/titanic：
- dirname = '/kaggle/input/titanic'；
- 子目录列表 = []（该目录下没有子目录）；
- filenames = ['train.csv', 'test.csv', 'gender_submission.csv']。
内层循环for filename in filenames：遍历当前目录下的每个文件，用os.path.join(dirname, filename)拼接目录路径 + 文件名 ，得到文件的完整路径（比如/kaggle/input/titanic/train.csv），最后打印出来。