Python基础4（模块异常）

阅读量：431 次

发布时间：2019-03-06

本文共 18772 字，大约阅读时间需要 62 分钟。

自定义模块

import

导入

import test       # test是模块名test.func() # func() 是test模块中的函数调用

模块分类

1.内置模块

标准库,python解释器自带的.py文件(模块)

2.第三方模块

各种大神写的,需要额外下载的(并发编程开始讲解)(pypi)

3.自定义模块

自己写的,不需要额外下载

导入的过程

1.当前的名称空间中开辟一个新的空间(test)

2.将模块中所有的代码执行

3.通过模块名,进行查找函数(工具)

示例

test模块def func():    print("这是test文件下的func函数")def foo():    print("这是test文件下的foo函数")print(123)print(456)name = "这是名字"import testprint(test.name) print(test.func()) # 123# 456# 这是名字# 这是test文件下的func函数import testimport testimport testimport testimport testimport testprint(test.name)# 123# 456# 这是名字

别名的使用

import test as tprint(t.name)# 123# 456# 这是名字

兼容性

test模块def func():    print("扳手")    meet模块def func():    print("螺丝刀")msg = """1.扳手2.螺丝刀"""choose = input(msg)if choose == "1": import test as telif choose == "2": import meet as tt.func()

import 和 from的区别

import test # 把工具箱拿过来from test import func   # 把工具拿过来

import的优缺点

优点: 不会和当前文件定义的变量或者函数发生冲突

test模块name = "alex"import testname = "宝元"print(test.name)print(name)# alex# 宝元

缺点: 占用内存比较大

from的优缺点

优点: 占用内存比较小

缺点: 会和当前文件定义的变量或者函数发生冲突

test模块name = "alex"name = "宝元"from test import nameprint(name)# alex 下面的变量或者函数会覆盖上面的

解决办法

test模块name = "alex"name = "宝元"from test import name as nprint(name)pirnt(n)# 宝元# alex

from 模块名 import *

test模块name = "alex"def func():    print("这是test下的func函数")name = "宝元"def func():    print("123")from test import *print(name)func()# alex# 这是test下的func函数# 注意会出现覆盖现象 __all__ = ["要被导入的功能名字"]

内存地址

test模块name = "alex"def func():    print("这是test下的func函数")def foo():    print("这是test下的foo函数")from test import fooprint(foo)import testprint(test.foo)

模块的用法

1.脚本(在cmd中执行 python test.py)

2.模块(不使用或者导入)

测试接口

if __name__ == "__main__"在当前模块中使用__name__就是"__main__"当模块被导入的时候__name__就是被导入的模块名

路径

导入路径

import meetprint(meet.name)

使用相对路径

from day15.t1 import meetprint(meet.name)

使用绝对路径

from sys import pathpath.insert(0,"D:\\")import meetprint(meet.name)

模块的查找顺序

自定义模块 > 内置模块 > 第三方

time模块

time -- 时间(内置模块)

time的方法

import time时间戳print(time.time())# 时间戳 浮点数 可计算print(time.time() + 5000)睡眠time.sleep(3)# 睡眠 以秒为单位时间节点print(time.strftime("%Y-%m-%d %H:%M:%S"))# 年-月-日 时:分:秒# 2019-07-25 16:43:24结构化时间时间戳转结构化print(time.gmtime()) / print(time.localtime())# time.struct_time(tm_year=2019, tm_mon=7, tm_mday=25, tm_hour=8,# tm_min=46, tm_sec=15, tm_wday=3, tm_yday=206, tm_isdst=0)print(time.gmtime()[0]) / print(time.localtime()[0])# 2019print(time.gmtime().tm_year) / print(time.localtime().tm_year)# 2019字符串时间转结构化print(time.strptime("2008-9-1 12:30:30","%Y-%m-%d %H:%M:%S"))时间戳转换成字符串print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime(156156641.46854)))# 1974-12-13 08:50:41字符串转结构化转换成时间戳print(time.mktime(time.strptime("2008-9-1 12:30:30","%Y-%m-%d %H:%M:%S")))# 1220243430.0

datetime

