[python基础] 输入和输出

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

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

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

 

rjust() 方法, 它可以将字符串靠右, 并在左边填充空格。

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

另一个方法 zfill(), 它会在数字的左边填充 0

>>> '12'.zfill(5)

'00012'

 

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

 

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

 

 

可选项 ':' 和格式标识符可以跟着字段名。 这就允许对值进行更好的格式化。

下面的例子将 Pi 保留到小数点后三位：

 

>>> import math
>>> print('常量 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

  

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

 

>>> import math
>>> print('常量 PI 的值近似为：%5.3f。' % math.pi)

 常量 PI 的值近似为：3.142。

 

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

 

 

读取键盘输入

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

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

 

str = input("请输入：");
print ("你输入的内容是: ", str)
这会产生如下的对应着输入的结果：
请输入：菜鸟教程
你输入的内容是:  菜鸟教程

 

 

读和写文件

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

open(filename, mode)

filename：filename 变量是一个包含了你要访问的文件名称的字符串值。

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

 

=============================================================================

r    只能读 

r+  可读可写 不会创建不存在的文件 从顶部开始写 会覆盖之前此位置的内容 

        r+如果直接写文件，则从顶部开始写，覆盖之前此位置的内容，

        如果先读后写，则会在文件最后追加内容。

w+ 可读可写 如果文件存在 则覆盖整个文件，不存在则创建 

w   只能写 覆盖整个文件 不存在则创建 

a    只能写 从文件底部添加内容 不存在则创建 

a+  可读可写 从文件顶部读取内容 从文件底部添加内容 不存在则创建

=============================================================================

 

 

以下实例将字符串写入到文件 foo.txt 中：

 

# 打开一个文件
f = open("/tmp/foo.txt", "w")
f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
# 关闭打开的文件
f.close()

此时打开文件 foo.txt,显示如下：
$ cat /tmp/foo.txt 
Python 是一个非常好的语言。
是的，的确非常好!!

 

 

文件对象的方法

f.read()

为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。

size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。

 

# 打开一个文件
f = open("/tmp/foo.txt", "r")

str = f.read()
print(str)

# 关闭打开的文件
f.close()

 

 

f.readline()

f.readline() 会从文件中读取单独的一行。换行符为 '\n'。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。

 

f.readlines()

f.readlines() 将返回该文件中包含的所有行。

如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。

 

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

f = open("/tmp/foo.txt", "r")
for line in f:
    print(line, end='')
f.close()

 

f.write()

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

f = open("/tmp/foo.txt", "w")
num = f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
print(num)
f.close()

 

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

f = open("/tmp/foo1.txt", "w")
value = ('www.runoob.com', 14)
s = str(value)
f.write(s)
f.close()

 

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('/tmp/foo.txt', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5)     # 移动到文件的第六个字节
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2) # 移动到文件的倒数第三字节
13
>>> f.read(1)
b'd'

 

当处理一个文件对象时, 使用 with 关键字是非常好的方式。在结束后, 它会帮你正确的关闭文件。 而且写起来也比 try - finally 语句块要简短:

>>> with open('/tmp/foo.txt', 'r') as f:
...     read_data = f.read()
>>> f.closed

 使用 with 语句操作文件对象

   

 with open(r'somefileName') as somefile:
        for line in somefile:
            print line
            # ...more code

 这里使用了 with 语句，不管在处理文件过程中是否发生异常，都能保证 with 语句执行完毕后已经关闭了打开的文件句柄。如果使用传统的 try/finally 范式，则要使用类似如下代码：

 

try/finally 方式操作文件对象

   

 somefile = open(r'somefileName')
    try:
        for line in somefile:
            print line
            # ...more code
    finally:
        somefile.close()

 

比较起来，使用 with 语句可以减少编码量。

 

pickle 模块

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

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

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

基本接口：

pickle.dump(obj, file, [,protocol])

有了 pickle 这个对象, 就能对 file 以读取的形式打开:

x = pickle.load(file)

注解：从 file 中读取一个字符串，并将它重构为原来的python对象。

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

参数protocol是序列化模式，默认值为0，表示以文本的形式序列化。protocol的值还可以是1或2，表示以二进制的形式序列化。

 

 

实例1：

import pickle

# 使用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 dictionary using protocol 0.
pickle.dump(data1, output)

# Pickle the list using the highest protocol available.
pickle.dump(selfref_list, output, -1)

output.close()

 

实例2：

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()

 

dump() 函数能一个接着一个地将几个对象转储到同一个文件。随后调用 load() 来以同样的顺序检索这些对象。

>>> a1 = 'apple'  
>>> b1 = {1: 'One', 2: 'Two', 3: 'Three'}  
>>> c1 = ['fee', 'fie', 'foe', 'fum']  
>>> f1 = file('temp.pkl', 'wb')  
>>> pickle.dump(a1, f1, True)  
>>> pickle.dump(b1, f1, True)  
>>> pickle.dump(c1, f1, True)  
>>> f1.close()  

>>> f2 = file('temp.pkl', 'rb')  
>>> a2 = pickle.load(f2)  
>>> a2  
'apple'  
>>> b2 = pickle.load(f2)  
>>> b2  
{1: 'One', 2: 'Two', 3: 'Three'}  
>>> c2 = pickle.load(f2)  
>>> c2  
['fee', 'fie', 'foe', 'fum']  
>>> f2.close()  

 对象：

import pickle  
class Person:  
    def __init__(self,n,a):  
        self.name=n  
        self.age=a  
    def show(self):  
        print self.name+"_"+str(self.age)  
aa = Person("JGood", 2)  
aa.show()  
f=open('d:\\p.txt','w')  
pickle.dump(aa,f,0)  
f.close()  
#del Person  
f=open('d:\\p.txt','r')  
bb=pickle.load(f)  
f.close()  
bb.show()  

 clear_memo()

　　清空pickler的“备忘”。使用Pickler实例在序列化对象的时候，它会“记住”已经被序列化的对象引用，所以对同一对象多次调用dump(obj)，pickler不会“傻傻”的去多次序列化。（没看懂，需要以后再理解）

import StringIO  
import pickle  
class Person:  
    def __init__(self,n,a):  
        self.name=n  
        self.age=a  
    def show(self):  
        print self.name+"_"+str(self.age)  
aa = Person("JGood", 2)  
aa.show()  
fle = StringIO.StringIO()   
pick = pickle.Pickler(fle)  
pick.dump(aa)  
val1=fle.getvalue()  
print len(val1)  
pick.clear_memo()  
pick.dump(aa)  
val2=fle.getvalue()  
print len(val2)  
fle.close()  

 。。