Python有两种较为常用的输出方式::表达式语句和 print() 函数。
第三种方式则是使用文件对象的 write() 方法,标准输出文件可以使用sys.stdout 。
如果你希望输出的形式更加多样,可以使用 str.format() 函数来格式化输出值。
如果你希望将输出的值转成字符串,可以使用 repr() 或 str() 函数来实现。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
>>> s = 'Hello'
>>> str (s)
'Hello'
>>> repr (s)
"'Hello'"
>>> str ( 1 / 7 )
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'x 的值为: ' + repr (x) + ', y 的值为:' + repr (y) + '...'
>>> print (s)
x 的值为: 32.5 , y 的值为: 40000. ..
>>>
... hello = 'hello\n'
>>> hello2 = repr (hello)
>>> print (hello2)
'hello\n'
>>>
... repr ((x, y, ( 'Google' , 'Baidu' )))
"(32.5, 40000, ('Google', 'Baidu'))"
|
str.format() 的基本使用如下:
1
2
|
>>> print ( '{}网址:"{}!"' . format ( 'zero' , 'www.zero01.org' ))
zero网址: "www.zero01.org!"
|
大括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。
在括号中的数字用于指向传入对象在 format() 中的位置,如下所示:
1
2
3
4
|
>>> print ( '{0} 和 {1} 不是好朋友' . format ( '小明' , '小红' ))
小明 和 小红 不是好朋友
>>> print ( '{1} 和 {0} 不是好朋友' . format ( '小明' , '小红' ))
小红 和 小明 不是好朋友
|
如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数。
1
2
|
>>> print ( '{name}网址:"{host}!"' . format (name = 'zero' ,host = 'www.zero01.org' ))
zero网址: "www.zero01.org!"
|
可以将以上两种使用方法结合一起使用:
1
2
3
|
>>> print ( '{0}{name}网址:"{host}"!' . format ( 'Test:' ,name = 'zero' ,host = 'www.zero01.org' ))
Test:zero网址: "www.zero01.org" !
|
使用以下几个字符可以在格式化某个值之前对其进行转化:
-
!a 等于调用了 ascii( ) 函数进行转化
-
!s 等于调用了 str( ) 函数进行转化
-
!r 等于调用了 repr( ) 函数进行转化
代码示例:
1
2
3
|
print ( '{!a}' . format ( 'hello' ))
print ( '{!s}' . format ( 'hello' ))
print ( '{!r}' . format ( 'hello' ))
|
运行结果:
‘hello’
hello
‘hello’
如果我们要保留n位小数时,可以使用冒号 ’ : ’ 来进行指定保留几位小数,例如下面的示例将 Pi 保留三位小数:
1
2
3
4
|
import math
print ( '保留三位小数的PI:{0:.3f}' . format (math.pi))
|
运行结果:
保留三位小数的PI:3.142
在 ‘:’ 后传入一个整数, 可以保证该域至少有这么多的宽度。 用于美化表格时很有用。
1
2
3
4
5
6
7
|
>>> 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
|
如果你有一个很长的格式化字符串, 而你不想将它们分开, 那么在格式化时通过变量名而非位置会是很好的事情。
最简单的就是传入一个字典, 然后使用方括号 ‘[]’ 来访问键值 :
1
2
3
4
|
>>> 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
|
旧式字符串格式化
% 操作符也可以实现字符串格式化。 它将左边的参数作为类似 sprintf() 式的格式化字符串, 而将右边的代入, 然后返回格式化后的字符串. 例如:
1
2
3
|
>>> import math
>>> print ( '常量 PI 的值近似为:%5.3f。' % math.pi)
常量 PI 的值近似为: 3.142 。
|
因为 str.format() 比较新的函数, 大多数的 Python 代码仍然使用 % 操作符。但是因为这种旧式的格式化最终会从该语言中移除, 应该更多的使用 str.format(),所以了解一下即可。
读取键盘输入
Python提供了一个内置函数 input() ,可以从标准输入读入一行文本,默认的标准输入是键盘,在PyCharm工具中使用这个函数就可以允许你从控制台中进行输入。
input 可以接收一个Python表达式作为输入,并将运算结果返回。
1
2
|
str = input ( "请输入:" )
print ( "你输入的内容是: " , str )
|
这会产生如下的对应着输入的结果:
请输入:hello
你输入的内容是: hello
如果你要通过键盘的输入进行一个运算的话,需要把类型转换成数字类型,例如:
1
2
|
num = int ( input ( "请输入:" ))
print ( "输入的数字平方是:" ,num * num)
|
运行结果:
请输入:3
输入的数字平方是: 9
如果不转类型的话,会按照字符串类型去进行运算,所以结果当然是错误的,错误示例:
1
2
|
num = input ( "请输入:" )
print ( "输入的数字乘以二是:" ,num * 2 )
|
运行结果:
请输入:3
输入的数字乘以二是: 33
读和写文件
在python中有一个内置的 open( ) 函数,这个函数可以用于打开某个文件进行读写操作,此函数会返回一个file对象,基本语法格式如下:
open(filename, mode)
不同模式打开文件的完全列表:

以下使用一个示例,演示将一段文字写入到一个文件中:
1
2
3
4
5
6
7
8
|
output = open ( "E:/test.txt" , "w" )
output.write( "Python 是一个非常好的语言。\n是的,人生苦短我用python!!\n" )
output.close()
|
运行结果:

打开此文件可以看到我们写入的内容。
以下再使用一个示例,读取我们刚刚写入的那个文件中的内容:
1
2
3
4
5
6
|
file_str = open ( "E:/test.txt" )
print (file_str.readline())
print (file_str.readline())
file_str.close()
|
运行结果:
Python 是一个非常好的语言。
是的,人生苦短我用python!!
文件对象的方法
上面已经介绍过两个文件对象的方法了,这两个方法也是最主要的方法,一个用于写文件一个用于读文件。除了这两个方法还有以下几个方法:
代码示例:
1
2
3
4
5
6
|
file_str = open ( "E:/test.txt" )
str = file_str.read( 10 )
print ( str )
file_str.close()
|
运行结果:
Python 是一个
因为设定只读取10个字节,所以文件内容没有被全部读取出来。
如果想要读取全部内容,就不需要指定这个参数:
1
2
3
4
5
6
|
file_str = open ( "E:/test.txt" )
str = file_str.read()
print ( str )
file_str.close()
|
运行结果:
Python 是一个非常好的语言。
是的,人生苦短我用python!!
代码示例:
1
2
3
4
5
6
7
8
9
10
11
12
|
file_str = open ( "E:/test.txt" )
while True :
str = file_str.readline()
if str = = "":
print ( "文件已经读取完了!" )
break
print ( str )
file_str.close()
|
运行结果:
Python 是一个非常好的语言。
是的,人生苦短我用python!!
文件已经读取完了!
代码示例:
1
2
3
4
5
|
file_str = open ( "E:/test.txt" )
print ( type (file_str.readlines()))
file_str.close()
|
运行结果:
<class 'list'>
从结果可以看到返回的对象类型是list列表。
我们可以通过遍历列表,来取出里面的元素:
代码示例:
1
2
3
4
5
6
7
8
9
10
11
|
file_str = open ( "E:/test.txt" )
listfile = file_str.readlines()
print ( "获得的是一个列表:" ,listfile, "\n" )
print ( "可以使用循环将列表中的内容遍历出来:" )
for i in listfile:
print (i)
file_str.close()
|
运行结果:
获得的是一个列表: [‘Python 是一个非常好的语言。\n’, ‘是的,人生苦短我用python!!\n’]
可以使用循环将列表中的内容遍历出来:
Python 是一个非常好的语言。
是的,人生苦短我用python!!
这个方法并不常用,毕竟用 readline( ) 方法就可以了。
代码示例:
1
2
3
4
5
6
7
|
file_str = open ( "E:/test.txt" , "w" )
data = [ "TestNumber:" , 123 , 45 , 12.5 ]
outData = str (data)
file_str.write(outData)
file_str.close()
|
运行结果:

