python基础语法

1、输⼊与输出
 print()
打印括号的内容
第1种：不带引号，让计算机读懂括号⾥的内容，打印最终的结果

print(1+2) 3

第2种：带单引号，计算机⽆须理解，原样复述引号中的内容

print(‘升职加薪到开课吧’)
升职加薪到开课吧

第3种：带双引号，作⽤和单引号⼀样；当打印内容中有单引号时，可以使⽤双引号

print(“Let’s go go go”)
Let’s go go go

第4种：带双引号，作⽤和单引号⼀样；当打印内容中有单引号时，可以使⽤双引号

print(“Let’s go go go”)
2 Let’s go go go

2、变量命名
1.只能是⼀个词；
2.只能包含字⺟、数字和下划线；
3.不能以数字开头；
4.尽量描述包含的数据内容；
5.不要使⽤Python函数名和关键字。

number = 34
name1 = 'kaikeba ’
list_class = [‘基础语法’，‘爬虫’，‘数据分析’]
#以上number，name1，list_class都是是变量名

3、Python中保留的字符（不需要记，熟悉即可）
这些保留字不能⽤作常数或变数，或任何其他标识符名称，所有 Python 的关键字只包
含⼩写字⺟。

4、Python 转义字符（不需要记，熟悉即可）

1、Python中的数据类型
Python3 中有六个标准的数据类型：
 Numbers（数值）
 String（字符串）
 List（列表）
 Tuple（元祖）
 Set（集合）
 Dict（字典）
最基本的数据类型有三种：
字符串str：⽤括号括起来的⽂本（如：‘python’、‘123’、‘开课吧’）
整数int：不带⼩数点的数字（如：-1、1、0、520、1314）
浮点数float：带⼩数点的数字，运算结果存在误差（如：-0.15、3.1415、1.0)
以下的数据结构会有⼀节或两节的课程介绍
列表list：是⼀种有序的集合，可以随时增加或删除其中的元素。标识是中括号[]。元组
tuple：⼀种类似列表的数据类型，但是不能被修改。
字典dice：全称为dictionary，使⽤键值对（key-value）作为存储⽅式。标识是⼤括号
{}。 布尔值bool：表示真假的数据类型，只有两个值，T rue和False。
Python3 的六个标准数据类型中：
 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
Number（数字）
Python3 ⽀持 int、float、bool、complex（复数）。在Python 3⾥，只有⼀种整数类
型 int，表示为⻓整型，没有 python2 中的 Long。
内置的 type() 函数可以⽤来查询变量所指的对象类型。
此外还可以⽤ isinstance 来判断.
isinstance 和 type 的区别在于：
 type()不会认为⼦类是⼀种⽗类类型。
 isinstance()会认为⼦类是⼀种⽗类类型。
String（字符串）
Python中的字符串⽤单引号 ’ 或双引号 " 括起来，同时使⽤反斜杠 \ 转义特殊字
符。字符串可以遍历切⽚。
Python 字符串从左⾄右截取：索引范围（0，⻓度-1），从右⾄左截取（-1，字符串
开 头）。
 1、反斜杠可以⽤来转义，使⽤r可以让反斜杠不发⽣转义。
 2、字符串可以⽤+运算符连接在⼀起，⽤运算符重复。
 3、Python中的字符串有两种索引⽅式，从左往右以0开始，从右往左以-1开始。
 4、Python中的字符串不能改变。
 5、Python 中不存在单字符。 Python 中即使有单字符，也会被当作字符串处理。


字符串格式化

格式化操作符辅助指令

Python2.6 开始，新增了⼀种格式化字符串的函数 str.format()，它增强了字符串格式
化的功能。
f-string 是 Python3.6 之后版本添加的，称之为字⾯量格式化字符串，是新的格式化
字符串的语法。f-string 格式化字符串以 f 开头，后⾯跟着字符串，字符串中的表达式
⽤⼤括号 {} 包起来，它会将变量或表达式计算后的值替换进去。

