python learning IO.py

f = open('test.txt', 'r') # 'r' 表示只读
s = f.read() # 调用read()方法可以一次读取文件的全部内容，Python把内容读到内存，用一个str对象表示
print(s)
f.close()

# 由于文件读写时都有可能产生IOError，一旦出错，后面的f.close()就不会调用。所以，为了保证无论是否出错都能正确地关闭文件，我们可以使用try ... finally来实现：

try:
    f = open('test.txt','r')
    print(f.read())
finally:
    if f:
        f.close()

# 但是每次都这么写实在太繁琐，所以，Python引入了with语句来自动帮我们调用close()方法：

with open('test.txt','r') as f:
    print(f.read())

# 这和前面的try ... finally是一样的，但是代码更佳简洁，并且不必调用f.close()方法。

# 调用read()会一次性读取文件的全部内容，如果文件有10G，内存就爆了，
# 所以，要保险起见，可以反复调用read(size)方法，每次最多读取size个字节的内容。
# 也可以 用readline()可以每次读取一行内容，调用readlines()一次读取所有内容并按行返回list。

# 如果文件很小，read()一次性读取最方便；
# 如果不能确定文件大小，反复调用read(size)比较保险；
# 如果是配置文件，调用readlines()最方便

f = open('test.txt', 'r')
for line in f.readlines():
    print(line.strip())

# file-like Object

# 动态语言没有严格的继承体系限制，只要“act like a duck” 那么就是一只鸭子。
# open 函数返回的是 有 read() 方法的对象。除了file外，还可以是内存的字节流，网络流，自定义流等等。file-like Object不要求从特定类继承，只要写个read()方法就行。

# 二进制文件

f = open('laopo.jpg', 'rb') # 用'rb'模式打开二进制文件
# print(f.read())

# 字符编码

# 要读取非UTF-8编码的文本文件，需要给open()函数传入encoding参数，例如，读取GBK编码的文件：

# f = open('/Users/michael/gbk.txt', 'r', encoding='gbk')

# 遇到有些编码不规范的文件，你可能会遇到UnicodeDecodeError，因为在文本文件中可能夹杂了一些非法编码的字符。遇到这种情况，open()函数还接收一个errors参数，表示如果遇到编码错误后如何处理。最简单的方式是直接忽略：

# f = open('/Users/michael/gbk.txt', 'r', encoding='gbk', errors='ignore')

# 写文件

# 参数改为 w 或 wb 表示写普通文件或二进制文件
# a 表示在文件末尾追加
# 具体模式定义参见文档：https://docs.python.org/3/library/functions.html#open
f  = open('text.txt', 'w')
f.write('Hello, world!')

# 小结：在Python中，文件读写是通过open()函数打开的文件对象完成的。使用with语句操作文件IO是个好习惯。

############################################################

# StingIO
# 就是在内存中创建的临时 file-like Object，常常用作临时缓冲

from io import StringIO
f = StringIO()
f.write('hello')
f.write(' ')
f.write('world!')

print(f.getvalue())

# BytesIO

# 如果要操作二进制数据，就需要使用BytesIO。

from io import BytesIO
f = BytesIO()
f.write('中文'.encode('utf-8'))
print(f.getvalue())

# StringIO和BytesIO是在内存中操作str和bytes的方法，使得和读写文件具有一致的接口。

############################################################

# 操作文件和目录

# Python内置的os模块也可以直接调用操作系统提供的接口函数。

import os
print(os.name) # 如果是posix，说明系统是Linux、Unix或Mac OS X，如果是nt，就是Windows系统。

# os模块的某些函数是跟操作系统相关的。

# 环境变量

# print(os.environ)

# 要获取某个环境变量的值，可以调用os.environ.get('key')

# print(os.environ.get('PATH'))

# 操作文件和目录的函数一部分放在os模块中，一部分放在os.path模块中，这一点要注意一下。
# 查看、创建和删除目录可以这么调用：

# 查看当前绝对路径
p = os.path.abspath('.')
print(p)

# 在某个目录下面创建一个新目录
os.mkdir("E://bb")
os.rmdir("E://bb")

