python

• 一.概論
  • 介紹
    • 特徵
      • 開源、簡單直觀容易理解、適用於短時間開發的平常任務
      • 徹底面向對象（一切皆對象）
        函數、模塊、數字、字符串都是對象，在 Python 中一切皆對象徹底支持繼承、重載、多重繼承支持重載運算符，也支持泛型設計
      • 擁有一個強大的標準庫
        Python 語言的核心只包含 數字、字符串、列表、字典、文件 等常見類型和函數，而由 Python 標準庫提供了 系統管理、網絡通訊、文本處理、數據庫接口、圖形系統、XML 處理 等額外的功能
      • 大量的第三方模塊
        使用方式與標準庫相似。它們的功能覆蓋 科學計算、人工智能、機器學習、Web 開發、數據庫接口、圖形系統 多個領域
    • 優勢
      簡單、易學免費、開源面向對象豐富的庫可擴展性​
    • 缺點
      運行速度國內市場較小中文資料匱乏​
  • 程序執行原理
    • 計算機中的三大件
      CPU 負責處理數據內存 負責臨時存儲數據，空間小速度快硬盤 負責永久存儲數據​​​​
    • 執行原理
      程序 運行以前，程序是 保存在硬盤 中的當要運行一個程序時操做系統會首先讓 CPU 把程序複製到 內存 中CPU 執行 內存 中的 程序代碼
    • python執行原理
      操做系統會首先讓 CPU 把 Python 解釋器 的程序複製到 內存 中Python 解釋器 根據語法規則，從上向下 讓 CPU 翻譯 Python 程序中的代碼CPU 負責執行翻譯完成的代碼
  • 編碼規範
    • 避免錯誤
      • 每一個import語句只導入一個模塊
        儘可能避免一次導入多個模塊
      • 行尾不要；
        不要在行尾添加分號「;」，也不要用分號將兩條命令放在同一行。
      • 建議每行不超過80個字符
      • 避免在循環中使用+和+=運算符累加字符串
      • 適當使用異常處理結構提升程序容錯性
    • 可讀性
      • 使用必要的空行能夠增長代碼的可讀性
      • 運算符兩側、函數參數之間、逗號「,」兩側建議使用空格進行分隔