⽤了这种⽅式明显更简单了，不⽤再去判断使⽤ %s，还是 %d。
在 Python 3.8 的版本中可以使⽤ = 符号来拼接运算表达式与结果

内建函数




List（列表）
List（列表） 是 Python 中使⽤最频繁的数据类型。
列表可以完成⼤多数集合类的数据结构实现。列表中元素的类型可以不相同，它⽀持数
字，字符串甚⾄可以包含列表（所谓嵌套）。
列表是写在⽅括号 [] 之间、⽤逗号分隔开的元素列表。
 1、List写在⽅括号之间，元素⽤逗号隔开。
 2、和字符串⼀样，list可以被索引和切⽚。
 3、List可以使⽤+操作符进⾏拼接。
 4、List中的元素是可以改变的。
列表脚本操作符
列表对 + 和 * 的操作符与字符串相似。+ 号⽤于组合列表， 号⽤于重复列表。
如下所示：

Python列表截取与拼接
Python的列表截取与字符串操作类型，如下所示：
L=[‘PDD’, ‘JD’, ‘Taobao’]

列表⽅法&函数

Python包含以下⽅法：

Tuple（元祖）
元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在⼩括号 ()
⾥，元素之间⽤逗号隔开。虽然tuple的元素不可改变，但它可以包含可变的对象，⽐如
list列表。
string、list 和 tuple 都属于 sequence（序列）。
与列表的区别
 类似列表，但列表⽤[ ]标识，元组⽤()标识，并且列表元素可⼆次赋值，但元组元素
不能。
元祖的创建
创建空元组：tuple() 。
 创建只有⼀个元素的元组：tuple(a,)，必须要在元素后加逗号。
元素的访问
 虽然创建时⽤（）包含，但是在访问单个元素时，与列表⼀样，通过[索引号]来访
问。
L[-2] ‘JD’ 从右侧开始读取倒数第⼆个元素: count from the
right
L[1:] [‘JD’, ‘Taobao’] 输出从第⼆个元素开始后的所有元素
序号 函数 描述
1 len(list) 列表元素个数
2 max(list) 返回列表元素最⼤值
3 min(list) 返回列表元素最⼩值
4 list(seq) 将元组转换为列表
序号 函数 描述
1 list.append(obj) 在列表末尾添加新的对象
2 list.count(obj) 统计某个元素在列表中出现的次数
3 list.extend(seq) 在列表末尾⼀次性追加另⼀个序列中的多个值（⽤新列
表扩展原来的列表）
4 list.index(obj) 从列表中找出某个值第⼀个匹配项的索引位置
5 list.insert(index, obj) 将对象插⼊列表
6 list.pop([index=-1]) 移除列表中的⼀个元素（默认最后⼀个元素），并且返
回该元素的值
7 list.remove(obj) 移除列表中某个值的第⼀个匹配项
8 list.reverse() 反向列表中元素
9 list.sort( key=None,
reverse=False)
对原列表进⾏排序
10 list.clear() 清空列表
11 list.copy() 复制列表
删除元祖
 元组中的单个元素不能被删除，但是元组可以通过 del 语句整个删除。
 元组运算符（通列表）
 任意⽆符号的对象，以逗号隔开，默认为元组（⽆关闭分隔符）
Python元组包含了以下内置函数

