字面量
代码中，被写入代码固定的值，称之为字面量。
字符串
python中字符串需要用（“）/（‘’）包围起来，同理被（”）/（‘’）包围起来的都是字符串。
注释
单行注释：#和注释内容建议一个空格隔开。
多行注释：一对三个双引号（“”“注释内容 “””）。一般用于整个文件，类，方法进行解释。
变量
通俗来说，就是程序运行时，记录数据用的。
变量名=变量值
特征： 变量的可以改变。
print可以输出多份内容，中间用（,）隔开。
# boolean
# list 列表
# tuple 元组
# dict 字典
# list 列表
# 场景：当获取很多数据的时候，可以把他们存储在列表中，然后直接使用列表访问
name_list = ['周杰伦','科比']
# tuple 元组
age_tuple = (18,19,20,21)
# dict 字典
# 场景：scrapy框架使用
#格式：变量的名字 = {key:value,key1,value1}
person = {'name':'红浪漫','age':18}
数据类型
type(被查看类型的数据)，也可以查看变量的数据类型。
变量无类型，但是它存储的数据有。
数据类型的转换
**int(x) float(x) str(x) bool(x)**同type语句一样，都是带有结果的返回值，可以直接用print输出，也可以用变量来存储。
万物皆可转字符串，但转数字必须要求内容全是数字。
转换整形
# 如果将float转换成整数，返回的是小数点前面的整数，不是四舍五入
# boolean类型转换为整型，true->1 false->0
a = '1.23' # 不能转换
# 如果字符串当中包含了非法字符，则不能转换
转换浮点数
# 爬虫时大部分获取的数据都是字符串类型
转换为字符串
# 整型转换为字符串 大部分应用场景
# boolean转换为字符串直接返回的是True/False
转换为布尔类型
# 如果对非0整数（int 包含正数和负数）进行bool类型转换，全为True
# 在整数范围内，0强制转换为bool结果为False
# 将float类型数据转换为bool，正的和负的浮点数结果都为True，0.0结果为False
# 只要字符串中有内容，强制转换为bool，结果为True（包含空格），非空则为True
# 只要列表中有数据，则为True，元组和字典也是如此
标识符
用户在编程中使用的一些名字用于给变量、类、方法等 命名。
规则
- 内容限定
- 英文
- 中文
- 数字
- **下划线 **
** 不能以数字开头**
- 大小写敏感
- 不可使用关键字
变量的命名规范
- ** 见名知意**
- 下划线命名法：多个单词组合时，使用_进行分隔
- 小驼峰命名法：myName
- 大驼峰命名法MyName
运算符
算术运算符
下面以a=10 ,b=20为例进行计算
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 | 两个对象相加a+b输出结果30 |
| - | 减 | 得到负数或是一个数减去另一个数a-b输出结果-10 |
| * | 乘 | 两个数相乘或是返回一个被重复若干次的字符串a*b输出结果200 |
| / | 除 | b /a输出结果2 |
| // | 取整除 | 返回商的整数部分9//2输出结果4,9.0//2.0输出结果4.0 |
| % | 取余 | 返回除法的余数b %a输出结果0 |
| ** | 指数 | a**b为10的20次方 |
| () | 小括号 | 提高运算优先级，比如：(1+2)*3 |
注意：混合运算时，优先级顺序为： ** 高于 * / % // 高于 + - ，为了避免歧义，建议使用 () 来处理运算符优先级。 并且，不同类型的数字在进行混合运算时，整数将会转换成浮点数进行运算。
:::info
字符串的加法，是进行拼接的
python中，+两端都是字符串才可以进行加法运算
字符串的乘法，是将字符串重复多少次
:::
赋值运算符
=、+=、*= ···
| 运算符 | 描述 | 实例 |
|---|---|---|
| += | 加法赋值运算符 | c+=a等效于c=c+a |
| -= | 减法赋值运算符 | c -=a等效于c=c-a |
| *= | 乘法赋值运算符 | c*=a等效于c=c*a |
| /= | 除法赋值运算符 | c /=a等效于c=c/a |
| //= | 取整除赋值运算符 | c //=a等效于c=c//a |
| %= | 取模赋值运算符 | c %=a等效于c=c%a |
| **= | 幂赋值运算符 | c**=a等效于c=c**a |
多个变量赋值（使用逗号分隔）
比较运算符
比较运算符返回的都为boolean类型的数据
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于：比较对象是否相等 | (a==b)返回False |
| != | 不等于：比较两个对象是否不相等 | (a!=b)返回true |
| > | 大于：返回x是否大于y | (a>b)返回False |
| >= | 大于等于：返回x是否大于等于y | (a>=b)返回False |
| < | 小于：返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特 殊的变量True和False等价 | (a<b)返回true |
| <= | 小于等于：返回x是否小于等于y | (a<=b)返回true |
逻辑运算符
| 运算符 | 逻辑表 达式 | 描述 | 实例 |
|---|---|---|---|
| and | x and y | 只要有一个运算数是False,结果就是False; 只有所有的运算数都为True时，结果才是True 做取值运算时，取第一个为False的值，如果所有的值都为True,取最后一个值 | True and True and False–>结果为False |
True and True and True–>结果为True |
| or | x or y | 只要有一个运算数是True,结果就是True
只有所有的运算数都为False时，结果才是False
做取值运算时，取第一个为True的值，如果所有的值都为False,取最后一个值 | False or False or True–>结果为True
False or False or False–>结果为False |
| not | not x | 布尔"非"-如果x为True,返回False。如果x为False,它返回True。 | not True -->False |
a = 36
# and的性能优化，当and前面的结果为false的情况下，and后面的代码就不再执行
a>10 and print('hello world')
# or 只要有一方为true，结果为true
# and 短路与
# or 短路或
字符串扩展
字符串定义的 三种方式
- 单引号定义法
- 双引号定义法
- 三引号定义法
单引号定义法可以内含双引号，双引号定义法可以内含单引号，可以使用转义字符\来解除效用，变成普通字符串。
name = ““xxx””
str = "'python'"
str = '"python"'
str = '\'python'
输入输出
输出
# 普通输出
print('')
# 格式化输出
# scrapy框架的时候 excel文件 mysql redis
age = 18
name = "红浪漫晶哥"
# %s代表字符串 %d 代表的是数据
print("我的姓名是%s, 年龄是%d" % (name, age))
输入
password = input("请输入密码:")
print('您刚刚输入的密码是:%s' % password)
input返回的是str类型
流程控制语句
if关键字
if语句是用来进行判断的，其使用格式如下：
if 要判断的条件:
条件成立时，要做的事情
注意：代码的缩进为一个tab键，或者4个空格
字符串和int是不可以比较的
if else
if 条件:
满足条件时的操作
else:
不满足条件时的操作
elif
if xxx1:
事情1
elif xxx2:
事情2
elif xxx3:
事情3
说明:
- 当xxx1满足时，执行事情1，然后整个if结束
- 当xxx1不满足时，那么判断xxx2，如果xxx2满足，则执行事情2，然后整个if结束
- 当xxx1不满足时，xxx2也不满足，如果xxx3满足，则执行事情3，然后整个if结束
for
在Python中 for循环可以遍历任何序列的项目，如一个列表或者一个字符串等。
for循环的格式
for 临时变量 in 列表或者字符串等可迭代对象:
循环满足条件时执行的代码
for循环的使用
- 遍历字符串:
for s in "hello":
# s是字符串中一个又一个的字符的变量
print(s)
h
e
l
l
o
- 打印数字
for i in range(5):
print(i)
0
1
2
3
4
**range **
range 可以生成数字供 for 循环遍历,它可以传递三个参数，分别表示 起始、结束和步长。
# range方法是一个可以遍历的对象
# range(5) 0-4 左闭右开区间
# range(起始值，结束值) 左闭右开
for i in range(1,6)
# 1 2 3 4 5
range(1,10,3)# 同样遵循左闭右开
# 1 4 7
# range(起始值，结束值，步长)
# 应用场景 会爬取一个列表返回给我们
# 循环一个列表
a_list = ['周杰伦','林俊杰','陶喆']
# 遍历列表中的元素
for i in a_list:
print(i)
# 遍历列表中的下标
# 判断列表元素的个数
print(len(a_list))
for i in range(len(a_list)):
print(i)
数据类型高级
字符串高级
字符串的常见操作包括：
- 获取长度:len len函数可以获取字符串的长度。
- 查找内容:find 查找指定内容在字符串中是否存在，如果存在就返回该内容在字符串 中第一次出现的开始位置索引值，如果不存在，则返回-1.
- 判断:startswith,endswith 判断字符串是不是以谁谁谁开头/结尾
- 计算出现次数:count 返回 str在start和end之间 在 mystr里面出现的次数
- 替换内容:replace 替换字符串中指定的内容，如果指定次数count，则替换不会超过 count次。
s.replace('old','new')
- 切割字符串:split 通过参数的内容切割字符串
s.split('#')
- 修改大小写:upper,lower 将字符串中的大小写互换
s.upper()
- 空格处理:strip 去空格 （只能去掉首尾的空格，中间的不行）
s.strip()
- 字符串拼接:join 字符串拼接
s = 'a'
print(s.join('hello'))
# haealalao
列表高级
列表的增删改查
**添加元素 **
添加元素有一下几个方法:
- append 在末尾添加元素
- insert 在指定位置插入元素
- extend 合并两个列表
# append
food_list = ['a','b']
food_list.append('c')
# ['a','b','c']
# insert
char_list = ['a','c','d']
# index的值是你想插入数据的那个下表
char_list.insert(1,'b')
# extend
num_list = [1,2,3]
num1_list = [4,5,6]
num_list.extend(num1_list)
**修改元素 **
我们是通过指定下标来访问列表元素，因此修改元素的时候，为指定的列表下标赋值即可
city_list = ['a','b','c','d','e']
# 列表中的元素的值修改
city_list[4] = 'f'
# ['a','b','c','d','f']
**查找元素 **
所谓的查找，就是看看指定的元素是否存在，主要包含一下几个方法：
- in 和 not in
**in, not in **
python中查找的常用方法为：
- in（存在）,如果存在那么结果为true，否则为false
- not in（不存在），如果不存在那么结果为true，否则false
#待查找的列表
nameList = ['xiaoWang','xiaoZhang','xiaoHua']
#获取用户要查找的名字
findName = input('请输入要查找的姓名:')
#查找是否存在
if findName in nameList:
print('在列表中找到了相同的名字')
else:
print('没有找到')
说明：
in的方法只要会用了，那么not in也是同样的用法，只不过not in判断的是不存在
**删除元素 **
类比现实生活中，如果某位同学调班了，那么就应该把这个条走后的学生的姓名删除掉；在开发中经常会用到删除这种功能。
列表元素的常用删除方法有：
- del：根据下标进行删除
- pop：删除最后一个元素
- remove：根据元素的值进行删除
a_list = [1,2,3,4,5]
# 爬取的数据中有个别不想要的，可以根据下标删除
del a_list[2]
# [1,2.4,5]
b_list = [1,2,3,4,5]
b_list.pop()
# [1,2,3,4]
c_list = [1,2,3,4,5]
c_list.remove(3)
# [1,2,4,5]
元组高级
Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。
a_tuple = (1,2,3,4)
a_tuple[0]
# 1
python中不允许修改元组的数据，包括不能删除其中的元素。
定义只有一个数据的元组
定义只有一个元素的元组，需要在唯一的元素后写一个逗号
a_tuple = (5,)
切片
切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
切片的语法：[起始:结束:步长]，也可以简化使用 [起始:结束]
注意：选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，步长表示选取间隔。
# 索引是通过下标取某一个元素
# 切片是通过下标去某一段元素
s = 'Hello World!'
# 遵循左闭右开
print(s)
print(s[4]) # o 字符串里的第4个元素
print(s[3:7]) # lo W 包含下标 3，不含下标 7
print(s[1:]) # ello World! 从下标为1开始，取出 后面所有的元素（没有结束位）
print(s[:4]) # Hell 从起始位置开始，取到 下标为4的前一个元素（不包括结束位本身）
print(s[1:5:2]) # el 从下标为1开始，取到下标为5的前一个元素，步长为2（不包括结束位本身）
字典高级
**查看元素 **
除了使用key查找数据，还可以使用get来获取数据
info = {'name':'班长','age':18}
print(info['age']) # 获取年龄
# 使用[]的方式，获取字典中不存在的key，会发生异常
# print(info['sex']) # 获取不存在的key，会发生异常
# 不能采用.的方式来访问字典的数据
print(info.get('sex')) # 获取不存在的key，获取到空的内容，不会出现异常
print(info.get('sex'， '男')) # 获取不存在的key, 可以提供一个默认值。
**修改元素 **
字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改
info = {'name':'班长', 'id':100}
print('修改之前的字典为 %s:' % info)
info['id'] = 200 # 为已存在的键赋值就是修改
print('修改之后的字典为 %s:' % info)
# 修改之前的字典为 {'name': '班长', 'id': 100}
# 修改之后的字典为 {'name': '班长', 'id': 200}
**添加元素 **
如果在使用 **变量名[‘键’] = 数据 **时，这个“键”在字典中，不存在，那么就会新增这个元素
info = {'name':'班长'}
print('添加之前的字典为:%s' % info)
info['id'] = 100 # 为不存在的键赋值就是添加元素
print('添加之后的字典为:%s' % info)
# 添加之前的字典为:{'name': '班长'}
# 添加之后的字典为:{'name': '班长', 'id': 100}
**删除元素 **
对字典进行删除操作，有一下几种：
- del
- clear()
# del删除指定的元素
info = {'name':'班长', 'id':100}
print('删除前,%s' % info)
del info['name'] # del 可以通过键删除字典里的指定元素
print('删除后,%s' % info)
# 删除前,{'name': '班长', 'id': 100}
# 删除后,{'id': 100}
# del删除整个字典
info = {'name':'monitor', 'id':100}
print('删除前,%s'%info)
del info # del 也可以直接删除变量
print('删除后,%s'%info)
# 删除前,{'name': 'monitor', 'id': 100}
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# NameError: name 'info' is not defined
# clear清空整个字典
info = {'name':'monitor', 'id':100}
print('清空前,%s'%info)
info.clear()
print('清空后,%s'%info)
# 清空前,{'name': 'monitor', 'id': 100}
# 清空后,{}
字典的遍历
遍历->就是数据一个一个的输出
person = {'name':'阿马','age':18,'sex':'男'}
# （1）遍历字典的key
# 字典.keys()方法 获取字典所有的key值 key是一个字典变量的名字
for key in person.keys():
print(key)
# （2）遍历字典的value
for value in person.values():
print(value)
# （3）遍历字典的key和value（键值对）
for key,value in person.items():
print(key,value)
# name 阿马
# age 8
# sex 男
# （4）遍历字典的项（元素）
for item in person.items():
print(item)
# ('name','阿马')
# ...
函数
定义函数
定义函数的格式如下：
def 函数名():
代码
# 定义一个函数，能够完成打印信息的功能
def f1():
print('欢迎马大哥光临红浪漫')
print('男宾2位')
调用函数
定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它
调用函数很简单的，通过 **函数名() **即可完成调用
# 定义完函数后，函数是不会自动执行的，需要调用它才可以
f1()
函数定义好以后，函数体里的代码并不会执行，如果想要执行函数体里的内容，需要手动的调用函数。
每次调用函数时，函数都会从头开始执行，当这个函数中的代码执行完毕后，意味着调用结束了。
函数参数
# 使用函数计算1和2的和
def sum():
a = 1
b = 2
c = a + b
print(c)
sum()
def sum(a,b):
c = a + b
print(c)
# 位置参数 按照位置一一对应关系来传递参数
sum(1,2)
# 关键字传参
sum(b = 200,a = 100)
# 定义函数的时候 sum(a,b) 我们称a和b为形式参数 简称形参
# 调用函数的时候 sum(1,2) 我们称1和2为实际参数 简称实参
为了让一个函数更通用，即想让它计算哪两个数的和，就让它计算哪两个数的和，在定义函数的时候可以让函数接收数据，就解决了这个问题，这就是函数的参数
注意点：
- 在定义函数的时候，小括号里写等待赋值的变量名
- 在调用函数的时候，小括号里写真正要进行运算的数据
函数返回值
所谓“返回值”，就是程序中函数完成一件事情后，最后给调用者的结果
**带有返回值的函数 **
想要在函数中把结果返回给调用者，需要在函数中使用return
# 返回值的关键字是return，存在函数中
def buyIceCream():
return '冰淇淋'
# 使用一个变量来接受函数的返回值
food = buyIceCream()
print(food)
局部变量
- 局部变量，就是在函数内部定义的变量
- 其作用范围是这个函数内部，即只能在这个函数中使用，在函数的外部是不能使用的
全局变量
- 在函数外边定义的变量叫做 全局变量
- 全局变量能够在所有的函数中进行访问
在满足条件的情况，要是用作用域最小的那个变量范围
文件
文件的打开与关闭
打开文件/创建文件
在python，使用open函数，可以打开一个已经存在的文件，或者创建一个新文件
open(文件路径，访问模式)
示例如下：f = open('test.txt', 'w')
说明:
**文件路径 **
- 绝对路径：指的是绝对位置，完整地描述了目标的所在地，所有目录层级关系是一目了然的。
- 例如： E:\python ，从电脑的盘符开始，表示的就是一个绝对路径。
- 相对路径：是从当前文件所在的文件夹开始的路径。
- test.txt ，是在当前文件夹查找 test.txt 文件
- ./test.txt ，也是在当前文件夹里查找 test.txt 文件， ./ 表示的是当前文件夹。
- …/test.txt ，从当前文件夹的上一级文件夹里查找 test.txt 文件。 …/ 表示的是上 一级文件夹
- demo/test.txt ，在当前文件夹里查找 demo 这个文件夹，并在这个文件夹里查找 test.txt 文件。
访问模式：
| 访问 模式 | 说明 |
|---|---|
| r | 以只读方式打开文件。文件的指针将会放在文件的开头。如果文件不存在，则报错。这是默认模式。 |
| w | 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
| w+ | 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| a+ | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写 |
| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。 |
| wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。 |
| wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| ab+ | 以二进制格式打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |
关闭文件
示例如下：
# 新建一个文件，文件名为:test.txt
f = open('test.txt', 'w')
# 关闭这个文件
f.close()
文件的读写
**写数据(write) **
使用write()可以完成向文件写入数据
demo: 新建一个文件 file_write_test.py ,向其中写入如下代码:
f = open('test.txt', 'w')
f.write('hello world, i am here!\n' * 5)
f.close()
注意：
- 如果文件不存在，那么创建；如果存在那么就先清空，然后写入数据
**读数据(read) **
使用read(num)可以从文件中读取数据，num表示要从文件中读取的数据的长度（单位是字节），如果没有传入
num，那么就表示读取文件中所有的数据
demo: 新建一个文件 file_read_test.py ，向其中写入如下代码:
# 默认情况下 read是一字节一字节读，效率比较低
f = open('test.txt', 'r')
content = f.read(5) # 最多读取5个数据
print(content)
print("‐"*30) # 分割线，用来测试
content = f.read() # 从上次读取的位置继续读取剩下的所有的数据
print(content)
f.close() # 关闭文件，这个可是个好习惯哦
# hello
# ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
# world, i am here!
注意：
- 如果用open打开文件时，如果使用的"r"，那么可以省略 open(‘test.txt’)
**读数据（readline） **
readline只用来读取一行数据。
# readline是一行行读取，但是只能读一行
f = open('test.txt', 'r')
content = f.readline()
print("1:%s" % content)
content = f.readline()
print("2:%s" % content)
f.close()
**读数据（readlines） **
readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行为列表的一个元素。
f = open('test.txt', 'r')
content = f.readlines()
print(type(content))
for temp in content:
print(temp)
f.close()
序列化和反序列化
通过文件操作，我们可以将字符串写入到一个本地文件。但是，如果是一个对象(例如列表、字典、元组等)，就无法直接写入到一个文件里，需要对这个对象进行序列化，然后才能写入到文件里。
设计一套协议，按照某种规则，把内存中的数据转换为字节序列，保存到文件，这就是序列化，反之，从文件的字节序列恢复到内存中，就是反序列化。
- 对象—》字节序列 === 序列化
- 字节序列–》对象 ===反序列化
Python中提供了JSON这个模块用来实现数据的序列化和反序列化。
JSON模块
JSON(JavaScriptObjectNotation, JS对象简谱)是一种轻量级的数据交换标准。JSON的本质是字符串。
使用JSON实现序列化
JSON提供了dump和dumps方法，将一个对象进行序列化。
dumps方法的作用是把对象转换成为字符串，它本身不具备将数据写入到文件的功能。
import json
file = open('names.txt', 'w')
# 默认情况下只能将字符串写入到文件中
names = ['zhangsan', 'lisi', 'wangwu', 'jerry', 'henry', 'merry', 'chris']
# file.write(names) 出错，不能直接将列表写入到文件里
# 可以调用 json的dumps方法，传入一个对象参数
result = json.dumps(names)
# dumps 方法得到的结果是一个字符串
print(type(result)) # <class 'str'>
# 可以将字符串写入到文件里
file.write(result)
file.close()
# 我们在使用scrapy框架的时候 该框架会返回一个对象 我们要将对象写入文件中，就要使用json.dumps
dump方法可以在将对象转换成为字符串的同时，指定一个文件对象，把转换后的字符串写入到这个文件里。
import json
file = open('names.txt', 'w')
names = ['zhangsan', 'lisi', 'wangwu', 'jerry', 'henry', 'merry', 'chris']
# dump方法可以接收一个文件参数，在将对象转换成为字符串的同时写入到文件里
json.dump(names, file)
file.close()
使用JSON实现反序列化
使用loads和load方法，可以将一个JSON字符串反序列化成为一个Python对象。
loads方法需要一个字符串参数，用来将一个字符串加载成为Python对象。（读的是数据）
import json
# 调用loads方法，传入一个字符串，可以将这个字符串加载成为Python对象
content = fp.read()
result = json.loads(content)
print(type(result)) # <class 'list'>
load方法可以传入一个文件对象，用来将一个文件对象里的数据加载成为Python对象。（读的是文件）
import json
# 以可读方式打开一个文件
file = open('names.txt', 'r')
# 调用load方法，将文件里的内容加载成为一个Python对象
result = json.load(file)
print(result)
file.close()
异常
程序在运行过程中，由于我们的编码不规范，或者其他原因一些客观原因，导致我们的程序无法继续运行，此时，程序就会出现异常。如果我们不对异常进行处理，程序可能会由于异常直接中断掉。为了保证程序的健壮性，我们在程序设计里提出了异常处理这个概念。
try…except语句
try…except语句可以对代码运行过程中可能出现的异常进行处理。 语法结构:
try:
可能会出现异常的代码块
except 异常的类型:
出现异常以后的处理语句
示例：
try:
f = open('test.txt', 'r')
print(f.read())
except FileNotFoundError:
print('文件没有找到,请检查文件名称是否正确')
扫一扫
1713
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
