eight day1----模块和包，异常处理

复习

 1 基础数据类型
 2     int float。。。
 3     list
 4     dict set  字典通过key取值
 5 for循环 while循环  条件语句
 6 。。
 7 文件操作：
 8     with打开两个文件，会报错；；最靠谱的close、open
 9     打开模式 ：记住 a w r ab wb rb即可
10         a w r  --直接对字符串操作
11          ab wb rb---直接对字节操作
12      操作系统的编码和python编码不一致的乱码问题
13  函数：
14     函数基础：
15     定义时：
16     调用：
17     函数的命名空间：
18         在函数的内部可以使用外部的变量 可以直接读  写改：global改全局 ，nonlocal改局部
19         在外部不能使用函数内部的变量
20     闭包--装饰器
21         是在函数的前后添加功能----以后直接引用写好的装饰器
22     生成器函数----迭代器--生成器表达式--列表推导式
23         yield写代码时可以尽量使用，很好的节省内存
24         生成器表达式和列表推导式能够很好的简化代码
25         迭代器  生成器函数（特点：调用不执行）--面试之前看即可
26     递归函数
27         大部分的递归都可以用循环实现
28         递归相比于循环来说，并不能节省内存，还占用更多的空间---会发视频
29         算法用到的特别多
30 模块
31     内置模块  10个
32         collections   namedtuple 有序字典--必须掌握   /默认字典
33         os    记住文件和文件夹的操作，和路径相关的（计算大小、是否是文件、文件夹）；执行操作系统命令
34         sys    sys.path   sys.argv
35         time    三种时间格式：字符串（格式化）--元祖（结构化）--浮点（时间戳）
36         random  随机的整数小数  抽取 打乱顺序
37         re   正则：大部分的正则表达式都能搜到（除了python）  findall search /match
38         序列化   pickle json ---四个方法必须记住  shelve
39         hashlib  摘要算法的模块  文件的一致性校验  加密认证
40         logging     加日志的模块copy模板即可
41         configpaser    配置文件相关的，不用记
42
43     扩展模块
44     自定义模块
45         模块和包
46 面向对象
47     基础的定义 ：类 对象 实例化
48     class 定义 语法
49     三大特性：继承**** 封装*** 多态*
50         继承的规则。。。 必须记
51             多继承的查找顺序问题：。。
52             super不是单纯的寻找父类，而是遵循mro（g广度优先）顺序
53         封装：__名字   私有的属性既不能被继承，也不能从类的外部调用
54         多态 python自带
55     组合。。
56     反射：hasattr getattr 用字符串的形式来获取变量
57     内置方法：__new__类的构造方法，在init执行执行   单例模式

 1 # 基础数据类型
 2     # int float      加减乘除 乘方取余 小数的保留几位小数 round
 3     # 可以存放任意的数据类型，增删改查
 4         # str  list tuple  序列  —— index
 5             # 字符串 split strip startswith join
 6         # dict set    散列
 7 # for循环 while循环 条件语句
 8     # while循环  你不知道要循环多少次
 9     # for循环    你知道要循环多少次