Set（集合）
集合（set）是由⼀个或数个形态各异的⼤⼩整体组成的，构成集合的事物或对象称作
元素或是成员。基本功能是进⾏成员关系测试和删除重复元素。可以使⽤⼤括号 { }
或者 set() 函数创建集合，注意：创建⼀个空集合必须⽤ set() ⽽不是 { } ，因
为 { } 是⽤来创建⼀个空字典。
Dict（字典）
字典（dictionary）是Python中另⼀个⾮常有⽤的内置数据类型。
列表是有序的对象集合，字典是⽆序的对象集合。两者之间的区别在于：字典当中的元
素是通过键来存取的，⽽不是通过索引存取。
字典是⼀种映射类型，字典⽤ { } 标识，它是⼀个⽆序的 键(key) : 值(value) 的
集合。
键(key)必须使⽤不可变类型。
在同⼀个字典中，键(key)必须是唯⼀的。
 1、字典是⼀种映射类型，它的元素是键值对。
 2、字典的关键字必须为不可变类型，且不能重复。
 3、创建空字典使⽤ { }。

Python字典包含了以下内置函数：

Python字典包含了以下内置⽅法：


2、Python数据类型转换
有时候，我们需要对数据内置的类型进⾏转换，数据类型的转换，你只需要将数据类型
作为函数名即可。
以下⼏个内置的函数可以执⾏数据类型之间的转换。这些函数返回⼀个新的对象，表示
转换的值。

三-分⽀语句
Python 条件语句是通过⼀条或多条语句的执⾏结果（True 或者 False）来决定执⾏的
代码块。
Python 中⽤ elif 代替了 else if，所以if语句的关键字为：if – elif – else。
注意：
 1、每个条件后⾯要使⽤冒号 :，表示接下来是满⾜条件后要执⾏的语句块。
 2、使⽤缩进来划分语句块，相同缩进数的语句在⼀起组成⼀个语句块。
 3、在Python中没有switch – case语句。
以下为if中常⽤的操作运算符:

在嵌套 if 语句中，可以把 if…elif…else 结构放在另外⼀个 if…elif…else 结构中。

1、Python 算术运算符

2、 Python ⽐较运算符
以下假设变量a为10，变量b为20：


3、Python 赋值运算符

4、Python 位运算符

Python 逻辑运算符

6、Python 成员运算符

7、Python身份运算符

8、Python运算符优先级

四、函数与复习
1、读取键盘输⼊
Python提供了 input() 内置函数从标准输⼊读⼊⼀⾏⽂本，默认的标准输⼊是键盘。
input 可以接收⼀个Python表达式作为输⼊，并将运算结果返回。
2、读和写⽂件
open() 将会返回⼀个 file 对象，基本语法格式如下:

 filename：包含了你要访问的⽂件名称的字符串值。
 mode：决定了打开⽂件的模式：只读，写⼊，追加等。所有可取值⻅如下的完全列
表。这个参数是⾮强制的，默认⽂件访问模式为只读®。
不同模式打开⽂件的完全列表：

下图很好的总结了这⼏种模式：


以下实例将字符串写⼊到⽂件：

 第⼀个参数为要打开的⽂件名。
 第⼆个参数描述⽂件如何使⽤的字符。 mode 可以是 ‘r’ 如果⽂件只读, ‘w’ 只⽤于写
