《零基础学Python》
文章目录
- 《零基础学Python》
- 第1章 初识Python
- 第2章 Python语言基础
- 2.1 Python语法特点
- 2.2 保留字与标识符
- 2.3 变量
- 2.4 基本数据类型
- 2.5 运算符
- 2.6 基本输入输出
- 第3章 流程控制语句
- 第4章 序列的应用
- 4.1 序列
- 4.2 列表
- 4.3 元组
- 4.4 字典
- 4.5 集合
- 第5章 字符串及正则表达式
- 5.1 字符串常用方法
- 5.2 格式化字符串
- 5.3 字符串编码转换
- 5.4 正则表达式
- 第6章 函数
- 第7章 面向对象程序设计
- 7.1 面向对象概述和方法
- 7.2 属性（property）
- 7.3 继承
- 第8章 模块
- 第9章 异常处理及程序调试
第1章 初识Python
Python，本意是指”蟒蛇“。1989年，荷兰人Guido van Rossum发明了一种面向对象的解释型高级编程语言，将其命名为Python。
- 人生苦短，我用python
- 使用
python3.0是大势所趋
Python的应用领域：
- Wed开发
- 大数据开发
- 人工智能
- 自动化运维开发
- 云计算
- 爬虫
- 游戏开发
第2章 Python语言基础
2.1 Python语法特点
单行注释与多行注释
#单行注释
""" 多行注释 --
----
"""
- 通常情况下采用4个空格作为一个缩进量
- python对代码的缩进量要求非常严格，同一个级别的代码块的缩进量必须相同
2.2 保留字与标识符
【保留字】被赋予特定意义的单词
| — | — | — | — | — | — |
|---|---|---|---|---|---|
| and | as | assert | break | class | cotinue |
| def | del | elif | else | except | finally |
| for | from | False | global | if | import |
| in | is | lambda | nonlocal | not | None |
| or | pass | raise | return | try | True |
| while | with | yield |
保留字可以在IDLE中输入下列两行代码查看
import keyword
keyword.kwlist
【标识符】
命名规则如下
- 由字母、下划线“_”和数字组成，第一个字符不能是数字，目前python只能使用ISO-Latin字符集中的字符AZ和az
- 不能使用python中的保留字
- python的标识符
不能包含空格、@、%和$等特殊字符
2.3 变量
- 慎用小写字母l和大写字母O
使用内置函数type()可以返回变量类型，id()可以返回变量所指的内存地址
str = "温润如玉"
print(type(str))
print(id(str))
2.4 基本数据类型
在python中，数字类型主要包括整数、浮点数和复数
【整数】
-
二进制数以
0b/0B开头 -
八进制数必须以
0o/0O开头 -
十六进制数以
0x/0X开头
【浮点数】1.414、0.5、-3.334、2.7e2、-3.23e-3
【复数】
python中的复数与数学中的复数形式完全一致，都是由实部和虚部组成，并且使用j或J表示虚部，如3.14+12.3j
【字符串类型】
常用的转义字符及其说明
| 转义字符 | 说明 |
|---|---|
| \ | 续行符 |
| \n | 换行符 |
| \0 | 空 |
| \t | 水平制表符，用于横向跳到下一制表位 |
| \f | 换页 |
【布尔类型】
标识符True和False被解释为布尔值。另外，python中的布尔值可以转化为数值，True表示1，False表示0。python中所有的对象都可进行真值测试。其中，只有下面列出的几种情况得到的值为假，其他对象在if或者while语句中都表现为真
- False或None
- 数值中的零，包括0、0.0、虚数0
- 空序列，包括字符串、空元组、空列表、空字典
- 自定义对象的实例，该对象的–bool–方法返回False或者–len–方法返回0
【数据类型转换】常用的数据类型转换及其作用
| 函数 | 作用 |
|---|---|
| int(x) | 将x转换成整数类型 |
| float(x) | 将x转换成浮点数类型 |
| complex(real[,imag]) | 创建一个复数 |
| str(x) | 将x转换为字符串 |
| repr(x) | 将x转换为表达式字符串 |
| eval(str) | 计算在字符串中的有效python表达式，并返回一个对象 |
| chr(x) | 将整数x转换为一个字符 |
| ord(x) | 将一个字符x转换为它对应的整数值 |
| hex(x) | 将一个整数x转换为一个十六进制字符串 |
| oct(x) | 将一个整数x转换为一个八进制的字符串 |
2.5 运算符
【算数运算符】+、-、*、/、%
//取整除，即返回商的整数部分**幂，返回x的y次方
【赋值运算符】=、+=、-=、*=、/=、%=、//=、**=
【比较（关系）运算符】>、<、==、>=、<=、！=
【逻辑运算符】逻辑与（and），逻辑或（or），逻辑非（not）
【位运算符】&、|、^、~、<<、>>
2.6 基本输入输出
x = int(input("请输入x的值："))
y = int(input("请输入y的值："))
print("x**y = " , x**y)
第3章 流程控制语句
【if…elif…else】python中没有switch语句，实现多重继承时，只能使用if···elif···else语句或者if语句的嵌套
number = 99
if number == 1:
print("1朵：你是我的唯一!")
elif number == 10:
print("10朵：十全十美!")
elif number == 99:
print("99朵：天长地久!")
else:
print("小默也不知道了!")
【while】循环
print("今有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二，问几何?")
none = True
number = 0
while none:
number += 1
if number % 3 == 2 and number % 5 == 3 and number % 7 == 2:
print("答曰：", number)
none = False
【for】循环
range()函数是python内置函数，用于生成一系列连续的整数，多用于for循环语句中，范围[start, end)
range(start, end, step)
参数说明：
- start，可以省略，默认为0
- end，不可省略
- setp：可以省略，默认步长为1
print("今有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二，问几何?")
for number in range(100):
if number % 3 == 2 and number % 5 == 3 and number % 7 == 2:
print("答曰：", number)
break
【跳转语句】break和continue
【pass】语句，表示空语句，它不做任何事情，一般起到占位作用
for i in range(1, 40, 3):
if i % 5 == 0:
print(i)
else:
pass
第4章 序列的应用
python中序列是最基本的数据结构。它是一块用于存放多个值的连续内存空间。python中内置了5个常用的序列结构，分别是列表、元组、集合、字典和字符串
列表、元组、字典和集合的区别
| 数据结构 | 是否可变 | 是否重复 | 是否有序 | 定义符号 |
|---|---|---|---|---|
| 列表(list) | 可变 | 可重复 | 有序 | [ ] |
| 元组(tuple) | 不可变 | 可重复 | 有序 | ( ) |
| 字典(dictionary) | 可变 | 可重复 | 无序 | {key:value} |
| 集合(set) | 可变 | 不可重复 | 无序 | { } |
4.1 序列
对于序列结构有以下几个同通用的操作。其中，集合和字典不支持索引、切片、相加和相乘操作
【索引】从左向右索引是从0开始递增的，从右向左索引是从-1开始递减的
【切片】
sname[start : end : step]
【序列相加】
在python中，支持两种相同类型的序列相加操作，即将两个序列进行连接，不会去除重复的元素，使用加(+)实现
- 不能将元组与字符串相加
【乘法】使用数字n乘以一个序列会生成新的序列，新序列的内容为原来序列被重复n次的结果
【检查某个元素是否是序列的成员】
【计算序列的长度、最大值和最小值】len()、max()、min()
ss = ["aaa", "bbb", "ccc"]
ns = [11, 22, 33, 44, 55]
print(ss[0], ns[-1]) #索引 aaa 55
print(ss[0:1], ns[0:5:2]) #序列相加 ['aaa'] [11, 33, 55]
print(ss * 2) #相乘 ['aaa', 'bbb', 'ccc', 'aaa', 'bbb', 'ccc']
print("ddd" in ss, 22 in ns) #检查是否含有某个元素 False True
print(len(ss), max(ns), min(ns)) #长度、最大最小值 3 55 11
python提供的内置函数及其作用
| 函数 | 作用 |
|---|---|
| list() | 将序列转换为列表 |
| str() | 将序列转换为字符串 |
| sum() | 计算元素和 |
| sorted() | 对元素进行排序 |
| reversed() | 反向序列中的元素 |
| enumerate() | 将序列组合为一个索引序列，多用在for循环中 |
4.2 列表
list相关函数如下
创建删除访问列表
nums = [1, 3, 5, 2, 9, 7] #创建列表
emptyList = [] #创建空列表
data = list(range(1, 20, 3)) #创建数值列表
print(data[-1]) #访问列表最后一个元素
del nums #删除列表
遍历列表
s = ["aaa", "bbb", "ccc"] #创建列表
#方法1
for item in s:
print(item)
#方法2
for index, item in enumerate(s):
print(index + 1, ": ", item)
#方法3
for i in range(0, len(s)) :
print(s[i])
添加、删除、修改列表元素
s = ["aaa", "bbb", "ccc"] #创建列表
s.append("ddd") #末尾追加元素
s2 = ["111", "222"]
s.extend(s2) #添加列表
s[2] = "111" #修改元素
del s[0] #根据元素索引删除元素
s.remove("111") #根据元素值删除第一个值等于它的元素
#使用remove()方法删除元素前，最好先判断该元素是否存在
if s.count("bbb") > 0:
s.remove("bbb")
对列表进行统计和计算
nums = [1, 1, 1, 2, 2, 4, 4, 5]
count2 = nums.count(2) #listname.count(obj) 获取指定元素出现的次数
index4 = nums.index(4) #listname.index(obj) 获取指定元素首次出现的下标（即索引）,不存在将抛出异常
sums = sum(nums, 4) #sum(iterable[,start]) 统计数值列表的元素和 + start
对列表进行排序
"""
使用列表对象的sort()方法 listname.sort(key=None, reverse=False)
key:表示指定从每个元素中提取一个用于比较的键(例：设置 key=str.lower 表示在排序时不区分字母大小写)
reverse:默认为升序(False),True为降序排列
"""
nums = [21, 2, 31, 9, 12, 8]
nums.sort(reverse=True)
#使用内置的sorted()函数实现 sorted(iterable, key=None, reverse=False)
chs = ["A", "v", "d", "M", "s"]
chs = sorted(chs, key=str.lower, reverse=True)
列表推导式
# newlist = [Expression for var in list]
import random
number = [random.randint(10, 100) for i in range(6)]
# newList = [Expression for var in list]
price = [1000, 2000, 3000, 4000]
sale = [int(x * 0.7) for x in price]
# newList = [Expression for var in list if condition]
price1 = [1000, 2000, 3000, 4000]
sale1 = [x for x in price1 if x > 2000]
二维列表的使用
#直接定义二维列表
verse = [['高','山', '仰', '止'], ['景', '行', '行', '止']]
#使用嵌套的for循环创建
arr = []
for i in range(3):
arr.append([])
for j in range(4):
arr[i].append(i * 10 + j)
#使用列表推导式创建
nums = [[(i * 100 + j) for j in range(4)] for i in range(2)]
4.3 元组
元组为不可变序列，因此元组也被称为不可变的列表。在同一个元组中，元素的类型可以不同，因为它们之间没有任何关系。相应方法与列表相同，除去修改对应的操作
元组相关函数如下
转换为元组使用tuple()函数，转换为列表使用list()函数
nums = tuple(i for i in range(2, 30, 4))
#注意，元组在连接时连接的内容必须是元组
arr = (1, 3, 4, 5)
arr1 = (2, 3, 4)
arr += arr1
元组与列表的区别
- 列表属于可变序列，它的元素可以随时修改和删除；元组属于不可变序列，其中的元素不可以修改，除非整体替换
- 列表可以使用append()、extend()、insert()、remove()、pop()，元组不能删除元素
- 列表可以使用切片访问和修改元素，而元组只能通过切片访问元素
- 元组比列表的访问和处理速度快，所以当只需要对其中的元素进行访问，而不进行任何修改时，建议使用元组
- 列表不能作为字典的键，而元组则可以
4.4 字典
字典是无序的可变序列，字典的键必须唯一，字典中的键必须不可变
字典相关函数如下
创建、删除字典
dictionary = {'a':111, 'b':222, 'c':333, 'd':444}
#创建空字典
d1 = {}
d2 = dict()
#通过映射创建字典
list1 = [11, 22, 33, 44]
list2 = ["aa", "bb", "cc", "dd"]
d3 = dict(zip(list1, list2))
#使用dict对象的fromkeys()方法创建值为空的字典
list3 = ["id1", "id2", "id3"]
d4 = dict.fromkeys(list3)
#删除字典
del dictionary
d1.clear()
d3.pop(11)
通过键值对访问字典
dictionary = {'a':111, 'b':222, 'c':333, 'd':444}
print(dictionary['a'])
print(dictionary.get('b'))
print(dictionary.get('e', '字典中无此键'))
遍历字典
dictionary = {'a':111, 'b':222, 'c':333, 'd':444}
for item in dictionary.items(): #遍历键值对整体
print(item)
for key, value in dictionary.items(): #遍历键和值
print(key, ": ", value)
for key in dictionary.keys(): #遍历键
print(key)
for value in dictionary.values(): #遍历值
print(value)
添加、修改和删除字典元素
dictionary = {'a':111, 'b':222, 'c':333, 'd':444}
dictionary['v'] = 555 #添加一个元素
dictionary['b'] = 999 #添加一个元素，当此键存在时更新它的值
if 'a' in dictionary: #删除元素
del dictionary['a']
字典推导式
name = ["绮梦", "冷一", "香菱", "黛兰"]
sign = ["水瓶座", "射手座", "双鱼座", "双子座"]
dictionary = {i:j for i, j in zip(name, sign)}
4.5 集合
集合是无序可变序列，直接用{}创建集合
集合相关函数如下
集合的创建
set1 = {}
set2 = {'python', 'c++', 'java', 'c'}
set3 = {1, 2, 4}
#使用set()函数创建
set4 = set("月遇从云") #{'从', '云', '遇', '月'}
set5 = set([1.22, 3.44, 5,44, 9.0]) #{1.22, 3.44, 5, 9.0, 44}
set6 = set(('人生苦短', '我用Python')) #{'我用Python', '人生苦短'}
集合的添加和删除
lan = {'python', 'c', 'c++', 'java'}
lan.remove('c++')
lan.add('ruby')
print('ruby' in lan, 'ddd' in lan)
lan.clear()
集合的交集(&)，并集(|)和差集(-)运算
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
print(set1 & set2) #交集& {3, 4}
print(set1 | set2) #并集| {1, 2, 3, 4, 5, 6}
print(set1 - set2) #差集- {1, 2}
第5章 字符串及正则表达式
5.1 字符串常用方法
为了实现某些功能，经常要对某些字符串进行特殊处理，如拼接字符串、截取字符串、格式化字符串等。
字符串常用函数如下表
| 方法 | 说明 |
|---|---|
| len(string) | 计算字符串的长度 |
| string[start : end : step] | 截取字符串 |
| str.split(sep, maxsplit) | 分割字符串 |
| str.count(sub[, start[, end]]) | 检索指定字符在指定范围内出现次数，不存在返回0 |
| str.find(sub[, start[, end]]) | 检索是否包含指定字符串，包含返回首次出现索引，不包含返回-1 |
| str.index(sub[, start[, end]]) | 与find方法类似，不存在时会抛出异常 |
| str.startswith(prefix[, start[, end]]) | 检索是否以指定字符串开头，True/False |
| str.startswith(prefix[, start[, end]]) | 检索是否以指定字符串结尾 |
| str.lower() | 将字符串中的大写转换为小写 |
| str.upper() | 将字符串中的小写转换为大写 |
| str.strip([chars]) | 去除字符串左右侧的空格或者特殊字符 |
| str.lstrip([chars]) | 去除字符串左侧的空格或者特殊字符 |
| str.rstrip([chars]) | 去除字符串右侧的空格或者特殊字符 |
部分示例代码如下：
s = "nothing is impossible!"
print(len(s)) #字符串长度为22
print("I believe " + s) #字符串拼接
print(s[3:] + "\n" + s[:3] + "\n" + s[0:20:2]) #截取字符串
print(s[0] + s[-1]) #访问
list1 = s.split() #分割字符串,默认采用空白符进行分割
list2 = s.split('i') #使用字母i分割字符串s
print(s.count('s')) #检索出现次数
print(s.find("poss")) #检索首次出现下标，不存在抛出异常
print(s.index("is")) #检索首次出现下标，不存在返回-1
print(s.startswith("noth")) #是否以指定字符串开头
print(s.endswith("ddd")) #是否以指定字符串结尾
print(s.upper()) #转换为大写字母
print(s.lower()) #转换为小写字母
str1 = " #@12345cdfg@@@ "
str1 = str1.strip() #去左右则空格
str1 = str1.lstrip('#') #去左侧‘#’ >>> @12345cdfg@@@
str1 = str1.rstrip('@') #去右侧‘@’ >>> @12345cdfg
5.2 格式化字符串
格式化字符串是指先制定一个模板，在这个模板上预留几个空位，然后再根据需要填上相应的内容。空位需要指定表示符号（也称为占位符）
| 格式化字符 | 说明 | 格式化字符 | 说明 |
|---|---|---|---|
| %s | 字符串（采用str显示） | %r | 字符串（采用repr显示） |
| %c | 单个字符 | %f或%F | 浮点数 |
| %o | 八进制整数 | %e | 指数(基底写为e) |
| %d或%i | 十进制整数 | %E | 指数(基底写为E) |
| %x | 十六进制整数 | %% | 字符% |
#使用 % 操作符
template = '编号: %09d\t公司名称: %s \t官网: http://www.%s' #定义模板
context1 = (7, '百度', 'baidu') #定义要转换的内容1
context2 = (8, '搜狗', 'sougou') #定义要转换的内容2
print(template%context1) #格式化输出
print(template%context2) #格式化输出
#使用字符串对象的format()方法
tem = '编号: {:0>9s}\t公司名称: {:s} \t官网: http://www.{:s}'
con1 = tem.format('7', '百度', 'baidu')
con2 = tem.format('8', '搜狗', 'sougou')
print(con1)
print(con2)
5.3 字符串编码转换
encode()方法为str对象的方法，用于将字符串转换为二进制数据（即bytes），也称为“编码”
decode()方法为bytes对象的方法用于将二进制数据转换为字符串，即将使用encode()方法转换的结果再转换为字符串，也称为“解码”
verse = '花遇和风'
byte = verse.encode('GBK') #采用GBK编码转化为二进制数据，不处理异常
print(verse) #>>>花遇和风
print(byte) #>>>b'\xbb\xa8\xd3\xf6\xba\xcd\xb7\xe7'
print(byte.decode('GBK')) #解码 >>>花遇和风
5.4 正则表达式
匹配字符串可以使用re模块提供的match()，search()，findall()等方法
【示例】验证手机号码是否为中国移动号码
import re
pattern = r'(13[4-9]\d{8})|(15[01289]\d{8})$'
mobiles = ('13634222222', '13144222221')
for mobile in mobiles:
match = re.match(pattern, mobile)
if match == None:
print(mobile, '不是有效的中国移动号码')
else:
print(mobile, '是有效的中国移动号码')
第6章 函数
-
在进行值传递时，改变形式参数的值后，实际参数的值不变；在进行引用传递时，改变形式参数的值后，实际参数的值也发生变化
-
形式参数：函数名后面括号中的参数
-
实际参数：函数的调用者提供给函数的参数
-
位置参数（必备参数）：按照正确的顺序传到函数中，位置与数量一致
-
关键字参数：使用形式参数的名称来确定输入的参数值，此时顺序不需一致
-
调用“
函数名.__defaults__”查看函数的默认值参数的当前值，结果是一个元组 -
定义函数时，为形式参数设置默认值要牢记一点：默认参数必须指向不可变对象
-
可变参数
【*parameter】接收任意多个实际参数并将其放到一个元组中
【**parameter】接收任意多个类似关键字参数一样显式赋值的实际参数，并将其赋值到一个字典中
-
局部变量、全局变量
在函数体内定义，并且使用global关键字修饰后，该变量也就为全局变量
【匿名函数】
匿名函数是指没有名字的函数，在python中，使用lambda表达式创建匿名函数
import math
def circlearea(r):
result = math.pi * r * r
return result
print('半径为3的圆的面积为：', circlearea(3))
#使用lambda表达式创建匿名函数
r = 10
result = lambda r : math.pi * r * r
print('半径为10的圆的面积为: ', result(r)) #此处变量r调用了lambda表达式
使用lambda表达式自定义排序
#根据到原点距离排序
points = [(1, 3), (9, 5), (8, 0), (7, 2), (1, 0)]
print('初始顺序: ', points)
points.sort(key = lambda x : (x[0] * x[0] + x[1] * x[1]))
print('排序顺序: ', points)
【以主程序的形式运行】
def getArea(r):
return 3.14 * r * r
if __name__ == '__main__':
area = getArea(10)
print(area)
第7章 面向对象程序设计
7.1 面向对象概述和方法
面向对象程序设计具有三大基本特征：封装、继承、多态
【封装】面向对象编程核心思想，将对象的属性和行为封装起来
【继承】具有共同特征
【多态】将父类对象应用于子类的特征就是多态
驼峰式命名法：ClassName
【__init__方法】，类似Java中的构造方法，该方法必须包含一个self参数，并且必须是第一个参数。self参数是一个指向实例本身的引用，用于访问类中的属性和方法，在方法调用时会自动传递实际参数self
【实例方法】在类的实例上操作的函数，且实例方法第一个参数必须是self
- 在创建实例方法时，也可以和创建函数时一样为参数设置默认值。但是被设置了默认值的参数必须位于所有参数的最后
【类属性和实例属性】
【示例】求圆的面积
import math
class Circle:
r = 0
def __init__(self, r):
self.r = r
def getArea(self):
return math.pi * self.r * self.r
circle = Circle(3)
print(circle.getArea())
【访问权限】
- 首尾双下划线表示定义特殊方法，一般是系统定义名字
- 以单下划线开头的表示protected（保护）类型的成员，只允许类本身和子类进行访问，不能使用(from…import)语句导入
- 双下划线表示private（私有）类型的成员，只允许定义该方法的类本身进行访问，而且也不能通过类的实例进行访问，但是可以通过“
类的实例名._类名__xxx”方式访问
7.2 属性（property）
通过@property（装饰器）将一个方法转换为属性。将方法转换为属性后，可以直接通过方法名来访问方法，而不需要加()，这样可以让代码更简洁
通过@property转换后的属性不能赋值，如果对其赋值将抛出异常
class Rect:
def __init__(self, width, height):
self.width = width
self.height = height
@property
def area(self):
return self.width * self.height
rect = Rect(3, 4)
print('面积为：', rect.area)
为属性添加安全保护机制，读取私有属性的值
class TVshow:
def __init__(self, show):
self.__show = show
@property
def show(self):
return self.__show
tvshow = TVshow("《肖申克的救赎》")
print("默认：", tvshow.show)
7.3 继承
在面向对象编程中，被继承的类称为父类或基类，新的类称为子类或派生类
【派生类中调用基类的__init__()方法】super().__init__()
【方法重写】
class Fruit: #定义水果类（基类）
def __init__(self, color = '绿色'):
Fruit.color = color #定义类属性
def harvest(self, color):
print("成熟后的水果是：" + self.color) #输出的是形式参数color
print("水果原来是：" + Fruit.color) #输出的是类属性color
class Apple(Fruit): #定义苹果类（派生类）
color = "红色"
def __init__(self):
print("我是苹果...")
super().__init__() #调用基类的__init__()方法
class Sapodilla(Fruit): #定义人参果类（派生类）
def __init__(self, color):
print("我是人参果...")
super().__init__(color) #调用基类的__init__()方法
#重写harvest()方法
def harvest(self, color):
print("成熟后的人参果是：" + color)
print("人参果原来是：" + Fruit.color)
apple = Apple()
apple.harvest(apple.color)
sapodilla = Sapodilla("白色")
sapodilla.harvest("金黄色带紫色条纹")
第8章 模块
创建模块，即类。然后是.py文件
-
#导入模块 import math print(math.fabs(-4)) import math as m print(m.atan(5)) from math import fabs print(fabs(-33)) from math import cos, fsum print(cos(2), " ", fsum((1, 2, 3))) from math import * print(pow(2, 6)) -
from math import * print(dir()) #查看导入定义 import sys print(sys.path) #输出具体目录
创建包实际上就是创建一个文件夹，并且在该文件夹中创建一个名称为“__init__.py”的python文件。在__init__.py中所编写的代码，在导入包时会自动执行
#使用包
import settings.size
from settings import size
from settings import width,height
第9章 异常处理及程序调试
python语言只有在程序运行后才会执行语法检查
python中常见的异常如下
| 异常 | 描述 |
|---|---|
| NameError | 尝试访问一个没有声明的变量引发的错误 |
| IndexError | 索引超出序列范围引发的错误 |
| IndentationError | 缩进错误 |
| ValueError | 传入的值错误 |
| KeyError | 请求一个不存在的字典关键字引发的错误 |
| IOError | 输入输出错误 |
| ImportError | 当import语句无法找到模块或from无法在模块中找到相应的名称时引发的错误 |
| AttributeError | 尝试访问未知的对象属性引发的错误 |
| TypeError | 类型不合适引发的错误 |
| MemoryError | 内存不足 |
| ZeroDivisionError | 除数为0时发生错误 |
【示例】异常处理
#try···except
#try···except···else
#try···except···finally
#使用raise抛出异常
try:
x = float(input('请输入被除数:'))
y = float(input('请输入除数:'))
z = float(x) / y
except(ZeroDivisionError, TypeError, NameError):
print('捕捉到了异常')
else:
print(x, '/', y, '=', z)
def div(x, y):
try:
print(x / y)
except ZeroDivisionError as e:
print('除数不能为0', e)
except TypeError:
print('TypeError')
else:
print('NoError')
finally:
print("end...")
div(3, 5) #NoError end...
div(3, 0) #除数不能为0 division by zer end...
div('1', 8) #TypeError end...
【assert】断言，一般用于对程序某个时刻必须满足的条件进行验证，assert语句只有在调试阶段有效
x = float(input('请输入被除数:'))
y = float(input('请输入除数:'))
assert x == 0, "除数不能为0"
z = float(x) / y
print(z)
[参考资料]《零基础学Python》吉林大学出版社
🎈
创作整理不易，如果对您有帮助的话，还望多+点赞、收藏☚
欢迎在评论区留下您宝贵的建议😉😉😉
更多推荐
《零基础学Python》✍知识点整理
发布评论