復習

 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()

三、包

包：一組py文件組成的文件夾，在這個文件夾裏有一個__init__.py

兩種import方式

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

from....import方式

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

為何模塊的導入要從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

eight day1----模塊和包，異常處理