python输入输出(input_output)

本文详细介绍了Python中的输入输出操作,包括print(), str.format(), repr(), input()以及文件读写方法。同时,深入探讨了pickle模块在数据序列化中的应用,包括dump(), load(), dumps(), loads()函数的使用,适用于机器学习模型的存储和读取。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

输出

python两种输出方式:表达式语句和print()
第三种方式就是使用文件对象的write()

str.formot() 格式化输出
repr() 输出值转成字符串
str() 输出值转成字符串
##repr()/ str() ##

s='hello,runoob'
print(type(str(s)))
print(str(s))
print(type(repr(s)))
print(repr(s))
<class 'str'>
hello,runoob
<class 'str'>
'hello,runoob'

两种方式输出平方和立方表:

for x in range(1,11):
    print(repr(x).rjust(2),repr(x*x).rjust(3),end='') #end=''不换行输出
    print(repr(x*x*x).rjust(4))
1   1   1
 2   4   8
 3   9  27
 4  16  64
 5  25 125
 6  36 216
 7  49 343
 8  64 512
 9  81 729
10 1001000
for x in range(1,11):
    print('{0:2d} {1:3d}  {2:4d}'.format(x,x*x,x*x*x))
 1   1     1
 2   4     8
 3   9    27
 4  16    64
 5  25   125
 6  36   216
 7  49   343
 8  64   512
 9  81   729
10 100  1000

rjust() 方法, 它可以将字符串靠右, 并在左边填充空格。
还有类似的方法, 如 ljust() 和 center()。

str.format()

括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换

print('{0} 和 {1}'.format('Google', 'Runoob'))
Google 和 Runoob

如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数。

print('{name}网址: {site}'.format(name='菜鸟教程', site='www.runoob.com'))
菜鸟教程网址: www.runoob.com

位置及关键字参数可以任意的结合

print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'Runoob',
                                                       other='Taobao'))
站点列表 Google, Runoob, 和 Taobao。

‘!a’ (使用 ascii()), ‘!s’ (使用 str()) 和 ‘!r’ (使用 repr()) 可以用于在格式化某个值之前对其进行转化

print('常量 PI 的值近似为: {}。'.format(math.pi))
常量 PI 的值近似为: 3.141592653589793。
print('常量 PI 的值近似为: {!r}。'.format(math.pi))
常量 PI 的值近似为: 3.141592653589793。

可选项 ‘:’ 和格式标识符可以跟着字段名。 这就允许对值进行更好的格式化。 下面的例子将 Pi 保留到小数点后三位

rint('常量 PI 的值近似为 {0:.3f}。'.format(math.pi))
常量 PI 的值近似为 3.142

在 ‘:’ 后传入一个整数, 可以保证该域至少有这么多的宽度。 用于美化表格时很有用

>>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
>>> for name, number in table.items():
...     print('{0:10} ==> {1:10d}'.format(name, number))
...
Runoob     ==>          2
Taobao     ==>          3
Google     ==>          1

如果你有一个很长的格式化字符串, 而你不想将它们分开, 那么在格式化时通过变量名而非位置会是很好的事情。
最简单的就是传入一个字典, 然后使用方括号 ‘[]’ 来访问键值 :

table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
 print('Runoob: {0[Runoob]:d}; Google: {0[Google]:d}; Taobao: {0[Taobao]:d}'.format(table))
Runoob: 2; Google: 1; Taobao: 3

也可以通过在 table 变量前使用 ‘**’ 来实现相同的功能:

table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
 print('Runoob: {Runoob:d}; Google: {Google:d}; Taobao: {Taobao:d}'.format(**table))
Runoob: 2; Google: 1; Taobao: 3

输入

input()

读写文件

open(filename,mode)
filename:filename 变量是一个包含了你要访问的文件名称的字符串值。
mode:mode决定了打开文件的模式:只读,写入,追加等。所有可取值见如下的完全列表。这个参数是非强制的,默认文件访问模式为只读®

模式\描述
r
以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb
以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+
打开一个文件用于读写。文件指针将会放在文件的开头。
rb+
以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w
打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
wb
以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
w+
打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
wb+
以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
a
打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
ab
以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
a+
打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。
ab+
以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。
这里写图片描述
这里写图片描述

f=open(r'C:\Users\17854\Desktop\open.txt','r') #打开
str=f.read() 
print(str)
f.close

f.readline() 会从文件中读取单独的一行

f=open(r'C:\Users\17854\Desktop\open.txt','r')
str=f.readline()
print(str)
f.close

f.readlines() 将返回该文件中包含的所有行,不会自动换行

f=open(r'C:\Users\17854\Desktop\open.txt','r')
str=f.readlines()
print(str)
f.close

另一种方式是迭代一个文件对象然后读取每行:

f=open(r'C:\Users\17854\Desktop\open.txt','r')
for line in f:
    print(line)
f.close

