day21:包和异常处理
1，复习
# 序列化模块 # json # dumps # loads # dump 和文件有关 # load load不能load多次 # pickle # 方法和json的一样 # dump和load的时候 文件是rb或者wb打开的 # 支持Python所有的数据类型 # 序列化和反序列化需要相同的环境 # shelve # 操作方法和字典类似 # open方法 # open方法获取了一个文件句柄
2，json的格式化输出，这个感兴趣的话了解一下就好，直接copy老师的博客
Serialize obj to a JSON formatted str.(字符串表示的json对象) Skipkeys：默认值是False，如果dict的keys内的数据不是python的基本类型(str,unicode,int,long,float,bool,None)，设置为False时，就会报TypeError的错误。此时设置成True，则会跳过这类key ensure_ascii:，当它为True的时候，所有非ASCII码字符显示为\uXXXX序列，只需在dump时将ensure_ascii设置为False即可，此时存入json的中文即可正常显示。) If check_circular is false, then the circular reference check for container types will be skipped and a circular reference will result in an OverflowError (or worse). If allow_nan is false, then it will be a ValueError to serialize out of range float values (nan, inf, -inf) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (NaN, Infinity, -Infinity). indent：应该是一个非负的整型，如果是0就是顶格分行显示，如果为空就是一行最紧凑显示，否则会换行且按照indent的数值显示前面的空白分行显示，这样打印出来的json数据也叫pretty-printed json separators：分隔符，实际上是(item_separator, dict_separator)的一个元组，默认的就是(‘,’,’:’)；这表示dictionary内keys之间用“,”隔开，而KEY和value之间用“：”隔开。 default(obj) is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. sort_keys：将数据根据keys的值进行排序。 To use a custom JSONEncoder subclass (e.g. one that overrides the .default() method to serialize additional types), specify it with the cls kwarg; otherwise JSONEncoder is used.
import json data = {'username':['李华','二愣子'],'sex':'male','age':16} json_dic2 = json.dumps(data,sort_keys=True,indent=2,separators=(',',':'),ensure_ascii=False) print(json_dic2) # 平时查看可以这样看，会显得很清晰，但是写到文件里面是，最好还是紧凑着写，节省空间 输出结果： { "age":16, "sex":"male", "username":[ "李华", "二愣子" ] }
3，包，把解决一类问题的模块放在同一个文件夹里就是包，我们之前接触的那些模块re,sys,其实都是包，只不过我们是直接import进来，没有关注过内部的结构。
4，如何创建一个包？pycharm里面project--》new--》Python package，上面还有一个是directory，创建的时候二者的图标稍有不同，两个的区别是包里面每个文件夹都有一个__init__双下init方法。
5，Python2里面只有带上__init__.py这个文件才叫做包，但是Python3里面没有也可以，
# 代码创建包 import os os.makedirs('glance/api') os.makedirs('glance/cmd') os.makedirs('glance/db') l = [] # 这个列表是为了后面批量关闭 # 两个包下有同名模块也不会冲突，因为来自两个不同的命名空间 l.append(open('glance/__init__.py','w')) l.append(open('glance/api/__init__.py','w')) l.append(open('glance/api/policy.py','w')) l.append(open('glance/api/versions.py','w')) l.append(open('glance/cmd/__init__.py','w')) l.append(open('glance/cmd/manage.py','w')) l.append(open('glance/db/__init__.py','w')) l.append(open('glance/db/models.py','w')) map(lambda f:f.close(),l)
6，关于包的导入分为import和from...import...但是二者无论何时何位置，都必须遵循一个原则就是：凡是在导入时带点的，点的左边都必须是一个包，否则非法。可以带有一连串的点，但是必须遵循这个原则。
7，模块名区分大小写，foo.py和FOO.py是两个模块
8，可以用点来调用的有包，模块，函数和类
# 可以有很多的点，但是点的左边必须是一个包 # as 另外一个用起来很方便的地方 import glance.api.policy as policy policy.get()
9，包也可以用from...import...来进行导入,这样import的话，import后面是不允许有点的
from glance.api import policy policy.get()
from glance import api.policy # 这是错误的，pycharm也会给报错的，后面不允许出现点
10，
# 直接这样写，是找不到的 # import glance # 如果要这样写，还需要一些操作，除了找不到的问题，还需要解决一些其他问题，下文会细讲 from part.glance.api import policy # 这就可以了或者把glance文件夹的路径添加到path里面也可以的 from glance.api import policy 把glance路径加到path里面就可以这样写了 import sys policy.get() # ["/Users/guolixiao/PycharmProjects/lisa's_practise/boys/part", "/Users/guolixiao/PycharmProjects/lisa's_practise/boys", sys.path.append("/Users/guolixiao/PycharmProjects/lisa's_practise/boys/part/glance") # 这样添加完成之后，虽然上面还是飘红，但是其实已经生效了 print(sys.path)
11，python2里面如果没有双下__init__方法，那么根本没有办法来做这些导入操作的，Python3没有限制
import glance # 这样写只有glance 大文件下的__init__会执行，子文件夹下的不会执行 # 模块和包还是有一点不一样的，模块一导入相当于执行了这个py文件 # 那问题来了，你这样导入包得话，他会去执行啥呢？啥也没执行，只有空的__init__函数 # 导入包的话，默认会执行包里面的__init__文件，这个是一定的，所以我们可以在__init__文件里面加代码 # glance.api.policy.get() # AttributeError: module 'glance' has no attribute 'api'
12，其实也不是所有的内置模块，都可以直接用import 包名 这样的方式来导入，当然大部分是可以的，有一个例外就是urllib
import urllib urllib.urlopen() # 这样是找不到的 # 这可以用from的方式来导入,这其实也就是说，他其实也是一个包，但是他没有对这个包进行任何的处理 # 只有进行过特殊处理的，来可以像导入一个模块那样直接import 包名 from urllib import urlopen
13，照搬老师的博客
什么是模块？ # 常见的场景：一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀。 # 但其实import加载的模块分为四个通用类别： # # 1 使用python编写的代码（.py文件） # # 2 已被编译为共享库或DLL的C或C++扩展 # # 3 包好一组模块的包 # # 4 使用C编写并链接到python解释器的内置模块 # 为何要使用模块？ # 如果你退出python解释器然后重新进入，那么你之前定义的函数或者变量都将丢失，因此我们通常将程序写到文件中以便永久保存下来，需要时就通过python test.py方式去执行，此时test.py被称为脚本script。 # # 随着程序的发展，功能越来越多，为了方便管理，我们通常将程序分成一个个的文件，这样做程序的结构更清晰，方便管理。这时我们不仅仅可以把这些文件当做脚本去执行，还可以把他们当做模块来导入到其他的模块中，实现了功能的重复利用，
14，绝对路径情况，从外到内，这些都是操作怎么直接import 包名的，我们也希望直接导入包名会把里面所有的变量和函数加载到内存里，这样我调用的时候就能调用到了，相当于是一个连续出发的动作。
import glance 调用的文件 # 绝对路径的时候，要给全路径，不然找不到，外面执行就能找到
print(sys.path) # 写内层和外层都要以这里面有的路径为基准，他有的路径就是glance的上层和上上层，才可以找到
print("glance***************") from part.glance import api from part.glance import cmd from part.glance import db
print("glance-api******") # import policy # 这个只可以在当前文件执行的时候会找到，到外面就找不到了，其实是没有什么意义的，因为我们不会再包的内部做什么操作，都是在外面操作 # import versions from part.glance.api import policy # 我们需要import然后把变量和函数加载到内存，然后才可以使用 from part.glance.api import versions
15包的进阶，绝对路径有个问题，就是我的包一旦移动了路径，前面写的就都得修改，这不是我们想要的，所以我们引入了相对路径，绝对路径修改后的绝对路径
# 我在part目录下新建一个dir文件夹，然后把整个glance文件，拖进去，当然pycharm会自动给我们修改绝对路径 # 但是我们不想用绝对路径了，相对路径怎么解决呢 # import glance # 因为glance变成了当前执行文件的下一层，所以这样肯定是找不到了 from dir import glance # 绝对路径的时候，要给全路径，不然找不到，外面执行就能找到 glance.db.models.register_models('sql') glance.api.policy.get()
from dir.glance import db # glance 目录的init文件 from dir.glance import api from part.dir.glance import cmd
from dir.glance.api import versions from dir.glance.api import policy
16，相对路径写法,这种情况下改变包的路径也不用去管，这是相对路径的优点，只要相对位置不变就可以，可以随意移动包，只要能找到包的位置，就能找到包里面的模块，缺点是不能再包里面使用，但是绝对路径里面外面都可以使用的,绝对路径只要写全，path里面能找到的就可以内部外部都执行
import glance glance.db.models.register_models('sql') glance.api.policy.get()
from . import db from . import api from . import cmd
from . import versions from . import policy
17，相对路径得话，外面调用不会报错，里面调用就会报错，因为你用点的方式去找的话，只有在外面的角度才能找到的，这是机制决定的，点和点点都不行，只要有相对路径，内部就不可以
# 总结 # 使用绝对路径， # 不管在包内还是外部，导入了就能用 # 不能挪动，但是直观 # 使用相对路径 # 可以随意移动包，只要能找到包的位置，就可以使用包里面的模块 # 不能在包里直接使用模块了，包里的模块如果想使用其他模块的内容只能使用相对路径，使用了相对路径就不能再包内直接执行了
18，一般我们也不需要修改包内部的内容，包都是直接拿来用就行。一般你能做一个很厉害的包的时候，就用相对路径，其他时候，就用绝对路径就可以了
目前大部分还没有达到能制作包的程度，另外包和包之间不可以相互依赖，极少的情况下可以，这种情况下，两个包需要一起安装的。最好是独立包，自己做的包，可以引用Python本身的内置模块，一般不需要引用扩展模块或者自己写的其他模块
19，包里面的__all__,all方法是和星号来配合使用的,第三种可以直接调用包的方法,这个不用glance来调用的话，目前我没有尝试成功， 从glance开始调用是成功的。先记住相对和绝对路径的吧
import glance glance.db.models.register_models('sql') glance.api.policy.get() # policy.get() 这样一直不成功
from .api import * from .cmd import * from .db import *
__all__ = ['policy','versions']
20，软件开发代码规范,以后所有的非web项目作业，都要用下面的格式来写，六个目录，bin,conf,core,db,lib,log，web项目他还有一个其他的规范
21，bin 目录下就写一个开始文件start.py，程序入口，你写的程序，其实99.9%不是你维护的，这个程序可能就交给运维，如果做运维的话，接触的就不止是Python代码，还有可以有Java，PHP，C++，C语言，go语言，PHP，都需要接触，可能都不精，那我就我规定好，所有的语言写的，我都有一个叫bin的目录，这里面存的都是我的程序入口，这里面就一个文件，Python里面叫start.py,PHP里面叫做start.php,只要执行start.py整个程序就执行起来了，我也不知道中间是怎么走的，这就是我们需要要的效果，只要执行他，整个程序就跑起来。所以这个文件里面的逻辑，不宜复杂，应该是非常简短的。有可能只有一句if __name__ =='__main__': core.main,当然不包括import啥的。假如你写了20几个py文件，不指定入口文件的话，别人看起来是非常痛苦的。
import sys import os sys.path.append(os.path.dirname(os.getcwd())) # 拿到当前路径的上一层目录，并把它放入到path里面，这是一个定式，只要每次执行前都把它这句话拿过来执行一下就好 from core import core # 这句话只有在pycharm里面执行没有问题，因为他会自动把路径加入到sys.path # print(sys.path) 会自动添加当前路径和pycharm的项目路径,这个项目路径是只有在pycharm里面才会添加的 if __name__ =='__main__': core.main()
22，core目录下的core.py，这个文件里面存的是你写的代码，整个目录结构中，只有这一个是和代码相关的文件，假如我在这个文件写一个main方法，这个方法才是我们程序真正的入口，这里面可能有调用了其他的方法，
from core import login # 由于项目路径直接加到了path里面，所以直接从core文件夹来导入就可以了，login还是在和core同级的文件login.py里面 def main(): print('main') login.login()
23，conf文件夹，配置文件文件夹，配置文件是给运维人员看的，运维人员虽然不懂代码，但是他却可以给你去调一些参数，比方说，IP地址，端口号，用户名，密码，文件路径，等等，后期可能会有数据库的名称，mysql还是Oracle呢等等。还能去配置一些程序的功能，但是我可以通过去修改配置项去增加或者修改一个功能。
24，db文件夹，主要放一些数据；lib里面主要放一些自己写的模块和包，通用的一些模块，每次写都可以用的，单是没有自动安装在Python解释器里面，他是你自己写的一些通用模块。比方说，你把你的计算器写成一个通用模块；log文件夹是你执行程序的过程中，你希望记录的一些过程。把中间的一些结果记录下来，后面我们还会去学习一个专门记录LOG文件的一个模块，现在先了解就好。
25， 异常处理，重要，但是不难，异常主要有两大类，程序的逻辑错误，语法错误，我们在程序中就要尽量去规避掉，程序中的语法错误，逻辑错误很多，也是我们真正要处理的一部分，如下
# 1/0 # ZeroDivisionError: division by zero # name # NameError: name 'name' is not defined # 2+'3' # TypeError: unsupported operand type(s) for +: 'int' and 'str' # [][3] # IndexError: list index out of range # {}['k'] # KeyError: 'k' ret = int(input('number >>>')) # 加入输入'a' print(ret * '*') # ValueError: invalid literal for int() with base 10: 'a'
26，遇到错误，程序就停下来不执行了，这不是我们我需要的，我们希望程序可以忽略掉错误，继续往下执行，或者是说，发生错误后，我们可以针对错误去做一些处理，能不是直接抛出错误，结束运行。那么久可以用try...catch...来处理。把你想要处理的，捕捉错误的代码放入到try里面，如果有错误就会被except捕捉到。try里面的代码是一定会执行的，除非遇到错误，except里面的代码，没有错误不会去执行。捕捉except后面指定的错误类型。一般情况下我们会把你认为可能会有问题的，或者你预估到客户可能会输入错误的的，但是你却没有办法处理的，放入到try...catch...里面。
try: ret = int(input('number >>>')) # 加入输入'a' print(ret * '*') except ValueError: print("您输入的内容有误，请输入一个数字") 运行结果： number >>>aaa 您输入的内容有误，请输入一个数字
27，except 支持多分支
try: [][3] ret = int(input('number >>>')) # 加入输入'a' print(ret * '*') except ValueError: print("您输入的内容有误，请输入一个数字") except IndexError: print("index error,list index out of range")
28，有没有一个万能的可以捕获所有错误的类型呢？有，就是exception
try: [][3] ret = int(input('number >>>')) # 加入输入'a' print(ret * '*') except ValueError: print("您输入的内容有误，请输入一个数字") except IndexError: print("index error,list index out of range") except Exception: print("你错了，老铁")
29，总结
# 总结： # 程序一旦发生错误，就从错误大的位置停下来了，不再继续执行后面的内容 # 使用try和except就能处理异常 # try使我们需要处理的代码 # except后面跟一个错误类型，当代码发生错误且错误类型符合的时候，就会执行except中的代码 # except支持多分支 #有没有一个能处理所有错误的类型：exception # 有了万能的处理机制仍然需要把能预测到的问题单独处理 # 单独处理的所有内容都应该卸载万能异常之前
# else：没有异常的时候执行else中的代码
finally：不管代码是否异常，都会执行
30，try...except...else...
try: ret = int(input('number >>>')) # 加入输入'a' print(ret * '*') print("没有被错误中断得话，这里面的代码就会全部执行") except ValueError: print("您输入的内容有误，请输入一个数字")except Exception: print("except里面，捕捉到指定错误是会执行") else: print("没有捕捉到错误的时候，执行这一步") # 类似循环的else分支，没有被break打断就会去执行
31，except后面直接加冒号，指的是捕捉所有错误类型
32，finally分支，因为我们希望在最后有一段代码，不管是否有异常都希望去执行，比如下面的例子
def func(): try: f = open('file','w') # 这儿只是举个例子是操作文件，也有可能是操作数据库，和网络，而且并不是所有都有with语法 ''' 中间自己写的一些代码，可能会有错，也可能没错，但是不管有错没错，我打开的文件，都需要关闭的 ''' # f.close() 加在这儿的话，程序遇到错误，就没有办法关闭了，所以不可以 print("try") return # 加上这句即使return，finnally也会执行 except: # f.close() # 这儿也不合适，只有发生错误才会关，没错呢？ print("except") # else: # f.close() # 也不合适，发生错误关不了 finally: f.close() # 只有加在这儿是可以的 f.close() # 加在外面为什么不行呢？如果前面有return得话，这句话就不执行了，但是finally里面即使前面return了，还是会执行。 print(func())
33，finally和return相遇的时候还是会执行，一般用作函数里做异常处理时，不管是否异常，去做一些收尾工作。一般else里面都是结论，就是没有错误的话我就是做什么，或者去触发一个什么任务。
34，什么时候用异常处理？try...except...应该尽量少用，因为他本身就是附加给程序的一种异常处理的逻辑，与你的主要工作是没有关系的，加多了，会导致代码可读性变差，只有在有些程序无法预知时，才应该加上try...except...,其他的逻辑错误，应该尽量修正。在代码没有成型之前，不要加这些，尽量先修正自己能够杜绝的，无法杜绝的再用try...except...去处理。
35，except打印具体错误,
try: ''' 你的代码 ''' 1/0 except Exception as e: # 这个名字随便起，要有意义 print('你错了',e) # 你错了 division by zero
36，三级菜单
menu = { '北京':{ '海淀':{ '五道口':{ 'soho':{}, '网易':{}, 'google':{} }, '中关村':{ '爱奇艺':{}, '汽车之家':{}, 'youku':{}, }, '上地':{ '百度':{}, } }, '昌平':{ '沙河':{ '老男孩':{}, '北航':{} }, '天通源':{}, '回龙观':{} }, '朝阳':{}, '东城':{} }, '上海':{ '闵行':{}, '闸北':{}, '浦东':{} }, '山东':{}, } # 此处的b 是比较难理解的地方，利用循环，实现返回上一层 # 此处的q 需要给每一层都要返回一个q 知道最上一层 # 最后层为空是，继续打印这一层的key，除非输入q或者是b # 递归实现 def threeLM(dic): while True: for k in dic:print(k) key = input('input>>').strip() # 北京 if key == 'b' or key == 'q' :return key elif key in dic.keys() and dic[key]: ret = threeLM(dic[key]) if ret == 'q':return 'q' # 加上这就会就会一直return到最后，不加这句话其实只是return了一层而已 print(ret) # elif (not dic.get(key)) or (not dic[key]): # continue # 最后两行不写也是continue的效果 # 列表实现，我觉得列表更好理解，堆栈的 l =[menu] while l: for key in l[-1]:print(key) k = input('input>>').strip() if k in l[-1].keys() and l[-1][k]: l.append(l[-1][k]) # 每次把用户输入key对应的小字典，放入列表的最后一个 if k == 'b': l.pop() if k == 'q': break else:continue threeLM(menu)
37，大作业 select name age where age > 12
column_dic = {'id':0,'name':1,'age':2,'phone':3,'job':4}
# 去文件里面拿符合age > 22这个条件的行
def filter_hander(operate,con):
selected_lst = []
col,val = con.split(operate)
col = col.strip()
val = val.strip()
# 文件中取到的值，和22来比较，所以要用整形
# 如果是like的话 ==，这个比较字符串就可以了，不用强转，我不在意你是否是int
judge = 'int(line_lst[column_dic[col]]) %s int(val)' %operate if operate=='<' or operate=='>' else \
'line_lst[column_dic[col]] %s val'%operate
f = open('users',encoding='utf-8')
for line in f:
line_lst = line.strip().split(',')
if eval(judge):
selected_lst.append(line_lst)
f.close()
return selected_lst
# 去文件里面拿符合age > 22这个条件的行
def get_selected_line(con):
if '>' in con:
selected_lst = filter_hander('>',con)
elif '<' in con:
selected_lst = filter_hander('<', con)
elif '=' in con:
selected_lst = filter_hander('==',con.replace('=','==')) # =换成==
elif 'like' in con:
selected_lst = filter_hander('in',con) # like转换成in
return selected_lst
# 这个函数的提高再用应用了列表生成时
# 这个函数拿到了你想显示的参数，name 和 age 返回值是一个列表
# 这个处理的是你像要哪些参数
def get_show_list(col_condition):
col_info_lst = col_condition.strip().split('select')
col_info_lst = [col_info_item for col_info_item in col_info_lst if col_info_lst.strip()]
if col_info_lst:
col_info = col_info_lst[0].strip()
if '*' == col_info:
return column_dic.keys()
elif col_info:
ret = col_info.strip(',')
return [item.strip() for item in ret]
else:print(col_info) # 空的时候
# 返回符合条件行的指定参数
def show(selected_lst,show_lst):
for selected_item in selected_lst:
for col in show_lst:
print(selected_item[column_dic[col]],end = '')
print('') # 打印一个空
# condition = input('>>>')
condition = 'select name age where age > 22'
ret = condition.split('where')
con = ret[1].strip()
print(con) # age > 22
show_lst = get_show_list(ret[0])
selected_lst = get_selected_line(con)
show(selected_lst,show_lst)
