Python3 输入和输出

一、输出格式美化

• 将输出的值 转成字符串 ，可以使用 repr() OR str() 函数来实现

# str()： 函数返回一个用户易读的表达形式
# repr()： 产生一个解释器易读的表达形式
>>> s = 'Hello, Huawei'
>>> str(s)
'Hello, Huawei'
>>> repr(s)
"'Hello, Huawei'"
>>> 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...
>>> # repr() 函数可以转义字符串中的特殊字符
... hello = 'Hello, Huawei\n'
>>> hellos = repr(hello)
>>> print(hellos)
'ello, Huawei\n'
>>> # repr() 的参数可以是 Python 的任何对象
... repr((x, y, ('Google', 'Huawei')))
"(32.5, 40000, ('Google', 'Huawei'))"

• 输出的 形式更加多样 ，可以使用 str.format() 函数来格式化输出值

# 该实例演示两种方式输出一个平方与立方的表
>>> for x in range(1, 11):
...     # 注意 'end' ，rjust(width) 的使用
...     print(repr(x).rjust(2), repr(x*x).rjust(3), 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 100 1000

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

# '!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。

# 在格式化时通过变量名而非位置

# 传入一个字典, 使用方括号 '[]' 来访问键值
>>> table = {'Google': 1, 'Huawei': 2, 'Taobao': 3}
>>> print('Huawei: {0[Huawei]:d}; Google: {0[Google]:d}; Taobao: {0[Taobao]:d}'.format(table))
Huawei: 2; Google: 1; Taobao: 3

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

二、旧式字符串格式化

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

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

三、读取键盘输入

• 从标准输入读入一行文本，默认的标准输入是 键盘

# 默认返回字符串，若用数学计算，则需要转换格式
>>> str = input("请输入：")
请输入：Hello
>>> str
'Hello'

四、读和写文件

# 一般形式
# filename：包含了你要访问的文件名称的字符串值
# mode：决定了打开文件的模式，默认文件访问模式为只读 (r)
open(filename, mode)

序号	模式	描述
01	r	打开一个文件只用于 只读 。文件指针将会放在文件的 开头
02	rb	以 二进制格式 打开一个文件用于 只读 。文件指针将会放在文件的 开头
03	r+	打开一个文件用于 读写。文件指针将会放在文件的 开头
04	rb+	以 二进制格式打开一个文件用于 读写 。文件指针将会放在文件的 开头
05	w	打开一个文件只用于 写入 。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件
06	wb	以 二进制格式 打开一个文件只用于 写入 。如果该文件 已存在 则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件 不存在 ，创建新文件
07	w+	打开一个文件用于 读写。如果该文件 已存在 则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件 不存在 ，创建新文件
08	wb+	以 二进制格式 打开一个文件用于 读写。如果该文件 已存在 则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件 不存在，创建新文件
09	a	打开一个文件用于 追加 。如果该文件已存在，文件指针将会放在文件的 结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件 不存在 ，创建新文件进行 写入
10	ab	以 二进制格式 打开一个文件用于 追加。如果该文件 已存在，文件指针将会放在文件的 结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件 不存在 ，创建新文件进行 写入
11	a+	打开一个文件用于 读写 。如果该文件 已存在 ，文件指针将会放在文件的 结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于 读写
12	ab+	以 二进制格式 打开一个文件用于 追加 。如果该文件 已存在 ，文件指针将会放在文件的 结尾 。如果该文件 不存在 ，创建新文件用于 读写

序号	模式	r	r+	w	w+	a	a+
01	读	+	+		+		+
02	写		+	+	+	+	+
03	创建			+	+	+	+
04	覆盖			+	+
05	指针在开始	+	+	+	+
06	指针在结尾					+	+

# 该实例完整演示文件操作过程
f = open("/tmp/foo.txt", "w")

f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )

f.close()

五、文件对象的方法

• f.read(size) 读取一个文件的内容，返回 字符串或字节对象，可设置 size ，则读取指定长度的字节

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

str = f.read()
print(str)

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

-> Python 是一个非常好的语言。
-> 是的，的确非常好!!

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

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

str = f.readline()
print(str)

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

-> Python 是一个非常好的语言。

• f.readlines(sizehint) 将返回该文件中包含的 所有行 ，可设置 sizehint ，则读取指定长度的字节, 并且将这些字节 按行分割

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

str = f.readlines()
print(str)

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

-> ['Python 是一个非常好的语言。\n', '是的，的确非常好!!\n']

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

# 另一种方式是迭代一个文件对象，然后读取每行
# 方法很简单, 但是并没有提供一个很好的控制
# 因为两者的处理机制不同, 最好不要混用
for line in f:
    print(line, end='')

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

-> Python 是一个非常好的语言。
-> 是的，的确非常好!!