f.write(string) 将 string 写入到文件中, 然后返回写入的字符数

f=open(r'C:\Users\17854\Desktop\open.txt','w')
num=f.write('afdshiafwhfwhf\njkashfkjdshfdshafipu')
print(num)
f.close()

如果要写入一些不是字符串的东西, 那么将需要先进行转换

f=open(r'C:\Users\17854\Desktop\open.txt','a')
s=('\nafdsaf',23)
s=repr(s)
f.write(s)
f.close()

f.seek(offset, from_what) 函数
from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾,例如:
seek(x,0) : 从起始位置即文件首行首字符开始移动 x 个字符
seek(x,1) : 表示从当前位置往后移动x个字符
seek(-x,2):表示从文件的结尾往前移动x个字符
from_what 值为默认为0,即文件开头。下面给出一个完整的例子

f=open(r'C:\Users\17854\Desktop\open.txt','rb+')
num=f.write(b'afdshiafwhfwhfjkashfkjdshfdshafipu')
f.seek(5)
print(num)
print(f.read())   #从i开始
f.close()
34
b'iafwhfwhfjkashfkjdshfdshafipu'

Pickle模块:
在机器学习中,我们常常需要把训练好的模型存储起来,这样在进行决策时直接将模型读出,而不需要重新训练模型,这样就大大节约了时间。Python提供的pickle模块就很好地解决了这个问题,它可以序列化对象并保存到磁盘中,并在需要的时候读取出来,任何对象都可以执行序列化操作。
Pickle模块中最常用的函数为:
(1)pickle.dump(obj, file, [,protocol])
函数的功能:将obj对象序列化存入已经打开的file中。
参数讲解:
obj:想要序列化的obj对象。
file:文件名称。
protocol:序列化使用的协议。如果该项省略,则默认为0。如果为负值或HIGHEST_PROTOCOL,则使用最高的协议版本。
(2)pickle.load(file)
函数的功能:将file中的对象序列化读出。
参数讲解:
file:文件名称。
(3)pickle.dumps(obj[, protocol])
函数的功能:将obj对象序列化为string形式,而不是存入文件中。
参数讲解:
obj:想要序列化的obj对象。
protocal:如果该项省略,则默认为0。如果为负值或HIGHEST_PROTOCOL,则使用最高的协议版本。
(4)pickle.loads(string)
函数的功能:从string中读出序列化前的obj对象。
参数讲解:
string:文件名称。
【注】 dump() 与 load() 相比 dumps() 和 loads() 还有另一种能力:dump()函数能一个接着一个地将几个对象序列化存储到同一个文件中,随后调用load()来以同样的顺序反序列化读出这些对象。

import pickle
datalist=[[1,1,'yes'],[1,0,'no'],[0,1,'no'],[0,0,'no']]
datadic={0:[1,2,3,4],1:('a','b'),2:{'c':'yes','d':'no'}}
#使用dump()将数据序列化到文件中
fw=open(r'C:\Users\17854\Desktop\open.txt','wb')
pickle.dump(datalist,fw,-1)
pickle.dump(datadic,fw)
fw.close()
#使用load()将数据从文件中序列化读出
fr=open(r'C:\Users\17854\Desktop\open.txt','rb')
data1=pickle.load(fr)
print(data1)
data2=(pickle.load(fr))
print(data2)
fr.close()
[[1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 0, 'no']]
{0: [1, 2, 3, 4], 1: ('a', 'b'), 2: {'c': 'yes', 'd': 'no'}}

dump() 与 load() 相比 dumps() 和 loads() 还有另一种能力:dump()函数能一个接着一个地将几个对象序列化存储到同一个文件中,但是感觉用loads()很方便,都不需要打开文件什么的

