7
expandtabs(tabsize=8)
把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
8
find(str, beg=0, end=len(string))
检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
9
index(str, beg=0, end=len(string))
跟find()方法一样，只不过如果str不在字符串中会报一个异常.
10
isalnum()
如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
11
isalpha()
如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
12
isdigit()
如果字符串只包含数字则返回 True 否则返回 False…
13
islower()
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
14
isnumeric()
如果字符串中只包含数字字符，则返回 True，否则返回 False
15
isspace()
如果字符串中只包含空白，则返回 True，否则返回 False.
16
istitle()
如果字符串是标题化的(见 title())则返回 True，否则返回 False
17
isupper()
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
18
join(seq)
以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
19
len(string)
返回字符串长度
20
ljust(width[, fillchar])
返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
21
lower()
转换字符串中所有大写字符为小写.
22
lstrip()
截掉字符串左边的空格或指定字符。
23
maketrans()
创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
24
max(str)
返回字符串 str 中最大的字母。
25
min(str)
返回字符串 str 中最小的字母。
26
replace(old, new [, max])
把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。
27
rfind(str, beg=0,end=len(string))
类似于 find()函数，不过是从右边开始查找.
28
rindex( str, beg=0, end=len(string))
类似于 index()，不过是从右边开始.
29
rjust(width,[, fillchar])
返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
30
rstrip()
删除字符串字符串末尾的空格.
31
split(str=“”, num=string.count(str))
num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串
32
splitlines([keepends])
按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
33
startswith(substr, beg=0,end=len(string))
检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
34
strip([chars])
在字符串上执行 lstrip()和 rstrip()
35
swapcase()
将字符串中大写转换为小写，小写转换为大写
36
title()
返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
37
translate(table, deletechars=“”)
根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
38
upper()
转换字符串中的小写字母为大写
39
zfill (width)
返回长度为 width 的字符串，原字符串右对齐，前面填充0
40
isdecimal()
检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。
8.3 List（列表）
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
del 删除某一项
列表截取的语法格式：变量[头下标:尾下标].
List的一些操作如下（与String类似）：
xiaobin = [“ranxia”, “0228”, 1011, 0.228]
test = [“hello world!”]
print(xiaobin) # [‘ranxia’, ‘0228’, 1011, 0.228]
print(xiaobin[0]) # ranxia
print(xiaobin[1:3]) # [‘0228’, 1011]
print(xiaobin[2:]) # [1011, 0.228]
print(xiaobin * 2) # [‘ranxia’, ‘0228’, 1011, 0.228, ‘ranxia’, ‘0228’, 1011, 0.228]
print(xiaobin +test) # [‘ranxia’, ‘0228’, 1011, 0.228, ‘hello world!’]
xiaoxiao = [“123”,123]
del xiaoxiao[0]
print(xiaoxiao) #[123]
与String不一样的是，列表中的元素是可以改变的：
xiaobin[2] = “love”
print(xiaobin) #[‘ranxia’, ‘0228’, ‘love’, 0.228]
与String类似，列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：
xiaobin = [‘1’,‘2’,‘3’,‘4’,‘5’,‘6’,‘7’,‘8’,‘9’]
print(xiaobin[1:8:2]) #[‘2’, ‘4’, ‘6’, ‘8’]
如果第三个参数为负数表示逆向读取，如翻转列表：
xiaobin = [‘1’,‘2’,‘3’,‘4’,‘5’,‘6’,‘7’,‘8’,‘9’]
print(xiaobin[-1: :-1]) #[‘9’, ‘8’, ‘7’, ‘6’, ‘5’, ‘4’, ‘3’, ‘2’, ‘1’]
列表脚本操作符：
Python 表达式 结果 描述
len([1, 2, 3]) 3 长度
[1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] 组合
[‘Hi!’] * 4 [‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’] 重复
3 in [1, 2, 3] True 元素是否存在于列表中
for x in [1, 2, 3]: print(x, end=" ") 1 2 3 迭代
列表函数&方法：
常用函数:
序号 函数
1 len(list)
列表元素个数
2 max(list)
返回列表元素最大值
3 min(list)
返回列表元素最小值
4 list(seq)
将元组转换为列表
Python还包含以下方法:
序号 方法
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()
复制列表
这些方法可以使得列表等结构可以当做数据结构使用，比如列表（List当做堆栈、队列、推导式使用）,具体在这就不深究了.
8.4 Tuple（元组）
string、list 和 tuple 都属于 sequence（序列），元组（tuple）与列表类似，对数据项的操作这里就不一一赘述了，不同之处如下：
元组的元素不能修改，但可以对元组进行连接组合元组合，写在小括号 () 里，元素之间也用逗号隔开。
虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
元组中的元素值是不允许删除的，但可以使用del语句来删除整个元组.
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
内置函数：
序号 方法及描述 实例
1 len(tuple)
计算元组元素个数。
tuple1 = (‘Google’, ‘Runoob’, ‘Taobao’)
len(tuple1)
3
2 max(tuple)
返回元组中元素最大值。
tuple2 = (‘5’, ‘4’, ‘8’)
max(tuple2)
‘8’
3 min(tuple)
返回元组中元素最小值。
tuple2 = (‘5’, ‘4’, ‘8’)
min(tuple2)
‘4’
4 tuple(seq)
将列表转换为元组。
list1= [‘Google’, ‘Taobao’, ‘Runoob’, ‘Baidu’]
tuple1=tuple(list1)
tuple1
(‘Google’, ‘Taobao’, ‘Runoob’, ‘Baidu’)
8.5 Set（集合）
集合（set）是由一个或数个不同或相同的整体组成的，构成集合的事物或对象称作元素或是成员。
基本功能是进行成员关系测试和删除重复元素（不能包含重复元素）。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
xiaobin = set([“ranxia”,111,111]) #xiaobin = {“ranxia”,111,111}
print(xiaobin) #{‘ranxia’, 111} 重复的元素会被自动屏蔽掉
#成员测试
if “ranxia” in xiaobin:
print(“ranxia 在集合xiaobin中”) # ranxia 在集合xiaobin中
else:
print(“ranxia 不在集合xiaobin中”)
集合还可以用来集合运算
xiaobin = set(“xiaobin”) #会把字符串中的每一个值单独作为一个元素
print(xiaobin) #{‘a’, ‘b’, ‘x’, ‘o’, ‘n’, ‘i’}
test = set(“xiao”)
print(xiaobin - test) # 差集 {‘n’, ‘b’}
print(xiaobin | test) # 并集 {‘o’, ‘n’, ‘x’, ‘i’, ‘a’, ‘b’}
print(xiaobin & test) # 交集 {‘o’, ‘x’, ‘a’, ‘i’}
print(xiaobin ^ test ) # 二者不同时存在的元素 {‘n’, ‘b’}
内置方法完整列表：
方法 描述
add() 为集合添加元素
clear() 移除集合中的所有元素
copy() 拷贝一个集合
difference() 返回多个集合的差集
difference_update() 移除集合中的元素，该元素在指定的集合也存在。
discard() 删除集合中指定的元素
intersection() 返回集合的交集
intersection_update() 返回集合的交集。
isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset() 判断指定集合是否为该方法参数集合的子集。
issuperset() 判断该方法的参数集合是否为指定集合的子集
pop() 随机移除元素
remove() 移除指定元素
symmetric_difference() 返回两个集合中不重复的元素集合。
symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union() 返回两个集合的并集
update() 给集合添加元素
8.6 Dictionary（字典）
和Java中的Map类似.
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用 { } 标识，也可以用构造函数 dict() 直接通过键值对构造它是一个无序的 键(key) : 值(value) 的集合。
键(key)必须使用不可变类型，所以可以用数字，字符串或元组充当，而用列表就不行
在同一个字典中，键(key)必须是唯一的，创建时如果同一个键被赋值两次，则只有后一个值会被记住.
xiaobin = {}
xiaobin[“lover”] = “ranxia”
xiaobin[520] = “冉冉”
print(xiaobin[“lover”]) #ranxia
print(xiaobin[520]) #冉冉
###另一种方式
xiaobin = {“lover” : “冉冉”, 520:“ranxia”}
print(xiaobin) #{‘lover’: ‘冉冉’, 520: ‘ranxia’}
print(xiaobin.keys()) #dict_keys([‘lover’, 520]) 输出所以键
print(xiaobin.values()) #dict_values([‘冉冉’, ‘ranxia’]) 输出说有值
##构造函数 dict()
xiaobin = dict([(“lover”,“冉冉”),(520,“ranxia”)])
print(xiaobin) #{‘lover’: ‘冉冉’, 520: ‘ranxia’}
内置函数&方法：
常见内置函数：
序号 函数及描述 实例
1 len(dict)
计算字典元素个数，即键的总数。
dict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’}
len(dict)
3
2 str(dict)
输出字典，以可打印的字符串表示。
dict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’}
str(dict)
“{‘Name’: ‘Runoob’, ‘Class’: ‘First’, ‘Age’: 7}”
3 type(variable)
返回输入的变量类型，如果变量是字典就返回字典类型。
dict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’}
type(dict)
<class ‘dict’>
Python字典还包含了以下内置方法：
序号 函数及描述
1 radiansdict.clear()
删除字典内所有元素
2 radiansdict.copy()
返回一个字典的浅复制
3 radiansdict.fromkeys()
创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4 radiansdict.get(key, default=None)
返回指定键的值，如果值不在字典中返回default值
5 key in dict
如果键在字典dict里返回true，否则返回false
6 radiansdict.items()
以列表返回可遍历的(键, 值) 元组数组
7 radiansdict.keys()
返回一个迭代器，可以使用 list() 来转换为列表
8 radiansdict.setdefault(key, default=None)
和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9 radiansdict.update(dict2)
把字典dict2的键/值对更新到dict里
10 radiansdict.values()
返回一个迭代器，可以使用 list() 来转换为列表
11 pop(key[,default])
删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
12 popitem()
随机返回并删除字典中的一对键和值(一般删除末尾对)。
8.7 数据类型转换
数据类型转换函数简介
函数 描述
int(x，base) 将x转换为一个整数，x是数字或者字符串，base是转换进制，如int(x, base=10)转为十进制
float(x) 将x转换到一个浮点数
complex(real，imag) complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。如：complex(1, 2) —>1+2j
str(x) 将对象 x 转换为字符串
repr(x) 将对象 x 转换为表达式字符串,函数str() 用于将值转化为适于人阅读的形式，而repr() 转化为供解释器读取的形式。如：print(repr(“ranxia”))---->‘ranxia’
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象，x = 7 ， eval( ‘3 * x’ )-----> 21
tuple(s) 将序列 s 转换为一个元组
list(s)
将序列 s 转换为一个列表
set(s)
转换为可变集合
dict(d)
创建一个字典。d 必须是一个 (key, value)元组序列。
frozenset(s)
转换为不可变集合
chr(x)
将一个整数转换为一个字符
ord(x)
将一个字符转换为它的整数值
hex(x)
将一个整数转换为一个十六进制字符串
oct(x)
将一个整数转换为一个八进制字符串
9、输入
读取键盘输入-input()：
ranxia = input(“请输入：”) #请输入：love ranxia
print(ranxia) #love ranxia
10、输出
Python两种输出值的方式: 表达式语句和 print() 函数。
print():
ranxia = “love”
xiaobin = “xiao”
print(ranxia) #love
print(xiaobin) #xiao
print(“-----------”)
print(ranxia,end=" “)
print(xiaobin,end=” ") #love xiao
如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。
如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。
str()： 函数返回一个用户易读的表达形式。
repr()： 产生一个解释器易读的表达形式。
s = ‘Hello, Runoob’
str(s)
‘Hello, Runoob’
repr(s)
“‘Hello, Runoob’”
str(1/7)
‘0.14285714285714285’
x = 10 * 3.25
y = 200 * 200
s = 'x 的值为： ’ + repr(x) + ‘, y 的值为：’ + repr(y) + ‘…’
print(s)
x 的值为： 32.5, y 的值为：40000…
===================================================================================
… hello = ‘hello, runoob\n’
hellos = repr(hello)
print(hellos)
‘hello, runoob\n’
=======================================================================================
… repr((x, y, (‘Google’, ‘Runoob’)))
“(32.5, 40000, (‘Google’, ‘Runoob’))”
str.format() 的基本使用如下:
#旧式格式化输出
print(“我喜欢%s已经%d年了”%(“冉冉”,16)) #我喜欢冉冉已经16年了
#新式格式化输出
print(“我喜欢{}已经{}年了”.format(“冉冉”,16)) #我喜欢冉冉已经16年了
print(“我喜欢{1}已经{0}年了”.format(16,“冉冉”)) #我喜欢冉冉已经16年了 #这种方式可以指定顺序
11、import
在 python 用 import 或者 from…import 来导入相应的模块。
将整个模块(somemodule)导入，格式为： import somemodule
从某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *
import…as ----->import A as B,给予A库一个B的别称，帮助记忆
12、运算符
算术运算符
比较运算符
赋值运算符
逻辑运算符
位运算符
成员运算符
身份运算符
算术运算符 ：
以下假设变量a为10，变量b为21：
运算符 描述 实例
-
加 - 两个对象相加 a + b 输出结果 31
-
减 - 得到负数或是一个数减去另一个数 a - b 输出结果 -11
-
乘 - 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 210
/ 除 - x 除以 y b / a 输出结果 2.1
% 取模 - 返回除法的余数 b % a 输出结果 1
** 幂 - 返回x的y次幂 a**b 为10的21次方
// 取整除 - 向下取接近除数的整数
9//2
4
-9//2
-5
比较运算符：
以下假设变量a为10，变量b为20：
运算符 描述 实例
== 等于 - 比较对象是否相等 (a == b) 返回 False。
!= 不等于 - 比较两个对象是否不相等 (a != b) 返回 True。
大于 - 返回x是否大于y (a > b) 返回 False。
< 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 (a < b) 返回 True。
= 大于等于 - 返回x是否大于等于y。 (a >= b) 返回 False。
<= 小于等于 - 返回x是否小于等于y。 (a <= b) 返回 True。
赋值运算符：
以下假设变量a为10，变量b为20：
运算符 描述 实例
= 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c
+= 加法赋值运算符 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
位运算符：
按位运算符是把数字看作二进制来进行计算的。下表中变量 a 为 60（0011 1100），b 为 13（0000 1101）
运算符 描述 实例
& 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 (a & b) 输出结果 12 ，二进制解释： 0000 1100
| 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 (a | b) 输出结果 61 ，二进制解释： 0011 1101
-
^ 按位异或运算符：当两对应的二进位相异时，结果为1 (a ^ b) 输出结果 49 ，二进制解释： 0011 0001
- 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x类似于 -x-1 (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<< 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 a << 2 输出结果 240 ，二进制解释： 1111 0000
右移动运算符：把">>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数 a >> 2 输出结果 15 ，二进制解释： 0000 1111
逻辑运算符：
假设变量 a 为 10, b为 20: 相当于C语言的 && ，|| ，！.
运算符 逻辑表达式 描述 实例
and x and y 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 (a and b) 返回 20。
or x or y 布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 (a or b) 返回 10。
not not x 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not(a and b) 返回 False
成员运算符：
成员运算符，成员包括字符串，列表或元组。
运算符 描述 实例
in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。
if “ranxia” in xiaobin:
print(“ranxia 在集合xiaobin中”) # ranxia 在集合xiaobin中
elif (111 not in xiaobin) :
print(“111 在集合xiaobin中”) #222 不在集合xiaobin中
身份运算符：
身份运算符用于比较两个对象的存储单元
运算符 描述 实例
is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not is not 是判断两个标识符是不是引用自不同对象 x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。
注： id() 函数用于获取对象内存地址。
x1 = “xiaobin”
x2 = “xiaobin”
if x1 is x2: #换成id(x1) == id(x2)一样
print(“x1和x2有相同标识”) #x1和x2有相同标识
else:
print(“x1和x2没有相同标识”)
运算符优先级：
以下表格列出了从最高到最低优先级的所有运算符：
运算符 描述
-
** 指数 (最高优先级)
-
-
- 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
-
-
/ % // 乘，除，取模和取整除
-
- 加法减法
<< 右移，左移运算符
& 位 ‘AND’
^ | 位运算符
<= < > >= 比较运算符
<> == != 等于运算符
= %= /= //= -= += *= **= 赋值运算符
is is not 身份运算符
in not in 成员运算符
not and or
逻辑运算符
13、控制结构
条件控制
循环控制
条件控制：if 语句（if – elif – else），应注意与C语言的else if区分.无switch结构
if condition_1:
statement_block_1
elif condition_2:
statement_block_2
else:
statement_block_3
循环控制：while + for
while 循环: 没有 do…while 循环。
a = 0
while a < 10:
print(a)
a += 1 #0 1 2 3 4 5 6 7 8 9
for 语句:
xiaobin = [1,2,3,4,5,6,7,8,9]
for x in xiaobin:
print(x) #1 2 3 4 5 6 7 8 9
range()函数:
是一个迭代器，range函数大多数时常出如今for循环中。在for循环中可做为索引使用。事实上它也能够出如今不论什么须要整数列表的环境中.
for x in range(5):
print(x) # 0 1 2 3 4
也可以使用range指定区间的值：
for x in range(5,10):
print(x) # 5 6 7 8 9
也可以使range以指定数字开始并指定不同的步长(可以是负数)：
for x in range(0,10,2):
print(x) #0 2 4 6 8
for x in range(0,-10,-2):
print(x) #0 -2 -4 -6 -8
还可以结合range()和len()函数以遍历一个序列的索引，还可以使用range()函数来创建一个列表：list(range(5)) ------>[0, 1, 2, 3, 4]
break 和 continue :
和C语言和JAVA都一样，这里稍作叙述，新手需要细细体会：
break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。
continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环。
pass语句：
Python pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句.
while True:
pass
14、迭代器与生成器
14.1 迭代器
Python最强大的功能之一.
是访问集合元素的一种方式。
是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法：iter() 和 next()。
字符串，列表或元组对象都可用于创建迭代器，通俗来讲，任何可以逐项地读取的对象，都做一个可迭代对象.
list = [1,2,3,4,5]
it = iter(list) #创建迭代器对象
print(next(it)) #1 输出下一个元素
print(next(it)) #2
有一点需要明确，迭代器指向的位置是元素之前的位置，其实和JAVA的ListIterator原理类似，如下图所示：
这里假设集合List由四个元素List1、List2、List3和List4组成，当使用语句it = iter(list)时，迭代器it指向的位置是上图中Iterator1指向的位置，当执行语句 next(it) 之后，迭代器指向的位置后移到上图Iterator2所指向的位置。
迭代器对象可以使用常规for语句进行遍历：
list = [5,6,7,8]
it = iter(list)
for x in it:
print(x,end=" ") #5 6 7 8
- 创建一个迭代器：
把一个类作为一个迭代器使用需要在类中实现两个方法 iter() 与 next() 。
iter() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 next() 方法并通过 StopIteration 异常标识迭代的完成。
next() 方法会返回下一个迭代器对象。
创建一个返回数字的迭代器，初始值为 1，逐步递增 1：
class MyNumbers:
def iter(self):
self.a = 1
return self
def next(self):
x = self.a
self.a += 1
return x
myclass = MyNumbers()
myiter = iter(myclass)
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
StopIteration：
StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 next() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。
在 20 次迭代后停止执行：
class MyNumbers:
def iter(self):
self.a = 1
return self
def next(self):
if self.a <= 20:
x = self.a
self.a += 1
return x
else:
raise StopIteration
myclass = MyNumbers()
myiter = iter(myclass)
for x in myiter:
print(x) #输出 1 . . . 20的整数
14.2 生成器
在 Python 中，使用了 yield 的函数被称为生成器（generator）。
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。调用一个生成器函数，返回的是一个迭代器对象（解决遍历时存储整个数列浪费内存的问题）。
更简单来说：
生成器是可以迭代的，但是你 只可以读取它一次 ，因为它并不把所有的值放在内存中，它是实时地生成数据:
yield 是一个类似 return 的关键字，迭代一次遇到yield时就返回yield后面(右边)的值。重点是：下一次迭代时，从上一次迭代遇到的yield后面的代码(下一行)开始执行。
也可以理解为：yield就是 return 返回一个值（这个值就是生成器），并且记住这个返回的位置，下次迭代就从这个位置后(下一行)开始。
def yield_test():
print(“开始…”)
yield “hello ranxia”
print(“测试”)
test = yield_test()
print(next(test)) #开始 hello ranxia
print(next(test)) #测试
可以看到“测试”并没有被输出，这里体现了它的return性，当执行第二条print(next(test))时，输出结果为“测试”，这一次的next开始的地方是接着上一次的next停止的地方执行的，所以调用next的时候，生成器并不会从test函数的开始执行，只是接着上一步停止的地方开始，然后遇到yield后，return出要生成的数，此步就结束。
注：百度和文档很多写得很生涩，这算是个最简单的例子了，先弄懂yield的特性和工作原理再去看什么yield实现斐波那契数列之类的就简单多了.
具体可以参见这篇译文：https://pyzh.readthedocs.io/en/latest/the-python-yield-keyword-explained.html
15、函数
定义一个函数&调用函数：
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数，参数可有可无。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
语法如下：
def 函数名（参数列表）:
函数体
def test(var):
if var == “ranxia”:
print(“love u”)
else:
print(“piss off”)
#调用函数
test(“ranxia”) #love u
python 函数的参数传递：
不可变类型（strings、 tuples, 、 numbers ）：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
def xx(a):
a = 1
b=2
xx(b)
print(b) # 2 可见并没有改变值
匿名函数 lambda：
意即不再使用 def 语句这样标准的形式定义一个函数。
lambda 只是一个表达式，函数体比 def 简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法如下：
lambda [arg1 [,arg2,…argn]]:expression
sum = lambda x1,x2:x1+x2
print(sum(1,2)) #3
变量作用域：
变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种，分别是：
L （Local） 局部作用域
E （Enclosing） 闭包函数外的函数中
G （Global） 全局作用域
B （Built-in） 内置作用域（内置函数所在模块的范围，其自身并没有放入内置作用域内，所以必须导入这个文件才能够使用它。可以使用dir查看）
import builtins
print(dir(builtins))
以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找。
全局变量和局部变量：
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。
total = 0 # 这是一个全局变量
===================================================================
def sum( arg1, arg2 ):
#返回2个参数的和."
total = arg1 + arg2 # total在这里是局部变量. #函数内是局部变量 : 30
print ("函数内是局部变量 : ", total)
return total
#调用sum函数
sum( 10, 20 )
print ("函数外是全局变量 : ", total) #函数外是全局变量 : 0
global 和 nonlocal关键字：
当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。
num = 1
def fun1():
global num # 需要使用 global 关键字声明
print(num) # 1
num = 123
print(num) #123
fun1()
print(num) #123
如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了，如下实例：
def outer():
num = 10
def inner():
nonlocal num # nonlocal关键字声明
num = 100
print(num) #100
inner()
print(num) #100
outer()
16、文件（File）
读和写文件:
open() 将会返回一个 file 对象，基本语法格式如下:
open(filename, mode)
filename：包含了你要访问的文件名称的字符串值。
mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读®。
不同模式打开文件的完全列表：
模式 描述
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+ 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
简要如下图：
模式 r r+ w w+ a a+
读 + + + +
写 + + + + +
创建 + + + +
覆盖 + +
指针在开始 + + + +
指针在结尾 + +
将字符串“I love ranxia”写入test.txt文件夹：
写入字符串
f = open(“files/test.txt”,“w”)
f.write(“I love ranxia”)
f.close()
#读取文件内容
f = open(“files/test.txt”,“r”)
str = f.read()
print(str) #I love ranxia
f.close() #关闭文件并释放系统的资源
pickle 模块：
python的pickle模块实现了基本的数据序列和反序列化。
通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。
通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。
基本接口：
pickle.dump(obj, file, [,protocol])
有了 pickle 这个对象, 就能对 file 以读取的形式打开:
x = pickle.load(file)
注解：从 file 中读取一个字符串，并将它重构为原来的python对象。
file: 类文件对象，有read()和readline()接口。
实例 1：
import pickle
=================================================================================
data1 = {‘a’: [1, 2.0, 3, 4+6j],
‘b’: (‘string’, u’Unicode string’),
‘c’: None}
selfref_list = [1, 2, 3]
selfref_list.append(selfref_list)
output = open(‘data.pkl’, ‘wb’)
Pickle dictionary using protocol 0.
================================================================================================
pickle.dump(data1, output)
Pickle the list using the highest protocol available.
==================================================================================================================
pickle.dump(selfref_list, output, -1)
output.close()
实例 2：
import pprint, pickle
#使用pickle模块从文件中重构python对象
pkl_file = open(‘data.pkl’, ‘rb’)
data1 = pickle.load(pkl_file)
pprint.pprint(data1)
data2 = pickle.load(pkl_file)
pprint.pprint(data2)
pkl_file.close()
常见方法：
file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：
序号 方法及描述
1
file.close()
关闭文件。关闭后文件不能再进行读写操作。
2
file.flush()
刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
3
file.fileno()
返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
4
file.isatty()
如果文件连接到一个终端设备返回 True，否则返回 False。
5
file.next()
Python 3 中的 File 对象不支持 next() 方法。
返回文件下一行。
6
file.read([size])
从文件读取指定的字节数，如果未给定或为负则读取所有。
7
file.readline([size])
读取整行，包括 “\n” 字符。
8
file.readlines([sizeint])
读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
9
file.seek(offset[, whence])
设置文件当前位置
10
file.tell()
返回文件当前位置。
11
file.truncate([size])
从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 Widnows 系统下的换行代表2个字符大小。
12
file.write(str)
将字符串写入文件，返回的是写入的字符长度。
13
file.writelines(sequence)
向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。
OS 文件/目录方法：
序号 方法及描述
1
os.access(path, mode)
检验权限模式
2
os.chdir(path)
改变当前工作目录
3
os.chflags(path, flags)
设置路径的标记为数字标记。
4
os.chmod(path, mode)
更改权限
5
os.chown(path, uid, gid)
更改文件所有者
6
os.chroot(path)
改变当前进程的根目录
7
os.close(fd)
关闭文件描述符 fd
8
os.closerange(fd_low, fd_high)
关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略
9
os.dup(fd)
复制文件描述符 fd
10
os.dup2(fd, fd2)
将一个文件描述符 fd 复制到另一个 fd2
11
os.fchdir(fd)
通过文件描述符改变当前工作目录
12
os.fchmod(fd, mode)
改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。
13
os.fchown(fd, uid, gid)
修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。
14
os.fdatasync(fd)
强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。
15
os.fdopen(fd[, mode[, bufsize]])
通过文件描述符 fd 创建一个文件对象，并返回这个文件对象
16
os.fpathconf(fd, name)
返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。
17
os.fstat(fd)
返回文件描述符fd的状态，像stat()。
18
os.fstatvfs(fd)
返回包含文件描述符fd的文件的文件系统的信息，Python 3.3 相等于 statvfs()。
19
os.fsync(fd)
强制将文件描述符为fd的文件写入硬盘。
20
os.ftruncate(fd, length)
裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。
21
os.getcwd()
返回当前工作目录
22
os.getcwdu()
返回一个当前工作目录的Unicode对象
23
os.isatty(fd)
如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。
24
os.lchflags(path, flags)
设置路径的标记为数字标记，类似 chflags()，但是没有软链接
25
os.lchmod(path, mode)
修改连接文件权限
26
os.lchown(path, uid, gid)
更改文件所有者，类似 chown，但是不追踪链接。
27
os.link(src, dst)
创建硬链接，名为参数 dst，指向参数 src
28
os.listdir(path)
返回path指定的文件夹包含的文件或文件夹的名字的列表。
29
os.lseek(fd, pos, how)
设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效
30
os.lstat(path)
像stat(),但是没有软链接
31
os.major(device)
从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。
32
os.makedev(major, minor)
以major和minor设备号组成一个原始设备号
33
os.makedirs(path[, mode])
递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。
34
os.minor(device)
从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。
35
os.mkdir(path[, mode])
以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。
36
os.mkfifo(path[, mode])
创建命名管道，mode 为数字，默认为 0666 (八进制)
37
os.mknod(filename[, mode=0600, device])
创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。
38
os.open(file, flags[, mode])
打开一个文件，并且设置需要的打开选项，mode参数是可选的
39
os.openpty()
打开一个新的伪终端对。返回 pty 和 tty的文件描述符。
40
os.pathconf(path, name)
返回相关文件的系统配置信息。
41
os.pipe()
创建一个管道. 返回一对文件描述符(r, w) 分别为读和写
42
os.popen(command[, mode[, bufsize]])
从一个 command 打开一个管道
43
os.read(fd, n)
从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。
44
os.readlink(path)
返回软链接所指向的文件
45
os.remove(path)
删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。
46
os.removedirs(path)
递归删除目录。
47
os.rename(src, dst)
重命名文件或目录，从 src 到 dst
48
os.renames(old, new)
递归地对目录进行更名，也可以对文件进行更名。
49
os.rmdir(path)
删除path指定的空目录，如果目录非空，则抛出一个OSError异常。
50
os.stat(path)
获取path指定的路径的信息，功能等同于C API中的stat()系统调用。
51
os.stat_float_times([newvalue])
决定stat_result是否以float对象显示时间戳
52
os.statvfs(path)
获取指定路径的文件系统统计信息
53
os.symlink(src, dst)
创建一个软链接
54
os.tcgetpgrp(fd)
返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组
55
os.tcsetpgrp(fd, pg)
设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。
56
os.ttyname(fd)
返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。
57
os.unlink(path)
删除文件路径
58
os.utime(path, times)
返回指定的path文件的访问和修改的时间。
59
os.walk(top[, topdown=True[, οnerrοr=None[, followlinks=False]]])
输出在文件夹中的文件名通过在树中游走，向上或者向下。
60
os.write(fd, str)
写入字符串到文件描述符 fd中. 返回实际写入的字符串长度
61
os.path 模块
获取文件的属性信息。
17、错误与异常
即便Python程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常，比如除数为0，文件找不等。
异常处理：try-except-finally
这一部分内容和JAVA的异常处理类似：
import sys
try: #try是需要检测异常的语句块
f = open(‘myfile.txt’)
s = f.readline()
i = int(s.strip())
except OSError as err: #捕获异常并作出相应处理
print(“OS error: {0}”.format(err))
except ValueError:
print(“Could not convert data to an integer.”)
except:
print(“Unexpected error:”, sys.exc_info()[0])
raise
try语句按照如下方式工作；
首先，执行try子句（在关键字try和关键字except之间的语句）
如果没有异常发生，忽略except子句，try子句执行后结束。
如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的except子句将被执行。最后执行 try 语句之后的代码。
如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中。
一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。
处理程序将只针对对应的try子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。
一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组，例如:
最后一个except子句可以忽略异常的名称，它将被当作通配符使用。你可以使用这种方法打印一个错误信息，然后再次把异常抛出。
except (RuntimeError, TypeError, NameError): pass
try except 语句还有一个可选的else子句，如果使用这个子句，那么必须放在所有的except子句之后。这个子句将在try子句没有发生任何异常的时候执行。例如:
for arg in sys.argv[1:]:
try:
f = open(arg, ‘r’)
except IOError:
print(‘cannot open’, arg)
else:
print(arg, ‘has’, len(f.readlines()), ‘lines’)
f.close()
使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到的、而except又没有捕获的异常。
抛出异常：
Python 使用 raise 语句抛出一个指定的异常。例如:
raise NameError(‘HiThere’)
Traceback (most recent call last):
File “”, line 1, in ?
NameError: HiThere
raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。
如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。
try:
raise NameError(‘HiThere’)
except NameError:
print(‘An exception flew by!’)
raise
An exception flew by!
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新
如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）
获取文件的属性信息。
17、错误与异常
即便Python程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常，比如除数为0，文件找不等。
异常处理：try-except-finally
这一部分内容和JAVA的异常处理类似：
import sys
try: #try是需要检测异常的语句块
f = open(‘myfile.txt’)
s = f.readline()
i = int(s.strip())
except OSError as err: #捕获异常并作出相应处理
print(“OS error: {0}”.format(err))
except ValueError:
print(“Could not convert data to an integer.”)
except:
print(“Unexpected error:”, sys.exc_info()[0])
raise
try语句按照如下方式工作；
首先，执行try子句（在关键字try和关键字except之间的语句）
如果没有异常发生，忽略except子句，try子句执行后结束。
如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的except子句将被执行。最后执行 try 语句之后的代码。
如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中。
一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。
处理程序将只针对对应的try子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。
一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组，例如:
最后一个except子句可以忽略异常的名称，它将被当作通配符使用。你可以使用这种方法打印一个错误信息，然后再次把异常抛出。
except (RuntimeError, TypeError, NameError): pass
try except 语句还有一个可选的else子句，如果使用这个子句，那么必须放在所有的except子句之后。这个子句将在try子句没有发生任何异常的时候执行。例如:
for arg in sys.argv[1:]:
try:
f = open(arg, ‘r’)
except IOError:
print(‘cannot open’, arg)
else:
print(arg, ‘has’, len(f.readlines()), ‘lines’)
f.close()
使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到的、而except又没有捕获的异常。
抛出异常：
Python 使用 raise 语句抛出一个指定的异常。例如:
raise NameError(‘HiThere’)
Traceback (most recent call last):
File “”, line 1, in ?
NameError: HiThere
raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。
如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。
try:
raise NameError(‘HiThere’)
except NameError:
print(‘An exception flew by!’)
raise
An exception flew by!
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-Sq5bKNLK-1713638989790)]
[外链图片转存中…(img-vybS0ts3-1713638989792)]
[外链图片转存中…(img-P7jUIHsx-1713638989792)]
[外链图片转存中…(img-qGnSnr2p-1713638989793)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新
如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
