Python_day24元组和OS模块

最新推荐文章于 2025-08-04 22:31:11 发布
原创 最新推荐文章于 2025-08-04 22:31:11 发布 · 1k 阅读 · 22 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python #开发语言

DAY 24 元组和OS模块

知识点回顾：

  1. 元组
  2. 可迭代对象
  3. os模块

作业：对自己电脑的不同文件夹利用今天学到的知识操作下，理解下os路径。

元组

元组的特点：

  1. 有序，可以重复，这一点和列表一样
  • 元组中的元素不能修改，这一点非常重要，深度学习场景中很多参数、形状定义好了确保后续不能被修改。

很多流行的 ML/DL 库（如 TensorFlow, PyTorch, NumPy）在其 API 中都广泛使用了元组来表示形状、配置等。

可以看到，元组最重要的功能是在列表之上，增加了不可修改这个需求

元组的创建

my_tuple1 = (1, 2, 3)

my_tuple2 = ('a', 'b', 'c')

my_tuple3 = (1, 'hello', 3.14, [4, 5]) # 可以包含不同类型的元素

print(my_tuple1)

print(my_tuple2)

print(my_tuple3)


(1, 2, 3)
('a', 'b', 'c')
(1, 'hello', 3.14, [4, 5])

可以省略括号

可以省略括号
my_tuple4 = 10, 20, 'thirty' # 逗号是关键

print(my_tuple4)

print(type(my_tuple4)) # 看看它的类型

(10, 20, 'thirty')

<class 'tuple'>

(10, 20, 'thirty')
<class 'tuple'>

创建空元组或者使用 tuple() 函数

empty_tuple = ()

#或者使用 tuple() 函数
empty_tuple2 = tuple()

print(empty_tuple)

print(empty_tuple2)
()
()

元组的常见用法

元组的索引

my_tuple = ('P', 'y', 't', 'h', 'o', 'n')

print(my_tuple[0]) # 第一个元素

print(my_tuple[2]) # 第三个元素

print(my_tuple[-1]) # 最后一个元素
P
t
n

元组的切片

my_tuple = (0, 1, 2, 3, 4, 5)

print(my_tuple[1:4]) # 从索引 1 到 3 (不包括 4)

print(my_tuple[:3]) # 从开头到索引 2

print(my_tuple[3:]) # 从索引 3 到结尾

print(my_tuple[::2]) # 每隔一个元素取一个
(1, 2, 3)
(0, 1, 2)
(3, 4, 5)
(0, 2, 4)

元组的长度获取

my_tuple = (1, 2, 3)

print(len(my_tuple))
3

与管道工程的关系

管道工程中pipeline类接收的是一个包含多个小元组的 列表 作为输入。

可以这样理解这个结构：

  1. 1.列表 []: 定义了步骤执行的先后顺序。Pipeline 会按照列表中的顺序依次处理数据。之所以用列表，是未来可以对这个列表进行修改。
  2. 2.元组 (): 用于将每个步骤的名称和处理对象捆绑在一起。名称用于在后续访问或设置参数时引用该步骤，而对象则是实际执行数据转换或模型训练的工具。固定了操作名+操作

不用字典因为字典是无序的。

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.metrics import accuracy_score

# 1. 加载数据
iris = load_iris()
X = iris.data
y = iris.target

# 2. 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 3. 构建管道
# 管道按顺序执行以下步骤：
#    - StandardScaler(): 标准化数据（移除均值并缩放到单位方差）
#    - LogisticRegression(): 逻辑回归分类器
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('logreg', LogisticRegression())
])

# 4. 训练模型
pipeline.fit(X_train, y_train)

# 5. 预测
y_pred = pipeline.predict(X_test)

# 6. 评估模型
accuracy = accuracy_score(y_test, y_pred)
print(f"模型在测试集上的准确率: {accuracy:.2f}")
模型在测试集上的准确率: 1.00

可迭代对象

可迭代对象 (Iterable) 是 Python 中一个非常核心的概念。简单来说，一个可迭代对象就是指那些能够一次返回其成员（元素）的对象，让你可以在一个循环（比如 for 循环）中遍历它们。