代码示例:
1
2
3
4
5
6
|
file_str = open ( "E:/test.txt" )
print (file_str.read())
print ( "读取了:" ,file_str.tell(), "个字节" )
file_str.close()
|
运行结果:
[‘TestNumber:’, 123, 45, 12.5]
读取了: 31 个字节
-
seek( )
如果要改变文件当前的读取位置, 可以使用 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,即文件开头。下面给出一个完整的例子:
1
2
3
4
5
6
7
8
9
10
|
file_str = open ( "E:/test.txt" , "rb+" )
file_str.write(b '0123456789' )
print (file_str.seek( 5 , 0 ),end = " " )
print (file_str.seek( 3 , 1 ),end = " " )
print (file_str.seek( - 3 , 2 ),end = " " )
file_str.close()
|
运行结果:
5 8 7
代码示例:
1
2
3
4
5
6
|
>>> file_str = open ( "E:/test.txt" )
>>> file_str.close()
>>> file_str.read()
Traceback (most recent call last):
File "<stdin>" , line 1 , in ?
ValueError: I / O operation on closed file
|
with 关键字
当处理一个file对象时, 使用 with 关键字是非常好的方式。在文件读写操作结束后, 它会自动帮你正确的关闭文件。这样就不需要每次都使用finally最终块来确保关闭资源了。
代码示例:
1
2
3
4
5
|
>>> with open ( "E:/test.txt" ) as file_str:
... read_data = file_str.read()
>>> f.closed
True
|
从上面这个示例可以看到,我并没有调用 close( ) 方法,with自动帮我正确的关闭了文件,因为with的这一个方便之处,所以with关键字很常用。
文件对象还有其他方法, 如 isatty() 和 trucate(), 但这些通常比较少用,就不赘述了。
pickle 模块
python的pickle模块实现了基本的数据序列和反序列化。
通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去,永久存储。
通过pickle模块的反序列化操作,我们能够从文件中创建上一次程序保存的对象。
简单来说,pickle可以保存和加载几乎任何的python数据对象,例如列表、字典、元组等。我们可以通过pickle把这些数据对象存储到文件中(序列化),反过来(反序列化)也可以把文件中保存的这些数据再读取到程序的内存中。
pickle模块提供了两个方法,一个是 dump( ) 一个是 load( ) ,前者用于将数据对象保存到文件中,后者用于将保存到文件中的数据读取到内存中。要注意的一点是:这种形式保存的数据将会是二进制的形式,也就是说并非保存为普通的文本文件而是一个二进制文件。
下面使用一个实际的例子来简单的演示一下dump方法的应用方式,代码示例:
# 导入pickle模块
import pickle
# 这是一个列表数据对象
listData=[["test","file"],("dump",78),{"name":"lisi"},"zero",12.5,100]
# 以二进制的模式打开文件
with open("E:/test.txt","wb") as file_str :
pickle.dump(listData,file_str) # 将数据对象写入到文件中
运行结果:

因为是二进制形式的数据,所以用文本打开就会是一片乱码。
然后再使用load方法,就可以将数据再读取回来,并且数据类型依旧是列表,代码示例:
# 导入pickle模块
import pickle
# 以二进制的模式打开文件
with open("E:/test.txt", "rb") as file_str:
listData = pickle.load(file_str) # 读取文件中的二进制数据
print("读取出来的数据:", listData)
print("该数据的类型是:", type(listData))
运行结果:
读取出来的数据: [[‘test’, ‘file’], (‘dump’, 78), {‘name’: ‘lisi’}, ‘zero’, 12.5, 100]
该数据的类型是: <class 'list'>
pickle模块主要就是像以上示例一样,用于将某个数据对象保存到文件中,这样就可以永久存储,然后还可以再次将这些数据再读取到内存中。
本文转自 ZeroOne01 51CTO博客,原文链接:http://blog.51cto.com/zero01/1980934,如需转载请自行联系原作者