[学习笔记 Day02]Python基础：从面向对象到文件IO，再到异常，解密编程语言背后的秘密

文件 IO

在 Python 中访问文件，需要先创建文件对象，再利用该文件对象执行读写操作。

文件操作

Python 中的 open() 函数用于打开一个文件，并返回一个文件对象。如果该文件不能被打开，则抛出 OSError 异常。

语法：open(file , mdoe = 'r' , buffering = -1 , encoding = None)

• file：表示要打开的文件名，以字符串类型来存储文件的路径。
• mode：设置打开文件的模式，可以是只读、写入或是追加等。（如下表）

模式	描述
r	以只读方式打开文件，文件的指针将会放在文件的开头（默认）。
rb	以二进制格式打开文件（只读），文件的指针将会放在文件的开头（默认），一般用于非文件文本，如图片等。
r+	打开一个文件进行读写。文件的指针将会放在文件的开头。
rb+	以二进制格式打开文件（读写），文件的指针将会放在文件的开头，一般用于非文件文本，如图片等。
w	打开一个文件进行写入，如果文件已存在，则打开文件，并从头开始编辑（覆盖）；如果文件不存在，则创建新的文件再写入。
wb	以二进制格式打开一个文件（只写入）
w+	打开一个文件进行读写
wb+	以二进制格式打开一个文件用于读写。一般用于非文本文件，如图片等。
a	打开一个文件进行追加。如果文件已存在，，文件指针将会放在文件的结尾，新的内容将会被写在已有内容后面；如果文件不存在，则创建新的文件再写入。
ab	以二进制格式打开一个文件进行追加。如果文件已存在，，文件指针将会放在文件的结尾，新的内容将会被写在已有内容后面；如果文件不存在，则创建新的文件再写入。
a+	打开一个文件用于读写。如果文件已存在，，文件指针将会放在文件的结尾，新的内容将会被写在已有内容后面；如果文件不存在，则创建新的文件再写入。
ab+	以二进制格式打开一个文件用于追加。如果文件已存在，，文件指针将会放在文件的结尾，新的内容将会被写在已有内容后面；如果文件不存在，则创建新的文件再写入。

注意：使用 open() 函数打开文件时，如果没有注明访问方式，则必须保证文件是存在的，否则会抛出 FileNotFoundError 异常。

• buffering：设置读写文件的缓冲方式。（如下表）

属性值	说明
0	不使用缓冲区，直接读写（尽在二进制模式下有效）
1	每次缓冲行
> 1	使用给定值作为缓冲区的大小
< 0	使用默认的缓冲机制（由设备决定）

• encoding：指定对文件进行编码或者解码的方式，一般使用 UTF-8 编码。

一个文件被打开后，Python 会创建一个文件对象，通过该文件对象可以得到与该文件相关的各种信息。

属性	说明
closed	如果判断一个文件已经关闭，则返回 True ，反之False
mode	返回被打开文件的访问方式
name	返回文件名称
softspace	如果用 print 输出后，必须跟一个空格符，返回 False，否则 True
encoding	返回文件编码
newlines	返回文件中用到的换行模式，是一个元组对象

例如：

f = open('demo.txt','a+')

print("文件名：",f.name)
# 文件名：demo.txt

print("是否已关闭：",f.closed)
# 是否已关闭：False

print("访问模式：",f.mode)
# 访问模式：a+

print("文件编码方式："，f.encoding)
# 文件编码方式：cp936

print("文件换行方式：",f.newlines)
# 文件换行方式：None

当文件内容操作完成以后，通过调用 Python 内置的 close() 函数关闭一打开的文件。

语法：fileObject.close()

with open 语法：

在 Python 中，是一个上下文管理协议的应用，她可确保文件被正确的打开和关闭，即使在处理文件时发生异常也是如此。

语法：

with open(file , mode = 'r' , encoding = None) as 对象名:
      文件操作方法块

参数说明：

• file：表示要打开的文件名，以字符串类型来存储文件的路径。
• mode：设置打开文件的模式，可以是只读、写入或是追加等（默认值为 r ，可选参数）。
• encoding：指定对文件进行编码或者解码的方式，一般使用 UTF-8 编码（默认值为 None，可选参数）。

在 Python 中与文件读取相关的函数有三种：read()、readline()、readlines()

• 对象名.read(size)
  • 作用：可以从指定文件中读取指定数据。
  • size：用于设置读取数据的字节数（可选参数），如果省略，则依次读取指定文件中的所有数据。
