【语法06】Python输入和输出

输出格式美化

Python两种输出值的方式: 表达式语句和 print() 函数。

第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。

如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。

如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。

str()： 函数返回一个用户易读的表达形式。

repr()： 产生一个解释器易读的表达形式。

s = 'ECUST'
print(str(s))
print(repr(s))
print(str(1/7))

x = 10 * 3.25
y = 200 * 200
s = 'x的值为' + repr(x) + '，y的值为' + repr(y) + '……'
print(s)

#repr()函数可以转义字符串中的特殊字符
x = 'ECUST\n'
print(repr(x))

#repr()的参数可以是python任何对象
print(repr((x,y,[123,22],{32,4,5})))

ECUST
'ECUST'
0.14285714285714285
x的值为32.5，y的值为40000……
'ECUST\n'
('ECUST\n', 40000, [123, 22], {32, 4, 5})

for x in range(1,11):
    print(repr(x).rjust(2),repr(x*x).rjust(3),end = ' ')
    print(repr(x*x*x).rjust(4))
    
for x in range(1,11):
    print('{0:2d} {1:3d} {2:4d}'.format(x,x*x,x*x*x))

'''
注意：在第一个例子中, 每列间的空格由 print() 添加。

这个例子展示了字符串对象的 rjust() 方法, 它可以将字符串靠右, 并在左边填充空格。

还有类似的方法, 如 ljust() 和 center()。 这些方法并不会写任何东西, 它们仅仅返回新的字符串。
'''

#zfill()方法会在数字的左边填充0
print('12'.zfill(4))
print('-3.14'.zfill(7))
print('3.14159265359'.zfill(5))

#str.format()函数
print('{}是世界最帅的人，{}是最丑的'.format('Xuhuan','Fengweiheng'))
#括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。

#可以用括号中的数字指向传入对象在format()中的位置
print('{0}和{1}一样帅'.format('Xuhuan','吴彦祖'))
print('{1}和{0}一样帅'.format('Xuhuan','吴彦祖'))

#如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数。
print('{c} is {w}'.format(c = 'Xuhuan',w = 'Handsome'))

#位置及关键字参数可以任意的结合
print('{1} is {0} like {c}'.format('Xuhuan','Handsome',c = '吴彦祖'))

#'!a' (使用 ascii()), '!s' (使用 str()) 和 '!r' (使用 repr()) 可以用于在格式化某个值之前对其进行转化
import math
print('PI的近似值为{}'.format(math.pi))
print('PI的近似值为{!r}'.format(math.pi))

#可选项 ':' 和格式标识符可以跟着字段名。 这就允许对值进行更好的格式化。 下面的例子将 Pi 保留到小数点后三位
import math
print('PI的近似值为{0:.3f}'.format(math.pi))

#在 ':' 后传入一个整数,1 可以保证该域至少有这么多的宽度。 用于美化表格时很有用。
table = {'Xuhuan':22,'123':333,'name':123}
for i,j in table.items():
    print('{0:10}==>{1:10d}'.format(i,j))
    
#如果你有一个很长的格式化字符串, 而你不想将它们分开, 那么在格式化时通过变量名而非位置会是很好的事情。
#最简单的就是传入一个字典, 然后使用方括号 '[]' 来访问键值 :
table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
print('Runoob: {0[Runoob]:d}; Google: {0[Google]:d}; Taobao: {0[Taobao]:d}'.format(table))

#也可以通过在 table 变量前使用 '**' 来实现相同的功能
table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
print('Runoob: {Runoob:d}; Google: {Google:d}; Taobao: {Taobao:d}'.format(**table))

 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
 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
0012
-003.14
3.14159265359
Xuhuan是世界最帅的人，Fengweiheng是最丑的
Xuhuan和吴彦祖一样帅
吴彦祖和Xuhuan一样帅
Xuhuan is Handsome
Handsome is Xuhuan like 吴彦祖
PI的近似值为3.141592653589793
PI的近似值为3.141592653589793
PI的近似值为3.142
Xuhuan    ==>        22
123       ==>       333
name      ==>       123
Runoob: 2; Google: 1; Taobao: 3
Runoob: 2; Google: 1; Taobao: 3

旧式字符串格式化