(如果存在同名⽂件则将被删除), 和 ‘a’ ⽤于追加⽂件内容; 所写的任何数据都会被⾃
动增加到末尾. ‘r+’ 同时⽤于读写。 mode 参数是可选的; ‘r’ 将是默认值
3、⽂件对象的⽅法。
3.1 f.read()
为了读取⼀个⽂件的内容，调⽤ f.read(size), 这将读取⼀定数⽬的数据, 然后作为字符
串或字节对象返回。size 是⼀个可选的数字类型的参数。 当 size 被忽略了或者为负,
那么该⽂件的所有内容都将被读取并且返回。
3.2 f.readline()
模式 r r+ w w+ a a+
读 + + + +
写 + + + + +
创建 + + + +
覆盖 + +
指针在开始 + + + +
指针在结尾 + +
1 # 打开一个文件
2 f = open(’./test.txt’, ‘w’)
3 # 写入内容
4 f.write(‘Python 是一门非常好学的语言。\n没错，很简单！！\n’)
5 # 关闭打开的文件
6 f.close()
f.readline() 会从⽂件中读取单独的⼀⾏。换⾏符为 ‘\n’。f.readline() 如果返回⼀个空字
符串, 说明已经已经读取到最后⼀⾏。
3.3 f.readlines()
f.readlines() 将返回该⽂件中包含的所有⾏。
如果设置可选参数 sizehint, 则读取指定⻓度的字节, 并且将这些字节按⾏分割。
3.4 f.write()
f.write(string) 将 string 写⼊到⽂件中, 然后返回写⼊的字符数。
3.5 f.tell()
f.tell() 返回⽂件对象当前所处的位置, 它是从⽂件开头开始算起的字节数。
3.6 f.seek()
如果要改变⽂件当前的位置, 可以使⽤ 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，即⽂件开头。
3.7 f.close()
在⽂本⽂件中 (那些打开⽂件的模式下没有 b 的), 只会相对于⽂件起始位置进⾏定位。
当你处理完⼀个⽂件后, 调⽤ f.close() 来关闭⽂件并释放系统的资源，如果尝试再调⽤
该⽂件，则会抛出异常。
当处理⼀个⽂件对象时, 使⽤ with 关键字是⾮常好的⽅式。在结束后, 它会帮你正确的
关闭⽂件。 ⽽且写起来也⽐ try - finally 语句块要简短:

五-列表与字典
六、躲不过的重复-for 与 while
Python 中的循环语句有 for 和 while。在 Python 中没有 do…while 循环。
以下实例使⽤了 while 来计算 1 到 100 的总和：


⽆限循环
while 1 或者 while True。
while 循环
在给定的判断条件为 true 时执⾏循环体，否则退出循环体。
for 循环
Python for循环可以遍历任何序列的项⽬，如⼀个列表或者⼀个字符串。
range()
如果你需要遍历数字序列，可以使⽤内置range()函数。它会⽣成数列
你可以在 while 循环体中嵌套 for 循环（for 中也可以嵌套 for ）
七、跳出循环-循环语句相关语句
1、跳出循环语句
break
 在语句块执⾏过程中终⽌循环，并且跳出整个循环
continue
 在语句块执⾏过程中终⽌当前循环，跳出该次循环，执⾏下⼀次循环。
pass
 pass 是空语句，是为了保持程序结构的完整性。
break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终⽌，任何
对应的循环 else 块将不执⾏。
continue 语句被⽤来告诉 Python 跳过当前循环块中的剩余语句，然后继续进⾏下⼀轮
循环。
2、pass 语句
Python pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，⼀般⽤做
占位语句。
 pass 语句在函数中的作⽤
当你在编写⼀个程序时，执⾏语句部分思路还没有完成，这时你可以⽤ pass 语句来占
位，也 可以当做是⼀个标记，是要过后来完成的代码。⽐如下⾯这样：

定义⼀个函数 iplaypython，但函数体部分暂时还没有完成，⼜不能空着不写内容，因
此可以 ⽤ pass 来替代占个位置。
 pass 语句在循环中的作⽤
pass 也常⽤于为复合语句编写⼀个空的主体，⽐如说你想⼀个 while 语句的⽆限循
环，每次 迭代时不需要任何操作，你可以这样写：

以上只是举个例⼦，现实中最好不要写这样的代码，因为执⾏代码块为 pass 也就是空
什么也不做，这时 python 会进⼊死循环。
 pass 语句⽤法总结
1、空语句，什么也不做
2、在特别的时候⽤来保证格式或是语义的完整性
3、while 循环案例

4、for 循环案例