• 对象名.readline()
  • 作用：可以从指定文件中读取一行数据（第一次读取，读取第一行数据，以此类推）。
• 对象名.readlines()
  • 作用：可以一次读取文件中的所有数据。

如果要持久的存储 Python 程序产生的数据，就需要使用数据写入方法将数据写入文件。

• write(str) 函数
  • str：表示要写入的数据。
• writelines(seq) 函数、
  • 作用：用于向文件写入字符串序列。
  • seq：表示要写入的字符串序列。

目录操作

Python 中的 os 和 shutil 模块提供了丰富的函数用于文件和文件夹的操作，

• 获取当前工作目录

import os
os.getcwd()

# 'C:\\Users\\user\\charp6'

• 创建目录：os.mkdir(path , mode)
  • path：表示要创建的目录
  • mode：表示目录的数字权限（Windows 系统可忽略）

import os

path = input('请输入目录名：')

# 判断输入的目录是否存在
flag = os.path.exists(path)

if flag is False:
      os.mkdir(apth)
      newFile = open(os.getcwd() + “//” + path + “//” + “demo.txt” , "w")
      newFile.write("hello")
      newFile.close()
      print("数据写入成功！")
else:
      print(”目录已存在！“)

• 遍历目录：
  • os.listdir(apth)：获取文件夹下文件或文件夹名的列表（以字母顺序排序）
    • path：表示要创建的目录
  • os.walk(top , topdown = True , onerror = None , followlinks = False)：用于遍历目录树，
    • 返回一个三元组（root,dirs,files）
      • root：表示当前遍历的目录路径
      • dirs：表示当前目录下的所有子目录
      • files：表示当前目录下的所有文件（不包括目录）
    • top：表示需要遍历的路径
    • topdown：表示首先遍历 top 目录，然后再目录下遍历子目录和文件（可选参数）
      • False：表示先便利子目录和文件，然后再遍历 top 目录
      • True：默认值
    • onerror：用于处理遍历过程中出现的错误。默认情况下，出现错误时将直接抛出异常，可以通过该参数指定自定义的错误处理函数（可选参数）。
    • followlinks：表示是否跟随符号链接（可选参数）。

import os

path = "C://"
a = os.walk()
for root,dirs,files in a:
      print(root)
      print("目录有：")
      for d in dirs:
            print("-",d)
      print("文件有：")
      for f in files:
            print("-",f)
            print()

• 删除目录：
  • shutil.rntree(path)：删除一个目录及其所有的子目录和文件。

import os
import shutil

if os,path.exists('txtdir'):
      shutil.rmtree('txtdir')
      print('删除成功！')
else:
      print('该目录不存在！')

• 扩展：
  • os.path.exists(path)：判断输入的目录是否存在

二进制文件操作

二进制文件是计算机中一种重要的文件格式，其数据以二进制形式存储，与文本文件有着显著的区别。

• 定位文件存储位置：
  • tell() 函数：用于获取当前文件 读 / 写 位置（文件指针的位置）。
    • 返回一个整数，表示从文件开始到当前位置的字节偏移量。
    • 语法：文件对象名.tell()
  • seek() 函数：用于移动文件 读 / 写的指针到指定位置。
    • 语法：文件对象名.seek(offset , whence = 0)
      • offset：指偏移量，表示读 / 写位置需要移动的字节数，这个值必须是整数。
      • whence：用于指定文件的读 / 写位置（只能是0、1、2其中一个）
        • 0：表示从文件头位置读 / 写（默认）
        • 1：表示从当前文件指针位置为原点开始读 / 写
        • 2：表示以文件末尾位置为原点开始读 / 写
    • 注意：如果问价以 a 或 a+ 的模式打开，每次写操作时，文件操作指针位置会自动返回到文件末尾

f = open('demo,txt' , mode = '+r' , encoding = 'utf - 8')

print('打开文件时文件读取的位置：',f.tell())

f.seek(21 , 0)
print('偏移后文件读取的位置：',f.tell())

print('从当前位置开始的全部文本')
print(f.read())
f.close()

执行结果：

/> 打开文件时文件读取的位置：0
/> 偏移后文件读取的位置：21
/> 从当前位置开始的全部文本
/> xxxx
/> xxxxxx
/> xxxxxx

• 读写二进制文件：
  • 注意：在 open() 函数的参数中，打开模式需要包含字母 ’b‘的模式，其余的跟普通文件读写操作一样！

# 读
with open('img.jpg' , 'rb') as f:
      imgData = f.read()

# 写
with open('data.bin' , 'wb') as f:
      f.write('资源刺客')

struct 模块读写二进制数据

Python 中的 struct 模块提供了一种方式来打包和解包二进制数据，这对于写入和读取特定格式的二进制数据非常有用。

• 写操作：
  • pack() 函数：将数据打包为字节字符串
  • 语法：struct.pack(format , v1 , v2 , ...)
    • format：表示一个字符串，用于特定数据的格式。格式字符串有一系列格式字符组成，每个格式字符对应一个参数（v1 , v2 , …）
    • v1 , v2 , … ：表示要打包的数据值，其数量和类型必须与 format 字符串中指定的格式字符相匹配
  • 例如：

import struct

# 定义一些数据
name = 'alice'
age = 30
height = 1.85

# 定义数据的格式：一个字符串（长度为 10 的字符串），一个整数，一个浮点数
format_str = '10sif'

# 将数据打包成二进制格式的数据
packedData = struct.pack(format , name.encode('utf-8').ljust(10) , age , height)

# 写入数据
with open('data.bin' , 'wb') as f:
      f.write(packedData)

• 读操作：
  • unpack() 函数：接收一个格式字符串和一个字节字符串作为输入，并返回一个包含解析出的数据的元组。
  • 语法：struct.unpack(format , buffer)
    • format：表示一个字符串，用于特定数据的格式。格式字符串有一系列格式字符组成，每个格式字符对应一个从 buffer 中解析出的数据项。
    • buffer：表示一个字节字符串（bytes），包含需要解析的二进制数据。
  • 例如：

import struct

# 定义数据的格式：一个字符串（长度为 10 的字符串），一个整数，一个浮点数
format_str = '10sif'

# 打开二进制文件用于读取
with open('demo.bin' , 'rb') as f:
      data = f.read()

# 解包数据
nameBytes , age , height = struct.unpack(format_str , data)

# 将字节串解码为字符串（去掉填充的空格）
name = nameBytes.decode('utf-8').rstrip()

pickle 模块读写二进制数据

Python 中的 pickle 模块用于序列化和反序列化 Python 对象结构

• 写操作：
  • dump() 函数：将 Python 对象序列化为二进制格式。
  • 语法：pickle.dump(obj , file , protocol = None , buffer_callback = None)
    • obj：表示要序列化的 Python 对象
    • file：表示一个拥有 write() 方法的对象。该文件对象需要以二进制模式 wb 打开。
    • protocol：指定序列化的协议版本（可以是0、1、2、3、4、5或 None(默认最高版本) 其中一个），更高版本会产生更小的序列化数据，但需要兼容的 Python 版本来序列化（可选参数）。
    • buffer_protocol：将在 pickle 尝试将某些类型的对象写入文件之前被调用，用于实现自定义的缓冲机制，或者对序列化过程中的特定对象进行特殊处理（可选参数）。
  • 例如：

import pickle

# 定义一些数据
data = {
      name = 'alice',
      age = 30,
      height = 1.85
}

# 写入数据
with open('data.bin' , 'wb') as f:
      pickle.dunp(data , f)

• 读操作：
  • load() 函数：从文件中读取二进制数据，将其反序列化为 Python 对象。
  • 语法：load(file , * , encoding = 'ASCII' , errors = 'strict' , buffers = ())
    • file：与 dump() 函数中的 file 参数相同。
    • encoding：指定用于编码 8 为字符串的编码
    • errors：指定编码或解码错误时的处理方式（可选参数）。
    • buffers：包含用于优化序列化的缓冲区的列表（可选参数）。
  • 例如：

import pickle

# 打开二进制文件用于读取
with open('demo.bin' , 'rb') as f:
      data = pickle.load(f)

print(data)

CSV 文件操作

CSV 模块是 Python 的内置模块，用 import 语句导入后就可以使用。

• 读取 CSV 文件：
  • csv.reader() 函数：用于从 CSV 文件中读取数据。返回一个 reader 对象（迭代器），可以逐行读取 CSV 的文件内容
    • 语法：csv.reader(文件对象名)
  • csv.DictReader() 函数：允许以字典的形式读取 CSV 文件中的行。
    • 语法：csv.DictReader(文件对象名)

import csv

width open('book.csv','r',encoding = 'utf-8') as f:
      # reader函数写法
      reader = csv.reader(f)
      for row in reader:
            print(row)

      #DictReader函数写法
      dicrReader = csv.DictReader(f)
      for row in dictReader:
            print(dict(row))

• 写入 CSV 文件：
  • csv.writer() 函数：创建一个 writer 对象，然后使用这个 writer 对象的 writerow 函数将数据逐行写入 csv 文件。
    • 语法：csv.writer(文件对象名)
    • 注意：在写入 CSV 文件时，需要设置 newline 参数为空字符串，否则可能会出现每行之间多一个空行的情况。
  • csv.DictWriter() 函数：用于将字典对象写入 CSV 文件中。该函数使用字典的键作为 CSV 文件的列名，并将字典的值作为相应列的数据，
    • 语法：csv.DictWriter(文件对象名 , 字典对象名.keys())

import csv

data1 = ['001','内容1','作者名1']
data2 = ['002','内容2','作者名2']

data3 = {'name': 'mark','age' = 20}

width open('book.csv','w+',encoding = 'utf-8' , newline = '') as f:
      # 使用 writer 函数写法
      writer = csv.writer(f)
      writer.writerow(data1)
      writer.writerow(data2)

      # 使用 DictWriter 函数写法
      writer = csv.DictWriter(f , data3.keys())
      writer.writerheader()
      writer.writerow(data)

pandas 模块读写 CSV 文件

介绍：pandas 是一个专门用于数据分析和处理的 Python 库。它可以以表格形式轻松处理数据，并支持读取和写入多种格式的数据文件。

首先需要使用下面的命令进行安装 pandas 库：

pip install pandas

• 写入操作：
  • pandas.DataFrame(数据)：可以存储和操作表格型数据。
  • pandas对象名.to_csv(path_or_buf = None , sep = ',' , na_rep = '' , index = False , header = True)：将 DataFrame 转化的数据导出为 csv 格式。
    • path_or_buf：表示写入 CSV 文件的路径或文件对象。
    • sep：表示列分隔符（默认为逗号）
    • na_rep：表示缺失值（默认为空字符串）
    • index：表示是否写入行索引（默认为 False）
    • header：表示是否写入列名（默认为 True）
  • 例如：

import pandas as pd

# 创建一个 DataFrame 数据
data = pd.DataFrame({
      'name':['mark','bob','lily'],
      'age':[10,20,50]
})

# 将 DataFrame 写入到 csv 文件中
data.to_csv('people.csv' , index = False)

• 读取操作：
  • pandas.DataFrame(数据)：可以存储和操作表格型数据。
  • pandas.read_csv(filepath_or_buffer = None , sep = ',' , header = 'infer' , names = None , index_col = None , usecols = None)：将读取的内容加载到 DataFrame 对象中。
    • filepath_or_buffer：表示读取 CSV 文件的路径或文件对象。（必填不能为空）
    • sep：表示每行数据内容的分隔符号（字符型，默认为逗号，还可是制表符 \t、空格等）
    • header：表示支持整型和由整型组成的列表，指定第几行为表头（默认第一行为表头）。
    • names：用来指定列的名称，他是一个类似列表的序列，与数据一一对应（如果不包含列名，则设置为 None）
    • index_col：用来指定索引列，可以是行索引的列编号或列名，如果给定一个序列，则有多个行索引。（不指定时会自动使用以 0 开始的自然索引）
    • usecols：指定只使用数据的部分列
  • 例如：

import pandas as pd

data = pd.read_csv('people.csv',se[=',')

# 显示数据
print(data.head())

面向对象程序设计 OOP

程序设计主要有两种：面向对象程序设计和面向过程程序设计。

面向对象程序设计主要针对大型软件设计而提出的，它是一种对现实世界理解和抽象的方法，

相关概念：

• 类：用来描述具有相同属性和方法的对象的集合。
• 类变量：类变量在整个实例化的对象中是公用的。
• 数据成员：类变量或者实例变量，用于处理类及其实例对象的相关数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，
• 局部变量：定义在方法中的变量，只作用于当前实例的类。
• 实例变量：在类的声明中，属性是用变量来表示的。
• 继承：即一个派生类继承基类的字段和方法，
• 方法：类中定义的函数。
• 对象：通过类定义的数据结构实例。

语法：

• 类的定义：

class 类名:
      类的属性
      类的方法

• 对象的创建：

对象名 = 类名()

# 通过对象名来访问属性与方法
对象名.方法名()
对象名.属性名

• Self 的使用：
  • 在类的方法中，第一个参数一般都是 self 。self 可以把它当作指针 this ，表示的是对象自身。

构造函数和析构函数

构造函数 __init__()，在实例化对象的时候自动被调用。

析构函数 __del__()，在销毁 / 删除对象的时候自动被调用。

例如：

class Person:
      def __init(self ,name ,age):
            self.name = name
            self.age = age

      def __del__(self):
            print('该对象已被销毁！')

      def introduce(self):
            print('大家好，我叫',name)

# 使用
p1 = Person('张三',20)
p1.introduce()

del p1

类的属性和方法

属性的修改和添加：

• 类添加属性：类名.新的属性名 = 值
• 对象添加属性：对象名.新的属性名 = 值
• 修改类属性值：类名.类属性名 = 值
• 修改实例属性值：对象名.实例属性 = 值

访问权限：

为了控制对类的成员的访问权限类的成员分为：公有、私有、保护。

• 保护成员一般都是可以访问的，只是不能使用 import 语句导出导入。保护成员以一条下划线 _ 开头。
• 私有成员类的外部不能直接访问，需要通过调用对象的公有成员方法来访问。私有成员以两条下划线 __ 开头。

注意：Python 中不存在严格意义上的私有成员。即使私有成员也可以通过 类名._类名私有成员 或 对象名._类名私有成员名 的方式进行访问。

例如：

class A:
      __password = 'xxxxxx'
      def get_pass(pass):
            return A.__password

print(A.__password)     # 报错，不可以直接访问

print(A._A__password)   # 类名._类名私有成员名

a = A()
print(a.get_pass)       # 对象名.公有方法
print(a._A__password)   # 对象名._类名私有成员名

类的方法分类：

类的方法可以分为实例方法、类方法和静态方法

• 实例方法：一般以 self 作为第一个参数，通过实例对象来引用。
• 类方法：指类对象所拥有的方法，对类属性进行修改。用修饰器 @classmethod 来标识，函数的第一个参数为 cls （类对象）通过类对象来引用。
• 静态方法：通过 @staticmethod 来进行修饰。

例如：

class Student:
      city = '苏州'
      def __init__(self ,name ,age):
            self.name = name
            self.age = age

      @classmethod
      def changeCity(cls ,newCity):
            cls.city = newCity
            return cls.city

      @staticmethod
      def getCity():
            return city

      def sayHi():
            print('打个招呼！')

# 使用
stu = Student('张三',20)
print(stu.changeCity('北京'))
print(stu.getCity())

print(Student.changeCity('南京'))
print(Student.getCity())

类的继承与派生

类的继承是指在一个现有类的基础上构建一个新的类，构建出来的新类被称作为子类或者派生类，被继承的类称为父类或者基类。

• 单继承：

class 子类名(父类名):
      子类类体语句

class Person:
      def __init__(self ,name ,age):
            self.name = name
            self.age = age

      def sayHi():
            print('打个招呼！')

class Student(Person):
      def __init__(self ,name ,age ,stu_no):
            Person.__init__(self ,name ,age)
            self.stu_no = stu_no

      def sayHi(self):
            Person.sayHi()
            print('老师好！')

# 使用
p1 = Person('张三' ,20)
p1.sayHi();

s1 = Student('李四',19,'001')
s1.sayHi()

• 多继承：

class 子类名(父类名1 ,父类名2 ,...):
      子类类体语句

class Mather():
      def myHobby(self):print('妈妈的爱好！')

class Father():
      def mySkills(self):print('爸爸的技能！')

class Baby(Mather ,Father):
      pass

b = Baby()
b.myHobby()
b.mySkills()

• 扩展：
  • 子类中调用父类的函数：父类类名.函数名() / super().函数名()

方法重写：

class Mather():
      def myHobby(self):print('妈妈的爱好！')

class Father():
      def mySkills(self):print('爸爸的技能！')

class Baby(Mather ,Father):
      def myHobby(self):print('我的爱好！')
      def mySkills(self):print('我的技能！')


b = Baby()
b.myHobby()
b.mySkills()

异常 Error

在 Python 中，将程序运行时产生的错误的情况叫做异常，如语法错误、变量名定义错误等。

异常可以分为系统异常和用户自定义异常。

异常的处理：

• try…except 语句
• try…except…else 语句
• try…except…finally 语句
• 使用 raise 语句抛出异常
• 使用 assert 断言语句调试

Python 中的异常类

异常名称	描述	异常名称	描述
BaseExcrption	所有异常基类	NameError	未声明 / 初始化对象异常
Exception	常见错误基类	RuntimeError	一般运行时错误异常
StandardError	所有内建标准异常的基类	SyntaxError	语法错误异常
Warning	警告基类	IndentationError	缩进错误异常
ZeroDivisionError	除数为 0 的异常	SystemError	系统错误异常
AssertionError	断言语句失败异常	TypeError	类型错误异常
AttributeError	对象属性不存在异常	ValueError	传入值无效异常
IOError	输入 / 输出异常	RuntimeWarning	运行时可疑行为警告
ImportError	模块导入异常	SyntaxWarning	语法警告
IndexError	序列中索引异常	UserWarning	用户代码生成警告
KeyError	映射中键不存在异常

捕获异常

• try…except 语句

try:
      # 语句块
exception:
      # 异常处理代码

• 使用 as 获取系统信息：

try:
      f = open('demo.txt' ,'r')
exception Exception as e:
      print('异常信息是：' ,e.args)

• 捕获多个异常：

try:
      # 语句块
exception 异常名称1类 as e1:
      # 异常处理代码
exception 异常名称2类 as e2:
      # 异常处理代码
exception 异常名称3类 as e3:
      # 异常处理代码
.
.
.
.
.
.

• try…except…else 语句：
  • 说明：当 try 块中没有异常时，会执行 else 块的代码。

try:
      # 语句块
exception 异常名称1类 as e1:
      # 异常处理代码
exception 异常名称2类 as e2,数据:
      # 异常处理代码
else:
      # 语句

• finally 语句：
  • 说明：无论是否发生错误，都会执行 finally 中的代码。

try:
      # 语句块
exception 异常名称1类 as e1:
      # 异常处理代码
......
else:
      # 语句
finally:
      # 语句

抛出异常

• raise 语句：
  • 用法：
    • raise 异常类名
    • raise 异常类对象
    • raise 重新引发刚刚发生的异常

# 使用类名引发异常
arrs = [1,2,3,4,5]
length = len(arrs)
index = 8

if index >= length:
      raise IndexError
else:
      print(arrs[index])

# 结果
Traceback(most recent call last):
      File "C:\xxx\xxx\xxx\xxx.py",line 5 in <module>
            raise IndexRoor
IndexError

# 使用异常类的实例引发异常
arrs = [1,2,3,4,5]
length = len(arrs)
index = 8
error = IndexError()

if index >= length:
      raise error
else:
      print(arrs[index])

# 结果
Traceback(most recent call last):
      File "C:\xxx\xxx\xxx\xxx.py",line 6 in <module>
            raise error
IndexError

# 传递异常
arrs = [1,2,3,4,5]
length = len(arrs)
index = 8

try:
      if index >= length:
            raise IndexError
      else:
            print(arrs[index])
exception:
      print('程序异常')
      raise

# 结果
Traceback(most recent call last):
      File "C:\xxx\xxx\xxx\xxx.py",line 7 in <module>
            raise IndexError
IndexError

# 指定异常的描述信息
arrs = [1,2,3,4,5]
length = len(arrs)
index = 8
msg = '数组异常'

if index >= length:
      raise IndexError(msg)
else:
      print(arrs[index])


# 结果
Traceback(most recent call last):
      File "C:\xxx\xxx\xxx\xxx.py",line 6 in <module>
            raise IndexError(msg)
IndexError : 数组异常

# 异常引发异常
arrs = [1,2,3,4,5]
length = len(arrs)
index = 8

try:
      print(num)
exception exception as e:
      print('程序异常',e.args)
      if index >= length:
            raise IndexError('数组异常') from exception
      else:
            print(arrs[index])

# 结果
Traceback(most recent call last):
      File "C:\xxx\xxx\xxx\xxx.py",line 7 in <module>
            raise IndexError
IndexError

• assert 语句（断言语句）：
  • 作用：期望用户满足指定的条件，当用户定义的约束条件不满足的时候，会触发 AssertionError 异常，所以 assert 语句可以当作条件式的 raise 语句。
  • 语法：assert 逻辑表达式, data
    • data：通常是一个字符串，当条件为 False 时作为异常的描述信息
    • raise语句等价于下面这条语句：

if not 逻辑表达式:
      raise AssertionError(data)

a = 0
b = '0'

try:
      assert a == b,'两个数必须相等'
except AssertionError as e:
      print('%s:%s'%(e.__class__ ,e))

# 结果
AssertionError：两个数必须相等

• with 语句：
  • with 语句是一个控制流工具，主要用于管理代码块的执行环境。
  • 执行过程：
    • 获取上下文管理器
    • 进入代码块
    • 执行代码块
    • 退出代码块
    • 处理异常
  • 语法：with context_expr [as var]: with_body