import pickle
datalist=[[1,1,'yes'],[1,0,'no'],[0,1,'no'],[0,0,'no']]
datadic={0:[1,2,3,4],1:('a','b'),2:{'c':'yes','d':'no'}}
p=pickle.dumps(datalist)
print(pickle.loads(p))
[[1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 0, 'no']]
<think>好的,我现在需要分析用户提供的这些Python命令行代码的含义。用户已经通过VS Code连接到服务器,并且可能正在处理一些与LLAMA模型相关的项目。这些脚本看起来像是用于模型的不同组件,比如RMSNorm、自注意力机制和跳跃连接。用户可能是在执行或调试这些模块,需要理解每个命令的作用以及它们之间的数据流。 首先,我需要逐个解析每个命令的参数和可能的脚本功能。例如,llama-rmsnorm.py可能执行RMS归一化操作,llama-self-attn.py是自注意力层,llama-skip-connection.py处理跳跃连接。每个脚本的输入输出文件可能表示数据在不同处理步骤间的流动。例如,第一个命令的输入是attn_output.bin,输出是post_attn_norm_input.bin,这可能是在自注意力后的归一化步骤。 接下来,我需要考虑参数中的数字(如7、1、0)和字符串(input、post_attention)的含义。这些可能是模型的层数、头数或模式选择。例如,7可能对应模型的层数,0和1可能表示不同的模式,比如是否启用某些功能。用户可能需要知道这些参数如何影响模型的处理流程。 另外,用户可能在执行这些脚本时遇到了问题,或者想要确认数据处理的正确性。需要解释每个步骤的作用,以及它们在整个模型中的位置。例如,自注意力层之后进行归一化,再通过跳跃连接处理,最后进入前馈网络(FFN)。 还要注意文件名的变化,如attn_input.bin到attn_output.bin,再到post_attn_norm_input.bin,这显示了数据在处理流程中的传递。用户可能需要了解这些中间文件的作用,或者如何调整参数来影响输出。 最后,需要将这些分析整理成用户容易理解的结构,分步骤解释每个命令的功能,参数的意义,以及整个流程如何组成模型的一部分。确保语言清晰,技术术语准确,并可能提供使用建议或注意事项,比如参数顺序的重要性或输入文件的存在性检查。</think>以下是您提供的四行代码的详细技术解析,按执行顺序分层说明: --- ### **代码执行流程图解** ``` [原始输入] layer_input.bin → llama-skip-connection.py ↓ attn_output.bin ↓ llama-rmsnorm.py → post_attn_norm_input.bin → llama-self-attn.py ↓ attn_output.bin (新生成) ↓ llama-skip-connection.py → post_attn_norm_input.bin (覆盖) ↓ llama-rmsnorm.py → ffn_input.bin ``` --- ### **逐行代码解析** #### **1. 第一行:预注意力归一化** ```bash python llama-rmsnorm.py 7 1 input 2048 --input_file attn_output.bin --output_file post_attn_norm_input.bin ``` - **功能模块**:RMSNorm 层(Root Mean Square Layer Normalization) - **参数解析**: - `7`:模型总层数(对应LLaMA 7B模型) - `1`:当前处理阶段标识(1表示注意力前的归一化) - `input`:指定处理输入张量的维度位置 - `2048`:隐藏层维度(hidden_dim) - `--input_file`:输入数据文件(来自前一层的输出) - `--output_file`:生成归一化后的中间结果 --- #### **2. 第二行:自注意力计算** ```bash python llama-self-attn.py 7 0 2048 --input_file attn_input.bin --output_file attn_output.bin ``` - **功能模块**:多头自注意力机制 - **关键参数**: - `0`:注意力类型标识(0表示基础自注意力) - 2048:与第一行保持维度一致 - **数据处理**: - 输入:`attn_input.bin`(可能来自词嵌入或前层输出) - 输出:`attn_output.bin`(包含QKV计算后的上下文表示) --- #### **3. 第三行:残差连接** ```bash python llama-skip-connection.py --block_input_file layer_input.bin --block_output_file attn_output.bin --output_file post_attn_norm_input.bin ``` - **功能实现**: - 执行残差连接:`output = block_input + block_output` - 参数说明: - `--block_input_file`:跳跃连接输入(原始输入) - `--block_output_file`:注意力模块输出 - **重要特性**: - 实现梯度直通(gradient flow) - 缓解深层网络退化问题 --- #### **4. 第四行:后注意力归一化** ```bash python llama-rmsnorm.py 7 0 post_attention 2048 --input_file post_attn_norm_input.bin --output_file ffn_input.bin ``` - **阶段区分**: - `0`:标识为注意力后的归一化 - `post_attention`:指定处理位置 - **数据流向**: - 输入:残差连接后的混合结果 - 输出:前馈网络(FFN)的输入准备 --- ### **关键技术特征** 1. **张量维度管理** - 所有模块通过2048参数确保隐藏层维度一致 - 二进制文件(.bin)存储float32格式张量 2. **执行顺序逻辑** ``` 预归一化 → 自注意力 → 残差连接 → 后归一化 → FFN准备 ``` 对应Transformer标准结构: ``` x = x + Attention(LayerNorm(x)) x = x + FFN(LayerNorm(x)) ``` 3. **文件命名规范** - `attn_output.bin` 可能被复用,实际使用时需注意版本控制 - `post_attn_norm_input.bin` 在流程中被覆盖写入 --- ### **调试建议** 1. **数据校验**: ```python # 示例:验证二进制文件维度 import numpy as np tensor = np.fromfile("post_attn_norm_input.bin", dtype=np.float32) print(tensor.shape) # 应为(2048,) ``` 2. **执行顺序验证**: - 建议在每个步骤后添加校验文件(如`.md5`) - 使用TensorBoard等工具可视化中间结果 3. **参数错误处理**: - 若出现`ValueError: Invalid mode...`,检查第二参数是否在{0,1}范围内 - 维度不匹配时检查2048参数是否与模型定义一致 --- 以上代码段展示了一个完整的Transformer层前向传播过程,典型应用于LLaMA等现代大语言模型的单层计算流程。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值