% 操作符也可以实现字符串格式化。 它将左边的参数作为类似 sprintf() 式的格式化字符串, 而将右边的代入, 然后返回格式化后的字符串.

import math
print(‘常量PI的值近似为 % 5.3f’% math.pi)

#因为 str.format() 比较新的函数， 大多数的 Python 代码仍然使用 % 操作符。但是因为这种旧式的格式化最终会从该语言中移除, 应该更多的使用 str.format().

读取键盘输入

Python提供了 input() 内置函数从标准输入读入一行文本，默认的标准输入是键盘。

input 可以接收一个Python表达式作为输入，并将运算结果返回。

扫描二维码关注公众号，回复： 3317756 查看本文章

str = input('请输入：')
print('你输入的内容是：',str)

请输入：Xuhuan
你输入的内容是： Xuhuan

读和写文件

open() 将会返回一个 file 对象，基本语法格式如下:

open(filename, mode)

filename：包含了你要访问的文件名称的字符串值。

mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读®。

'''
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
'''

f = open('test.txt','w')
f.write('Python file read and write test!')
f.close()

文件对象的方法

#f.read()

f = open('test.txt','w')
f.write('Python file read and write test!\n1\n2\n3')
f.close()

f = open('test.txt','r')
s = f.read()
print(s)
f.close()

f = open('test.txt','r')
s1 = f.readline()
print(s1)
f.close()

#f.readlines() 将返回该文件中包含的所有行。如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。
f = open('test.txt','r')
s2 = f.readlines()
print(s2)
f.close()

#另一种方式是迭代一个文件对象然后读取每行
f = open('test.txt','r')
for line in f:
    print(line,end = ' ')
f.close()

Python file read and write test!
1
2
3
Python file read and write test!

['Python file read and write test!\n', '1\n', '2\n', '3']
Python file read and write test!
 1
 2
 3 

#f.write()

#f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。
f = open('foo.txt','w')
num = f.write('PYthon test')
print(num)
f.close()

#如果要写入一些不是字符串的东西, 那么将需要先进行转换
f = open('foo.txt','w')
value = ('East China University of Science and Technology',123)
s = str(value)
f.write(s)
f.close()
f = open('foo.txt','r')
print(f.read())
f.close()

11
('East China University of Science and Technology', 123)

#f.tell()
'''
f.tell() 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。
'''

#f.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，即文件开头。
'''
f = open('foo.txt','rb+')
f.write(b'0123456789zxcvbnm')
f.seek(5)
print(f.read(2))
f.seek(-4,2)
print(f.read(1))
f.seek(-2,1)
print(f.read())

#f.close()
'''
在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位。

当你处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。
'''
#当处理一个文件对象时, 使用 with 关键字是非常好的方式。在结束后, 它会帮你正确的关闭文件。 而且写起来也比 try - finally 语句块要简短
with open('foo.txt','r') as f:
    print(f.read())
    
print(f.closed)

b'56'
b'v'
b'cvbnm'
0123456789zxcvbnm
True

#pickle 模块
'''
python的pickle模块实现了基本的数据序列和反序列化。

通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。

通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。
基本接口：

pickle.dump(obj, file, [,protocol])
有了 pickle 这个对象, 就能对 file 以读取的形式打开:

x = pickle.load(file)
注解：从 file 中读取一个字符串，并将它重构为原来的python对象。

file: 类文件对象，有read()和readline()接口。
'''

import pickle

data1 = {'a': [1, 2.0, 3, 4+6j],
         'b': ('string', u'Unicode string'),
         'c': None}

selfref_list = [1, 2, 3]
selfref_list.append(selfref_list)

output = open('data.pkl','wb')

pickle.dump(data1,output)

pickle.dump(selfref_list,output,-1)

output.close()

import pprint, pickle

#使用pickle模块从文件中重构python对象
pkl_file = open('data.pkl', 'rb')

data1 = pickle.load(pkl_file)
pprint.pprint(data1)

data2 = pickle.load(pkl_file)
pprint.pprint(data2)

pkl_file.close()

{'a': [1, 2.0, 3, (4+6j)], 'b': ('string', 'Unicode string'), 'c': None}
[1, 2, 3, <Recursion on list with id=2178257104328>]