datetime -- 对象

datetime的方法

from datetime import datetime获取当前时间(浮点数)print(datetime.now())# 2019-07-25 17:24:58.037219计算时间差距print(datetime(2019,5,20,13,14,00) - datetime(2019,5,20,14,20,00))# -1 day, 22:54:00将当前时间转化成时间戳print(datetime.now().timestamp())# 1564047101.042584将时间戳转化成当前时间print(datetime.fromtimestamp(1564047101.042584))# 2019-07-25 17:31:41.042584将对象转成字符串print(str(datetime.now()))print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))# 2019-07-25 17:40:47时间加减(datetime加减)from datetime import datetime,timedeltaprint(datetime.now() + timedelta(hours=30)) # 当前时间加30个小时# 2019-07-27 00:19:38.461757总结: 用处: 记录日志时使用 计算时间

random模块

random -- 随机

random的方法

import random0-1随机取值(浮点数)print(random.random())# 0.042331418394662590-10随机取值(浮点数)print(random.uniform(1,10))# 1.04345035389078381-3随机取值(包含1和3)print(random.randint(1,3))# 1/2/3randrange(起始,终止,步长)(顾头不顾尾)print(random.randrange(1,5,2))# 1/3 随机选择一个元素print(random.choice([1,2,3,4,5]))# 1/2/3/4/5随机选择两个元素(会重复)print(random.choices([1,2,3,4,5],k=2))# 从列表中随机选择两个元素(会有重复元素,比如:[1,1])随机选择两个元素(不会重复)print(random.sample([1,2,3,4,5],k=2))# 从列表中随机选择两个元素(不会有重复元素,除非列表只有两个重复元素,比如[1,1])顺序打乱lst = [1,2,3,4,5,6,7,8,9,0]random.shuffle(lst)print(lst)# [4, 3, 9, 5, 1, 2, 8, 7, 6, 0]# 随机打乱

序列化

json

1.dumps loads

import jsondumps 将对象转换成字符串(序列化)lst = [1,2,3,4,5]print(repr(json.dumps(lst)))# "[1,2,3,4,5]"loads 将字符串转换成对象(反序列化)str_lst = '[1, 2, 3, 4, 5]'lst = json.loads(str_lst)print(repr(lst))# [1,2,3,4,5]特例:dic = {"k1":"名字"}str_dic = json.dumps(dic)print(str_dic)# {"k1": "\u540d\u5b57"}解决方法:dic = {"k1":"名字"}str_dic = json.dumps(dic,ensure_ascii=False)print(str_dic)# {"k1": "名字"}# ensure_ascii=False 关闭ascii码

2.dump load

dump 将对象转换成字符串写入文件当中(序列化)import jsonlst = [1,2,3,4,5,6]with open("info","w",encoding="utf-8")as f:    json.dump(lst,f)# info文件中写入一行[1,2,3,4,5,6]load 将文件中的字符串转换成对象(反序列化)import jsonlst = [1,2,3,4,5,6]with open("info","r",encoding="utf-8")as f: lst1 = json.load(f) print(lst1)# [1,2,3,4,5,6]

同时读取多个内容进行反序列

with open("info","r",encoding="utf-8")for i in f:    l = json.loads(i)    print(l)

pickle

序列化(可对python所有对象进行转换)

python自带的(只有python可以用)

1.dumps loads

对象转换成类似字节import picklelst = [1,2,3,4,5]b_lst = pickle.dumps(lst)print(b_lst)# b'\x80\x03]q\x00(K\x01K\x02K\x03K\x04K\x05e.'类似字节转换成对象import picklelst = [1,2,3,4,5]b_lst = pickle.dumps(lst)t_lst = pickle.loads(b_lst)print(t_lst)# [1,2,3,4,5]

2.dump load

将对象转换成乱码写入对象import pickle dic = {"user":"baoyuan"}pickle.dump(dic,open("info","wb"))# �}q X   userqX   baoyuanqs.将乱码转换成对象输出import pickle dic = {"user":"baoyuan"}pickle.dump(dic,open("info","wb"))print(pickle.load(open("info","rb")))# {'user': 'baoyuan'}

