程序要处理的数据源，其中一个比较常见的就是文件，文件提供了大量数据。另外，文件让我们可以保存程序处理的结果，避免数据丢失。

程序处理过程中难免会出错，我们需要进行错误处理，python提供了异常对象，用于管理程序运行时出现的错误，可以让我们的程序更加健壮。

文件读取

要使用文本文件中的信息，首先需要将信息读取到内存中。为此，你可以一次性读取文件的全部内容，也可以以每次一行的方式逐步读取。

注意：文件使用完需要关闭，python关键字with在不再需要访问文件后将其关闭。

对比java，java采用了文件流，主要有三种类型：字节流、字符流和对象流，提供了IntputStream接口和该接口的不同实现类，实现读取文件操作。JDK7新增的try-with-resource语句提供自动关闭文件流的功能。

data.txt

1 2 3
4 5 6
7 8 9

#main.py
#1.读取文件全部内容
#打开文件得到文件对象，使用文件对象的read函数读取
#如果要打开的文件存放在modules目录下，可以使用相对路径"modules/data.txt"
with open("data.txt") as file:
    print(type(file))
    file_content=file.read()
print(file_content.rstrip())
print("------------")
#2.1逐行读取文件内容,在with结构中进行处理
with open("data.txt") as file:
    for line in file:
        print("line:"+line.rstrip())
print("------------")
#2.2逐行读取文件内容,在with结构外部进行处理
with open("data.txt") as file:
     #返回一个列表
     lines=file.readlines()
for line in lines:
    print("line:" + line.rstrip())

输出结果:
1 2 3
4 5 6
7 8 9
------------
line:1 2 3
line:4 5 6
line:7 8 9
------------
line:1 2 3
line:4 5 6
line:7 8 9

文件写入

持久化数据的最简单的方式之一是写入文件当中，下次可以从文件读取到内存中进行处理。

注意：文件使用完需要关闭，python关键字with在不再需要访问文件后会自动将其关闭。

对比java，java采用了文件流，提供了OutputStream接口和该接口的不同实现类，实现写入文件操作。JDK7新增的try-with-resource语句提供自动关闭文件流的功能。

#main.py
#1.写入文件
#打开文件时，可指定读取模式('r')、写入模式('w')、附加模式('a')或读写模式('r+')。
#如果省略了模式实参，默认以只读模式打开文件。
#如果要写入的文件不存在，函数open()将自动创建它。
#以写入模式('w')打开文件时，因为如果指定的文件已经存在，将在返回文件对象前清空文件内容。
with open("data.txt",'w') as file:
    #注意这里写入的是字符串，数值需要通过str转换
    file.write(str(123)+'\n')
    file.write(str(456)+'\n')
#2.附加文件
#以附加模式打开文件时，不会清空文件的内容，而是添加到文件末尾。
#如果指定的文件不存在，将为你创建一个空文件。
with open("data.txt",'a') as file:
    #注意这里写入的是字符串，数值需要通过str转换
    file.write(str(789)+'\n')
    file.write(str(111)+'\n')

data.txt:

123
456
789
111

字节存储方式

python默认采用字符方式存储文本数据，如果想操作字节数据，需要添加'b'参数。

#main.py
content="this is a test"
#byte_data=b"this is a test"
int_value = 10
byte_seq = int_value.to_bytes(4, "big")
print(byte_seq)
byte_data=bytes(content,'utf-8')
print(byte_data)

#1.1写入字符串的字节串
with open("data.bin",'wb') as file:
    #注意这里写入的字节串
    file.write(byte_data)
#1.2读取文件
with open("data.bin",'rb') as file:
    file_content=file.read()
    file_str = str(file_content, 'utf-8')
    #file_str=file_content.decode('utf-8')
    print(file_str)

#2.1写入整数的字节串
with open("data.bin",'wb') as file:
    #注意这里写入的字节串
    file.write(byte_seq)
#2.2读取文件
with open("data.bin",'rb') as file:
    #注意这里只能写入字符串，数值需要通过str转换
    file_content=file.read()
    file_int = int.from_bytes(file_content,'big')
    #file_str=file_content.decode('utf-8')
    print(file_int)

输出结果:
b'\x00\x00\x00\n'
b'this is a test'
this is a test
10

序列化

如果想把对象存储到文件，需要序列化成字节串；读取文件内容后，需要进行反序列化。

1.字节方式