'''
把两个路径合成一个时，不要直接拼字符串，而要通过os.path.join()函数，这样可以正确处理不同操作系统的路径分隔符。在Linux/Unix/Mac下，os.path.join()返回这样的字符串：

part-1/part-2
而Windows下会返回这样的字符串：

part-1\part-2
'''

print(os.path.join(r'\Users\michael', 'testdir'))

# 同样的道理，要拆分路径时，也不要直接去拆字符串，而要通过os.path.split()函数，这样可以把一个路径拆分为两部分，后一部分总是最后级别的目录或文件名：

p = os.path.split(r'C:\Users\michael\testdir\file.txt')
print(p)

# os.path.splitext()可以直接让你得到文件扩展名，很多时候非常方便：

p = os.path.splitext(r'C:\Users\michael\testdir\file.txt')
print(p)

# 这些合并、拆分路径的函数并不要求目录和文件要真实存在，它们只对字符串进行操作。

# 对文件重命名:
# os.rename('test.txt', 'test.py')
# 删掉文件:
# os.remove('test.py')

# 如何利用Python的特性来过滤文件。

# 列出当前目录下的所有目录：

L = [x for x in os.listdir('.') if os.path.isdir(x)]
print(L)

# 列出当前目录下所有的.py后缀的文件

L = [x for x in os.listdir('.') if os.path.isfile(x) and os.path.splitext(x)[1]=='.py']
print(L)

# 练习
#实现dir -l
import os

def mydir(path):
  if os.path.exists(path):
    L = [(path+x) for x in os.listdir(path)]
    print(L)
  else:
    print('The path not exists!')

#编写一个程序，能在当前目录以及当前目录的所有子目录下查找文件名包含指定字符串的文件，并打印出相对路径。

def findrelapath(path):
  if os.path.exists(path):
    L = os.listdir(path)
    for x in L:
      newpath = os.path.join(path,x)
      if os.path.isfile(newpath):
        print(x)
      elif os.path.isdir(newpath):
        findrelapath(newpath)
  else:
    print('The path not exists!')

####################################################################################

# 序列化 

# 在程序运行的过程中，所有的变量都是在内存中的
# 一旦程序结束，变量所占用的内存就被操作系统全部回收。
# 把变量从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思
# 序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。
# 反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。
# Python提供了pickle模块来实现序列化。

import pickle
d = dict(name='bob', age=20, score=88)

print(d['name'])
print(d['age'])

print(pickle.dumps(d))

# pickle.dumps()方法把任意对象序列化成一个bytes，然后，就可以把这个bytes写入文件。

f = open('dump.txt', 'wb')
pickle.dump(d,f)
f.close()

# 看看写入的dump.txt文件，一堆乱七八糟的内容，这些都是Python保存的对象内部信息。
# 当我们要把对象从磁盘读到内存时，可以先把内容读到一个bytes，然后用pickle.loads()方法反序列化出对象，也可以直接用pickle.load()方法从一个file-like Object中直接反序列化出对象。

f = open('dump.txt', 'rb')
e = pickle.load(f)
f.close()
print(e)

# 变量的内容又回来了！不过，这个变量和原来的变量是完全不相干的对象，它们只是内容相同而已。
# Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容

# JSON

# 如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

# JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：

# Python内置的json模块提供了非常完善的Python对象到JSON格式的转换。我们先看看如何把Python对象变成一个JSON：

'''
JSON类型	  Python类型
{}	        dict
[]	        list
"string"	  str
1234.56	    int 或 float
true/false	True/False
null	      None
'''

import json
d = dict(name='bob', age=20, score=88)
f = open('json.txt','w')
json.dump(d,f)
f.close()

# dumps()方法返回一个str，内容就是标准的JSON。
# .txt 文件中的内容：{"name": "bob", "age": 20, "score": 88}

# 要把JSON反序列化为Python对象，用loads()或者对应的load()方法，
# 前者把JSON的字符串反序列化，后者从file-like Object中读取字符串并反序列化：

f = open('json.txt','r')
s = f.read()
d = json.loads(s)
print(d)
f.close()