对象转换成乱码多行写入

import pickledic = {"1":2}with open("info","wb")as f:    s = "\n".encode("utf-8")    f.write(pickle.dumps(dic) + s)    f.write(pickle.dumps(dic) + s) f.write(pickle.dumps(dic) + s)

乱码转换对象全部读取

import pickledic = {"1":2}with open("info","wb")as f:    s = "\n".encode("utf-8")    f.write(pickle.dumps(dic) + s)    f.write(pickle.dumps(dic) + s) f.write(pickle.dumps(dic) + s)f1 = open("info","rb")for i in f1: print(pickle.loads(i))

总结:

1.推荐使用json

2.json是各种语言通用的

3.pickle是python私有的

os模块

os模块 -- 程序员通过python向操作系统发送指令(与操作系统交互的接口)

1.工作目录

当前工作路径 ***print(os.getcwd())路径切换    **os.chdir(r"D:\pycharm demo\123")当前目录print(os.curdir)父级目录print(os.pardir)

2.文件夹

import os   创建一个文件夹    ***os.mkdir("ttt")删除一个文件夹    ***os.rmdir("ttt")递归创建文件夹    ***os.makedirs("ttt/sss/ddd/ee")递归删除文件夹 ***os.removedirs("ttt/sss/ddd/ee")获取当前文件夹下所有文件名 ***print(os.listdir())

3.文件

import os修改名字     ***os.rename("123","info")删除文件     ***os.remove("info")

4.路径

import os通过相对路径获取绝对路径   ***print(os.path.abspath("info"))将路径以最后一个"\"切割(路径,文件名)print(os.path.split(os.path.abspath("info")))获取路径        ***print(os.path.dirname("D:\pycharm demo\info"))                      获取文件名       **print(os.path.basename("D:\pycharm demo\info"))判断路径是否存在    ***print(os.path.exists("D:\pycharm demo\info"))判断是不是路径 ***print(os.path.isdir(r"D:\pycharm demo"))判断是不是文件名 ***print(os.path.isfile("info"))判断是不是绝对路径 ***print(os.path.isabs("D:\pycharm demo\info"))路径拼接 *****print(os.path.join("D:\\","pycharm demo","info"))文件最后修改的时间(返回时间戳)print(os.path.getatime("D:\pycharm demo\info"))文件最后的访问时间(返回时间戳)print(os.path.getctime("D:\pycharm demo\info"))print(os.path.getmtime("D:\pycharm demo\info"))获取当前文件的大小(返回字节b) ***print(os.path.getsize("D:\pycharm demo\代码练习.py"))

sys模块

sys -- 与python解释器交互的接口

import sys脚本本身,当前文件运行(返回一个绝对路径)   ***print(sys.argv)退出程序，正常退出时exit(0),错误退出sys.exit(1)print(sys.exit(n))获取解释器版本print(sys.version)添加自定义模块查找路径print(sys.path)区分操作系统然后进行相关逻辑操作print(sys.platform)

加密

hashlib 加密和校验

加密

alex:alex123加密后:alex:23lw23jky321jh4gqyt1234gj8b7t{"1234":23lw23jky321jh4gqyt1234gj8b7t}

常用的加密

md5,sha1,sha256,sha512

1.只要明文相同密文就是相同的

2.只要明文不相同密文就是不相同的

3.不能反逆(不能解密) -- md5中国人破解了

加密过程:

1.加密的内容

2.将要加密的内容转成字节

示例:

md5示例:import hashlibmd5 = hashlib.md5()md5.update("alex123".encode("utf-8"))print(md5.hexdigest())sha1示例:import hashlibsha1 = hashlib.sha1()sha1.update("alex123".encode("utf-8"))print(sha1.hexdigest())最常用的是md5但是被中国人破解平时加密的时候使用sha1

加盐(二次加密)

加固定盐

import hashlibmd5 = hashlib.md5("alex".encode("utf-8"))md5.update("wusir".encode("utf-8"))print(md5.hexdigest())

动态加盐