#main.py
import pickle
data = {
    'name': 'John',
    'age': 30,
    'city': 'New York'
}
#序列化:
#dumps(obj):将对象序列化后返回字节串；
#dump(obj, file): 将对象序列化后存储到文件
serialized_data=pickle.dumps(data)
print(serialized_data)

#1.1写入文件
with open("data.bin",'wb') as file:
    file.write(serialized_data)
#1.2读取文件
with open("data.bin",'rb') as file:
    file_content=file.read()
    #反序列化:
    #loads(data):将字节码串反序列化成对象
    #load(file)：从打开的文件中读取出数据，将数据反序列化成对象
    deserialized_data=pickle.loads(file_content)
    print(deserialized_data)

输出结果:
b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x04\x00\x00\x00Johnq\x02X\x03\x00\x00\x00ageq\x03K\x1eX\x04\x00\x00\x00cityq\x04X\x08\x00\x00\x00New Yorkq\x05u.'
{'name': 'John', 'age': 30, 'city': 'New York'}

2.JSON方式

#main.py
import json
data = {
    'name': 'John',
    'age': 30,
    'city': 'New York'
}
#序列化:
#dumps(obj):将对象序列化后返回json字符串；
#dump(obj, file): 将对象序列化后存储到文件
serialized_data=json.dumps(data)
print(serialized_data)

#1.1写入文件
with open("data.bin",'w') as file:
    file.write(serialized_data)
#1.2读取文件
with open("data.bin",'r') as file:
    file_content=file.read()
    #反序列化:
    #loads(data):将json字符串反序列化成对象
    #load(file)：从打开的文件中读取出数据，将数据反序列化成对象
    deserialized_data=json.loads(file_content)
    print(deserialized_data)

输出结果:
{"name": "John", "age": 30, "city": "New York"}
{'name': 'John', 'age': 30, 'city': 'New York'}

异常处理

python使用称为异常的特殊对象来管理程序执行期间发生的错误。异常是使用try-except代码块处理的。try-except代码块让python执行指定的操作，同时告诉python发生异常时怎么办。

对比java，java采用try-catch代码块捕获异常，异常可以多个，如果不知道具体的异常类型，可以使用异常父类Exception。finally语句跟python差不多，退出try时总会执行，不管是否发生了异常，都要执行finally的部分。

#main.py

a,b=1,2

try:
    c=a/b
    with open('not exist',encoding='utf-8') as file:
        print(file.read())
#如果存在未捕获的异常类型，同样会中断程序运行
except ZeroDivisionError:
    print("the b can't be zero.")
except FileNotFoundError:
    #Python有一个pass语句，可用于让Python在代码块中什么都不要做
    #pass
    print("file not exist.")
else:
    #正常执行try-except之间的语句，然后执行该代码块
    print(c)

可以通过继承异常基类Exception创建自己的异常，如果不知道具体的异常类型，也可以直接捕获Exception。

预定义的异常继承关系：