八-函数封装
函数是组织好的，可重复使⽤的，⽤来实现单⼀，或相关联功能的代码段。
函数能提⾼应⽤的模块性，和代码的重复利⽤率。你已经知道Python提供了许多内建函
数，⽐如print()。但你也可以⾃⼰创建函数，这被叫做⽤户⾃定义函数。
1、 定义⼀个函数
你可以定义⼀个由⾃⼰想要功能的函数，以下是简单的规则：
 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
 任何传⼊参数和⾃变量必须放在圆括号中间，圆括号之间可以⽤于定义参数。
 函数的第⼀⾏语句可以选择性地使⽤⽂档字符串—⽤于存放函数说明。
 函数内容以冒号起始，并且缩进。
 return [表达式] 结束函数，选择性地返回⼀个值给调⽤⽅。不带表达式的return相
当于返回 None。

2、参数调⽤
Python3 的六个标准数据类型中：
 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
不可变类型：类似 c++的值传递，如 整数、字符串、元组。如 fun（a），传递的只是
a 的 值，没有影响 a 对象本身。⽐如在 fun（a）内部修改 a 的值，只是修改另⼀个复
制的对象， 不会影响 a 本身。

int2 对象指向变量 b，⽽调⽤ changeInt 函数时，变量 a 就是变量 b，此时的变量 a
和变量 b 都对应 int 2 对象，但是在之后 a 被重新赋值为 10，此时变量 a 指向对象 int
10，产⽣了 ⼀个新的 int 型对象，⽽变量 b 所指向的对象不变。
可变类型：类似 c++的引⽤传递，如 列表，字典。如 fun（la），则是将 la 真正的传过
去， 修改后 fun 外部的 la 也会受影响
python 中⼀切都是对象，严格意义我们不能说值传递还是引⽤传递，我们应该说传不
可变对 象和传可变对象。

3、 参数
以下是调⽤函数时可使⽤的正式参数类型：
 必需参数
 关键字参数
 默认参数
 不定⻓参数
调⽤函数时的参数使⽤
1）必备参数 必须与函数声明时⼀致的顺序来传递参数。

2）关键字参数 传参数时可与函数声明的顺序不⼀样，因为 Python 解释器可以⽤参数

名来匹配参数值。
3）缺省参数 传⼊参数时未给参数赋值，则保持默认值。
调⽤函数时，如果没有传递参数，则会使


4）不定⻓参数（也就是包含⾮必备参数的参数定义）
当不确定会传⼊参数的个数时，可以对可以不输⼊的参数名前⾯加 * 号，按顺序输⼊
时进⾏ 对应即可。加了星号 * 的参数会以元组(tuple)的形式导⼊，存放所有未命名的
变量参数。

还有⼀种就是参数带两个星号 ** 加了两个星号 ** 的参数会以字典的形式导⼊。

4、return语句
return [表达式] 语句⽤于退出函数，选择性地向调⽤⽅返回⼀个表达式。不带参数值的
return语句返回None。
**⼗、经营 KFC-函数
1、Python 数学函数
**

2、Python 随机函数
常⽤于游戏、数学、安全等领域


3、Python 三⻆函数

4、匿名函数
python 使⽤ lambda 来创建匿名函数。
所谓匿名，意即不再使⽤ def 语句这样标准的形式定义⼀个函数。
 lambda 只是⼀个表达式，函数体⽐ def 简单很多。
 lambda的主体是⼀个表达式，⽽不是⼀个代码块。仅仅能在lambda表达式中封装有
限的逻辑进去。
 lambda 函数拥有⾃⼰的命名空间，且不能访问⾃⼰参数列表之外或全局命名空间⾥
的参数。
 虽然lambda函数看起来只能写⼀⾏，却不等同于C或C++的内联函数，后者的⽬的
是调⽤⼩函数时不占⽤栈内存从⽽增加运⾏效率。
语法：
lambda 函数的语法只包含⼀个语句，如下：

5、变量作⽤域
1）全局变量 定义在所有函数外则为全局变量，可在所有代码中使⽤。
当需要在函数内定义全局变量时，必须⽤ global 语句。
2）局部变量 定义在函数内则为局部变量，只能在相应的代码块内使⽤。

