你的代碼“balance”怎麼樣?找到簡潔性和可讀性的平衡點

雲棲號資訊:【點擊查看更多行業資訊
在這裏您可以找到不同行業的第一手的上雲資訊,還在等什麼,快來!

image

Python對初學者非常友好,許多人在開始學習編程時都會選擇Python。簡單易上手是你接觸它之後發現的第一個優點。進一步瞭解之後,你可能會被它的靈活性所吸引——可通過各種方式做同一功能。

事實上,還有更便捷的解決方案。代碼越簡潔,可讀性越高且能夠長期存在。用Python編寫簡潔代碼的方法有很多,本文想與大家分享筆者在日常Python項目中發現的特別有用的五個技巧。

1.列表、字典和集合推導式

列表推導式是衆多Python程序員最喜歡的特徵之一。這是一種從迭代器創建列表的簡潔方法。基本語法是[expression for x in iterable]。可以看一些示例進一步瞭解其用法:

>>># Create a list for subsequentoperations
          >>> numbers = [1, 2, 3, 4, 5, 6]
          >>>
>>># Typical way to create a list consisting of squares
          >>> squares0 = []
          >>>for number in numbers:
          ...     squares0.append(number*number)
          ...
          >>># List comprehensions
          >>> squares1 = [number*number for number in numbers]

在不使用列表推導式的情況下,必須創建一個空列表,並通過運行for循環來添加每個數字的平方,這通常需要三行代碼。使用列別推導式後,只需一行代碼即可構建相同的平方列表。

除了列表推導式,還有字典和集合推導式。字典推導式有該基本語法 {key_expr:value_expr for x in iterable},集合推導式的基本語法是 {expressionfor x in iterable}。與列表推導式示例類似,不使用推導式的情況下,需要多行代碼來構建所需的字典和集合。

>>># Dictionary comprehension
            >>> squares_dict = {number: number*number for number in numbers}
            >>> squares_dict
            {1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}
            >>>
>>># Set comprehension
            >>> numbers_dups = [1, 2, 3, 4, 3, 2, 1]
            >>> squares_set = {number*number for number in numbers_dups}
            >>> squares_set
            {16, 1, 4, 9}

2.Lambda函數

Lambda函數是Python中的匿名函數,通常用於小規模操作。Lambda函數可以接受一到多個參數,只需一個表達式,其語法爲lambda parameters:expression。

image

筆者將使用內置sorted()函數演示lambda函數的用法。具體而言,sorted()函數會使用key函數對迭代進行排序,該函數由key參數指定。我們可以將lambda函數作爲key參數,而不是用def關鍵字聲明常規函數。

>>># Create a list of students with theirgrading information
          >>> grades = [{ name :  John ,  grade : 95}, { name :  Aaron ,  grade : 92}, { name :  Jennifer ,  grade : 100}]
          >>>
>>># Sort using a regular function
          >>>defsort_grade(student):
          ...     return student[ grade ]
          ...
          >>>sorted(grades, key=sort_grade)
          [{ name :  Aaron ,  grade : 92}, { name :  John ,  grade : 95}, { name :  Jennifer ,  grade : 100}]
          >>>
>>># Sort using a lambda
          >>>sorted(grades, key=lambda x: x[ grade ])
          [{ name :  Aaron ,  grade : 92}, { name :  John ,  grade : 95}, { name :  Jennifer ,  grade : 100}]

如上所示,使用lambda函數可以編寫出更簡潔的調用sorted()函數的命令。在使用正則表達式之前,必須先聲明該函數,然後才能使用sorted()函數,這一定比直接使用lambda函數更繁瑣。

3.命名元組作數據結構

元組可以存儲一些相關數據,但是使用起來並不順手,特別是涉及特定元素時,必須記住順序並使用特定元素的正確索引。如果不想使用元組,雖然可以構建一個自定義類來管理相關數據,但namedtuple數據類型是一種非常有用的輕量級數據結構。

通過集合模塊,namedtuple數據類型採用以下基本語法:namedtuple(Typename,field_names)。語法並不直截了當,不過從概念上來說是容易理解的。

來看看示例。理想的特性是創建一個可以存儲學生信息的數據結構,包括姓名、性別和學生ID號。

>>># Use a custom class
      >>>classStudent0:
      ...     def__init__(self, name, gender, student_id):
      ...         self.name = name
      ...         self.gender = gender
      ...         self.student_id = student_id
      ...
      >>> s0 =Student0( John ,  M , 2020001)
      >>>f"Name: {s0.name}; Gender: {s0.gender}; ID #: {s0.student_id}"
       Name: John; Gender: M; ID #: 2020001 
      >>>
>>># Use the namedtuple
      >>>from collections import namedtuple
      >>>Student1=namedtuple("Student1", ["name", "gender", "student_id"])
      >>> s1 =Student1( Jennifer ,  F , 2020002)
      >>>f"Name: {s1.name}; Gender: {s1.gender}; ID #: {s1.student_id}"
       Name: Jennifer; Gender: F; ID #:2020002 

