python输入输出（input_output）

输出

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']]