在上⾯的例⼦中，在函数内部，total 是局部变量，⽽在外部 total 是全局变量，局部变
量的 改变不会改变全局变量的值，因此第⼀个打印结果是 30，⽽第⼆个是 0。
变量是拥有匹配对象的名字（标识符）。
命名空间是⼀个包含了变量名称们（键）和它们各⾃相应的对象们（值）的字典。每个
函数都会有⾃⼰的命名空间，当变量出现在函数内部时，Python 默认其为局部变量，
若存在⼀个与 局部变量重名的全局变量，则由局部变量覆盖全局变量。
Python 的命名空间分局部命名空间和全局命名空间。
根据调⽤地⽅的不同，globals()和 locals()函数可被⽤来返回全局和局部命名空间⾥的
名字。 如果在函数内部调⽤ locals()，返回的是所有能在该函数⾥访问的命名。 如果在
函数内部调⽤ globals()，返回的是所有在该函数⾥能访问的全局名字。 两个函数的返
回类型都是字典。所以名字们能⽤ keys() 函数摘取。
6、Python 内置函数
Python 解释器内置了很多函数和类型，您可以在任何时候使⽤它们。以下按字⺟表顺
序列出它们。具体功能可点连接进去官⽹查阅，或⾃⾏百度。

⼗⼆、雍正专治bug-debug 调试
1、语法错误
Python 的语法错误或者称之为解析错，是初学者经常碰到的。
2、异常
即使语句或表达式在语法上是正确的，但在尝试执⾏时，它仍可能会引发错误。 在执⾏
时检测到的错误被称为 异常，异常不⼀定会导致严重后果：你将很快学会如何在
Python 程序中处理它们。 但是，⼤多数异常并不会被程序处理。
异常以不同的类型出现，这些类型都作为信息的⼀部分打印出来。异常速查表。



处理异常
捕捉异常可以使⽤try/except语句。try/except语句⽤来检测try语句块中的错误，从⽽
让except语句捕获异常信息并处理。如果你不想在异常发⽣时结束你的程序，只需在try
⾥捕获它。
以下为简单的try…except…else的语法：

3.1 try/except
异常捕捉可以使⽤ try/except 语句。

以下例⼦中，让⽤户输⼊⼀个合法的整数，但是允许⽤户中断这个程序（使⽤ ControlC
或者操作系统提供的⽅法）。⽤户中断的信息会引发⼀个 KeyboardInterrupt 异常。

try 语句按照如下⽅式⼯作；
 ⾸先，执⾏ try ⼦句（在关键字 try 和关键字 except 之间的语句）。
 如果没有异常发⽣，忽略 except ⼦句，try ⼦句执⾏后结束。
 如果在执⾏ try ⼦句的过程中发⽣了异常，那么 try ⼦句余下的部分将被忽略。如果
异常的类型和 except 之后的名称相符，那么对应的 except ⼦句将被执⾏。
 如果⼀个异常没有与任何的 except 匹配，那么这个异常将会传递给上层的 try 中。
⼀个 try 语句可能包含多个except⼦句，分别来处理不同的特定的异常。最多只有⼀个
分⽀会被执⾏。
处理程序将只针对对应的 try ⼦句中的异常进⾏处理，⽽不是其他的 try 的处理程序中
的异常。
⼀个except⼦句可以同时处理多个异常，这些异常将被放在⼀个括号⾥成为⼀个元组，
例如:

最后⼀个except⼦句可以忽略异常的名称，它将被当作通配符使⽤。你可以使⽤这种⽅
法打印⼀个错误信息，然后再次把异常抛出。


3.2 try/except…else
try/except 语句还有⼀个可选的 else ⼦句，如果使⽤这个⼦句，那么必须放在所有的
except ⼦句之后。else ⼦句将在 try ⼦句没有发⽣任何异常的时候执⾏

以下实例在 try 语句中判断⽂件是否可以打开，如果打开⽂件时正常的没有发⽣异常则
执⾏ else 部分的语句，读取⽂件内容：