使用namedtuple模塊,可以用更簡潔的代碼編寫輕量級數據結構。當然,請注意,自定義類提供了更多可以操作的功能。但如果只是爲了存儲和檢索數據而創建一個數據結構,完全可以考慮使用namedtuple模塊。

image

4.使用enumerate()和zip()進行迭代

編碼的一個關鍵原則是精簡。當處理一系列數據(如數字列表)時,通常需要對列表中的每個數字執行相同的操作。爲了避免重複相同的代碼,可以使用for循環loop來運行整個列表的迭代。

當迭代一個列表或任何序列時,有時還需要知道該項在序列中的位置。下面幾種方法可以做到這一點。

>>># Create a list of students based ontheir arrival sequence
        >>> students = [ John ,  Aaron ,  Jennifer ,  Ashley ]
        >>>
>>># Lengthy way
        >>>for index inrange(len(students)):
        ...     student = students[index]
        ...     print(f"Arrival # {index+1}: {student}")
        ...
        Arrival# 1: John
        Arrival# 2: Aaron
        Arrival# 3: Jennifer
        Arrival# 4: Ashley
        >>>
>>># Concise way
        >>>for index, student inenumerate(students, 1):
        ...     print(f"Arrival # {index}: {student}")
        ...
        Arrival# 1: John
        Arrival# 2: Aaron
        Arrival# 3: Jennifer
        Arrival# 4: Ashley

通過使用內置函數enumerate(),可以輕鬆訪問序列中的索引和元素,這比第一次迭代更簡潔。更重要的是,它可以設置開始計數的數字。在上面的示例中設置爲了1。

除了enumerate()函數,zip()函數在迭代中也頗爲有用。此函數可以從多個迭代中創建元組,而無需特意爲這些迭代創建複合迭代。

>>># Create two lists for zip(), with oneto one match
     >>> names = [ John ,  Danny ,  Jennifer ]
     >>> scores = [95, 99, 100]
     >>>
>>># Lengthy way
     >>>for index inrange(len(names)):
     ...     name, score = names[index], scores[index]
     ...     print(f"Name: {name}; Score: {score}")
     ...
     Name: John; Score: 95
     Name: Danny; Score: 99
     Name: Jennifer; Score: 100
     >>>
>>># Concise way
     >>>for name, score inzip(names, scores):
     ...     print(f"Name: {name}; Score: {score}")
     ...
     Name: John; Score: 95
     Name: Danny; Score: 99
     Name: Jennifer; Score: 100

基本上,zip()函數所做的就是從迭代中獲取每個元素,以便在每次迭代中形成一個有順序的元組。這樣一來代碼會更簡潔,可讀性也更高。

image

5.f字符串格式化

字符串太基礎了,我們基本上在哪都會用它。字符串的一個基本應用是與某些格式一併使用。有幾種格式化字符串的方法,筆者想介紹的是f字符串,這個方法非常簡單。

f字符串是使用字母f(或F)作爲字符串文本的前綴插入的字符串文本。爲了編寫簡潔的代碼,下面兩個用例首選f字符串:

· 顯示變量。最基本的用法是顯示一些變量的值,以便在開發過程中進行調試。如果使用傳統的format()方法,代碼會偏長。

>>># Construct a list for formatting/debugging
                           >>> prime_numbers = [2, 3, 5, 7, 11]
                           >>>
>>># Show the list using format
                           >>>print("Prime Numbers: {}".format(prime_numbers))
                           PrimeNumbers: [2, 3, 5, 7, 11]
                           >>>
>>># Show the list using f-string
                           >>>print(f"Prime Numbers: {prime_numbers}")
                           PrimeNumbers: [2, 3, 5, 7, 11]

· 加入變量/連接字符串。f字符串不是使用+和字符串的join()方法,而是非常直接地用於字符串連接,並且它們具有最高的可讀性。在實際操作中可用於構造文件路徑,如下所示:

>>># The folder and extension
                 >>> folder = ./usr/images 
                 >>> ext = .jpg 
                 >>>
>>># File name is computed from this list
                 >>> names = [10, 11, 12]
                 >>>
>>># Construct File paths
                 >>># Use + for concatenation
                 >>> paths0 = [folder + / +str(x) + ext for x in names]
                 >>>
>>># Use join()
                 >>> paths1 = [  .join([folder,  / , str(x), ext]) for x in names]
                 >>>
>>># Use f strings
                 >>> paths2 = [f"{folder}/{x}{ext}"for x in names]

image

編寫越簡短,代碼的可讀性和可維護性就會得到實際的提高,這是亙古不變的真理。但請記住,簡潔的代碼不應該帶來任何潛在的歧義或混淆。

你必須在簡潔性和可讀性之間尋求平衡點。一旦發生衝突,首先考慮可讀性,哪怕這會需要更多的代碼。

【雲棲號在線課堂】每天都有產品技術專家分享!
課程地址:https://yqh.aliyun.com/live

立即加入社羣,與專家面對面,及時瞭解課程最新動態!
【雲棲號在線課堂 社羣】https://c.tb.cn/F3.Z8gvnK

原文發佈時間:2020-06-25
本文作者:讀芯術
本文來自:“讀芯術公衆號”,瞭解相關信息可以關注“讀芯術

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章