06 . Python3入门之IO编程(文件操作)

# Python有两种输出值的方式，表达式语句和print()函数
# 第三种方式是使用文件对象的write()方法，标准输出文件可以用sys.stdout引用
# 如果你希望输出的形式更加多样，可以使用str.format()函数格式化输出值
# 如果你希望输出值都转换成字符串，可以使用repr()或str()函数实现

# str:  函数返回一个用户易读的表达形式
# repr():  产生一个解释器易读的表达形式

# 简单应用
name = '幽梦'
age = 18
sex = '男'

msg = F'姓名: {name}, 性别: {age} , 年龄: {sex}'  # 大写字母也可以
print(msg)

# 任意表达式

print(f'{3*21}')

name = 'flying'
print(f'全部大写: {name.upper()}')

# 字典也可以
teacher = {'name':'幽梦','age':18}
msg = f"The student is {['name']}, age{teacher['age']}"
print(msg)  # The comedian is 太白金星, aged 18

# 列表也行
li1 = ['幽梦',18]
msg = f'姓名：{li1[0]},年龄：{li1[1]}.'
print(msg)


# 也可以插入表达式
def sum_a_b(a,b):
    return a + b
a = 1
b = 2
print('求和的结果为' + f'{sum_a_b(a,b)}')


# 多行f
name = 'youmen'
age = 18
sex = '男'

speaker = f'Hi {name}.'
          f'You are {age} years old.'
          f'You are a {sex} guy!'
print(speaker)

print('{}网址: "{}!"'.format('菜鸟教程','www.YouMen.com'))
菜鸟教程网址: "www.YouMen.com!"

# 括号及其里面的字符（称作格式化字段）将被format()中的参数替换.
# 在括号中的数字用于指向传入对象在format()中的位置，如下所示:
>>> print('{0}和{1}'.format('Google','baidu'))
Google和baidu

# 如果在format()中使用了关键字参数，那么他们的值会指向使用该名字的参数.

print('站点列表{0},{1},和{other}'.format('Google','baidu.com',other='TaoBao'))
站点列表Google,baidu.com,和TaoBao

>>> import math
>>> print('常亮p1的值近似为: {}.'.format(math.pi))
常亮p1的值近似为: 3.141592653589793.

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

# 在:后传入一个整数，可以保证该域至少有那么多的宽度，对于美化表格很有用
>>> table={'Google':1,'YouMen':2,'Baidu':3}
>>> for name, number in table.items():
...     print('{0:10} ==> {1:10d}'.format(name, number))
... 
Google     ==>          1
YouMen     ==>          2
Baidu      ==>          3

# 如果你有一个很长的格式化字符串，而你不想将他们分开，那么在格式化时通过变量名而非位置会是很好的事情.
# 最简单的就是传入一个字典，然后使用方括号[]来访问键值.
>>> 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

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

常量PI的值近似为: 3.142。

str = input("请输入:")
print("你输入的内容是:",str)

请输入:
zhou

open(filename,mode)

open(file,mode='r')
# 完整语法格式为:
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数说明:
* file: 必需，文件路径（相对或者绝对路径）。
* mode: 可选，文件打开模式
* buffering: 设置缓冲
* encoding: 一般使用utf8
* errors: 报错级别
* newline: 区分换行符
* closefd: 传入的file参数类型
* opener:

# 打开一个文件
f = open("test.txt","w",encoding="utf-8")
f.write("hello world! n 世界你好!")

# 关闭打开的文件
f.close

cat test.txt   
hello world!   
 世界你好!


# 在实际编程中，我们经常忘记关闭已经打开的文件对象，这样就会导致系统资源的浪费。
# 使用 with 语句来管理上下文操作之后，python内部会自动关闭并释放文件资源。
# 操作只需要为文件句柄起个别名为f，下面直接使用即可
# 打开一个文件
with open('test.txt','w',encoding="utf-8") as you:
    li = ['hellon','worldn']
    you.writelines(li)
print("结束")

cat test.txt
hello
world

f = open("test.txt","r")
str = f.read()
print(str)
f.close()

hello
world

f = open("test.txt","r")
str = f.readline()
print(str)
f.close()

hello

f = open("test.txt","r")
str = f.readlines()
print(str)
f.close()

['hellon', 'worldn']

for line in f:
    print(line,end='')
f.close()

hello
world
# 这个方法很简单, 但是并没有提供一个很好的控制。 因为两者的处理机制不同, 最好不要混用。

f = open("test.txt","w",encoding="utf-8")
str1 = ("www.youmen.com",100)
s = str(str1)
# 如果不是字符串类型，需要先将其转换一下，否则执行报错.
num = f.write(s)
print(num)
f.close()

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

# 如果要改变文件当前的位置, 可以使用 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'

# 在文本文件中（那些打开文件的模式是没有b的），只会相对于文件起始位置进行定位.
# 当你处理一个文件后，调用f.close()来关闭文件并释放系统的资源，如果尝试在调用该文件，则会抛出异常.
# 所以当处理文件对象时，使用with关键字是非常好的方式，结束后，会帮你正确的关闭文件，写起来比try - finally语句块要简短
>>> with open('/tmp/foo.txt', 'r') as f:  
...     read_data = f.read()  
>>> f.closed  
True

# Python的pickle模块实现了基本的数据序列和反序列化
# 通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储
# 通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象

# 基本接口
pickle.dump(obj, file, [,protocol])

# 有了pickle这个对象，就能对file以读取的形式打开:
x = pickle.load(file)

# 从file中读取一个字符串，并将它重构成原来的python对象.
# file: 类文件对象，有read()和readline()接口

import os   
with open('a.txt', 'r', encoding='utf-8') as read_f, open(   
'.a.txt.swap','w', encoding='utf-8') as write_f:   
    
r_data=read_f.read() 					# 全部读入内存,如果文件很大,会很卡   
w_data=r_data.replace('world','python') 	# 在内存中完成修改   
    
 write_f.write(w_data) 			# 一次性写入新文件   
os.remove('a.txt')   
os.rename('.a.txt.swap','a.txt')