使⽤ else ⼦句⽐把所有的语句都放在 try ⼦句⾥⾯要好，这样可以避免⼀些意想不到，
⽽ except ⼜⽆法捕获的异常。
异常处理并不仅仅处理那些直接发⽣在 try ⼦句中的异常，⽽且还能处理⼦句中调⽤的
函数（甚⾄间接调⽤的函数）⾥抛出的异常。
3.3 try-finally 语句
try-finally 语句⽆论是否发⽣异常都将执⾏最后的代码


4、抛出异常
Python 使⽤ raise 语句抛出⼀个指定的异常。
raise语法格式如下：

执⾏以上代码会触发异常：

raise 唯⼀的⼀个参数指定了要被抛出的异常。它必须是⼀个异常的实例或者是异常的
类（也就是 Exception 的⼦类）。如果你只想知道这是否抛出了⼀个异常，并不想去处
理它，那么⼀个简单的 raise 语句就可以再次把它抛出。

5、⽤户⾃定义异常
你可以通过创建⼀个新的异常类来拥有⾃⼰的异常。异常类继承⾃ Exception 类，可以
直接继承，或者间接继承，例如:

在这个例⼦中，类 Exception 默认的 init() 被覆盖。
当创建⼀个模块有可能抛出多种不同的异常时，⼀种通常的做法是为这个包建⽴⼀个基
础异常类，然后基于这个基础类为不同的错误情况创建不同的⼦类


⼤多数的异常的名字都以"Error"结尾，就跟标准的异常命名⼀样
十三-⾯向对象、类
1、 ⾯向对象技术简介
 类(Class): ⽤来描述具有相同的属性和⽅法的对象的集合。它定义了该集合中每个对
象所共有的属性和⽅法。对象是类的实例。
 ⽅法：类中定义的函数。
 类变量：类变量在整个实例化的对象中是公⽤的。类变量定义在类中且在函数体之
外。类变量通常不作为实例变量使⽤。
 数据成员：类变量或者实例变量⽤于处理类及其实例对象的相关的数据。
3 pass
4
5 class InputError(Error):
6 “”“Exception raised for errors in the input.
7
8 Attributes:
9 expression – input expression in which the error occurred
10 message – explanation of the error
11 “””
12
13 def init(self, expression, message):
14 self.expression = expression
15 self.message = message
16
17 class TransitionError(Error):
18 “”“Raised when an operation attempts a state transition that’s not
19 allowed.
20
21 Attributes:
22 previous – state at beginning of transition
23 next – attempted new state
message – explanation of why the specific transition is not
allowed
24
25 “””
26
27 def init(self, previous, next, message):
28 self.previous = previous
29 self.next = next
30 self.message = message
 ⽅法重写：如果从⽗类继承的⽅法不能满⾜⼦类的需求，可以对其进⾏改写，这个
过程叫⽅法的覆盖（override），也称为⽅法的重写。
 局部变量：定义在⽅法中的变量，只作⽤于当前实例的类。
 实例变量：在类的声明中，属性是⽤变量来表示的，这种变量就称为实例变量，实
例变量就是⼀个⽤ self 修饰的变量。
 继承：即⼀个派⽣类（derived class）继承基类（base class）的字段和⽅法。继
承也允许把⼀个派⽣类的对象作为⼀个基类对象对待。例如，有这样⼀个设计：⼀
个Dog类型的对象派⽣⾃Animal类，这是模拟"是⼀个（is-a）"关系（例图，Dog是
⼀个Animal）。
 实例化：创建⼀个类的实例，类的具体对象。
 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）
和⽅法。
和其它编程语⾔相⽐，Python 在尽可能不增加新的语法和语义的情况下加⼊了类机
制。
Python中的类提供了⾯向对象编程的所有基本功能：类的继承机制允许多个基类，派⽣
类可以覆盖基类中的任何⽅法，⽅法中可以调⽤基类中的同名⽅法。
对象可以包含任意数量和类型的数据。
1.1 类定义
语法格式如下：