10     # 条件判断   一条if语句只有一个分支被执行
11 # 文件操作：open/close
12     # 打开模式
13         # a w r     ——直接对字符串操作
14         # ab wb rb  ——直接对字节操作
15     # 操作系统的编码和python编码不一致的乱码问题
16 # 函数
17     # 函数基础 ：
18         # 定义：关键字、参数：位置参数，*args，默认参数(关键字参数)=默认值，**kwargs、返回值
19         # 调用：关键字：函数名(),参数：按照位置传，按照关键字传，接收返回值
20     # 函数的命名空间：
21         # 在函数的内部可以使用外部的变量：读，写改：声明 global改全局，nonlocal是改局部
22         # 在外部不能使用函数内部的变量
23     # 闭包 —— 装饰器
24         # 是在函数的前后添加功能
25     # 生成器函数 —— 迭代器 —— 生成器表达式 —— 列表推导式
26         # yield写代码的时候可以尽量用，很好的节省内存
27         # 生成器表达式和列表推导时能够很好的简化代码
28         # 迭代器 生成器函数（调用不执行）—— 面试之前看
29     # 递归函数
30         # 大部分的递归都可以用循环实现
31         # 递归相比循环来说 并不能节省内存 还占用更多的空间
32         # 算法用到的特别多
33 # 模块
34     # 内置模块
35         # collections  namedtuple 有序字典 /默认字典
36         # os   文件和文件夹的操作/和路径相关的/执行操作系统命令
37         # sys  sys.path  sys.argv
38         # time   三种时间格式 ：字符串(格式化) 元祖(结构化) 浮点(时间戳)
39         # random 随机整数 小数 抽取 打乱顺序
40         # re     正则 ： findall search
41         # 序列化 pickle json shelve
42         # hashlib 摘要算法的模块 文件的一致性校验 加密认证
43         # logging 加日志的模块
44         # configpaser --
45     # 扩展模块
46     # 自定义的模块
47         # 模块和包
48 # 面向对象
49     # 基础的定义
50         # 类 对象 实例化
51         # class 定义 语法
52         # 三大特性 ： 继承**** 封装*** 多态*
53             # 继承 继承的规则 子类可以使用中的所有非私有的名字，前提是子类没有
54                 #  多继承的查找顺序问题： 经典类深度优先 新式类 广度优先
55                 #  super不是单纯的寻找父类，而是遵循mro(广度优先)顺序
56             # 封装
57                 # 私有的属性既不能被继承 也不能从类的外部调用
58             # 多态 python自带
59         # 组合 一个类的对象作为另外一个类对象的属性
60         # 反射 ： hasattr getattr 用字符串的形式来获取变量
61         # 内置方法 ：__new__类的构造方法，在init之前执行

课上详细版

一、异常处理

语法错误：缩进错误，输入不存在的命令逻辑错误：代码排错，从下往上看；找自己写的代码ValueError等except 找到一个满足条件的其他分支都不走了常用异常万能异常except:pass   except Exception:pass except Exception as e:print(e)  推荐使用，报的异常更具体

最好分开写异常。万能异常放在最下面

# 具体的异常处理+万能异常：
    # 能够提前预料到的异常都应该用具体的异常去处理，剩下其他的异常用万能异常控制
    # 万能异常应该写在最后

如果try语句中的代码都顺利的执行了，没有报错，那么执行else中的语句else不能脱离except，不写except会报错finally:无论如何都会执行总结：

# try:
#     pass #可能有问题的代码
# except ValueError:  # 能预料到的错误
#     pass
# except Exception as e:print(e) # 能处理所有的异常
# else:pass          # try中的代码没有错误的时候执行
# finally:pass       # 无论如何都会执行的

#知道错误类型，不知道如何处理，可以用except在代码未成型时不用加异常处理

raise ValueError:pass 主动抛异常--不常用自定义异常：自定义一个类，继承BaseException

# class EvaException(BaseException):
#     def __init__(self,msg):
#         self.msg=msg
#     def __str__(self):
#         return self.msg
# obj = EvaException(‘类型错误‘)
# print(obj)

断言 assert 条件不满足，后面代码都不执行    eg：if 1==2 抛异常二、模块 （py）

导入一个模块，就相当于执行这个文件一个模块如果执行多次import是什么效果？只执行一次import     一个模块相当于执行这个模块    那么再导入这个模块所处的命名空间中，就有了一个名字，这个名字会指向属于自己的空间，    空间里存储了所有文件中的名字    起别名 import...as    不推荐一行导入多个模块from 模块名 import 函数名/类名    导入所有名字，不会节省内存    也可以起别名  from my_module import func as f,money as m    小结。。from 模块名 import *  导入所有名字  可以直接用，与import 模块名不同my_module.函数名    *和被导入模块__all__是互相影响的