user = input("user")pwd = input("pwd")import hashlibmd5 = hashlib.md5(user.encode("utf-8"))md5.update(pwd.encode("utf-8"))print(md5.hexdigest())

tips

import hashlibss = "baoyuanwusirtaibai"s = "baoyuan"s1 = "wusir"s2 = "taibai"md5 = hashlib.md5()md5.update(ss.encode("utf-8"))print(md5.hexdigest())import hashlibss = "baoyuanwusirtaibai"s = "baoyuan"s1 = "wusir"s2 = "taibai"md5 = hashlib.md5()md5.update(s.encode("utf-8"))md5.update(s1.encode("utf-8"))md5.update(s2.encode("utf-8"))print(md5.hexdigest())# 拼接加密 和 分解加密 的加密结果一样

collections模块

1.namedtuple

# 生成可以使用名字来访问元素内容的tuplefrom collections import namedtuplepoint = namedtuple("tu",["a","b","c"])     # 第一个参数是元组的名字,第二参数是元组中元素的[名字,名字]p = point({"key":(1,2,3,4)},20,10)print(p)# tu(a={'key': (1, 2, 3, 4)}, b=20, c=10)

2.deque

# 双端队列,可以快速的从另外一端追加和推出对象from collections import dequelst = deque([1,2,3,4,5,6])lst.append(8)lst.appendleft(0)print(lst)# deque([0,1,2,3,4,5,6,8])lst = deque([1,2,3,4,5,6])lst.pop()lst.popleft()print(lst)# deque([2,3,4,5])# 队列:先进先出# 栈:先进后出 -- 栈顶

3.counter

c = Counter('abcdeabcdabcaba')print(c)# Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})

4.orderedDict

有序字典,python3.6以上默认有序

5.defaultdict

from collections import defaultdictdic = defaultdict(list)dic["k1"].append(12)print(dic)# defaultdict(
        
         , {'k1': [12]})

re(正则)模块

re.findall

