Pyth
o
n
核心语法笔记
——
Day
4
一、异常（
e
xc
e
pti
o
n
）处理
异常的理解
异常就是程序运行中发生的错误。
p
yt
hon
将各种错误抽象出来，分门别类，形成各种类型的异常。
V
a
l
ueE
rr
o
r
——
值错误异常，往往发生在类型转换失败。
Z
e
r
o
D
ivi
s
i
onE
rr
o
r
——
零除错误异常，发生在用
0
作除数。
I
nde
x
E
rr
o
r
——
索引错误异常，发生在索引越界（字符串、列表、元组）
……
异常如果不处理的话，程序会崩溃，在发生异常位置中断。
处理异常
语法
执行机制
如果
t
r
y
中的语句发生异常，则立即跳转到
e
x
cep
t
代码块中去执行
fi
na
lly
是可以省略的
二、文本文件读写
文件读写的步骤：打开文件、读写文件、关闭文件
调用
open
函数打开文件
使用
with
代码块更安全的打开文件
能保证在
wit
h
主体语句结束时，自动关闭文件，无论主体语句执行过程中是否发生异常
try:
可能会发生异常的语句
1
可能会发生异常的语句
2
可能会发生异常的语句
N
except
异常
1:
当
try
中的语句发生异常
1
时
执行的语句
except
异常
2:
当
try
中的语句发生异常
2
时
执行的语句
except
异常
N:
当
try
中的语句发生异常
N
时
执行的语句
finally:
无论是否发生异常，都会执行
的语句
f = open("
文件路径
", "
打开模式
", encoding="
字符编码
") #
打开文件，返回文件对象
文件的路径
可以是绝对路径：
E:\my\
日记
.txt
也可以是相对路径：
日记
.txt
、
book\
图书借阅记录
.txt
文件的
“
打开模式
”
r
——
读取模式（只能从文件中读取内容，且文件必须存在），这是默认的打开模式
w
——
覆盖写入（只能向文件中写入内容，文件不必须存在），会覆盖文件中的原有
内容
a
——
追加写入（只能向文件中写入内容，文件不必须存在），在原有内容后追加新
写入的内容
从文件中读取内容
向文件中写入内容
关闭文件
三、面向对象编程（
OOP
）
——
o
bj
e
ct
o
ri
e
nt
e
d pr
o
gramming
面向对象的理解
面向对象是一种程序设计思想，目的是为了降低复杂程序的设计难度
是将程序中的各种功能抽象成【类】，用类来创建【对象实例】，让这些对象互相通信（调
用），完成整个业务功能。
我们希望大家掌握的是【定义类】、【创建对象】、【操作对象】的语法
类
(
c
l
a
ss)
和对象
(
ob
j
ec
t
)
的概念
类是抽象的，将一些事物的共有特征和行为抽象出来，就形成了类。
类是个概念、模板、蓝图。 特征，称为类的
属性
/
字段（本质就是变量） 行为，称为类的
方法（本质就是函数）
对象是具体的，是根据类创建出来的实例
(
i
n
s
t
ance
)
。先定义类，再创建对象。
类就是数据类型
我们定义的类跟
i
n
t
、
fl
oa
t
、
s
t
r
、
li
s
t
、
t
up
l
e
、
……
这些数据类型是同一种东西。
with open("
文件路径
", "
打开模式
", encoding="
字符编码
") as f:
#
对文件进行读写操作
#
不用写关闭文件的代码
f.read() #
读取文件中的所有内容，返回一个
str
f.readlines() #
读取文件中的所有内容，返回一个
list
，
list
中的每个元素是文件中的一行内
容（含换行）
f.readline() #
读取文件中的下一行内容，返回一个
str
，如果读取的文件的末尾，会返回空
串
""
f.write("
内容
") #
向文件中写入内容，必须是
str
类型的值，不会默认生成换行
f.close() #
关闭文件，以释放资源
i
n
t
、
fl
oa
t
、
li
s
t
这些数据类型可以直观的表现一些简单的数据，可以以字面量的方式创
建。
定义类
语法
创建对象、操作对象（访问属性、调用方法）
创建对象的语法
创建对象的执行本质就是去调用这个类中定义的初始化方法
__init__
访问对象的属性
调用对象的方法
class
类名
:
#
类属性 属
性
1 =
值 属
性
2 =
值
#
类的初始化方法，这个方法的名字固定为
__init__
#
这个方法会在后续创建该类的对象时，由系统自动调用
#
初始化方法中经常用来给类的对象创建属性
def __init__(self,
形参
1,
形参
2,
形参
N):
#
实例属性
self.
属性
1 =
形参
1
self.
属性
2 =
形参
2
self.
属性
N =
形参
N
def
方法名
(self,
其它形参
):
#
实现此方法的具体业务代码
#
如果需要返回值，使用
return
关键字
def
方法名
2(self,
其它形参
):
#
实现此方法的具体业务代码
#
如果需要返回值，使用
return
关键字
@classmethod
def
方法名
3(cls,
其它形参
):
#
实现此方法的具体业务代码
#
如果需要返回值，使用
return
关键字
变量名
/
对象名
=
类名
(
可选的参数
) #
创建指定类的对象实例，用一个变量名
/
对象名来引
用
zwj = Person("
张无忌
", 25, "
男
")
对象
.
属性名
# “.”
可以理解成
“
的
”
字
print(zwj.name)
print("
今年：
", zwj.age)
zwj.age += 1
if zwj.age >= 20:
pass
实例属性和实例方法，类属性和类方法
实例属性只能用【对象实例（
s
e
lf
、对象名）】来访问 类属性既能用【
对象实例（
s
e
lf
、对象名）】，也能用【类名】来访问 实例方法只能用
【对象实例（
s
e
lf
、对象名）】来调用 类方法既能用【对象实例（
s
e
lf
、对象名）】，也能用【类名】来调用
继承（
inherit
）
将类中共有的属性、方法，抽取出来，定义在一个更高层次的类中，这个更高层次的类就被
称为父类。让那么些具体的类来继承父类，公用这些属性和方法，减少代码的重复。继承下
来的类，称为子类。
子类默认继承父类的所有成员（属性、方法），子类中无需重新定义
子类可以扩展一些父类中没有的属性和方法
子类可以重新定义父类中已经定义过的方法，会构成重写。
重写后，子类的方法会覆盖父类的方法（对子类而言） 继承是有传递性的，例如
类
C
继承了类
B
，类
B
继承了类
A
，那我们也说类
C
也继承类
A
。
object
类是所有类的父类，所有的类都直接或间接继承这个类，当定义一个类的时候，不
显式地使用继承的语法，就默认继承
object
类
语法
对象
.
方法名
(
可选的实参
) #
让对象去做指定的事儿，执行一个函数
zwj.say_hi()
#
调用
zwj
对象的
say_hi
方法，实现打招呼
zwj.say_hi()
#
又调用
zwj
对象的
say_hi
方法，实现打招呼
zwj.eat("
牛肉面
") #
调用
zwj
对象的
eat
方法，传入了实参
“
牛肉面
”
，实现吃东西
r = zwj.eat("
大龙虾
")
print("
吃饱了吗：
", r)
class A:
pass
# B
类继承了
A
类
class B(A):
pass
# C
类继承了
B
类
class C(B):
pass