BaseException  # 所有异常的基类
 +-- SystemExit  # 解释器请求退出
 +-- KeyboardInterrupt  # 用户中断执行(通常是输入^C)
 +-- GeneratorExit  # 生成器(generator)发生异常来通知退出
 +-- Exception  # 常规异常的基类
      +-- StopIteration  # 迭代器没有更多的值
      +-- StopAsyncIteration  # 必须通过异步迭代器对象的__anext__()方法引发以停止迭代
      +-- ArithmeticError  # 各种算术错误引发的内置异常的基类
      |    +-- FloatingPointError  # 浮点计算错误
      |    +-- OverflowError  # 数值运算结果太大无法表示
      |    +-- ZeroDivisionError  # 除(或取模)零 (所有数据类型)
      +-- AssertionError  # 当assert语句失败时引发
      +-- AttributeError  # 属性引用或赋值失败
      +-- BufferError  # 无法执行与缓冲区相关的操作时引发
      +-- EOFError  # 当input()函数在没有读取任何数据的情况下达到文件结束条件(EOF)时引发
      +-- ImportError  # 导入模块/对象失败
      |    +-- ModuleNotFoundError  # 无法找到模块或在在sys.modules中找到None
      +-- LookupError  # 映射或序列上使用的键或索引无效时引发的异常的基类
      |    +-- IndexError  # 序列中没有此索引(index)
      |    +-- KeyError  # 映射中没有这个键
      +-- MemoryError  # 内存溢出错误(对于Python 解释器不是致命的)
      +-- NameError  # 未声明/初始化对象 (没有属性)
      |    +-- UnboundLocalError  # 访问未初始化的本地变量
      +-- OSError  # 操作系统错误，EnvironmentError，IOError，WindowsError，socket.error，select.error和mmap.error已合并到OSError中，构造函数可能返回子类
      |    +-- BlockingIOError  # 操作将阻塞对象(e.g. socket)设置为非阻塞操作
      |    +-- ChildProcessError  # 在子进程上的操作失败
      |    +-- ConnectionError  # 与连接相关的异常的基类
      |    |    +-- BrokenPipeError  # 另一端关闭时尝试写入管道或试图在已关闭写入的套接字上写入
      |    |    +-- ConnectionAbortedError  # 连接尝试被对等方中止
      |    |    +-- ConnectionRefusedError  # 连接尝试被对等方拒绝
      |    |    +-- ConnectionResetError    # 连接由对等方重置
      |    +-- FileExistsError  # 创建已存在的文件或目录
      |    +-- FileNotFoundError  # 请求不存在的文件或目录
      |    +-- InterruptedError  # 系统调用被输入信号中断
      |    +-- IsADirectoryError  # 在目录上请求文件操作(例如 os.remove())
      |    +-- NotADirectoryError  # 在不是目录的事物上请求目录操作(例如 os.listdir())
      |    +-- PermissionError  # 尝试在没有足够访问权限的情况下运行操作
      |    +-- ProcessLookupError  # 给定进程不存在
      |    +-- TimeoutError  # 系统函数在系统级别超时
      +-- ReferenceError  # weakref.proxy()函数创建的弱引用试图访问已经垃圾回收了的对象
      +-- RuntimeError  # 在检测到不属于任何其他类别的错误时触发
      |    +-- NotImplementedError  # 在用户定义的基类中，抽象方法要求派生类重写该方法或者正在开发的类指示仍然需要添加实际实现
      |    +-- RecursionError  # 解释器检测到超出最大递归深度
      +-- SyntaxError  # Python 语法错误
      |    +-- IndentationError  # 缩进错误
      |         +-- TabError  # Tab和空格混用
      +-- SystemError  # 解释器发现内部错误
      +-- TypeError  # 操作或函数应用于不适当类型的对象
      +-- ValueError  # 操作或函数接收到具有正确类型但值不合适的参数
      |    +-- UnicodeError  # 发生与Unicode相关的编码或解码错误
      |         +-- UnicodeDecodeError  # Unicode解码错误
      |         +-- UnicodeEncodeError  # Unicode编码错误
      |         +-- UnicodeTranslateError  # Unicode转码错误
      +-- Warning  # 警告的基类
           +-- DeprecationWarning  # 有关已弃用功能的警告的基类
           +-- PendingDeprecationWarning  # 有关不推荐使用功能的警告的基类
           +-- RuntimeWarning  # 有关可疑的运行时行为的警告的基类
           +-- SyntaxWarning  # 关于可疑语法警告的基类
           +-- UserWarning  # 用户代码生成警告的基类
           +-- FutureWarning  # 有关已弃用功能的警告的基类
           +-- ImportWarning  # 关于模块导入时可能出错的警告的基类
           +-- UnicodeWarning  # 与Unicode相关的警告的基类
           +-- BytesWarning  # 与bytes和bytearray相关的警告的基类
           +-- ResourceWarning  # 与资源使用相关的警告的基类。被默认警告过滤器忽略。

#main.py

class CommonException(Exception):
    def __init__(self,code,message):
        super().__init__()
        self.code=code
        self.message=message
    def __str__(self):
        return f"MyCustomException: code:{self.code} message:{self.message}"

a,b=1,2

try:
    c=a/b
    #with open('not exist', encoding='utf-8') as file:
    #    print(file.read())
    #主动抛出自定义异常
    raise CommonException(101,"exception")
#捕获预定义异常
except FileNotFoundError:
    print("file not exist.")
#捕获自定义异常
except CommonException as e:
    print(e.code)
    print(e)
#捕获公共异常
except Exception:
    print("Exception.")
#正常执行try-except之间的语句，然后执行该代码块
else:
    print(c)
#退出try时总会执行，不管是否发生了异常，都要执行finally的部分
finally:
    print("finally")

输出结果:
101
MyCustomException: code:101 message:exception
finally