import res = "meet_宝元_meet"print(re.findall("meet",s))# ['meet', 'meet']# 从字符串中全部查找内容,返回一个列表s = "meet_宝元_meet123"print(re.findall("\w",s))# ['m', 'e', 'e', 't', '_', '宝', '元', '_', 'm', 'e', 'e', 't', '1', '2', '3']# 查找数字,字母(中文),下划线s = "meet_宝元_meet123!@#"print(re.findall("\W",s))# ['!', '@', '#']# 查找非数字,字母(中文),下划线s = "meet_ 宝元_ me et\t \n"print(re.findall("\s",s))# [' ', ' ', ' ', ' ', ' ', ' ', '\t', ' ', '\n']# 查找任意空格,换行符,制表符s = "meet_ 宝元_ me et\t \n"print(re.findall("\S",s))# ['m', 'e', 'e', 't', '_', '宝', '元', '_', 'm', 'e', 'e', 't']# 查找非任意空格,换行符,制表符s = "meet_ 宝元_123me et\t \n"print(re.findall("\d",s))# ['1', '2', '3']# 查找数字s = "meet_ 宝元_123me et\t \n"print(re.findall("\D",s))# ['m', 'e', 'e', 't', '_', ' ', '宝', '元', '_', 'm', 'e', ' ', ' ', 'e', 't', '\t', ' ', '\n']# 查找非数字s = "meet宝元_123meet\t \n"print(re.findall("\Ameet",s))# ['meet']# 查找是否以什么开头s = "meet宝元_123meet"print(re.findall("meet\Z",s))# ['meet']# 查找是否以什么结尾s = "meet宝元_123meet \n \t \n"print(re.findall("\n",s))# ['\n', '\n']# 查找换行符s = "meet宝元_123meet \n \t \n"print(re.findall("\t",s))# ['\t']# 查找制表符s = "mtet宝元_123maet \n \t"print(re.findall("m.e",s))# ['mte', 'mae']# .只能匹配任意一个内容(非换行符)s = "m\net宝元_123maet \n \t "print(re.findall("m.e",s,re.DOTALL))# ['m\ne', 'mae']# .只能匹配任意一个内容s = "meet宝元_1A-23maet"print(re.findall("[a-z]",s))# ['m', 'e', 'e', 't', 'm', 'a', 'e', 't']# 小写的a到zprint(re.findall("[A-Z]",s))# ['A']# 大写的A到Zprint(re.findall("[A-Za-z]",s))# ['m', 'e', 'e', 't', 'A', 'm', 'a', 'e', 't']# 大写和小写的A到Z,a到zprint(re.findall("[a-z0-9]",s))# ['m', 'e', 'e', 't', '1', '2', '3', 'm', 'a', 'e', 't']# 小写的a到z和数字0到9s = "meet宝元_1A-23maet"print(re.findall("[^0-9]",s))# ['m', 'e', 'e', 't', '宝', '元', '_', 'A', '-', 'm', 'a', 'e', 't']# [^0-9] 查找非0-9的内容s = "mmmmmm"print(re.findall("m*",s))# ['mmmmmm', '']# 匹配 * 前元素0个或多个 [贪婪匹配] s = "meet_asdf_meees_mmns_aaam_meeeee"print(re.findall("me+",s))# ['mee', 'meee', 'meeeee']# 匹配 + 前元素一个或多个 s = "meet_asdf_m"print(re.findall("m?",s))# ['m', '', '', '', '', '', '', '', '', '', 'm', '']# 匹配 ? 前元素0个或一个[非贪婪匹配]s = "meet_asdf_msss_mmns_aaam"print(re.findall("s{3}",s))# ['sss']# 匹配 s{3} s重复3次 == sss s = "meet_assdf_msss_mmns_aaam"print(re.findall("s{1,3}",s))# ['ss', 'sss', 's']# 指定元素最少重复多少次,最多重复多少次s = "meet_assdf_msss_mmns_aaam"print(re.findall("m|s",s))# ['m', 's', 's', 'm', 's', 's', 's', 'm', 'm', 's', 'm']# m|s,m或者s s = "meet_meet_assdf_mssst_(.)mmns_aaamt"print(re.findall("m(.+)t",s))# ['eet_meet_assdf_mssst_(.)mmns_aaam']# m()t,取m与t中间的所有元素 [贪婪匹配]s = "meet_assdf_mssst_(.)mmns_aaamaaat"print(re.findall("m(?:..?)t",s))# ["meet"]# ?: 会匹配到括号两边的元素

扩展练习:

扩展练习:import res = "alex_sb ale123_sb wu12sir_sb wusir_sb ritian_sb 的 alex wusir "print(re.findall("\w+_sb",s))print(re.findall("[a-z]+_sb",s))# ['alex_sb', 'ale123_sb', 'wu12sir_sb', 'wusir_sb', 'ritian_sb']# ['alex_sb', 'sir_sb', 'wusir_sb', 'ritian_sb']print(re.findall("常(.*)娃","常鑫垃圾_井盖_烧饼吃娃娃_自行车_葫芦爷爷救娃娃"))print(re.findall("常(.*?)娃","常鑫垃圾_井盖_烧饼吃娃娃_自行车_葫芦爷爷救娃娃"))# ['鑫垃圾_井盖_烧饼吃']# ['鑫垃圾_井盖_烧饼吃娃娃_自行车_葫芦爷爷救娃']

re.search

import res = "_sb alex 123_sb wu12sir_sb wusir_sb ritian_sb 的 x wusir "print(re.search("ale",s).group())# "ale"# 找到一个元素后就停止查找,从字符串中进行查找,找到后返回的是一个元素,查看元素加.group()# 如果字符串中没有该元素,报错

re.match

import res = 'alex_sb alex 123_sb wu12sir_sb wusir_sb ritian_sb 的 x wusir 'print(re.match("ale",s).group())# "ale"# match 找到1个后就停止查找了,只从字符串的开头查找.找到后返回的是一个对象,查看元素.group()# 如果字符串开头没有则报错

re.split

import res = "_sb alex,123:sb;wu12sir#sb*wusir!sb ritian_sb 的 x wusir "print(re.split("[#,:!*]",s))# ['_sb alex', '123', 'sb;wu12sir', 'sb', 'wusir', 'sb ritian_sb 的 x wusir ']# 分割

