<dl id="3wz6h"></dl><li id="3wz6h"></li>

      1. <dl id="3wz6h"></dl>

      2. <dl id="3wz6h"><ins id="3wz6h"></ins></dl>

            <dl id="3wz6h"></dl>

            <dl id="3wz6h"><ins id="3wz6h"></ins></dl>
            1. 
              
              <output id="3wz6h"><ins id="3wz6h"><nobr id="3wz6h"></nobr></ins></output>

              <li id="3wz6h"><ins id="3wz6h"></ins></li>
              
              

            2. <output id="3wz6h"><ins id="3wz6h"><nobr id="3wz6h"></nobr></ins></output>
              首頁»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條評論
              登錄會員中心
              云南十一选往期