sys.path获取路径

 1 # 模块总结
 2 # 能不能导入模块 ： sys.path
 3 # 导入模块的顺序 ： 内置 扩展 自定义
 4 # 导入模块 ： 相当于执行了这个模块，文件中的名字会被存储在一块独立的内存空间中
 5
 6 # import
 7 # 在全局创建了一个模块名，指向属于这个模块的命名空间
 8 # 空间里存储了所有文件中的名字
 9 # 起别名 import ... as ..
10 # 不推荐一行导入多个模块
11
12 # from import
13 # import后面的名字会出现在全局 ，相当于对独立命名空间中的一个引用
14 # from import 也支持 as语句 也支持 导入多个名字
15 # from import * 相当于导入所有名字,*和被导入模块__all__是互相影响的

模块总结

1 # import my_module
2 # my_module.func()
3 #
4 # from my_module import func
5 # func()
6 #
7 # from my_module import *
8 # func()

3种结果一样

三、包

包：一组py文件组成的文件夹，在这个文件夹里有一个__init__.py

两种import方式

# import glance.api.policy as policy
# policy.get()
# import glance.api.policy
# glance.api.policy.get()

import--起别名调用时简化

from....import方式

# from glance.api import policy
# policy.get()

from...import

为何模块的导入要从glance开始?默认在当前目录下要精确到模块

import glance 不能用glance.api.policy.get()导入一个文件相当于执行了这个文件中的代码

# import glance
# glance.api.policy.get()  # 不行
# 导入一个文件相当于执行了这个文件中的代码
# __init__文件有什么用？
# 但是导入一个包相当于执行这个包中的init文件
# import后面的这个名字 永远会出现在全局的命名空间里

绝对路径的导入： 在两个init中添加，导入例子

# import glance       # 绝对导入
# glance.api.policy.get()

from glance import api

from glance.api import policy

相对路径的导入：两个init中改为.  只要能找到glance即可

# import glance       #相对导入
# # D:\myproject\PY21\day8
# glance.api.policy.get()

相对导入缺点：带有相对导入路径的文件不能直接执行--会报错（在自己的init中不能执行，因为所执行的目录不一致啊） 经常用all的形式py中一切皆对象，类似于实例化

 1 glance/
 2
 3 ├── __init__.py      from glance import api
 4                              from glance import cmd
 5                              from glance import db
 6
 7 ├── api
 8
 9 │   ├── __init__.py  from glance.api import policy
10                               from glance.api import versions
11
12 │   ├── policy.py
13
14 │   └── versions.py
15
16 ├── cmd                 from glance.cmd import manage
17
18 │   ├── __init__.py
19
20 │   └── manage.py
21
22 └── db                   from glance.db import models
23
24     ├── __init__.py
25
26     └── models.py
27
28 绝对导入

绝对导入例子

glance/                   

├── __init__.py      from . import api  #.表示当前目录
                     from . import cmd
                     from . import db

├── api                  

│   ├── __init__.py  from . import policy
                     from . import versions

│   ├── policy.py

│   └── versions.py

├── cmd              from . import manage

│   ├── __init__.py

│   └── manage.py    from ..api import policy
                     #..表示上一级目录，想再manage中使用policy中的方法就需要回到上一级glance目录往下找api包，从api导入policy

└── db               from . import models

    ├── __init__.py

    └── models.py

相对导入

相对导入例子

import glance之后直接调用模块中的方法

glance/                   

├── __init__.py     from .api import *
                    from .cmd import *
                    from .db import *
├── api                  

│   ├── __init__.py   __all__ = [‘policy‘,‘versions‘] 

│   ├── policy.py

│   └── versions.py

├── cmd               __all__ = [‘manage‘]    

│   ├── __init__.py

│   └── manage.py    

└── db                __all__ = [‘models‘]              

    ├── __init__.py

    └── models.py

import glance
policy.get()

import glance

import glance

原文地址：https://www.cnblogs.com/lijie123/p/9102650.html