Python 中有很多内置的可迭代对象，目前我们见过的类型包括：

类型

序列类型 (Sequence Types):

  1. list (列表)
  2. tuple (元组)
  3. str (字符串)
  4. range (范围)

  5. 集合类型 (Set Types):

set (集合)

字典类型 (Mapping Types):

dict (字典) - 迭代时返回键 (keys)

文件对象 (File objects)

生成器 (Generators)

迭代器 (Iterators) 本身

迭代利用循环

迭代列表

#列表 (list)
print("迭代列表:")

my_list = [1, 2, 3, 4, 5]

for item in my_list:

print(item)
迭代列表:
1
2
3
4
5

迭代元组 (tuple)

# 元组 (tuple)
print("迭代元组:")
my_tuple = ('a', 'b', 'c')
for item in my_tuple:
    print(item
迭代元组:
a
b
c

迭代字符串 (str)

# 字符串 (str)
print("迭代字符串:")
my_string = "hello"
for char in my_string:
    print(char)
迭代字符串:
h
e
l
l
o

关于range (范围)迭代

# range (范围)
print("迭代 range:")
for number in range(5):  # 生成 0, 1, 2, 3, 4
    print(number)
迭代 range:
0
1
2
3
4

迭代集合类型 (Set Types)

# 集合类型 (Set Types)

# 集合 (set) - 注意集合是无序的，所以每次迭代的顺序可能不同
print("迭代集合:")
my_set = {3, 1, 4, 1, 5, 9}
for item in my_set:
    print(item)
迭代集合:
1
3
4
5
9

迭代字典 (dict) - 默认迭代时返回键 (keys)

# 字典 (dict) - 默认迭代时返回键 (keys)
print("迭代字典 (默认迭代键):")
my_dict = {'name': 'Alice', 'age': 30, 'city': 'Singapore'}
for key in my_dict:
    print(key)
迭代字典 (默认迭代键):
name
age
city
迭代字典的值 (values)
# 迭代字典的值 (values)
print("迭代字典的值:")
for value in my_dict.values():
    print(value)
迭代字典的值:
Alice
30
Singapore
迭代字典的键值对 (items) 
# 迭代字典的键值对 (items)
print("迭代字典的键值对:")
for key, value in my_dict.items(): # items方法很好用
    print(f"Key: {key}, Value: {value}")
迭代字典的键值对:
Key: name, Value: Alice
Key: age, Value: 30
Key: city, Value: Singapore

OS 模块

随着深度学习项目变得越来越大、数据量越来越多、代码结构越来越复杂，你会越来越频繁地用到 os 模块来管理文件、目录、路径，以及进行一些基本的操作系统交互。虽然深度学习的核心在于模型构建和训练，但数据和模型的有效管理是项目成功的关键环节，而 os 模块为此提供了重要的工具。

在简单的入门级项目中，你可能只需要使用 pd.read_csv() 加载数据，而不需要直接操作文件路径。但是，当你开始处理图像数据集、自定义数据加载流程、保存和加载复杂的模型结构时，os 模块就会变得非常有用。

好的代码组织和有效的文件管理是大型深度学习项目的基石。os 模块是实现这些目标的重要组成部分。

import

import os

#os是系统内置模块，无需安装

获取当前工作目录

os.getcwd() # get current working directory 获取当前工作目录的绝对路径

获取当前工作目录下的文件列表

os.listdir() # list directory 获取当前工作目录下的文件列表

拼接

我们使用 r'' 原始字符串，这样就不需要写双反斜杠 \\，因为\会涉及到转义问题

#    我们使用 r'' 原始字符串，这样就不需要写双反斜杠 \\，因为\会涉及到转义问题
path_a = r'C:\Users\YourUsername\Documents' # r''这个写法是写给python解释器看，他只会读取引号内的内容，不用在意r的存在会不会影响拼接
path_b = 'MyProjectData'
file = 'results.csv'

# 使用 os.path.join 将它们安全地拼接起来，os.path.join 会自动使用 Windows 的反斜杠 '\' 作为分隔符
file_path = os.path.join(path_a , path_b, file)

file_path

环境变量方法

# os.environ 表现得像一个字典，包含所有的环境变量
os.environ

使用 .items() 方法

# 使用 .items() 方法可以方便地同时获取变量名（键）和变量值，之前已经提过字典的items()方法，可以取出来键和值
# os.environ是可迭代对象

for variable_name, value in os.environ.items():
  # 直接打印出变量名和对应的值
  print(f"{variable_name}={value}")

# 你也可以选择性地打印总数
print(f"\n--- 总共检测到 {len(os.environ)} 个环境变量 ---")

目录树

os.walk() 是 Python os 模块中一个非常有用的函数，它用于遍历（或称“行走”）一个目录树。

核心功能：

os.walk(top, topdown=True, οnerrοr=None, followlinks=False) 会为一个目录树生成文件名。对于树中的每个目录（包括 top 目录本身），它会 yield（产生）一个包含三个元素的元组 (tuple)：

(dirpath, dirnames, filenames)

  1. dirpath: 一个字符串，表示当前正在访问的目录的路径。
  2. dirnames: 一个列表（list），包含了 dirpath 目录下所有子目录的名称（不包括 . 和 ..）。
  3. filenames: 一个列表（list），包含了 dirpath 目录下所有非目录文件的名称。

示例目录结构 (Markdown形式):

假设你的 start_directory (当前工作目录 .) 是 my_project，其结构如下：

my_project/
├── data/
│   ├── processed/
│   └── raw/
│       └── data1.csv
├── src/
│   ├── models/
│   │   └── model_a.py
│   └── utils.py
├── main.py
└── README.md

os.walk 的遍历顺序及输出 (模拟):

(注意：dirnames 和 filenames 的顺序可能因操作系统或文件系统而略有不同，但遍历的 深度优先 逻辑是一致的)

--- 开始遍历目录: my_project ---

  当前访问目录 (dirpath): my_project
  子目录列表 (dirnames): ['data', 'src']  # <--- 列出第一层子目录
  文件列表 (filenames): ['main.py', 'README.md']

  当前访问目录 (dirpath): my_project/data  # <--- 深入到 data
  子目录列表 (dirnames): ['processed', 'raw'] # <--- 列出 data 下的子目录
  文件列表 (filenames): []

  当前访问目录 (dirpath): my_project/data/processed # <--- 深入到 processed
  子目录列表 (dirnames): []
  文件列表 (filenames): []

  当前访问目录 (dirpath): my_project/data/raw # <--- 回溯到 data，然后深入到 raw
  子目录列表 (dirnames): []
  文件列表 (filenames): ['data1.csv']

  当前访问目录 (dirpath): my_project/src # <--- 回溯到 my_project，然后深入到 src
  子目录列表 (dirnames): ['models']
  文件列表 (filenames): ['utils.py']

  当前访问目录 (dirpath): my_project/src/models # <--- 深入到 models
  子目录列表 (dirnames): []
  文件列表 (filenames): ['model_a.py']

# 遍历结束

总结:

os.walk 会首先访问起始目录 (my_project)，然后它会选择第一个子目录 (data) 并深入进去，访问 data 目录本身，然后继续深入它的子目录 (processed -> raw)。只有当 data 分支下的所有内容都被访问完毕后，它才会回到 my_project 这一层，去访问下一个子目录 (src)，并对 src 分支重复深度优先的探索。

它不是按层级（先访问所有第一层，再访问所有第二层）进行的，而是按分支深度进行的。这种策略被称之为深度优先

import os

start_directory = os.getcwd() # 假设这个目录在当前工作目录下

print(f"--- 开始遍历目录: {start_directory} ---")

for dirpath, dirnames, filenames in os.walk(start_directory):
    print(f"  当前访问目录 (dirpath): {dirpath}")
    print(f"  子目录列表 (dirnames): {dirnames}")
    print(f"  文件列表 (filenames): {filenames}")

    # # 你可以在这里对文件进行操作，比如打印完整路径
    # print("    文件完整路径:")
    # for filename in filenames:
    #     full_path = os.path.join(dirpath, filename)
    #     print(f"      - {full_path}")

介绍这个方法，是因为在你面临云服务器时候，往往只能通过命令行和代码块中函数来查看，无法像电脑一样在界面中查看，所以，这个方法可以让你直接在代码块中查看。

上图为kaggle平台代码提交的代码 理解下这个函数的遍历 以后如果这个训练营说到大模型相关，我们还会经常和os模块打交道

@浙大疏锦行

python的os模块详细解读
景天科技苑
01-11 1万+
os是“operating system”的缩写，os模块提供各种 Python 程序与操作系统进行交互的接口，使用os模块，一方面可以方便地与操作系统进行交互，另一方面页可以极大增强代码的可移植性
Python_Day11 - 目录 & 包 & 模块
Lancelot_Lv的博客
08-03 315
1. 目录 2. 包 3. 模块 3.1 概念 a. 模块 每一个.py文件就是一个模块 b. 封装思路： 函数 ==> 类 ==> 模块 ==> 包 ==> 项目 3.2 OS模块 a. 概念： 提供有关操作系统的函数，处理文件或者文件夹 3.2.1 os模块的操作 a. 获取当前操作系统的名称 【os. name】 语法： import os print(os. name) ‘’’ nt----->Windows posix------>Linux, Mac
Python打卡 DAY 24 元组和OS模块
2301_76970300的博客
06-07 1209
使用示例print(num) # 输出 3 2 1。
Python打卡Day24 元组和OS模块
2501_91037531的博客
07-26 266
随着深度学习项目变得越来越大、数据量越来越多、代码结构越来越复杂，你会越来越频繁地用到 os 模块来管理文件、目录、路径，以及进行一些基本的操作系统交互。虽然深度学习的核心在于模型构建和训练，但数据和模型的有效管理是项目成功的关键环节，而 os 模块为此提供了重要的工具。简单来说，一个可迭代对象就是指那些能够一次返回其成员（元素）的对象，让你可以在一个循环（比如 for 循环）中遍历它们。2. 元组中的元素不能修改，这一点非常重要，深度学习场景中很多参数、形状定义好了确保后续不能被修改。
疏锦行Python打卡 DAY 24 元组和OS模块
weixin_51658332的博客
06-09 191
【代码】疏锦行Python打卡 DAY 24 元组和OS模块。
python训练Day24 元组和OS模块
Win927w的博客
06-08 902
然后继续深入它的子目录 (`processed` -> `raw`)。只有当 `data` 分支下的所有内容都被访问完毕后，它才会回到 `my_project` 这一层，去访问下一个子目录 (`src`)，并对 `src` 分支重复深度优先的探索。当前访问目录 (dirpath): my_project/src # <--- 回溯到 my_project，然后深入到 src。当前访问目录 (dirpath): my_project/data/raw # <--- 回溯到 data，然后深入到 raw。
DAY 24 元组和OS模块
2501_92280986的博客
07-25 811
os.walk会首先访问起始目录 (my_project)，然后它会选择第一个子目录 (data) 并深入进去，访问 data 目录本身，然后继续深入它的子目录 (processed -> raw)。只有当 data 分支下的所有内容都被访问完毕后，它才会回到 my_project 这一层，去访问下一个子目录 (src)，并对 src 分支重复深度优先的探索。它不是按层级（先访问所有第一层，再访问所有第二层）进行的，而是按分支深度进行的。这种策略被称之为深度优先@浙大疏锦行。
day24 元组和OS模块
weixin_68674900的博客
06-07 925
元组是python中一个内置数据类型，用于存储一系列有序的元素。元组中的元素可以是任何类型，包括数据、字符串、列表等，且元组之间用逗号分隔，整个元组用圆括号包围。对自己电脑的不同文件夹利用今天学到的知识操作下，理解下os路径。path = '/Users/wangbinhao/Desktop/毕业设计'/Users/wangbinhao/Desktop/毕业设计/.DS_Store/Users/wangbinhao/Desktop/毕业设计/基于SpringBoot技术的汽车维修系统.doc。
Python训练营打卡 DAY 24 元组和OS模块
zifoyyds的博客
07-30 71
对自己电脑的不同文件夹利用今天学到的知识操作下，理解下os路径。
【python机器学习】Day24 元组和OS模块
2203_75479908的博客
05-13 164
对自己电脑的不同文件夹利用今天学到的知识操作下，理解下os路径。
Day24 元组和OS模块
2501_91906624的博客
06-07 805
1、元组（
PYthon入门代码_python_
09-29
模块化编程是Python的一大特色，`import`语句用于引入外部模块，如内置的math、os、sys等，或者自定义的模块。Python标准库提供了大量功能，例如网络通信、文件操作、日期时间处理等。此外，Python的异常处理机制...
python列表相关，元组，相关内置函数,常用模块os、time
2301_80176068的博客
12-24 761
python列表相关，元组，相关内置函数,常用模块os、time
RAGFlow Agent 知识检索节点源码解析：从粗排到精排的完整流程
澄南澄北的博客
08-01 890
文本检索：基于关键词匹配，擅长精确匹配和术语查找向量检索：基于语义相似度，擅长理解查询意图和同义词匹配Embedding 检索方法通过分别编码 Query 和 Chunk 得到向量，并用余弦相似度评估相关性。优点是可以提前计算Chunk的向量并存储，检索效率高、可大规模向量召回，适合在粗排阶段使用。但这种独立编码方式无法建模两者之间的语义交互。而 Rerank 模型会将 Query 和 Chunk 作为一个成对的输入，同时送入模型进行处理。
使用yolo11训练饮料瓶盖缺陷检测质量检测数据集VOC+YOLO格式1432张5类别步骤和流程
FL1623863129的博客
08-03 519
训练完成后，最佳权重保存路径为：runs/detect/train/weights/best.pt，如果多次运行命令runs/detect/train2,runs/detect/train3文件夹生成只需要到数字最大文件夹查看就可以找到模型。经过上面训练可以使用模型做一步部署，比如使用onnx模型在嵌入式部署，使用engine模型在jetson上deepstream部署，使用torchscript模型可以在C++上部署等等。通过比较不同模型在这些指标上的表现，可以判断哪个模型在实际应用中可能更有效。
学习日志27 python
最新发布
AYheyheyhey的博客
08-04 623
封装是 “隐藏内部细节”，解决数据安全和接口简化问题；多态是 “统一接口，不同实现”，解决代码灵活性和扩展性问题；二者常结合使用：封装为多态提供了基础（确保对象内部稳定），多态通过封装的接口实现灵活交互。
numpy广播
2402_89746772的博客
08-01 400
展平数组并返回拷贝（修改不影响原数组）。展平数组并返回视图（修改会影响原数组）。将数组广播到指定形状（返回只读视图）。数组元素迭代器，用于遍历所有元素。不改变数据，仅修改数组形状。对换数组维度（矩阵转置）。删除数组中的一维条目。滚动指定轴到新位置。
ORACLE复杂查询
ZZH1120KQ的博客
08-04 942
在Oracle数据库中，逻辑判断和条件判断是两个密切相关但又不完全相同的概念。逻辑判断主要关注的是根据逻辑运算符（如AND、OR、NOT）对条件表达式的结果进行逻辑运算，从而得出最终的布尔值（true或false）。条件判断则更侧重于根据给定的条件或表达式来判断某个操作是否应该执行，或者应该执行哪个分支的操作。
【笔记】ROS1｜5 ARP攻击Turtlebot3汉堡Burger并解析移动报文【旧文转载】
shandianchengzi的博客
08-04 517
本文介绍了如何使用ARP攻击技术干扰Turtlebot3汉堡机器人的ROS通信。作者首先讲解了ARP协议的基本原理和攻击依据，然后通过实验演示了如何利用arpspoof工具实施ARP欺骗攻击，包括干扰普通主机上网和小车与控制机的通信。文章提供了详细的实验步骤和思考题，并建议读者在虚拟机环境下进行实践。实验结果显示，通过持续发送虚假ARP响应包可以成功劫持网络通信，开启IP转发后虽能恢复但会降低网速。最后作者还演示了如何解析被攻击机器人的移动控制报文。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值