re.sub

import reprint(re.sub("barry","太亮","barry是最好的讲师,barry就是一个普通老师,请不要将barry当男神对待"))# 太亮是最好的讲师,太亮就是一个普通老师,请不要将太亮当男神对待# 替换

compile

obj = re.compile("\w")print(obj.findall("meet_宝元_常鑫垃圾"))# ['m', 'e', 'e', 't', '_', '宝', '元', '_', '常', '鑫', '垃', '圾']# 自定义匹配规则

finditer

g = re.finditer("\w","常鑫垃圾")for i in g:    print(i.group())# 常 鑫 垃 圾# 返回的是一个迭代器的地址,查看元素加 .group()

给分组起名字

import reret = re.search("<(?P
          
           \w+)>\w+
           ","
           hello
")print(ret.group("tag_name"))print(ret.group())# h1# 
           hello
import reret = re.search(r"<(\w+)>\w+
           ","
           hello
")print(ret.group(1))print(ret.group())# h1# 
           hello
import reret = re.search("(?P
           
            \w+)dfa","asbsadfasdfa")print(ret.group())print(ret.group("aaa"))# asbsadfasdfa# asbsadfas

包

包是什么

文件夹下具有__init__.py文件的就是包

import 包.包.包或者from 包.包.包 import 模块

路径

绝对路径:从最外层的包开始导入

相对路径:从当前(.)开始导入或者从父级(..)开始导入

使用相对路径的时候必须在包的外层且同级

from 包 import *

需要在__init__.py文件中操作

python2: import 文件夹(没有__init__.py)报错python3: import 文件夹(没有__init__.py)不报错

logging

logging -- 日志

记住怎么使用就好

#     自己定义日志开始

import logging

logger = logging.getLogger()

# 创建一个logger

fh = logging.FileHandler('test.log',mode="a",encoding='utf-8') # 文件

ch = logging.StreamHandler() # 屏幕

formatter = logging.Formatter('%(asctime)s - %(name)s - %(filename)s - [line:%(lineno)d] - %(levelname)s - %(message)s')

# 将屏幕和文件都是用以上格式

logger.setLevel(logging.DEBUG)

# 设置记录级别

fh.setFormatter(formatter)

# 使用自定义的格式化内容

ch.setFormatter(formatter)

logger.addHandler(fh) #logger对象可以添加多个fh和ch对象

logger.addHandler(ch)

自己定义日志结束

logger.debug('logger debug message')

logger.info('logger info message')

logger.warning('logger warning message')

logger.error('logger error message')

logger.critical('logger critical message')

logging旗舰版使用

import logging.config# 定义三种日志输出格式 开始standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d][%(levelname)s][%(message)s]' #其中name为getlogger指定的名字simple_format = '在 %(asctime)s %(message)s'id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'# log文件的全路径logfile_path = 'all2.log'# log配置字典LOGGING_DIC = {    'version': 1, 'disable_existing_loggers': False, 'formatters': { 'standard': { 'format': standard_format }, 'simple': { 'format': simple_format }, }, 'filters': {}, 'handlers': { #打印到终端的日志 'stream': { 'level': 'DEBUG', 'class': 'logging.StreamHandler', # 打印到屏幕 'formatter': 'simple' }, #打印到文件的日志,收集info及以上的日志 'file': { 'level': 'DEBUG', 'class': 'logging.handlers.RotatingFileHandler', # 保存到文件 'formatter': 'standard', 'filename': None, # 日志文件 'maxBytes': 1024*1024*1024, # 日志大小 5M 'backupCount': 5, 'encoding': 'utf-8', # 日志文件的编码，再也不用担心中文log乱码了 }, }, 'loggers': { #logging.getLogger(__name__)拿到的logger配置 '': { 'handlers': ['stream', 'file'], # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕 'level': 'DEBUG', 'propagate': True, # 向上（更高level的logger）传递 }, },}def get_logger(): path = r'F:\s24\day21\liye.log' LOGGING_DIC['handlers']['file']['filename'] = path logging.config.dictConfig(LOGGING_DIC) # 导入上面定义的logging配置 logger = logging.getLogger(__name__) # 生成一个log实例 return loggerdef save(): logger = get_logger() logger.info(f'{} 存入300元') # 记录该文件的运行状态save()

异常处理

错误分类

语法错误

if 2 > 1    print(222)# 未加冒号dic = {"name"; "alex"}# 字典中用冒号分隔键和值tu = (2,3,4!5)# 元组中用逗号相隔

逻辑错误

num = int(input("请输入数字"))# 输入数字以外的内容,无法整型化,报错dic = {"name": "海狗", "age": 18}dic["hobby"]# dic字典中没有["hobby"], 找不到报错

try except

try:    num = int(input('>>>'))    print(111)except ValueError:    print(666)# input输入字符串类型的数字时, 输出111# input输入字符串类型的非数字时, 输出666try: dic = {'name': '嘉欣'} print(dic['age']) # 出现KeyError时 直接跳转except num = int(input('>>>')) print(111)except KeyError: print(555)

结构分类

结构1 单分支

try:    num = int(input(">>>"))        # 出现ValueError错误时, 直接跳转except    dic = {"name": "嘉欣"}    print(dic["age"])    print(111)except ValueError:    print(666)

结构2 多分支

try:    num = int(input(">>>"))    dic = {"name": "嘉欣"}    print(dic['age'])    l1 = [1,2]    print(l1[100]) print(111)except ValueError: print("输入的有非数字元素")except KeyError: print("没有此键")except IndexError: print("没有此下标")print(666)

结构3 万能异常处理处理所有python可以识别的异常

try:    dic = {"name": "嘉欣"}    print(dic["age"])    l1 = [1,2]    print(l1[100])    print(111) for i in 123: passexcept Exception: print(666)# 有异常直接跳转except try: dic = {"name": "嘉欣"} # print(dic["age"]) l1 = [1,2] # print(l1[100]) print(111) for i in 123: passexcept Exception as e: print(e)# 捕捉异常并打印出异常原因

tips

什么时候用万能? 什么时候用多分支?

如果你对错误信息不关心, 只是想排除信息继续让程序走下去, 用万能异常.

你对错误信息要进行明确的分流, 让你的程序多元化开发.

例如:

def func():    passdef func1():    passdic = {1: func,       2: func1}try: num = int(input("请输入序号")) dic[num]()except ValueError: print("请输入数字")except KeyError: print("请输入范围内数字")

结构4 多分支 + 万能异常处理

def func():    passdef func1():    passdic = {1: func,       2: func1}try: num = int(input("请输入序号")) dic[num]()except ValueError: print("请输入数字")except KeyError: print("请输入范围内数字")except Exception: print("程序出现了意料之外的错误...")

结构5 try else finally

try:    dic = {"name": "嘉欣"}    print(dic["age"])    l1 = [1, 2]    print(l1[100])    print(111)except KeyError: print("没有此键")except IndexError: print("没有此下标")else: print("如果没有出现异常则执行这里")finally: print("finally 666") # except 必须依赖于try, else必须依赖于except和try# finally只是依赖于try# finally : 在异常出现之前, 执行finallytry: dic = {"name": "嘉欣"} print(dic["age"]) l1 = [1,2] print(l1[100])except KeyError: print("没有此键")except IndexError: print("没有此下标")except Exception: passprint(111)finally: print("finally 666")# finally 关闭数据库连接, 文件句柄关闭,数据保存等时,用到finally# 在return 结束函数之前, 执行finally代码def func(): try: print(111) return 666 finally: print(222)print(func())"""111222666"""

结构6 主动触发异常

raise ValueError("出现了value错误")

结构7 断言:展现出一种强硬的态度.

assert 条件name = "alex"n1 = input("请输入:")assert name == n1print(111)print(222)

结构8 自定义异常

# python 中给你提供的错误类型很多,但是不是全部的错误class LiYeError(BaseException):    def __init__(self, msg):        self.msg = msg    def __str__(self):        return self.msg    try: # 报错代码(万能异常处理无法识别) raise LiYeError("socket.connent...")except LiYeError as e: print(e)