1. <em id="2qvri"><tr id="2qvri"></tr></em>
      1. 首頁»Python»改善 Python 程序的 91 個建議(二)

        改善 Python 程序的 91 個建議(二)

        來源:馭風者 發布時間:2017-05-17 閱讀次數:

        建議 24:遵循異常處理的幾點基本原則

        異常處理的幾點原則:

        1. 注意異常的粒度,不推薦在 try 中放入過多的代碼

        2. 謹慎使用單獨的 except 語句處理所有異常,最好能定位具體的異常

        3. 注意異常捕獲的順序,在適合的層次處理異常,Python 是按內建異常類的繼承結構處理異常的,所以推薦的做法是將繼承結構中子類異常在前拋出,父類異常在后拋出

        4. 使用更為友好的異常信息,遵守異常參數的規范

        建議 25:避免 finally 中可能發生的陷阱

        當 finally 執行完畢時,之前臨時保存的異常將會再次被拋出,但如果 finally 語句中產生了新的異常或執行了 return 或 break 語句,那么臨時保存的異常將會被丟失,從而異常被屏蔽。

        在實際開發中不推薦 finally 中使用 return 語句進行返回。

        建議 26:深入理解 None,正確判斷對象是否為空

        類型FalseTrue布爾False (與0等價)True (與1等價)字符串""( 空字符串)非空字符串,例如 " ", "blog"數值0, 0.0非0的數值,例如:1, 0.1, -1, 2容器[], (), {}, set()至少有一個元素的容器對象,例如:[0], (None,), ['']NoneNone非None對象

        >>> id(None)
        10743840
        >>> a = None
        >>> id(a)
        10743840
        >>> l = []
        >>> if l is not None:       # 判斷邏輯 l 不為空
        ...     print('l is {}'.format(l))
        ... else:
        ...     print('l is empty')
        ... 
        l is []
        >>> if l:   # #3 正確的判斷形式
        ...     print('Do something...')
        ... else:
        ...     print('Do other thing...')
        ... 
        Do other thing...
        

        #3執行中會調用__nonzero__()來判斷自身對象是否為空并返回0/1或True/False,如果沒有定義該方法,Python 將調用__len__()進行判斷,返回 0 表示為空。如果一個類既沒有定義__len__()又沒有定義__nonzero__(),該類實例用 if 判斷為True。

        建議 27:連接字符串優先使用 join 而不是 +

        這一點之前我在博文里總結過,+涉及到更多的內存操作。

        建議 28:格式化字符串時盡量使用 .format 而不是 %

        同上。

        建議 29:區別對待可變對象和不可變對象

        Python 中一切皆對象,每個對象都有一個唯一的標識符(id)、類型(type)和值。數字、字符串、元組屬于不可變對象,字典、列表、字節數組屬于可變對象。

        class Student(object):
            def __init__(self, name, course=[]):    # 問題就出在這里
                self.name = name
                self.course = course
            def addcourse(self, coursename):
                self.course.append(coursename)
            def printcourse(self):
                for item in self.course:
                    print(item)
        stuA = Student('Wang yi')
        stuA.addcourse('English')
        stuA.addcourse('Math')
        print("{}'s course: ".format(stuA.name))
        stuA.printcourse()
        print('---------------------------')
        stuB = Student('Su san')
        stuB.addcourse('Chinese')
        stuB.addcourse('Physics')
        print("{}'s course: ".format(stuB.name))
        stuB.printcourse()
        # run
        Wang yi's course: 
        English
        Math
        ---------------------------
        Su san's course: 
        English
        Math
        Chinese
        Physics
        

        默認參數在初始化時僅僅被評估一次,以后直接使用第一次評估的結果,course 指向的是 list 的地址,每次操作的實際上是 list 所指向的具體列表,所以對于可變對象的更改會直接影響原對象。

        最好的方法是傳入None作為默認參數,在創建對象的時候動態生成列表。

        >>> list1 = ['a', 'b', 'c']
        >>> list2 = list1
        >>> list1.append('d')
        >>> list2
        ['a', 'b', 'c', 'd']
        >>> list3 = list1[:]    # 可變對象的切片操作相當于淺拷貝
        >>> list3.remove('a')
        >>> list3
        ['b', 'c', 'd']
        >>> list1
        ['a', 'b', 'c', 'd']
        

        建議 30:[]、() 和 {} 一致的容器初始化形式

        >>> list1 = [['Hello', 'World'], ['Goodbye', 'World']]
        >>> list2 = [[s.upper() for s in xs] for xs in list1]
        >>> list2
        [['HELLO', 'WORLD'], ['GOODBYE', 'WORLD']]
        >>> [v**2 if v%2 == 0 else v+1 for v in [2, 3, 4, -1] if v>0]
        [4, 4, 16]
        

        其實就是列表生成式、元組生成式和字典生成式。

        建議 31:記住函數傳參既不是傳值也不是傳引用

        正確的說法是傳對象(call by object)或傳對象的引用(call-by-object-reference),函數參數在傳遞過程中將整個對象傳入,對可變對象的修改在函數外部以及內部都可見,對不可變對象的”修改“往往是通過生成一個新對象然是賦值實現的。

        建議 32:警惕默認參數潛在的問題

        其中就是默認參數如果是可變對象,在調用者和被調用者之間是共享的。

        import time
        # 對當前系統時間進行處理
        def report(when=time.time): # 而不是when=time.time()
            pass
        

        建議 33:慎用變長參數

        原因如下:

        1. 使用過于靈活,導致函數簽名不夠清晰,存在多種調用方式

        2. 使用*args和**kw簡化函數定義就意味著函數可以有更好的實現方法

        使用場景:

        1. 為函數添加一個裝飾器

        2. 參數數目不確定

        3. 實現函數的多態或子類需要調用父類的某些方法時

        建議 34:深入理解 str() 和repr() 的區別

        總結幾點:

        1. str()面向用戶,返回用戶友好和可讀性強的字符串類型;repr()面向 Python 解釋器或開發人員,返回 Python 解釋器內部的含義

        2. 解釋器中輸入a默認調用repr(),而print(a)默認調用str()

        3. repr()返回值一般可以用eval()還原對象:obj == eval(repr(obj))

        4. 以上兩個方法分別調用內建的__str__()和__repr__(),一般來說類中都應該定義__repr__(),但當可讀性比準確性更為重要時應該考慮__str__(),用戶實現__repr__()方法的時候最好保證其返回值可以用eval()是對象還原

        建議 35:分清 staticmethod 和 classmethod 的適用場景

        這兩種方法之前已經總結過了的,下面我們只討論它們的使用場景。

        調用類方法裝飾器的修飾器的方法,會隱式地傳入該對象所對應的類,可以動態生成對應的類的類變量,同時如果我們期望根據不同的類型返回對應的類的實例,類方法才是正確的解決方案。

        反觀靜態方法,當我們所定義的方法既不跟特定的實例相關也不跟特定的類相關,可以將其定義為靜態方法,這樣使我們的代碼能夠有效地組織起來,提高可維護性。

        當然,也可以考慮定義一個模塊,將一組的方法放入其中,通過模塊來訪問。

        第 4 章 庫

        建議 36:掌握字符串的基本用法

        # 小技巧:Python 遇到未閉合的小括號會自動將多行代碼拼接為一行
        >>> s = ('SELECT * '
        ...      'FROM table '
        ...      'WHERE field="value"')
        >>> s
        'SELECT * FROM table WHERE field="value"'
        # Python2 中使用 basestring 正確判斷一個變量是否是字符串
        # 性質判斷
        isalnum() isalpha() isdigit() islower() isupper() isspace() istitle()
        # 查找替換
        startswith(prefix[, start[, end]]) endswith(suffix[, start[, end]]) # prefix參數可以接收 tuple 類型的實參
        count(sub[, start[, end]]) find(sub[, start[, end]]) index(sub[, start[, end]])
        rfind(sub[, start[, end]]) rindex(sub[, start[, end]]) replace(old, new[, count])   # count是指的替換次數,不指定就全部替換
        # 切分
        partition(sep) rpartition(sep) splitlines([keepends]) split([sep, [, maxsplit]]) rsplit([sep[, maxsplit]])  # partition 返回一個3個元素的元組對象
        # 變形
        lower() upper() capitalize() swapcase() title()
        # 刪減填充
        strip([chars]) lstrip([chars]) rstrip([chars]) # 沒有提供chars默認是空白符,由string.whitespace 常量定義
        center(width[, fillchar]) ljuct(width[, fillchar]) rjust(width[, fillchar])
        zfill(width) expandtabs([tabszie])
        

        下面來介紹一些易混淆的地方:

        >>> '  hello world'.split()
        ['hello', 'world']
        >>> '  hello world'.split(' ')
        ['', '', 'hello', 'world']
        >>> 'hello wORld'.title()
        'Hello World'
        >>> import string
        >>> string.capwords(' hello world!')
        'Hello World!'
        >>> string.whitespace
        ' \t\n\r\x0b\x0c'
        

        建議 37:按需選擇 sort() 或者 sorted()

        # 函數原型
        sorted(iterable[, cmp[, key[, reverse]]])   # 返回一個排序后的列表
        s.sort([cmp[, key[, reverse]]])             # 直接修改原列表,返回為None
        >>> persons = [{'name': 'Jon', 'age': 32}, {'name': 'Alan', 'age': 50}, {'name': 'Bob', 'age': 23}]
        >>> sorted(persons, key=lambda x: (x['name'], -x['age']))
        [{'name': 'Alan', 'age': 50}, {'name': 'Bob', 'age': 23}, {'name': 'Jon', 'age': 32}]
        >>> a = (1, 2, 4, 2, 3)
        >>> sorted(a)
        [1, 2, 2, 3, 4]
        

        所以如果實際過程中需要保留原有列表,可以使用sorted()。sort()不需要復制原有列表,消耗內存較小,效率較高。同時傳入參數key比傳入參數cmp效率要高,cmp傳入的函數在整個排序過程中會調用多次,而key針對每個元素僅作一次處理。

        建議 38:使用 copy 模塊深拷貝對象

        • 淺拷貝(shallow copy):構造一個新的復合對象并將從原對象中發現的引用插入該對象中。工廠函數、切片操作、copy 模塊中的 copy 操作都是淺拷貝

        • 深拷貝(deep copy):針對引用所指向的對象繼續執行拷貝,因此產生的對象不受其它引用對象操作的影響。深拷貝需要依賴 copy 模塊的 deepcopy() 操作

        在 python 中,標識一個對象唯一身份的是:對象的id(內存地址),對象類型,對象值,而淺拷貝就是創建一個具有相同類型,相同值但不同id的新對象。因此使用淺拷貝的典型使用場景是:對象自身發生改變的同時需要保持對象中的值完全相同,比如 list 排序:

        def sorted_list(olist, key=None):
            copied_list = copy.copy(olist)
            copied_list.sort(key=key)
            return copied_list
        a = [3, 2, 1]       # [3, 2, 1]
        b = sorted_list(a)  # [1, 2, 3]
        

        深拷貝不僅僅拷貝了原始對象自身,也對其包含的值進行拷貝,它會遞歸的查找對象中包含的其他對象的引用,來完成更深層次拷貝。因此,深拷貝產生的副本可以隨意修改而不需要擔心會引起原始值的改變:

        >>> a = [1, 2]
        >>> b = [a, a]
        >>> b
        [[1, 2], [1, 2]]
        >>> from copy import deepcopy
        >>> c = deepcopy(b)
        >>> id(b[0]) == id(c[0])
        False
        >>> id(b[0]) == id(b[1])
        True
        >>> c
        [[1, 2], [1, 2]]
        >>> c[0].append(3)
        >>> c
        [[1, 2, 3], [1, 2, 3]]
        

        使用 _copy_ 和 __deepcopy__ 可以完成對一個對象拷貝的定制。

        參考博文

        建議 39: 使用 Counter 進行計數統計

        常見的計數統計可以使用dict、defaultdict、set和list,不過 Python 提供了一個更優雅的方式:

        >>> from collections import Counter
        >>> some_data = {'a', '2', 2, 3, 5, 'c', '7', 4, 5, 'd', 'b'}
        >>> Counter(some_data)
        Counter({'7',: 1, 2: 1, 3: 1, 4: 1, 5: 1, '2': 1, 'b': 1, 'a': 1, 'd': 1, 'c': 1})
        

        Counter 類屬于字典類的子類,是一個容器對象,用來統計散列對象,支持+、-、&、|,其中&和|分別返回兩個 Counter 對象各元素的最小值和最大值。

        # 初始化
        Counter('success')
        Counter(s=3, c=2, e=1, u=1)
        Counter({'s': 3, 'c': 2, 'u': 1, 'e': 1})
        # 常用方法
        list(Counter(some_data).elements())     # 獲取 key 值
        Counter(some_data).most_common(2)       # 前 N 個出現頻率最高的元素以及對應的次數
        (Counter(some_data))['y']               # 訪問不存在的元素返回 0
        c = Counter('success')
        c.update('successfully')                # 更新統計值
        c.subtract('successfully')              # 統計數相減,允許為0或為負
        

        建議 40:深入掌握 ConfigParser

        幾乎所有的應用程序都會讀取配置文件,ini是一種比較常見的文件格式:

        [section1]
        option1=0
        

        Python 提供標準庫 ConfigParser 來支持它:

        import ConfigParser
        conf = ConfigParser.ConfigParser()
        conf.read('example.conf')
        print(conf.get('section1', 'in_default'))
        

        再來看個SQLAlchemy配置文件的例子:

        [DEFAULT]
        conn_str = %(dbn)s://%(user)s:%(pw)[email protected]%(host)s:%(port)s/%(db)s
        dbn = mysql
        user = root
        host = localhost
        port = 3306
        [db1]
        user = aaa
        pw = ppp
        db = example
        [db2]
        host = 192.168.0.110
        pw = www
        db = example
        
        import ConfigParser
        conf = ConfigParser.ConfigParser()
        conf.read('format.conf')
        print(conf.get('db1', 'conn_str'))
        print(conf.get('db2', 'conn_str'))
        
        QQ群:WEB開發者官方群(515171538),驗證消息:10000
        微信群:加小編微信 849023636 邀請您加入,驗證消息:10000
        提示:更多精彩內容關注微信公眾號:全棧開發者中心(fsder-com)
        網友評論(共0條評論) 正在載入評論......
        理智評論文明上網,拒絕惡意謾罵 發表評論 / 共0條評論
        登錄會員中心
        江苏快3投注技巧