[19/10/16-星期三] Python中的模塊和包、異常、操做文件

1、模塊

# 模塊（module）
# 模塊化，模塊化指將一個完整的程序分解爲一個一個小的模塊
#   經過將模塊組合，來搭建出一個完整的程序
# 不採用模塊化，統一將全部的代碼編寫到一個文件中
# 採用模塊化，將程序分別編寫到多個文件中
#   模塊化的有點：
#       ① 方便開發
#       ② 方便維護
#       ③ 模塊能夠複用！

# 在Python中一個py文件就是一個模塊，要想建立模塊，實際上就是建立一個python文件
# 注意：模塊名要符號標識符的規範

# 在一個模塊中引入外部模塊
# ① import 模塊名 （模塊名，就是python文件的名字，注意不要後邊的.py）
# ② import 模塊名 as 模塊別名
#   - 能夠引入同一個模塊屢次，可是模塊的實例只會建立一個
#   - import能夠在程序的任意位置調用，可是通常狀況下，import語句都會統一寫在程序的開頭
#   - 在每個模塊內部都有一個__name__屬性，經過這個屬性能夠獲取到模塊的名字
#   - __name__屬性值爲 __main__的模塊是主模塊，一個程序中只會有一個主模塊
#       主模塊就是咱們直接經過 python 執行的模塊
import test_module as test

# print(test.__name__)
print(__name__)

測試

# 能夠在模塊中定義變量，在模塊中定義的變量，在引入模塊後，就能夠直接使用了
#m.py文件

a = 10
b = 20

# 添加了_的變量，只能在模塊內部訪問，在經過import * 引入時，不會引入_開頭的變量
_c = 30

# 能夠在模塊中定義函數，一樣能夠經過模塊訪問到
def test():
    print('test')

def test2():
    print('test2')

# 也能夠定義類    
class Person:
    def __init__(self):
        self.name = '孫悟空'

# 編寫測試代碼，這部分代碼，只要噹噹前文件做爲主模塊的時候才須要執行
#   而當模塊被其餘模塊引入時，不須要執行的，此時咱們就必需要檢查當前模塊是不是主模塊  
if __name__ == '__main__':
    test()
    test2()
    p = Person()
    print(p.name)

# import m

# # 訪問模塊中的變量：模塊名.變量名
# # print(m.a , m.b)

# # m.test2()

# p = m.Person()

# print(p.name)

def test2():
    print('這是主模塊中的test2')


# 也能夠只引入模塊中的部份內容
# 語法 from 模塊名 import 變量,變量....
# from m import Person
# from m import test
# from m import Person,test #引入2個
# from m import * # 引入到模塊中全部內容，通常不會使用
# p1 = Person()
# print(p1)
# test()
# test2()

# 也能夠爲引入的變量使用別名
# 語法：from 模塊名 import 變量 as 別名
# from m import test2 as new_test2

# test2()
# new_test2()

from m import *
# print(_c)

# import xxx
# import xxx as yyy
# from xxx import yyy , zzz , fff
# from xxx import *
# from xxx import yyy as zz

包

# 包 Package
# 包也是一個模塊
# 當咱們模塊中代碼過多時，或者一個模塊須要被分解爲多個模塊時，這時就須要使用到包
# 普通的模塊就是一個py文件，而包是一個文件夾
#   包中必需要一個一個 __init__.py 這個文件，這個文件中能夠包含有包中的主要內容
from hello import a , b

print(a.c)
print(b.d)

# __pycache__ 是模塊的緩存文件
# py代碼在執行前，須要被解析器先轉換爲機器碼，而後再執行
#   因此咱們在使用模塊（包）時，也須要將模塊的代碼先轉換爲機器碼而後再交由計算機執行
#   而爲了提升程序運行的性能，python會在編譯過一次之後，將代碼保存到一個緩存文件中
#   這樣在下次加載這個模塊（包）時，就能夠再也不從新編譯而是直接加載緩存中編譯好的代碼便可

2、標準庫

# 開箱即用
# 爲了實現開箱即用的思想，Python中爲咱們提供了一個模塊的標準庫
# 在這個標準庫中，有不少很強大的模塊咱們能夠直接使用，
#   而且標準庫會隨Python的安裝一同安裝
# sys模塊，它裏面提供了一些變量和函數，使咱們能夠獲取到Python解析器的信息
#   或者經過函數來操做Python解析器
# 引入sys模塊
import sys

# pprint 模塊它給咱們提供了一個方法 pprint() 該方法能夠用來對打印的數據作簡單的格式化
import pprint

# sys.argv
# 獲取執行代碼時，命令行中所包含的參數
# 該屬性是一個列表，列表中保存了當前命令的全部參數
# print(sys.argv)

# sys.modules
# 獲取當前程序中引入的全部模塊
# modules是一個字典，字典的key是模塊的名字，字典的value是模塊對象
# pprint.pprint(sys.modules)

# sys.path
# 他是一個列表，列表中保存的是模塊的搜索路徑
# ['C:\\Users\\lilichao\\Desktop\\resource\\course\\lesson_06\\code',
# 'C:\\dev\\python\\python36\\python36.zip',
# 'C:\\dev\\python\\python36\\DLLs',
# 'C:\\dev\\python\\python36\\lib',
# 'C:\\dev\\python\\python36',
# 'C:\\dev\\python\\python36\\lib\\site-packages']
# pprint.pprint(sys.path)