类实例化后，可以使⽤其属性，实际上，创建⼀个类之后，可以通过类名访问其属性。
1.2 类对象
类对象⽀持两种操作：属性引⽤和实例化。
属性引⽤使⽤和 Python 中所有的属性引⽤⼀样的标准语法：obj.name。
类对象创建后，类命名空间中所有的命名都是有效属性名。所以如果类定义是这样

以上创建了⼀个新的类实例并将该对象赋给局部变量 x，x 为空的对象。
执⾏以上程序输出结果为：

类有⼀个名为 init() 的特殊⽅法（构造⽅法），该⽅法在类实例化时会⾃动调
⽤，像下⾯这样：

类定义了 init() ⽅法，类的实例化操作会⾃动调⽤ init() ⽅法。如下实例
化类 MyClass，对应的 init() ⽅法就会被调⽤:

当然， init() ⽅法可以有参数，参数通过 init() 传递到类的实例化操作上。
例如:

1.3 self代表类的实例，⽽⾮类
类的⽅法与普通的函数只有⼀个特别的区别——它们必须有⼀个额外的第⼀个参数名称,
按照惯例它的名称是 self。

从执⾏结果可以很明显的看出，self 代表的是类的实例，代表当前对象的地址，⽽
self.class 则指向类。
self 不是 python 关键字。
2、类的⽅法
在类的内部，使⽤ def 关键字来定义⼀个⽅法，与⼀般函数定义不同，类⽅法必须包含
参数 self, 且为第⼀个参数，self 代表的是类的实例。

十四-类的继承与定制
1、 继承
Python 同样⽀持类的继承，如果⼀种语⾔不⽀持继承，类就没有什么意义。派⽣类的
定义如下所示:

BaseClassName（示例中的基类名）必须与派⽣类定义在⼀个作⽤域内。除了类，还
可以⽤表达式，基类定义在另⼀个模块中时这⼀点⾮常有⽤:


2、多继承
Python同样有限的⽀持多继承形式。多继承的类定义形如下例:

需要注意圆括号中⽗类的顺序，若是⽗类中有相同的⽅法名，⽽在⼦类使⽤时未指定，
python从左⾄右搜索 即⽅法在⼦类中未找到时，从左到右查找⽗类中是否包含⽅法。


执⾏以上程序输出结果为：

3、⽅法重写
如果你的⽗类⽅法的功能不能满⾜你的需求，你可以在⼦类重写你⽗类的⽅法，实例如
下：
super() 函数是⽤于调⽤⽗类(超类)的⼀个⽅法。
执⾏以上程序输出结果为：

如果在⼦类中需要⽗类的构造⽅法就需要显式地调⽤⽗类的构造⽅法，或者不重写⽗类
的构造⽅法。
⼦类不重写 init ，实例化⼦类时，会⾃动调⽤⽗类定义的 init 。


如果重写了 init 时，实例化⼦类，就不会调⽤⽗类已经定义的 init ，语法
格式如下：

输出结果为：
如果重写了 init ，要继承⽗类的构造⽅法，可以使⽤ super 关键字：

4、类属性与⽅法
4.1 类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使⽤或直接
访问。在类内部的⽅法中使⽤时 self.__private_attrs。
4.2 类的⽅法
在类的内部，使⽤ def 关键字来定义⼀个⽅法，与⼀般函数定义不同，类⽅法必须包含
参数 self，且为第⼀个参数，self 代表的是类的实例。
self 的名字并不是规定死的，也可以使⽤ this，但是最好还是按照约定是⽤ self。
4.3 类的私有⽅法
__private_method：两个下划线开头，声明该⽅法为私有⽅法，只能在类的内部调⽤
，不能在类的外部调⽤。self.__private_methods。
类的私有属性实例如下：