• f.write(string) 将 字符串 写入到文件中，返回写入的 字符数

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

num = f.write("Python 是一个非常好的语言。\n是的，的确非常好!!\n")
print(num)
# 关闭打开的文件
f.close()

-> 29

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

# 如果要写入一些不是字符串的东西, 那么将需要先进行转换
value = ('www.huawei.com', 14)
s = str(value)
f.write(s)

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

$ cat /tmp/foo1.txt 
('www.huawei.com', 14)

• f.tell() 返回 文件指针当前所处的位置 ，它是从文件开头开始算起的字节数

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

f.readline()

# 返回当前文件指针位置
num = f.tell()
print(num)

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

-> 30

• f.seek(offset, from_what) 改变 文件指针当前的 位置

序号	位置	from_what
01	开头	0
02	当前	1
03	结尾	2

序号	函数	描述
01	f.seek(x, 0)	表示从文件 首行首字符 往后移动 x 个字符
02	f.seek(x, 1)	表示从 当前位置 往后移动 x 个字符
03	f.seek(x, 2)	表示从文件 结尾 往前移动 x 个字符

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

• f.close() 关闭 文件并 释放 系统的资源，如果尝试再调用该文件，则会 抛出异常

>>> f.close()
>>> f.read()
Traceback (most recent call last):
  File "", line 1, in ?
ValueError: I/O operation on closed file

# 在结束后, 'with' 关键词会帮你正确的关闭文件，而且写起来也比 try - finally 语句块要简短
# 文件对象还有其他方法, 如 isatty() 和 trucate(), 但这些通常比较少用
>>> with open('/tmp/foo.txt', 'r') as f:
...     read_data = f.read()
>>> f.closed
True

六、pickle 模块

• 通过 序列化 操作，能够将程序中运行的对象 信息保存到文件中去 ，永久存储
• 通过 反序列化 操作，能够从文件中 创建上一次程序保存的对象

# 保存接口
pickle.dump(obj, file, protocol)

# 读取接口
x = pickle.load(file)

# 保存信息
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()

# 读取信息
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()

# 该实例实现一个简单联系人信息管理
import pickle
import os

datafile = 'person.data'
line = '======================================='
message = '''
=======================================
Welcome bookmark:
    press 1 to show list
    press 2 to add pepole
    press 3 to edit pepole
    press 4 to delete pepole
    press 5 to search pepole
    press 6 to show menu
    press 0 to quit
=======================================
'''
print(message)

class Person(object):
    """通讯录联系人"""
    def __init__(self, name, number):
        self.name = name
        self.number = number

# 获取数据
def get_data(filename=datafile):
    # 文件存在且不为空
    if os.path.exists(filename) and os.path.getsize(filename):
        with open(filename, 'rb') as f:
            return pickle.load(f)
    return None
        
# 写入数据
def set_data(name, number, filename=datafile):

    personList = {} if get_data() == None else get_data()

    with open(filename, 'wb') as f:
        personList[name] = Person(name,number)
        pickle.dump(personList, f)

# 保存字典格式的数据到文件
def save_data(dictPerson, filename=datafile):
    with open(filename,'wb') as f:
        pickle.dump(dictPerson, f)

# 显示所有联系人
def show_all():
    personList = get_data()
    if personList:
        for v in personList.values():
            print(v.name, v.number)
        print(line)
    else:
        print('not yet person,please add person')
        print(line)

# 添加联系人
def add_person(name, number):
    set_data(name, number)
    print('success add person')
    print(line)

# 编辑联系人
def edit_person(name, number):
    personList = get_data()
    if personList:
        personList[name] = Person(name, number)
        save_data(personList)
        print('success edit person')
        print(line)

# 删除联系人
def delete_person(name):
    personList = get_data()
    if personList:
        if name in personList:
            del personList[name]
            save_data(personList)
            print('success delete person')
        else:
            print(name, ' is not exists in dict')
        print(line)


# 搜索联系人
def search_person(name):
    personList = get_data()
    if personList:
        if name in personList.keys():
            print(personList.get(name).name, personList.get(name).number)
        else:
            print('No this person of ', name)
        print(line)
        

while True:
    num = input('>>')

    if num == '1':
        print('show all personList:')
        show_all()
    elif num == '2':
        print('add person:')    
        name = input('input name>>')
        number = input('input number>>')
        add_person(name,number)
    elif num == '3':
        print('edit person:')
        name = input('input name>>')
        number = input('input number>>')
        edit_person(name,number)
    elif num == '4':
        print('delete person:')
        name = input('input name>>')
        delete_person(name)
    elif num == '5':
        print('search :')
        name = input('input name>>')
        search_person(name)
    elif num == '6':
        print(message)
    elif num == '0':
        break
    else:
        print('input error, please retry')