• 二.註釋 #
  TODO註釋 ​"""文檔註釋todo，​在 # 後跟上 TODO，用於標記須要去作的工做文檔註釋，
• 三.變量
  • 概述
    • 定義變量
      • 賦值，不須要指定類型
        Python 能夠根據 = 等號右側的值，自動推導出變量中存儲數據的類型
      • 命名
        • 不能以數字開頭，能夠包含字母、數字和下劃線，不能與關鍵字重名
        • 小寫字母，單詞與單詞之間用_鏈接或者用駝峯命名法
          qq_number、firstName
    • 局部變量--函數內的變量
    • global x 全局變量--函數內的變量
  • 數據類型
    • 類型
      • 數字型
        • int float bool
        • complex
          主要用於科學計算，例如：平面場問題、波動問題、電感電容等問題​
      • 非數字型
        特色：​
        • 特色/公共方法
          都是一個 序列 sequence，也能夠理解爲 容器
          • 索引取值 []
            • greeting[-1] 負數索引
              ​>>> greeting = 'chongshi'>>> greeting[0]'c'>>> greeting[-1]'i'>>> greeting[-2]'h'
            • 'chongshi'[-1] 直接字符串索引
              ​>>> 'chongshi'[0]'c'>>> 'chongshi'[-1]'i'​
            • input('year:')[3] 函數索引
              >>> fourth = raw_input('year:')[3]year:2013>>> fourth'3'
          • 遍歷 for in
          • 分片 [:]
            • tag[32:-4] 負數分片
              >>> tag = '<a href="http://www.python.org">Python web site</a>'>>> tag[9:30] # 取第9個到第30個之間的字符'http://www.python.org'>>> tag[32:-4] #取第32到第-4（倒着數第4個字符）'Python web site'>>> ​
            • numbers[0:10:2] 步長/每2個取一個
              ​>>> numbers = [0,1,2,3,4,5,6,7,8,9]>>> numbers[0:10:1] #求0到10之間的數，步長爲1[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]>>> numbers[0:10:2] #步長爲2[0, 2, 4, 6, 8]>>> numbers[0:10:3] #步長爲3[0, 3, 6, 9]
            • num_str[:] 完整的字符串
            • num_str[::-1] 字符串的逆序
          • 序列相鏈接 +
            兩種相同類型的序列才能進行鏈接操做​>>> 'hello.'+'world!''hello.world!'>>> [1,2,3] + 'world!'Traceback (most recent call last): File "<pyshell#20>", line 1, in <module> [1,2,3] + 'world!'TypeError: can only concatenate list (not "str") to list​​
          • 序列重複 *
            ​>>> 'python ' * 5'python python python python python '>>> [25] * 10[25, 25, 25, 25, 25, 25, 25, 25, 25, 25]>>> sequence = [None] * 10>>> sequence[None, None, None, None, None, None, None, None, None, None]​
          • in 成員資格 not in
            >>> permissions = 'rw'>>> 'w' in permissionsTrue>>> 'y' in permissionsFalse>>> users = ['zhangsan', 'lisi','wangwu']>>> raw_input('Enter your user name: ') in usersEnter your user name: lisiTrue>>> subject ='$$$ Get rich now!!! $$$'>>> '$$$' in subjectTrue​
          • len(x) 長度、min(x) 最小值、max(x) 最大值
            >>> numbers = [100,34,678]>>> len (numbers)3>>> max(numbers)678>>> min(numbers)34>>> max(2,3)3>>> min(9,3,2,5)2​
          • 刪除 del
        • 類型
          • string
            • 定義
              • 單引號和雙引號
                若是字符串內部須要使用 "，可使用 ' 定義字符串若是字符串內部須要使用 '，可使用 " 定義字符串
              • 轉義字符
                轉義字符是指使用「\」對一些特殊字符進行轉義​
                • \\ 反斜槓符號， ​\' 單引號， \" 雙引號
                • \n 換行， \t 橫向製表符，​ \​​​r 回車
              • 長字符串
                • ‘‘‘ ’’’
                  若是須要寫一個很是很是長的字符串，它須要跨多行，那麼，可使用三個引號帶點普通引號。
                • \
                  普通字符串也能夠跨行。若是一行之中最後一個字符是反斜線，那麼，換行符自己就「轉義」了，也就是被忽略了。>>> 1+2+\...​ 4+512​​
            • 操做
              • hello_str.
                太多了，具體看md文檔吧
                • 判斷
                • 查找 替換
                • 大小寫轉換
                • 文本對齊
                • 去除空白字符
                • 拆分和鏈接
            • 應用場景
          • list []
            列表 數組 元素有序且可修改
            • 定義
              List（列表） 是 Python 中使用 最頻繁 的數據類型，在其餘語言中一般叫作 數組專門用於存儲 一串 信息列表用 [] 定義，數據 之間使用 , 分隔列表的 索引 從 0 開始索引 就是數據在 列表 中的位置編號，索引 又能夠被稱爲 下標註意：從列表中取值時，若是 超出索引範圍，程序會報錯​
            • 操做
              • name_list.
                name_list.append   name_list.count    name_list.insert   name_list.reversename_list.clear    name_list.extend   name_list.pop      name_list.sortname_list.copy     name_list.index    name_list.remove 
              • 轉換成元組 tuple(列表)
            • 應用場景
              儘管 Python 的 列表 中能夠 存儲不一樣類型的數據可是在開發中，更多的應用場景是列表 存儲相同類型的數據經過 迭代遍歷，在循環體內部，針對列表中的每一項元素，執行相同的操做
          • tuple ()
            元組元素不可修改
            • 定義
              Tuple（元組）與列表相似，不一樣之處在於元組的 元素不能修改元組 表示多個元素組成的序列元組 在 Python 開發中，有特定的應用場景用於存儲 一串 信息，數據 之間使用 , 分隔元組用 () 定義元組的 索引 從 0 開始索引 就是數據在 元組 中的位置編號​
            • 操做
              • 賦值
                建立空元組info_tuple = ()​元組中 只包含一個元素 時，須要 在元素後面添加逗號​info_tuple = (50, )
              • info_tuple.
                info.count  info.index
              • 轉換成列表 list(元組) 
            • 應用場景
              儘管可使用 for in 遍歷 元組可是在開發中，更多的應用場景是：函數的 參數 和 返回值，一個函數能夠接收 任意多個參數，或者 一次返回多個數據有關 函數的參數 和 返回值，在後續 函數高級 給你們介紹格式字符串，格式化字符串後面的 () 本質上就是一個元組讓列表不能夠被修改，以保護數據安全
          • dictionary {}
            字典元素無序，但有鍵值對
            • 定義
              dictionary（字典） 是 除列表之外 Python 之中 最靈活 的數據類型字典一樣能夠用來 存儲多個數據一般用於存儲 描述一個 物體 的相關信息 和列表的區別列表 是 有序 的對象集合字典 是 無序 的對象集合字典用 {} 定義
              • 鍵值對
                • {key1:value1,key2:value2}
                • 鍵必須是惟一的,且只能使用 字符串、數字或 元組
                • 值 能夠取任何數據類型
            • 操做
              • in 在對 字典 操做時，判斷的是 字典的鍵
              • xiaoming.
                xiaoming.clear       xiaoming.items       xiaoming.setdefaultxiaoming.copy        xiaoming.keys        xiaoming.updatexiaoming.fromkeys    xiaoming.pop         xiaoming.valuesxiaoming.get         xiaoming.popitem  
              • dict 經過映射創建字典
                >>> items = [('name','gumby'),('age',42)]>>> d = dict(items)>>> d{'age': 42, 'name': 'gumby'}>>> d['name']'gumby'​
              • popitem 獲取/刪除鍵值對
                scoundrel ={'name':'robin','girlfriend':'marion'}key,value=scoundrel.popitem()print(key) girlfriendprint(value)​ marion
            • 應用場景
              儘管可使用 for in 遍歷 字典可是在開發中，更多的應用場景是：使用 多個鍵值對，存儲 描述一個 物體 的相關信息 —— 描述更復雜的數據信息將 多個字典 放在 一個列表 中，再進行遍歷，在循環體內部針對每個字典進行 相同的處理
              • 栗子
                #簡單數據庫#使用人名做爲鍵的字典，每一個人用另外一個字典表示，其鍵‘phone’和‘addr’分別表示他們的電話號和地址，people ={ 'zhangsan':{ 'phone':'2341', 'addr':'foo drive 23' }, 'lisi':{ 'phone':'9102', 'addr':'bar street 42' }, 'wangwu':{ 'phone':'3158', 'addr':'baz avenue 90' }}#針對電話號碼和地址使用的描述性標籤，會在打印輸出的時候用到labels = { 'phone':'phone number', 'addr':'address'}name = input('Name:')#查找電話號碼仍是地址？ 使用正確的鍵：request = input('phone number(p) or address (a)?')#使用正確的鍵：if request == 'p':key = 'phone'if request == 'a':key = 'addr'#若是名字是字典中的有效鍵纔打印信息：if name in people: print("%s's %s is %s." %(name, labels[key], peo​ple[name][key]))
    • 類型轉換
      • int(x) float(x)
      • str(x) hex(x)16 oct(x)8
    • type函數能夠查看變量的類型
  • 計算
    • +-*/%
      10/20=0.5，10//20=0
    • // 取整除
    • ** 冪運算
    • 賦值運算符
      = += -= *= /= //= %= **=
    • 不一樣類型變量之間的計算
      • 數字型變量 之間能夠直接計算
      • 字符串變量 能夠和 整數 使用 * 重複拼接相同的字符串
      • 數字型變量 和 字符串 之間 不能進行其餘計算
  • 其餘
    • 引用
      • 概念
        ​在 Python 中變量 和 數據 是分開存儲的數據 保存在內存中的一個位置變量 中保存着數據在內存中的地址變量 中 記錄數據的地址，就叫作 引用注意：若是變量已經被定義，當給一個變量賦值的時候，本質上是 修改了數據的引用變量 再也不 對以前的數據引用變量 改成 對新賦值的數據引用
      • 函數的 實參、返回值 都是是 引用
        多個返回值，其實返回的是元組；使用多個變量接收結果時，變量的個數應該和元組中元素的個數保持一致
      • id() 查看變量中保存數據所在的 內存地址
    • 可變類型--只有list和dictionary
      函數內部給變量賦值，這個變量改值了；可變類型的數據變化，是經過 方法 來實現
      • 注意
        • 變量 再也不 對以前的數據引用， 變量 改成 對新賦值的數據引用
        • 可變類型+=的操做，本質上是在調用列表的 extend 方法，因此也會
    • 全局變量
      全局變量名前應該增長 g_ 或者 gl_ 的前綴
      • global
        若是在函數中須要修改全局變量，須要使用 global 進行聲明
• 四.函數
  • def f(x):定義函數
    >>> def fibs(num): result = [0,1] for i in range(num-2): result.append(result[-2]+result[-1]) return result#直接調用fibs函數>>> fibs(10)[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]>>> fibs(15)[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]​
    • 命名
      函數名稱 的命名應該 符合 標識符的命名規則能夠由 字母、下劃線 和 數字 組成不能以數字開頭不能與關鍵字重名​
    • 文檔註釋
      ​在開發中，若是但願給函數添加註釋，應該在 定義函數 的下方，使用 連續的三對引號在 連續的三對引號 之間編寫對函數的說明文字在 函數調用 位置，使用快捷鍵 CTRL + Q 能夠查看函數的說明信息注意：由於 函數體相對比較獨立，函數定義的上方，應該和其餘代碼（包括註釋）保留 兩個空行
    • 默認參數
      def say(message,times=1): print message*timessay('Hello')say('World',5)#輸出>>> HelloWorldWorldWorldWorldWorld​
    • 關鍵參數
      def func(a,b=5,c=10): print 'a is',a, 'and b is',b,'and c is',cfunc(3,7)func(24,c=32)func(c=23,a=14)#輸出>>> a is 3 and b is 7 and c is 10a is 24 and b is 5 and c is 32a is 14 and b is 5 and c is 23​
  • 基本
    • pow(,) 冪函數
    • abs() 絕對值
    • round() 四捨五入
    • round(99,0,-1) round(0,100) round(5)
  • 遞歸
    def f(n): if n == 1: return 1 else: return n*f(n-1)​
  • 其餘
    • 缺省參數
      定義函數時，能夠給 某個參數 指定一個默認值，具備默認值的參數就叫作 缺省參數調用函數時，若是沒有傳入 缺省參數 的值，則在函數內部使用定義函數時指定的 參數默認值函數的缺省參數，將常見的值設置爲參數的缺省值，從而 簡化函數的調用
      • def print_info(name, gender=True): ...
      • 必須保證 帶有默認值的缺省參數 在參數列表末尾
      • 調用函數時，若是有 多個缺省參數，須要指定參數名
    • 可變參數
      def assert_body(self, body, *body_msg, expected_msg): ​msg = body for n in body_msg: msg = msg[n] assert msg == expected_msg return True
    • 多值參數
      有時可能須要 一個函數 可以處理的參數 個數 是不肯定的
      • 參數名前增長 一個 * 能夠接收 元組
      • 參數名前增長 兩個 * 能夠接收 字典
      • 拆包
        def demo(*args, **kwargs): print(args) print(kwargs)# 元組變量/字典變量gl_nums = (1, 2, 3)gl_dict = {"name": "小明", "age": 18}# demo(gl_nums, gl_dict)# 拆包語法，簡化元組變量/字典變量的傳遞demo(*gl_nums, **gl_dict)demo(1, 2, 3, name="小明", age=18)
    • eval函數
      將字符串 當成 有效的表達式 來求值 並 返回計算結果
      • 栗子
        # 基本的數學計算In [1]: eval("1 + 1")Out[1]: 2​# 字符串重複In [2]: eval("'*' * 10")Out[2]: '**********'​# 將字符串轉換成列表In [3]: type(eval("[1, 2, 3, 4, 5]"))Out[3]: list​# 將字符串轉換成字典In [4]: type(eval("{'name': 'xiaoming', 'age': 18}"))Out[4]: dict
    • random.randint(a, b)
      返回 [a, b] 之間的整數，包含 a 和 b
• 五.語句
  • 導入 模塊
    • math.floor(4.4) 捨去小數
      import math
    • sqrt(9) 平方根
      from math import sqrt 防止導入多個同名文件
    • 模塊名
      標示符能夠由 字母、下劃線 和 數字 組成不能以數字開頭不能與關鍵字重名注意：若是在給 Python 文件起名時，以數字開頭 是沒法在 PyCharm 中經過導入這個模塊的
  • 輸入輸出
    • input("") 獲取用戶輸入
      price = float(input("請輸入價格:"))
    • print("") 打印輸出（會自動換行）
      print("%s's %s is %s" %(name, labels[key], peo​ple[name][key]))
      • 不但願末尾增長換行，能夠在 print 函數輸出內容的後面增長 , end=""
        # 向控制檯輸出內容結束以後，不會換行print("*", end="")# 單純的換行print("")
      • %s 字符串
      • %d 有符號十進制整數
        %06d 表示輸出的整數顯示位數，不足的地方使用 0 補全
      • %f 浮點數
      • %% 輸出%
  • 賦值語句
    • 序列解包
      >>> x,y,z = 1,2,3>>> x,y=y,x>>> print (x,y,z)2 1 3
    • x = y = 42 鏈式賦值
    • x += 1 增理賦值
  • 控制語句
    • if ; if else ; if elif else
      • if 條件:操做
        ​>>> if 1==2 : print 'one equals two' ... >>> if 1==1 : print 'one equals one' ... one equals one
      • if 條件:操做 else:操做
      • if 條件:操做 elif 條件:操做 else:操做
    • assert斷言
      確保程序中的某個條件必定爲真才能讓程序正常工做​>>> age = 10>>> assert 0 < age < 100>>> age = -1>>> assert 0 < age < 100 , 'the age must be realistic'Traceback (most recent call last): File "<pyshell#8>", line 1, in <module> assert 0 < age < 100 , 'the age must be realistic'AssertionError: the age must be realistic​​
  • 循環語句
    • while
      name = ''while not name: name = raw_input('please enter your name:')print 'hello.%s!' %name​
    • for
      ​for number in range(1,101):　　print number​d = {'x':1,'y':2,'z':3}for key in d:　　print key,'corresponds to',d[key]#輸出>>> y corresponds to 2x corresponds to 1z corresponds to 3​​
      • 遍歷語句
        # for 循環內部使用的變量 in 列表、元組、字典 以及 字符串元組for item in info:    循環內部針對元組元素進行操做    print(item)​
      • 完整的 for 循環語法
        for 變量 in 集合:    循環體代碼else:    沒有經過 break 退出循環，循環結束後，會執行的代碼
        • 遍歷嵌套的數據類型
          students = [    {"name": "阿土",     "age": 20,     "gender": True,     "height": 1.7,     "weight": 75.0},    {"name": "小美",     "age": 19,     "gender": False,     "height": 1.6,     "weight": 45.0},]find_name = "阿土"for stu_dict in students:    print(stu_dict)    # 判斷當前遍歷的字典中姓名是否爲find_name    if stu_dict["name"] == find_name:        print("找到了")        # 若是已經找到，直接退出循環，就不須要再對後續的數據進行比較        breakelse:    print("沒有找到")print("循環結束")
    • break 結束循環
      from math import sqrtfor n in range(99,0,-1): root = sqrt(n) if root == int(root): print n break#輸出>>> 81​
    • continue 跳到下一輪循環
      while True: s=raw_input('enter something:') if s == 'quit': break if len(s) < 3: continue　　print 'Input is of sufficient length'#輸入>>> enter something:huzhiheng#輸入長度大於3，提示信息Input is of sufficient lengthenter something:ha #輸入長度小於3，要求重輸enter something:hah#輸入長度等於3，提示信息Input is of sufficient lengthenter something:quit #輸入內容等於quit，結果​
  • 其餘
    • 空語句 pass
• 六.面向對象
  • 概念
    • 定義
      面向對象 是 更大 的 封裝，根據 職責 在 一個對象中 封裝 多個方法
      • 在完成某一個需求前，首先肯定 職責 —— 要作的事情（方法）
      • 根據 職責 肯定不一樣的 對象，在 對象 內部封裝不一樣的 方法（多個）
      • 最後完成的代碼，就是順序地讓 不一樣的對象 調用 不一樣的方法
    • 特色
      • 注重 對象和職責，不一樣的對象承擔不一樣的職責
      • 更加適合應對複雜的需求變化，是專門應對複雜項目開發，提供的固定套路
      • 須要在面向過程基礎上，再學習一些面向對象的語法
    • 封裝 繼承 多態
      • 封裝
        根據 職責 將 屬性 和 方法 封裝 到一個抽象的 類 中，對外部世界隱藏對象的工做細節
      • 繼承
        實現代碼的重用
      • 多態
        可對 不一樣類的對象使用一樣的操做，增長代碼靈活度
  • 類和對象
    • 類
      類 是對一羣具備 相同 特徵（屬性） 或者 行爲（方法） 的事物的一個統稱，是抽象的，不能直接使用
      • 命名
        • 大駝峯命名法 CapWords
      • 建立類
        • self參數
          self是對於對象自身的引用
        • dir 內置函數
          • 在 標識符 / 數據 後輸入一個 .
          • __方法名__
            • __new__ 和 __init__
              init配置屬性，xiaoming = Person("小明", 75.0)
            • __del__
              del，對象最後必定都會自動del的
            • __str__​​​
              print(xiaoming)
        • 私有屬性和私有方法
          • 定義方式 __age
            在 定義屬性或方法時，在 屬性名或者方法名前 增長 兩個下劃線，定義的就是 私有 屬性或方法
          • 實際上是僞私有 xiaofang._Women__age
            在 名稱 前面加上 _類名 => _類名__名稱
        • 類屬性
          • 類屬性放日常位置
          • 對象屬性放_init_方法裏面
          • 若是使用 對象.類屬性 = 值 賦值語句，只會 給對象添加一個屬性，而不會影響到 類屬性的值
        • 類方法
          標識符@classmethod
          • 類方法的 第一個參數 應該是 cls
        • 靜態方法
          標識符@staticmethod
          • 定義
            既 不須要 訪問 實例屬性 或者調用 實例方法也 不須要 訪問 類屬性 或者調用 類方法
      • 新式類
        在 Python 3.x 中定義類時，若是沒有指定父類，會 默認使用 object 做爲該類的 基類 —— Python 3.x 中定義的類都是 新式類
    • 對象
      類 是對一羣具備 相同 特徵 或者 行爲 的事物的一個統稱，是抽象的，不能直接使用。由 哪個類 建立出來的 對象，就擁有在 哪個類 中定義的：屬性、方法​
      • 建立對象
        • 對象變量 = 類名()
      • 訪問特性 .
      • 身份運算符
        • is和is not
          針對 None 比較時，建議使用 is 判斷
          • is 用於判斷 兩個變量 引用對象是否爲同一個
          • == 用於判斷 引用變量的值 是否相等
    • 單例
      讓 類 建立的對象，在系統中 只有 惟一的一個實例
      • __new__
        • 做用
          • 1) 在內存中爲對象 分配空間
          • 2) 返回 對象的引用
        • 重寫
          • return super().__new__(cls)
            不然 Python 的解釋器 得不到 分配了空間的 對象引用，就不會調用對象的初始化方法。注意：__new__ 是一個靜態方法，在調用時須要 主動傳遞 cls 參數。
      • 實現步驟
        • 1.定義一個 類屬性，初始值是 None，用於記錄 單例對象的引用
        • 2.重寫 __new__ 方法
        • 3.若是 類屬性 is None，調用父類方法分配空間，並在類屬性中記錄結果
        • 4.返回 類屬性 中記錄的 對象引用
      • 只執行一次初始化工做
        • 定義一個類屬性 init_flag 標記是否 執行過初始化動做，初始值爲 False
        • 在 __init__ 方法中，判斷 init_flag，若是爲 False 就執行初始化動做
        • 而後將 init_flag 設置爲 True
        • 這樣，再次 自動 調用 __init__ 方法時，初始化動做就不會被再次執行 了
  • 繼承
    每個類均可能擁有一個或多個超類（父類）
    • class Zi(Fu): 建立子類
      • 方法重寫
      • 拓展父類方法
        • super函數
          只能在新式類使用
        • 父類名.方法(self)
          和super不要混用
        • 若是使用 當前子類名 調用方法，會出現死循環
      • 父類的 私有屬性 和 私有方法
        • 子類對象 不能 在本身的方法內部，直接 訪問 父類的 私有屬性 或 私有方法
        • 子類對象 能夠經過 父類 的 公有方法 間接 訪問到 私有屬性 或 私有方法
      • 多繼承同名方法
        • __mro__ 查看方法搜索順序
      • property 建立屬性
        __metaclass__ = typeclass Rectangle: def __int__(self): self.width = 0 self.height = 0 def setSize(self,size): self.width, self.height = size def getSize(self): return self.width ,self.height size = property(getSize ,setSize)>>> r = Rectangle()>>> r.width = 10>>> r.height = 5>>> r.size(10, 5)>>> r.size = 150,100>>> r.width150​
    • issubclass 調查繼承
      >>> issubclass(SPAMFilter, Filter)True>>> issubclass(Filter,SPAMFilter)False​
  • 異常
    • 概念
      • 定義
        • 程序在運行時，若是 Python 解釋器 遇到 到一個錯誤，會中止程序的執行，而且提示一些錯誤信息，這就是 異常
        • 程序中止執行而且提示錯誤信息 這個動做，咱們一般稱之爲：拋出(raise)異常
        • 程序開發時，很難將 全部的特殊狀況 都處理的面面俱到，經過 異常捕獲 能夠針對突發事件作集中的處理，從而保證程序的 穩定性和健壯性
    • 捕獲異常
      • 語法
        try:    嘗試執行的代碼except:    出現錯誤的處理
        • 捕獲未知錯誤
          except Exception as result:    print("未知錯誤 %s" % result)
        • 完整語法
          except Exception as result:    print("未知錯誤 %s" % result)
    • 異常的傳遞
      • 概念
        異常的傳遞 —— 當 函數/方法 執行 出現異常，會 將異常傳遞 給 函數/方法 的 調用一方若是 傳遞到主程序，仍然 沒有異常處理，程序纔會被終止
      • 方法
        • 在開發中，能夠在主函數中增長 異常捕獲
        • 而在主函數中調用的其餘函數，只要出現異常，都會傳遞到主函數的 異常捕獲 中
        • 這樣就不須要在代碼中，增長大量的 異常捕獲，可以保證代碼的整潔
    • 拋出 raise 異常
      • 概念
        • 在開發中，除了 代碼執行出錯 Python 解釋器會 拋出 異常以外
        • 還能夠根據 應用程序 特有的業務需求 主動拋出異常
      • 方法
        • 建立 一個 Exception 的 對象
        • 使用 raise 關鍵字 拋出 異常對象
  • 模塊和包
    • 模塊
      • 概念
        • 每個以擴展名 py 結尾的 Python 源代碼文件都是一個 模塊
        • 其餘
          • 模塊名 一樣也是一個 標識符，須要符合標識符的命名規則
          • 在模塊中定義的 全局變量 、函數、類 都是提供給外界直接使用的 工具
          • 模塊 就比如是 工具包，要想使用這個工具包中的工具，就須要先 導入 這個模塊
      • 模塊的導入
        • 方式
          • import 導入
          • from...import 導入
        • 同名衝突
          若是 兩個模塊，存在 同名的函數，那麼 後導入模塊的函數，會 覆蓋掉先導入的函數開發時 import 代碼應該統一寫在 代碼的頂部，更容易及時發現衝突一旦發現衝突，可使用 as 關鍵字 給其中一個工具起一個別名
        • 模塊的搜索順序
          內置屬性 __file__ 表示文件自己，能夠 查看模塊 的 完整路徑
          • 搜索 當前目錄 指定模塊名的文件，若是有就直接導入
          • 若是沒有，再搜索 系統目錄
        • 原則 — 每個文件都應該是能夠被導入的
          • 一個 獨立的 Python 文件 就是一個 模塊
          • 在導入文件時，文件中 全部沒有任何縮進的代碼 都會被執行一遍！
        • __name__ 屬性
          __name__ 屬性能夠作到，測試模塊的代碼 只在測試狀況下被運行，而在 被導入時不會被執行！
          • __name__ 是 Python 的一個內置屬性，記錄着一個 字符串
          • 若是 是被其餘文件導入的，__name__ 就是 模塊名
          • 若是 是當前執行的程序 __name__ 是 __main__
    • 包
      • 概念
        使用 import 包名 能夠一次性導入 包 中 全部的模塊
        • 包 是一個 包含多個模塊 的 特殊目錄
        • 目錄下有一個 特殊的文件 __init__.py
        • 包名的 命名方式 和變量名一致，小寫字母 + _
      • __init__.py
        # 從 當前目錄 導入 模塊列表from . import send_messagefrom . import receive_message
      • 發佈模塊
        • 。。。
  • 文件
    • 函數和方法
      • open函數
        f = open("文件名", "訪問方式")頻繁的移動文件指針，會影響文件的讀寫效率，開發中更多的時候會以 只讀、只寫 的方式來操做文件​
        • 若是文件 存在，返回 文件操做對象
        • 若是文件 不存在，會 拋出異常
      • read write close 方法
        打開文件，而且返回文件對象
        • read 能夠一次性 讀入 並 返回 文件的 全部內容
          read 方法執行後，會把 文件指針 移動到 文件的末尾
        • close 負責 關閉文件
          若是 忘記關閉文件，會形成系統資源消耗，並且會影響到後續對文件的訪問
        • readline 方法
          readline 方法能夠一次讀取一行內容方法執行後，會把 文件指針 移動到下一行，準備再次讀取
    • 文件/目錄的經常使用管理操做
      • 導入os模塊
        建立、重命名、刪除、改變路徑、查看目錄內容、……
      • 文件操做
        • rename
          os.rename(源文件名, 目標文件名)
        • remove 刪除
          os.remove(文件名)
      • 目錄操做
        • listdir
        • mkdir
        • rmdir
        • getcwd 獲取當前目錄
        • chdir 修改工做目錄
        • path.isdir 判斷是不是文件
    • 其餘
      • 文件指針
        文件指針 標記 從哪一個位置開始讀取數據
        • 第一次打開 文件時，一般 文件指針會指向文件的開始位置
        • 當執行了 read 方法後，文件指針 會移動到 讀取內容的末尾
          默認狀況下會移動到 文件末尾
      • 文本文件的編碼格式
        • 常見的編碼
          • ASCII編碼
            計算機中只有 256 個 ASCII 字符一個 ASCII 在內存中佔用 1 個字節 的空間
          • UTF-8編碼
            計算機中使用 1~6 個字節 來表示一個 UTF-8 字符，涵蓋了 地球上幾乎全部地區的文字大多數漢字會使用 3 個字節 表示UTF-8 是 UNICODE 編碼的一種編碼格式