# sys.platform
# 表示當前Python運行的平臺
# print(sys.platform)

# sys.exit()
# 函數用來退出程序
# sys.exit('程序出現異常，結束！')
# print('hello')

# os 模塊讓咱們能夠對操做系統進行訪問
import os

# os.environ
# 經過這個屬性能夠獲取到系統的環境變量
# pprint.pprint(os.environ['path'])

# os.system()
# 能夠用來執行操做系統的名字
# os.system('dir')
os.system('notepad')

3、異常

# 第七章 異常和文件

## 異常
    程序在運行過程中，不可避免的會出現一些錯誤，好比：
        使用了沒有賦值過的變量
        使用了不存在的索引
        除0
        ...
    這些錯誤在程序中，咱們稱其爲異常。
    程序運行過程當中，一旦出現異常將會致使程序當即終止，異常之後的代碼所有都不會執行！    

## 處理異常
    程序運行時出現異常，目的並非讓咱們的程序直接終止！
    Python是但願在出現異常時，咱們能夠編寫代碼來對異常進行處理！    

    try語句
        try:
            代碼塊（可能出現錯誤的語句）
        except 異常類型 as 異常名:
            代碼塊（出現錯誤之後的處理方式）
        except 異常類型 as 異常名:
            代碼塊（出現錯誤之後的處理方式）
        except 異常類型 as 異常名:
            代碼塊（出現錯誤之後的處理方式）
        else：
            代碼塊（沒出錯時要執行的語句）    
        finally:
            代碼塊（該代碼塊總會執行）    

        try是必須的 else語句有沒有都行
        except和finally至少有一個    

    能夠將可能出錯的代碼放入到try語句，這樣若是代碼沒有錯誤，則會正常執行，
        若是出現錯誤，則會執行expect子句中的代碼，這樣咱們就能夠經過代碼來處理異常
        避免由於一個異常致使整個程序的終止            

## 異常的傳播（拋出異常）
    當在函數中出現異常時，若是在函數中對異常進行了處理，則異常不會再繼續傳播,
        若是函數中沒有對異常進行處理，則異常會繼續向函數調用處傳播,
        若是函數調用到處理了異常，則再也不傳播，若是沒有處理則繼續向調用處傳播
        直到傳遞到全局做用域（主模塊）若是依然沒有處理，則程序終止，而且顯示異常信息

    當程序運行過程當中出現異常之後，全部的異常信息會被保存一個專門的異常對象中，
        而異常傳播時，實際上就是異常對象拋給了調用處
        好比 ： ZeroDivisionError類的對象專門用來表示除0的異常
                NameError類的對象專門用來處理變量錯誤的異常
                ....

    在Python爲咱們提供了多個異常對象            

## 拋出異常
    - 可使用 raise 語句來拋出異常，
        raise語句後須要跟一個異常類 或 異常的實例

## 文件（File）
    - 經過Python程序來對計算機中的各類文件進行增刪改查的操做
    - I/O(Input / Output)
    - 操做文件的步驟：
        ① 打開文件
        ② 對文件進行各類操做（讀、寫），而後保存
        ③ 關閉文件

 

# print('hello')
# try:
#     # try中放置的是有可能出現錯誤的代碼
#     print(10/0)
# except:
#     # except中放置的是出錯之後的處理方式
#     print('哈哈哈，出錯了~~~')
# else:
#     print('程序正常執行沒有錯誤')    
# print('你好')


# print(10/0)


def fn():
    print('Hello fn')
    print(a)
    print(10/0)

def fn2():
    print('Hello fn2')
    fn()

def fn3():
    print('Hello fn3')
    fn2()

fn3()    

print('異常出現前')
l = []
try:
    # print(c)
    # l[10]
    # 1 + 'hello'
    print(10/0)
except NameError:
    # 若是except後不跟任何的內容，則此時它會捕獲到全部的異常
    # 若是在except後跟着一個異常的類型，那麼此時它只會捕獲該類型的異常
    print('出現 NameError 異常')
except ZeroDivisionError:
    print('出現 ZeroDivisionError 異常')
except IndexError:
    print('出現 IndexError 異常')
# Exception 是全部異常類的父類，因此若是except後跟的是Exception，他也會捕獲到全部的異常
# 能夠在異常類後邊跟着一個 as xx 此時xx就是異常對象
except Exception as e :
    print('未知異常',e,type(e))
finally :
    print('不管是否出現異常，該子句都會執行')

print('異常出現後')

自定義異常

# 也能夠自定義異常類，只須要建立一個類繼承Exception便可
class MyError(Exception):
    pass

def add(a,b):
    # 若是a和b中有負數，就向調用處拋出異常
    if a < 0 or b < 0:
        # raise用於向外部拋出異常，後邊能夠跟一個異常類，或異常類的實例
        # raise Exception    
        # 拋出異常的目的，告訴調用者這裏調用時出現問題，但願你本身處理一下
        # raise Exception('兩個參數中不能有負數！')  
        raise MyError('自定義的異常')
        
        # 也能夠經過if else來代替異常的處理
        # return None
    r = a + b
    return r

print(add(-123,456))