Python数据类型
int ：整型
str ：字符串型
float ：浮点型
bool ：布尔型
list ：列表
tuplu ：元组
dict ：字典
set ：集合
字符串string：双引号包裹或括号包裹 print(str[起始值:终止值])
元组tuple： 小括号+逗号+双引号 print(tuple[起始值:终止值])
列表list: 中括号+逗号+双引号 print(list[起始值:终止值])
字典dict: 大括号+双引号+冒号 dict={建：值} dict.keys(建) dict.value(值)
标识符
由数字下划线组成，但是数字不能开头
命名规则
1.见文知义
2.驼峰命名法
大驼峰 MyName
小驼峰 myName
3._下划线来链接每个单词
My_name
import keyword #python拥有特殊含义的词/不可当标识符或变量名来使用
print(keyword.kwlist)
String字符串
len() 计算字符串的长度
capitalize() 将字符串首字母大写
upper() 将字符串全部变为大写
fine() 查找指定字符在字符串中的位置
startswith() 函数判断字符串的开头字符
endswith() 查询结尾是否与查询的相符
index() 返回下标索引值，不存在报异常
split() 分割字符
maxsplit() 分割几次
strip() 用于删除字符串开头和结尾的固定字符
lstrip() 用于删除字符串左边开头的第一个字符
rsprip() 用于删除字符串右边开头的第一个字符
jojn() 插入
count() 返回指定值在字符串中出现的次数
字符串的常见操作
1.查
| 方法 | 方法说明 |
|---|---|
| find(str) | 检测str是否被包含，若是返回索引值，否则返回-1 |
| index(str) | 与find()方法一样，若str不在会报异常 |
| count(str) | str出现的次数 |
| startswith(str) | 是否以str开头，返回 True or False |
| endswith(str) | 是否以str结束，返回 True or False |
| rfind(str) | 类似于find()，从右边开始查找 |
| rindex(str) | 类似于index()，从右边开始查找 |
2.增
| 方法 | 方法说明 |
|---|---|
| join(mystr) | mystr中每个元素后面插入str |
3.删
| 方法 | 方法说明 |
|---|---|
| lstrip | 删除左边的空白字符 |
| rstrip | 删除末尾的空白字符 |
| strip | 删除两端的空白字符 |
4.改
| 方法 | 方法说明 |
|---|---|
| replace(str1,str2) | 将str1替换成str2 |
| split(str,x) | 以str为分隔符切片，仅分隔x个子字符串 |
| capitalize() | 把字符串的第一个字符大写 |
| title() | 每一个字符串首字母大写 |
| lower() | 所有大写字符为小写 |
| upper() | 所有小写字符为大写 |
| ljust(x) | 原字符串左对齐，用空格填充至长度为x |
| rjust(x) | 原字符串右对齐，用空格填充至长度为x |
| center(x) | 原字符串居中，用空格填充至长度为x |
| partition(str) | 把字符串分为str前，str和str后三部分 |
| rpartition(str) | 类似于partition()，从右边开始 |
| splitlines() | 按照行分隔，返回一个包含各行作为元素的列表 |
List列表
list列表是一个有序且可变的集合，允许重复成员。
append() 在列表末尾添加数据元素，每次只能添加一个
extend(可迭代对象) 在列表末尾一次性追加另一个序列中的多个值
insert(下标，对象) 两个参数，第一个参数是位置索引，第二个是插入对象
clear() 清空列表
pop() 移除列表中的一个元素(默认最后的元素)并且返回该元素的值
remove(对象) 用于移除列表中某个值的第一个匹配项
index() 在列表中找出某个值第一个匹配项的索引位置
reverse() 反向列表中元素
sort() 对源列表进行排序，从小到大排序输出
len() 获取列表的长度(元素)
jojn() 插入
max() 返回列表元素最大值
min() 返回列表元素最小值
count() 返回列表中某个元素出现的次数
列表的常见操作
| 操作 | 函数 |
|---|---|
| 列表长度 | len(list) |
| 列表访问 | list[索引] |
| 列表切片 | list[start:stop:step] |
| 列表添加元素 | append/extend/insert |
| 列表修改元素 | list[索引]=新元素 |
| 列表查找元素 | in/not in/index/count |
| 列表删除元素 | del/pop/remove |
| 列表排序 | sort/reverse |
tuple元组
tuple元组是一个有序且不可更改的集合，允许重复成员
max() 返回列表元素最大值
min() 返回列表元素最小值
len() 获取列表的长度(元素)
count() 统计某个元素在列表出现的次数
dict字典
dict字典是一个有序且可变的集合，键必须是唯一的，没有重复成员
keys() 以列表形式返回字典中的所有的键
value() 以列表形式返回字典中的值
items() 函数以列表形式返回可遍历的(键/值)元组数组
get() 返回指定键的值
pop() 移除字典中的一个元素(默认最后一个元素)并且返回该元素的值
字典的常见操作
| 操作 | 函数 |
|---|---|
| 字典修改元素 | dict[ ‘key’ ] = 新value |
| 字典添加元素 | dict[ ‘新key’ ] = value |
| 字典删除元素 | del()/clear() |
| 键值对个数 | len() |
| 查看字典的键 | keys() |
| 查看字典的值 | values() |
| 所有(键，值)元组的列表 | items() |
set集合
set集合是一个无序且无索引的集合，没有重复的成员
add() 添加单个元素到集合
update() 添加多个元素到集合
remove() 用于移除列表中某个值的第一个匹配项
discard() 用于移除列表中某个值的第一个匹配项，不同于remove方法，因为 remove方法在移除一个不存在的元素时会发生错误，而 discard方法不会。
len() 查询当前集合有多少个元素值
clear() 清空集合
del 彻底删除集合
union() 返回两个集合的并集，及包含了所有集合的元素，重复的元素只会出现一次
get() 返回指定键的值，如果键不在集合中返回默认值 None 或者设置的默认值
数据类型的转换
| 函数 | 函数说明 |
|---|---|
| int(x) | 将x转换为一个整数 |
| str(x) | 将x转换为字符串型 |
| float(x) | 将x转换为浮点型 |
| tuple(x) | 将x转换为元组类型 |
| list(x) | 将x转换为列表类型 |
| dict(x) | 创建一个字典，x必须是一个序列 |
| set(x) | 将x转换为可变集合 |
特殊符号使用及运算符大全
算数运算符
以下假设变量 /a = 10 ，b = 20
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加-两个对象相加 | a + b 输出结果 30 |
| - | 减-两个对象相减 | a - b 输出结果 -10 |
| * | 乘-两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 200 |
| / | 除 - x除以y | b / a 输出结果 2 |
| % | 取模 - 返回除法的余数 | b % a 输出结果 0 |
| ** | 幂 - 返回x的y次幂 | a**b 为10的20次方， 输出结果 1000000000 |
| // | 取整除 - 返回商的整数部分 | 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0 |
比较运算符
以下假设变量 /a = 10 ，b = 20
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 - 比较对象是否相等 | (a == b) 返回 False |
| != | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 True |
| <> | 不等于 - 比较两个对象是否不相等 | (a <> b) 返回 true，这个运算符类似 != |
| > | 大于 - 返回x是否大于y | (a > b) 返回 False |
| < | 小于 - 返回x是否小于y | (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 = 10 ，b = 20
| 运算符 | 逻辑表达式 | 描述 |
|---|---|---|
| and | x and y | 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 |
| or | x or y | 布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。 |
| not | not x | 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 |
| 运算符 | 描述 | 实例 |
|---|---|---|
| 和 | 逻辑与运算符 | 标志= True和True = True |
| 要么 | 逻辑或运算符 | 标志= False或True = True |
| 不 | 逻辑非运算符 | 标志=不（False）= True |
成员运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
身份运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| 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。 |
运算符优先级
| 运算符 | 描述 |
|---|---|
| ** | 指数 (最高优先级) |
| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 ‘AND’ |
| ^ | | 位运算符 |
| <= < > >= | 比较运算符 |
| > == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 身份运算符 |
| in not in | 成员运算符 |
| not or and | 逻辑运算符 |
格式化输出
| 符号 | 格式化说明 |
|---|---|
| %s | 输出字符串 |
| %d | 输出int类型数字 |
| %f | 输出浮点数 |
| %x | 输出16进制数据 |
分支结构
1.条件结构
if语句 执行1 条件判断
if else 语句对条件进行判断，然后根据不同的结果执行不同的代码，这称为选择结构或者分支结构
elif 再次判断的意思,elif语句不能独立使用，可以在需要检查更多条件时，与if和else一同使用，一个if语句可以包含多个elif语句，结尾只能有一个else语句
计算机之所以能做很多自动化的任务，因为它可以自己做条件判断。
比如，输入用户年龄，根据年龄打印不同的内容，在Python程序中，使用分支语句if实现
age = 20
if age >= 18:
print("your age is",age)
print("adult")
根据Python的缩进规则，如果if语句判断是True，就把缩进的两行print语句执行了，否则，什么也不做。
也可以给if添加一个else语句，意思是，如果if判断是False，不要执行if的内容，去把else执行了。
age = 6
if age >= 18:
print("你的年龄",age)
print("成年")
else:
print("你的年龄",age)
print("未成年")
当然上面的判断是很粗略的，完全可以用elif做更细致的判断：
age = 6
if age >= 18:
print("成年")
elif age >= 7:
print("青少年")
else:
print("儿童")
2.循环语句
while 无限循环
for in 遍历循环
range 范围函数，可控制开始位置，结束位置和步长
break 跳出循环
continue 跳过本次循环，后面的循环继续执行
Break/continue 只能用在循环中，除此之外不能单独使用
Break/continue 在嵌套循环中，只对最近一次的循环起作用
while循环
while循环语句语法:
"""
while 条件:
条件满足时，做的事情1
条件满足时，做的事情2
条件满足时，做的事情3
...(省略)...
"""
for循环
for循环和while循环一样同样可以进行循环，并且是运用最多的循环方式，而且它有一项非常厉害的功能——遍历
names = ['Mike', 'Huahua', 'Jay']
for name in names:
print(name)
for x in…循环就是把每个元素代入变量x，然后执行缩进块的语句
Python还提供了一个range()函数，可以配合我们的for循环使用
例如：
for i in range(10):
print(i)
# 效果等同于 while 循环的
break语句
在循环中，break语句可以提前退出循环
m = 1
while m <= 50:
if m > 10:
# 当 m = 11时，条件满足，执行break语句
break
# break语句会结束当前循环
print(m)
m = m + 1
print("END")
# 打印出1~10后，紧接着打印END，程序结束
continue语句
在循环过程中，也可以通过continue语句，跳过当前的这次循环，直接开始下一次循环
n = 0
while n < 10:
n = n + 1
if n % 2 == 0:
# 如果n是偶数，执行continue语句
continue
# continue语句会直接继续下一轮循环
# 后续的print()语句不会执行
print(n)
# 打印的不再是1~10，而是1，3，5，7，9
def函数
一. 函数代码块以def关键词开头，后接函数标识符名称和圆括号()
二. 任何传入参数和自变量必须放在括号中间，括号之间可以用于定义参数
三. 函数的第一行语句可以选择性的使用文档字符串-用于存放函数说明
四. 函数内容以冒号：起始，并且缩进
五. return结束函数，选择性的返回一个值给调用方，不使用则返回Nome
help： 查看帮助，函数帮助我们了解模块，类型，对象，方法，属性的详细信息
return：函数返回的结果，可以是数值，字符串，列表，表达式，函数
函数的定义和调用
-
定义函数
函数必须先定义，后调用
定义函数的格式：def 函数名(): #代码（代码前有缩进，tab） # 定义函数，完成打印信息的功能 def huan(): print("hello") print("Python")调用函数 定义函数后，函数是不能够自动执行的，需要调用函数 调用函数的格式：函数名() -
调用函数
定义函数后，函数是不能够自动执行的，需要调用函数
调用函数的格式：函数名()
def huan():
print("李乐")
print("李环")
huan() # 调用函数
调用函数时，函数从头执行，代码执行完毕，调用结束
函数文档说明：
在定义函数时，添加的字符串信息，当用help查看函数时，才会显示文档说明。
def sum():
'这是两个数相加'
a = 4
b = 8
print('%s' %(a+b))
print(help(sum)) #help:查看帮助，函数帮助我们了解模块、类型、对象、方法、属性的详细信息
#多个返回值
#函数中如果有多个return语句，只要有一个被执行到，函数就会结束
def cal_nums():
print("---1---")
return 1
# 下面的代码不会执行，因为return有结束函数的功能
print("---2---")
return 2
print("---3---")
return 3
若函数中有return语句，执行到return语句时，调用结束
四种函数类型
#无参数，无返回值的函数：此类函数，不能接收参数，也没有返回值
def domo1():
print('这是一个无参数无返回值的函数')
domo1()
#无参数，有返回值的函数：此类函数，不能接收参数，但是可以返回某个数据
def domo2():
return 100
num = domo2()
print(num)
#有参数，无返回值的函数：此类函数，能接收参数，但不可以返回数据，一般情况下，对某些变量设置数据而不需结果时，用此类函数
def my_print(name):
print("我爱你%s" % name)
my_print("Python")
#有参数，有返回值的函数：此类函数，不仅能接收参数，还可以返回某个数据，一般情况下，像数据处理并需要结果的应用，用此类函数:
def domo4(num1,num2):
num = num1 + num2
return num
a = domo4(100,300)
print(a)
#函数注意点
#1.在调用函数时，如果需要把一些数据一起传递过去，被调用函数就需要用参数来接收
#2.参数列表中变量的个数根据实际传递的数据的多少来确定
def domo4(num1, num2):
num = num1 + num2
return num # 参数列表中变量的个数根据参数来确定
a = domo4(1,2,3)
递归函数
递归函数：即函数在内部调用自己本身
优点：定义简单，逻辑清晰
缺点：过深的调用会导致栈溢出
例如：
def fact(n):
if n == 1:
return 1
return n * fact(n-1)
- 注意：
可通过尾递归防止栈溢出。尾递归事实上和循环是等价的，没有循环语句的编程语言只能通过尾递归实现循环
Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题
顺序传参
使用索引来顺序传参
案例：
x = 1 ，y = 2，z = 3
#多项式 s = 1 + 2*x + y^2 + z*y
def huan(x,y,z):
s = 1 + 2*x + y*y +z*y
return s
#按位置输入
print(huan(1,2,3)) #按顺序传入 1 ， 2 ，3
关键字传参
直接在参数列表里设定关键词确定
案例如下：
#多项式 s = 1 + 2*x + y^2 + z*y
def huan(x,y,z):
s = 1 + 2*x + y*y +z*y
return s
print(huan(x=1,y=2,z=3)) #通过关键字来传入参数
print(huan(1,y=3,z=4)) #可以结合顺序传参使用，如果第一个传入的参数是关键词传入的，那么后面每个参数都需要关键字传参，否则会出现语法错误
默认传参
输入的参数可以是事先设定好赋值，也就是默认值，在调用函数的时候可以不输入参数，函数内部会直接调用默认参数值
例如以下默认 z = 3：
def huan(x,y,z=3): #z=3 是默认传参
s = 1 + 2*x + y*y +z*y
return s
#调用函数
huan(x=1,y=2) #z因为有了z=3 就可以不用传入参数，因为它默认使用默认传参
默认参数的默认值是可以修改的，将上面的z值传入设置为4
需要注意的是，默认参数必须放到参数的末尾
#调用函数，并输入修改的z参数
huan(1,2,z=4) #z = 4是修改后的参数
不定长传参
格式：def函数名(参数名1，*args，**kwarg) *args可以使用 也可以自定义
*args可以存放所有未命名的变量参数 加一个 * 为元组
** kwarg可以存放命名参数，即型如key = value的参数 加两个 ** 为字典
案例如下：
def user(a,b,*args,**kwargs):
print(a)
print(b)
print(args)
print(kwargs)
user(1,2,704704800,name='李乐',age=22) #1，2为a，b 704704800为一个元组 name为字典
def Jiafa(*args): #*args用来存放未命名的变量参数 *args为元组形式
sum = 0
for i in args:
sum = sum + i
print(sum)
Jiafa(1, 3, 5)
Jiafa(2, 4, 6, 8, )
#运行结果为《《《 9，20
def dict(**kwargs): #*kwargs用来存放命名参数。 **kwargs为字典新手
return kwargs
mydict = dict(system="系统", China="中国", link="联接")
x = input("请输入单词：")
if x in mydict.keys():
print("中文意思：", mydict[x])
else:
print("抱歉，没找到。")
函数的返回值
print 和 return 的区别，print 仅仅是打印在控制台，而 return 则是将 return 后面的部分作为返回值作为函数的输出，可以用变量接走，继续使用该返回值做其它事
python 函数使用 return 语句返回 “返回值”，可以将其赋给其它变量作其它的用处；
所有函数都有返回值，如果没有 return 语句，会隐式地调用 return None 作为返回值；
一个函数可以存在多条 return 语句，但只有一条可以被执行，如果没有一条 reutrn 语句被执行，同样会隐式调用 return None 作为返回值；
如果有必要，可以显式调用 return None 明确返回一个None(空值对象)作为返回值，可以简写为 return，不过 python 中懒惰即美德，所以一般能不写就不写；
如果函数执行了 return 语句，函数会立刻返回，结束调用，return 之后的其它语句都不会被执行了
- return 语句的作用：结束函数调用、返回值
案例如下：
def sum(a,b):
return a+b #return返回a+b的值
f = sum(100,50) #return返回值后需要一个变量接收
print(f)
def name(a,b):
c =a+b
d =a-b
return c,d
f = name(100,200)
print(f)
局部变量与全局变量
全局变量
全局变量：在函数外边定义的变量
作用范围：能够在所有的函数中进行访问
例如：
# 定义全局变量
money = 1200
def test1():
print(money)
# 虽然没有定义变量money但是可以使用全局变量money
test1()
局部变量
局部变量：在函数内定义的变量
作用范围：只能在当前定义的函数中使用
例如：
def test2():
sales = 200 # 定义局部变量
print(sales)
test2()
print(sales)
# 函数内部定义的局部变量，函数外面不能使用
注意：
1.函数外面与函数里面，都能够使用全局变量，局部变量只能在函数内使用
2.当全局变量与局部变量冲突时，函数内部听从局部变量
3.函数内部修改全局变量，必须加global关键字，修饰全局变量
Lambda匿名函数
一. Lambda只是一个表达式
二. Lambda主体是一个表达式，而不是一个代码块，仅仅能在lambda表达式中封装有限的逻辑进去
三. Lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数
四. Lambda函数所谓匿名函数，通俗地说就是没有名字的函数，lambda函数没有名字。
一个 lambda 函数，它把作为参数传入的数字加 10，然后打印结果：
x = lambda a : a + 10
print(x(5))
ambda 函数可接受任意数量的参数：
一个 lambda 函数，它把参数 a 与参数 b 相乘并打印结果：
x = lambda a, b : a * b
print(x(5, 6))
def函数与lambda函数的区别：
def sum(a,b):
c = a+b
d = a-b
return c,d
c = sum(10,20)
print(c)
c = lambda a,b:a+b
print(c(10,20))
错误类型和异常捕获
错误类型
语法错误(Syntax errors)
代码编译时的错误，不符合python语言规则的代码会停止编译并返回错误信息
| 语法 | 错误类型 |
|---|---|
| SyntaxError | 语法错误 |
| AttributeError | 属性错误 |
| NameError | 名称错误 |
| ZeroDivisionError | 除零错误 |
| TypeError | 类型错误 |
| ValueError | 数值错误 |
| lndexError | 索引错误 |
捕获异常
异常(Exceptions)
它只在代码运行时才会发生，如类型错误，数值错误，索引错误和属性错误等，语法错误包含在异常基类中
异常通常由以下问题引起
1.在定义函数之前就引用该函数
2.调用不属于某个对象的方法或属性
3.试图将某个值转换为不恰当的数据类型
try:
尝试执行的代码
except 错误类型1
针对错误类型1，对应的代码处理
except 错误类型2
针对错误类型2，对应的代码处理
except Exception as huan： #Exception语句可以捕获到任何未知错误 as后面接变量名
print('未知错误 %s' %huan)
else：
没有异常才会执行的代码
finally：
无论是否有异常，都会执行的代码
def input_password():
#1. 提示用户输入密码
password = input('请输入密码：')
#2. 判断密码长度 >=8, 返回输入的密码
if len(password) >= 8 :
return password
# 3. 如果 < 8 主动抛出异常 #raise手动抛出异常案例
print('请重新输入')
# 1> 创建异常对象 - 可以使用错误信息字符串作为参数
exception = Exception('密码长度不够') # 2> 主动抛出异常
raise exception
#4.既然抛出了异常，我们就可以捕获异常
try:
print(input_password())
except Exception as result :
print(result)
try:
num = int(input('请输入一个整数：'))
a = [777, 4596459, 145]
print(1 / num)
print(a[6]) #索引错误
print(s) #没有定义错误
print(float(a)) #类型错误
print(dda) #值错误
for i in a:
if i > 100:
print(i)
except IndexError:
print('索引错误')
except TypeError:
print('类型错误')
except ValueError:
print('请输入正确的整数')
except ZeroDivisionError:
print('除零错误')
except NameError:
print('没有定义错误')
except SyntaxError:
print('语法错误')
except Exception:
print('未知错误')
else:
print('处理成功')
finally:
print('成功啦')
异常的类型
异常类型：
Python内置异常
Python的异常处理能力是很强大的，它有很多内置异常，可向用户准确反馈出错信息。在Python中，异常也是对象，可对它进行操作。BaseException是所有内置 异常的基类，但用户定义的类并不直接继承BaseException，所有的异常类都是从Exception继承，且都在exceptions模块中定义。Python自动将所有异常名称放在内建命名空间中，所以程序不必导入exceptions模块即可使用异常。一旦引发而且没有捕捉SystemExit异常，程序执行就会终止。如果交互式会话遇到一个未被捕捉的SystemExit异常，会话就会终止。
内置异常类的层次结构如下：
BaseException # 所有异常的基类
+-- SystemExit # 解释器请求退出
+-- KeyboardInterrupt # 用户中断执行(通常是输入^C)
+-- GeneratorExit # 生成器(generator)发生异常来通知退出
+-- Exception # 常规异常的基类
+-- StopIteration # 迭代器没有更多的值
+-- StopAsyncIteration # 必须通过异步迭代器对象的__anext__()方法引发以停止迭代
+-- ArithmeticError # 各种算术错误引发的内置异常的基类
| +-- FloatingPointError # 浮点计算错误
| +-- OverflowError # 数值运算结果太大无法表示
| +-- ZeroDivisionError # 除(或取模)零 (所有数据类型)
+-- AssertionError # 当assert语句失败时引发
+-- AttributeError # 属性引用或赋值失败
+-- BufferError # 无法执行与缓冲区相关的操作时引发
+-- EOFError # 当input()函数在没有读取任何数据的情况下达到文件结束条件(EOF)时引发
+-- ImportError # 导入模块/对象失败
| +-- ModuleNotFoundError # 无法找到模块或在在sys.modules中找到None
+-- LookupError # 映射或序列上使用的键或索引无效时引发的异常的基类
| +-- IndexError # 序列中没有此索引(index)
| +-- KeyError # 映射中没有这个键
+-- MemoryError # 内存溢出错误(对于Python 解释器不是致命的)
+-- NameError # 未声明/初始化对象 (没有属性)
| +-- UnboundLocalError # 访问未初始化的本地变量
+-- OSError # 操作系统错误，EnvironmentError，IOError，WindowsError，socket.error，select.error和mmap.error已合并到OSError中，构造函数可能返回子类
| +-- BlockingIOError # 操作将阻塞对象(e.g. socket)设置为非阻塞操作
| +-- ChildProcessError # 在子进程上的操作失败
| +-- ConnectionError # 与连接相关的异常的基类
| | +-- BrokenPipeError # 另一端关闭时尝试写入管道或试图在已关闭写入的套接字上写入
| | +-- ConnectionAbortedError # 连接尝试被对等方中止
| | +-- ConnectionRefusedError # 连接尝试被对等方拒绝
| | +-- ConnectionResetError # 连接由对等方重置
| +-- FileExistsError # 创建已存在的文件或目录
| +-- FileNotFoundError # 请求不存在的文件或目录
| +-- InterruptedError # 系统调用被输入信号中断
| +-- IsADirectoryError # 在目录上请求文件操作(例如 os.remove())
| +-- NotADirectoryError # 在不是目录的事物上请求目录操作(例如 os.listdir())
| +-- PermissionError # 尝试在没有足够访问权限的情况下运行操作
| +-- ProcessLookupError # 给定进程不存在
| +-- TimeoutError # 系统函数在系统级别超时
+-- ReferenceError # weakref.proxy()函数创建的弱引用试图访问已经垃圾回收了的对象
+-- RuntimeError # 在检测到不属于任何其他类别的错误时触发
| +-- NotImplementedError # 在用户定义的基类中，抽象方法要求派生类重写该方法或者正在开发的类指示仍然需要添加实际实现
| +-- RecursionError # 解释器检测到超出最大递归深度
+-- SyntaxError # Python 语法错误
| +-- IndentationError # 缩进错误
| +-- TabError # Tab和空格混用
+-- SystemError # 解释器发现内部错误
+-- TypeError # 操作或函数应用于不适当类型的对象
+-- ValueError # 操作或函数接收到具有正确类型但值不合适的参数
| +-- UnicodeError # 发生与Unicode相关的编码或解码错误
| +-- UnicodeDecodeError # Unicode解码错误
| +-- UnicodeEncodeError # Unicode编码错误
| +-- UnicodeTranslateError # Unicode转码错误
+-- Warning # 警告的基类
+-- DeprecationWarning # 有关已弃用功能的警告的基类
+-- PendingDeprecationWarning # 有关不推荐使用功能的警告的基类
+-- RuntimeWarning # 有关可疑的运行时行为的警告的基类
+-- SyntaxWarning # 关于可疑语法警告的基类
+-- UserWarning # 用户代码生成警告的基类
+-- FutureWarning # 有关已弃用功能的警告的基类
+-- ImportWarning # 关于模块导入时可能出错的警告的基类
+-- UnicodeWarning # 与Unicode相关的警告的基类
+-- BytesWarning # 与bytes和bytearray相关的警告的基类
+-- ResourceWarning # 与资源使用相关的警告的基类。被默认警告过滤器忽略。
模块
一.创建模块，只需要将代码保存带文件扩展名为.py的文件中即可
二.重命名模块，可以 as 关键字创建别名
三.dir()函数，可以列出模块中所有的函数名(或者变量名)
四.from关键字，仅从模块导入某个函数或者某个部件
注意：在使用from关键字导入时，请勿在引用模块中的元素时使用模块名称
#二.重命名模块 可用 as 关键字创建别名， 例如：
import huan as mx
a = mx.dict["age"]
print(a)
#三.dir（）函数可以列出模块中所有的函数名(或者变量名) 列出属于 huan 模块的所有已定义名称： dir() 函数可用于所有模块，也可用于您自己创建的模块。
import huan
x = dir(huan)
print(x)
#四.form关键字仅从模块导入某个函数或者某个部件
#例如：仅从模块导入 dict字典：
form huan import dict
#导入名为 huan 的模块，并调用 name 函数：
import huan
huan.name("Bill")
#导入名为 huan 的模块，并访问 dict 字典：
import Mokuai
print(Mokuai.dict['age'])
#为 huan 模块 创建别名 mx：
import huan as mx
print(mx.dict['age'])
文件读取
文件操作：
文件是指存储在外部介质上数据的集合，文本文件编码方式包括ASCII格式、Unicode码、UTF-8码、GBK编码等。文件的操作流程为“打开文件-读写文件-关闭文件”三部曲。
打开文件
f = open(file='abcd.txt',mode='r',encoding='utf-8') #相对文件路径
#mode：设置模式 encoding：设置编码格式
f = open(r'H:\txt\8888\huan.txt',mode='r',encoding='utf-8') #绝对路径
#关于file参数有两种表示方式 1：相对文件，2：绝对路径
#相对路径，是相对代码文件的位置,适用于目标地址和代码文件的地址相对较近的情况
#绝对路径，从根目录开始索引的路径
mode模式常见参数
| 模式 | 功能 | 说明 |
|---|---|---|
| t | 文本模式 | 默认，以文本模式打开文件。一般用于文本文件 |
| b | 二进制模式 | 以二进制格式打开文件。一般用于非文本文件，如图片等。 |
| r | 只读模式 | 默认。以只读方式打开一个文件，文件指针被定位到文件头的位置。如果该文件不存在，则会报错 |
| w | 只写模式 | 打开一个文件只用于写入，如果该文件已存在，则打开文件，清空文件内容，并把文件指针定位到 文件头位置开始编辑。如果该文件不存在，则创建新文件，打开并编辑。 |
| a | 追加模式 | 打开一个文件用于追加，仅有只写权限，无权读操作。如果该文件已存在，文件指针定位到文件尾 新内容被写入到原内容之后。如果该文件不存在，则创建新文件并写入。 |
| r+ | 文本格式读写 | 打开文件后，可以读取文件内容，也可以写入新的内容覆盖原有内容(从文件开头进行覆盖) 如果该文件不存在，则会报错。 |
| rb | 二进制格式只读 | 以二进制格式打开文件，并且采用只读模式。文件的指针将会放在文件的开头。一般用于非文本文件，如图片、声音等。如果该文件不存在，则会报错。 |
| rb+ | 二进制格式读写 | 以二进制格式打开文件，并且采用读写模式。文件的指针将会放在文件的开头。一般用于非文本文件，如图片、声音等。如果该文件不存在，则会报错。 |
| w+ | 文本格式读写 | 打开文件后，先清空原有内容，使其变为一个空的文件，对这个空文件有读写权限 |
| wb | 二进制格式只写 | 以二进制格式打开文件，并且采用只写模式。一般用于非文本文件，如图片、声音等 |
| wb+ | 二进制格式读写 | 以二进制格式打开文件，并且采用读写模式。一般用于非文本文件，如图片、声音等 |
| a+ | 文本格式读写 | 以读写模式打开文件。如果该文件已经存在，文件指针将放在文件的末尾（即新内容会被写入到已有内容之后），否则，创建新文件用于读写 |
| ab | 二进制格式只写 | 以二进制格式打开文件，并且采用追加模式。如果该文件已经存在，文件指针将放在文件的末尾（即新内容会被写入到已有内容之后），否则，创建新文件用于写入 |
| ab+ | 二进制格式读写 | 以二进制格式打开文件，并且采用追加模式。如果该文件已经存在，文件指针将放在文件的末尾（即新内容会被写入到已有内容之后），否则，创建新文件用于读写 |
读取文件方法
常用文件读取方法包括：
- read() 返回值为包含整个文本内容的一个字符串
- readline() 返回值为文件内容的下一行内容的字符串
- readlines() 返回值为整个文件内容的列表，列表中每项为一行字符串
注意：读取文件的时候务必设置 ’ r '为读取模式 否则使用以上三个函数会报错
f = open(r'H:\txt\8888\huan.txt',mode='r',encoding='utf-8')
print(f.read) #read用法 读取整个文件
f.close #close:关闭文件函数
infile = open("test.txt","r",encoding="utf8")
list_data = infile.readlines() #readlines用法，读取并返回列表形式包裹的内容
print(list_data)
f = open(r'H:\txt\8888\春.txt',mode='r',encoding='GBK')
print(f.readline()) #readline用法，返回文件内容的第一行内容
f.close()
写文件
从计算机内存向文件写入数据，方法包括：
- write() 逐次写入，把含有文本数据或二进制数据集的字符串写入文件中
- writelines() 可对一个列表里的所有数据一次性写入文件
- with open() 读写完文件自动保存关闭
注意：写入文件的时候设置模式为 ’ w ’ 否则报错
outfile1 = open('test.txt','a+',encoding="utf8")
str1 = '\nhello\n'
str2 = 'world\n'
outfile1.write(str1)
outfile1.write(str2)
outfile1.close()
outfile2 = open('test02.txt','w',encoding="utf8")
outfile2.writelines(['hello',' ','world'])
outfile2.close()
infile = open('test.txt','r',encoding="utf8")
data = infile.read()
print(data)
with open('text2.txt', 'w') as f:
f.write('加油奥里给') #as就是 = f是变量名
f.close()
针对test.txt文件完成追加写入操作，针对test02.txt文件完成新建及写入操作，同时调用write()和writelines()不同方法写入数据。
关闭文件
文件读写结束后，一定要记住使用close()方法关闭文件。如忘记使用该关闭语句，则当程序突然崩溃时，该程序不会继续执行写入操作，甚至当程序正常执行完文件写操作后，由于没有关闭文件操作，该文件可能会没有包含已写入的数据。为安全起见，在使用完文件后需要关闭文件，建议读者使用try-except-finally异常捕获语句，并在finally子句中关闭文件。
try:
#文件操作
except :
#异常处理
finally:
file.close()
其他方法包括：
- file.flush()：刷新文件内部缓冲
- file.next()：返回文件下一行
- file.seek(offset[, whence])：设置文件当前位置
- file.tell()：返回文件当前位置
- file.truncate([size])：截取文件，截取的字节通过size指定
JSON模块
JSON 是基于 JavaScript 语言的轻量级的数据交换格式，是 JavaScript 对象的表示法 (JavaScript Object Notation)，它是用来存储和交换文本信息的。信息表示格式为：
- 数据在名称 / 值对中。
- 数据由逗号分隔。
- 大括号保存对象。
- 方括号保存数组。
例如，下面的格式：
{
"login": [
{"password": "123456", "username": "AmoXiang"},
{"password": "123", "username": "你很棒棒"},
{"password": "111", "username": "xw1680"},
]
}
JSON标准库的作用
1.使用JSON字符串生成python对象（load）
2.由python对象格式化为JSON字符串（dump）
数据类型转换
| Python | JSON |
|---|---|
| dict | object |
| list,tuple | array |
| str | string |
| int,float | number |
| True | true |
| False | false |
| None | null |
JSON使用方法
| 方法 | 功能 |
|---|---|
| json.dump(obj,fp) | 将python数据类型转换并保存到json格式的文件内 |
| json.dumps(obj) | 将python数据类型转换为json格式的字符串 |
| json.load(fp) | 从json格式的文件中读取数据并转换为python的类型 |
| json.loads(s) | 将json格式的字符串转换为python的类型 |
案例如下：
dump()方法
定义 JSON 格式字符串，然后使用 dump() 方法将其写入 json 文件，代码如下：
import json
data1 = [{"a": "Amo", "b": (9, 99), "c": 6.6, "d": 11}]
with open("aa.json", "w") as file:
json.dump(data1, file, allow_nan=False, sort_keys=True, indent=4)
#sort_keys：默认值为 False。如果值为True，那么字典的输出会以键的顺序排序
#indent：默认值为 None。选择最紧凑的表达。如果 indent 是一个非负整数或者字符串，那么 JSON 数组元素和对象成员会被美化输出为该值指定的缩进等级，一般使用4
dumps() 方法
dumps() 方法用于将 Python 对象转换为 JSON 格式的字符串。语法格式如下：
def dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True,
allow_nan=True, cls=None, indent=None, separators=None,
default=None, sort_keys=False, **kw):
#dumps() 方法的参数与 dump() 方法的参数使用方法相同
参数说明：
(1) obj：表示 Python 对象。
(2) fp：表示一个支持 write() 方法的文件对象。
(3) *：星号本身不是参数。星号表示其后面的参数都是关键字参数，需要使用关键字参数传值，否则程序会出现错误。
(4) skipkeys：默认值为 False。如果值为True，则不是基本对象 (包括str、int、float、bool、None) 的字典的键会被跳过，否则引发一个 TypeError 错误信息。
(5) ensure_ascii：默认值为 True，会将所有输入的非 ASCII 字符转义输出，如果值为 False，会将输入的非 ASCII 字符原样输出。
(6) check_circular：表示检验循环引用，默认值为 True。如果值为 False，则容器类型的循环引用会被跳过并引发一个 OverflowError 错误。
(7) allow_nan：默认值为 True。如果值为 False，那么在对 JSON 规范以外的 float 类型值 (nan、inf 和 -inf) 进行序列化时将会引发一个 ValueError 错误；如果值为 True，则使用它们的 JavaScript 等价形式(NaN、Infinity 和 -Infinity )。
(8) cls：默认值为 None。通过该关键字参数可以指定自定义的 JSONEncoder 的子类。
(9) indent：默认值为 None。选择最紧凑的表达。如果 indent 是一个非负整数或者字符串，那么 JSON 数组元素和对象成员会被美化输出为该值指定的缩进等级。如果缩进等级为零、负数或者 “”，则只会添加换行符。当 indent 为一个正整数时会让每一层缩进同样数量的空格；如果 indent 是一个字符串如换行符、制表符 ( “\n”、 “\t”) 等，那么这个字符串会被用于每一层。
(10) separators：默认值为 None。该参数是一个元组，即：(’,’, ‘: ‘)，其中包含空白字符。如果想要得到最紧凑的 JSON 表达式，应指定该参数为：(’,’,’:’)，不要空白字符。
(11) default：默认值为 None。如果要指定该参数，则该参数应是一个函数。每当某个对象无法被序列化时，它就会被调用。它返回该对象的一个可以被 JSON 编码的版本或者引发一个 TypeError (传入参数的类型错误)。如果不指定该参数，则会直接引发 TypeError。
(12) sort_keys：默认值为 False。如果值为True，那么字典的输出会以键的顺序排序。
(13) **kw：其他关键字参数，用于字典。
(14) 返回值：返回 JSON 格式字符串。
load() 方法
load() 方法用于从 json 文件中读取数据。语法格式如下：
def load(fp, *, cls=None, object_hook=None, parse_float=None,
parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):
参数说明：
(1) fp：一个支持 read() 方法或包含一个 JSON 格式字符串的文本文件或二进制文件。
(2) *：星号本身不是参数。星号表示其后面的参数都是关键字参数，需要使用关键字参数传值，否则程序会出现错误。
(3) cls：可选参数，实例化的类。
(4) object_hook：可选参数，每一个解码出的对象 (即一个字典) 会取代原来的字典。
(5) parse_float：如果指定了该参数，将使用要解码的每个 JSON float 字符串调用。默认情况下为 float 字符串。此参数用于为 JSON 浮点数指定使用另一种数据类型或解析器 (例如 decimal.Decimal)。
(6) parse_int：如果指定该参数，将使用要解码的每个 JSON int 字符串调用。默认情况下为 int 字符串。此参数用于为 JSON 整数指定使用另一种数据类型或解析器 (例如 float)。
(7) parse_constant：如果指定该参数，将为下列字符串之一：
(8) object_pairs_hook：可选参数，将使用有序的对象列表对解码的任何对象的结果进行调用。用于实现自定义解码器。如果还定义了 object_hook，则 object_pairs_hook 优先。
(9) **kw：其他关键字参数，用于字典。
(10) 返回值：返回字典。
loads() 方法
loads() 方法用于将 JSON 格式字符串转换成 Python 字典对象。语法格式如下：
def loads(s, *, encoding=None, cls=None, object_hook=None, parse_float=None,
parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):
参数说明：
(1) s：包含 JSON 格式字符串，字节或字节数组的实例。
(2) *：星号本身不是参数。星号表示其后面的参数都是关键字参数，需要使用关键字参数传值，否则程序会出现错误。
(3) encoding：表示编码方式。
(4) cls：可选参数，实例化的类。
(5) object_hook：可选参数，每一个解码出的对象 (即一个字典) 会取代原来的字典。
(6) parse_float：如果指定了该参数，将使用要解码的每个 JSON float 字符串调用。默认情况下为 float 字符串。此参数用于为 JSON 浮点数指定使用另一种数据类型或解析器 (例如 decimal.Decimal)。
(7) parse_int：如果指定该参数，将使用要解码的每个 JSON int 字符串调用。默认情况下为 int 字符串。此参数用于为 JSON 整数指定使用另一种数据类型或解析器 (例如 float)。
(8) parse_constant：如果指定该参数，将为下列字符串之一
1742
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
