編程是一件很有意思的事情,而用Python
編程就更加有趣了,因?yàn)樵?code>Python中實(shí)現(xiàn)一種功能,可以有很多種不同的方法。
但是,大多數(shù)時候都有一些首選的實(shí)現(xiàn)方法,有些人將其稱為Pythonic
。這些Pythonic
的共同特征是實(shí)現(xiàn)的代碼簡潔明了。
用Python
或任何編碼語言進(jìn)行編程不是像火箭一樣的科學(xué),而主要是關(guān)于技巧。如果有意嘗試使用Pythonic
編碼,那么這些技術(shù)將很快成為我們工具包的一部分,并且我們會發(fā)現(xiàn)在項(xiàng)目中使用它們變得越來越自然。因此,讓我們探索其中的一些簡單技巧。
1.負(fù)索引
人們喜歡使用序列,因?yàn)楫?dāng)我們知道元素的順序,我們就可以按順序操作這些元素。在Python
中,字符串、元組和列表是最常見的序列數(shù)據(jù)類型。我們可以使用索引訪問單個項(xiàng)目。與其他主流編程語言一樣,Python
支持基于 0 的索引,在該索引中,我們在一對方括號內(nèi)使用零訪問第一個元素。此外,我們還可以使用切片對象來檢索序列的特定元素,如下面的代碼示例所示。
>>> # Positive Indexing
... numbers = [1, 2, 3, 4, 5, 6, 7, 8]
... print("First Number:", numbers[0])
... print("First Four Numbers:", numbers[:4])
... print("Odd Numbers:", numbers[::2])
... First Number: 1
First Four Numbers: [1, 2, 3, 4]
Odd Numbers: [1, 3, 5, 7]
但是,Python
通過支持負(fù)索引而進(jìn)一步走了一步。具體來說,我們可以使用 -1 來引用序列中的最后一個元素,并向后計(jì)數(shù)。例如,最后一個元素的索引為 -2,依此類推。重要的是,負(fù)索引也可以與切片對象中的正索引一起使用。
>>> # Negative Indexing
... data_shape = (100, 50, 4)
... names = ["John", "Aaron", "Mike", "Danny"]
... hello = "Hello World!"
...
... print(data_shape[-1])
... print(names[-3:-1])
... print(hello[1:-1:2])
... 4
['Aaron', 'Mike']
el ol
2.檢查容器是否為空
容器是指可以存儲其他數(shù)據(jù)的那些容器數(shù)據(jù)類型。一些經(jīng)常使用的內(nèi)置容器是元組,列表,字典和集合。在處理這些容器時,我們經(jīng)常需要在執(zhí)行其他操作之前檢查它們是否包含任何元素。確實(shí),我們可以檢查這些容器的長度,該長度與已存儲項(xiàng)目的數(shù)量相對應(yīng)。當(dāng)長度為零時,容器為空。下面顯示了一個簡單的示例。
if len(some_list) > 0:
# do something here when the list is not empty
else:
# do something else when the list is empty
但是,這不是最好的Pythonic
方式。相反,我們可以簡單地檢查容器本身,它將在容器True
包含元素時進(jìn)行評估。盡管以下代碼向您展示了主要的容器數(shù)據(jù)類型,但這種用法也可以應(yīng)用于字符串(即,任何非空字符串都是True)。
>>> def check_container_empty(container):
... if container:
... print(f"{container} has elements.")
... else:
... print(f"{container} doesn't have elements.")
...
... check_container_empty([1, 2, 3])
... check_container_empty(set())
... check_container_empty({"zero": 0, "one": 1})
... check_container_empty(tuple())
... [1, 2, 3] has elements.
set() doesn't have elements.
{'zero': 0, 'one': 1} has elements.
() doesn't have elements.
3.使用Split()創(chuàng)建字符串列表
我們經(jīng)常使用字符串作為特定對象的標(biāo)識符。例如,我們可以使用字符串作為字典中的鍵。在數(shù)據(jù)科學(xué)項(xiàng)目中,字符串通常是數(shù)據(jù)的列名。選擇多個列時,不可避免地需要創(chuàng)建一個字符串列表。確實(shí),我們可以使用列表中的文字創(chuàng)建字符串。但是,我們必須編寫成對的引號將每個字符串括起來,這對于“懶惰”的人來說有點(diǎn)繁瑣。因此,我更喜歡利用字符串的split()
方法來創(chuàng)建字符串列表,如下面的代碼片段所示。
>>> # List of strings
... # The typical way
... columns = ['name', 'age', 'gender', 'address', 'account_type']
... print("* Literals:", columns)
...
... # Do this instead
... columns = 'name age gender address account_type'.split()
... print("* Split with spaces:", columns)
...
... # If the strings contain spaces, you can use commas instead
... columns = 'name, age, gender, address, account type'.split(', ')
... print("* Split with commas:", columns)
...
* Literals: ['name', 'age', 'gender', 'address', 'account_type']
* Split with spaces: ['name', 'age', 'gender', 'address', 'account_type']
* Split with commas: ['name', 'age', 'gender', 'address', 'account type']
如上所示,split()
默認(rèn)情況下,該方法使用空格作為分隔符,并根據(jù)字符串創(chuàng)建字符串列表。值得注意的是,當(dāng)您創(chuàng)建包含某些包含空格的元素的字符串列表時,可以選擇使用其他類型的分隔符(例如,逗號)。
這種用法受到一些內(nèi)置功能的啟發(fā)。例如,當(dāng)你創(chuàng)建一個元組類,我們可以這樣做:Student = namedtuple(“Student”, [“name”, “gender”, “age”])
。字符串列表指定了元組的“屬性”。但是,也可以通過以下方式定義該類來本地支持它:Student = namedtuple(“Student”, “name gender age”)
。對于另一個實(shí)例,創(chuàng)建一個Enum
類支持相同的替代解決方案。
(推薦教程:python教程)
4.三元表達(dá)
在許多用例中,我們需要根據(jù)條件定義具有特定值的變量,并且我們可以簡單地使用if ... else
語句來檢查條件。但是,它需要幾行代碼。如果僅處理一個變量的賦值,則可能需要使用三元表達(dá)式,該表達(dá)式檢查條件并僅用一行代碼即可完成賦值。此外,它的格式更短,從而使代碼更加簡潔。考慮以下示例。
# The typical way
if score > 90:
reward = "1000 dollars"
else:
reward = "500 dollars"
# Do this instead
reward = "1000 dollars" if score > 90 else "500 dollars"
有時,我們可以從已定義的函數(shù)中獲取一些數(shù)據(jù),并且可以利用這一點(diǎn)并編寫三元表達(dá)式的簡單操作,如下所示。
# Another possible scenario
# You got a reward amount from somewhere else, but don't know if None/0 or not
reward = reward_known or "500 dollars"
# The above line of code is equivalent to below
reward = reward_known if reward_known else "500 dollars"
5.帶文件對象的語句
我們經(jīng)常需要從文件讀取數(shù)據(jù)并將數(shù)據(jù)寫入文件。最常見的方法是使用內(nèi)置open()
函數(shù)簡單地打開文件,該函數(shù)會創(chuàng)建一個我們可以操作的文件對象。
>>> # Create a text file that has the text: Hello World!
...
... # Open the file and append some new data
... text_file0 = open("hello_world.txt", "a")
... text_file0.write("Hello Python!")
...
... # Open the file again for something else
... text_file1 = open("hello_world.txt")
... print(text_file1.read())
...
Hello World!
在前面的代碼片段中,我們從一個文本文件開始,該文件的文本為“ Hello World!”
。然后,我們將一些新數(shù)據(jù)附加到文件中。但是,過了一會兒,我們想再次處理該文件。當(dāng)我們讀取文本文件時,它仍然具有舊數(shù)據(jù)。換句話說,附加的文本不包括在文本文件中。
這是因?yàn)槲覀兪紫葲]有關(guān)閉文件對象。如果不關(guān)閉文件,則無法保存更改。確實(shí),我們可以close()
在文件對象上顯式調(diào)用該方法。但是,我們可以使用“with”
語句執(zhí)行此操作,該語句將自動為我們關(guān)閉文件對象,如下所示。完成對文件的操作后,我們可以通過訪問文件對象的closed
屬性來驗(yàn)證文件已關(guān)閉。
>>> with open("hello_world.txt", "a") as file:
... file.write("Hello Python!")
...
... with open("hello_world.txt") as file:
... print(file.read())
...
... print("Is file close?", file.closed)
...
Hello World!Hello Python!Hello Python!
Is file close? True
用更籠統(tǒng)的術(shù)語來說,with
語句是在Python
中使用上下文管理器的語法。上一個示例涉及文件操作,因?yàn)檫@些文件是共享資源,我們負(fù)責(zé)釋放這些資源。上下文管理器可以幫助我們完成工作。如前所示,文件操作結(jié)束后,將使用with
語句自動關(guān)閉文件。
6.評估多個條件
通常,我們需要評估多個條件。有幾種可能的方案。對于數(shù)值,我們可以對同一變量進(jìn)行多次比較。在這種情況下,我們可以鏈接這些比較。
# Multiple Comparisons
# The typical way
if a < 4 and a > 1:
# do something here# Do this instead
if 1 < a < 4:
# do somerthing here
在其他一些情況下,我們可以進(jìn)行多個相等比較,并且可以使用以下in
關(guān)鍵字進(jìn)行成員測試。
# The typical way
if b == "Mon" or b == "Wed" or b == "Fri" or b == "Sun":
# do something here# Do this instead, you can also specify a tuple ("Mon", "Wed", "Fri", "Sun")
if b in "Mon Wed Fri Sun".split():
# do something here
另一種技術(shù)是使用內(nèi)置的all()
和any()
函數(shù)用于評估多個條件的功能。具體而言,該all()
函數(shù)將評估何時迭代中的元素全部為True
,因此該函數(shù)適合于替換一系列AND
邏輯比較。另一方面,該any()
函數(shù)的計(jì)算結(jié)果為True
當(dāng)?shù)械娜魏卧貫?code>True,因此適合替換一系列OR
邏輯運(yùn)算。相關(guān)示例如下所示。
# The typical ways
if a < 10 and b > 5 and c == 4:
# do somethingif a < 10 or b > 5 or c == 4:
# do something# Do these instead
if all([a < 10, b > 5, c == 4]):
# do somethingif any([a < 10, b > 5, c == 4]):
# do something
7.在函數(shù)聲明中使用默認(rèn)值
在幾乎所有的Python
項(xiàng)目中,大多數(shù)代碼都涉及創(chuàng)建和調(diào)用函數(shù)。換句話說,我們不斷處理函數(shù)聲明和重構(gòu)。在許多情況下,我們需要多次調(diào)用一個函數(shù)。根據(jù)不同的參數(shù)集,該功能將略有不同。但是,有時一組參數(shù)可能比其他一組更常用,在這種情況下,我們在聲明函數(shù)時應(yīng)考慮設(shè)置默認(rèn)值??紤]下面的簡單示例。
# The original form:
def generate_plot(data, image_name):
"""This function creates a scatter plot for the data"""
# create the plot based on the data
...
if image_name:
# save the image
...# In many cases, we don't need to save the image
generate_plot(data, None)# The one with a default value
def generate_plot(data, image_name=None):
pass# Now, we can omit the second parameter
generate_plot(data)
要注意的一件事是,如果在設(shè)置默認(rèn)值時要處理可變數(shù)據(jù)類型(例如列表,集合),請確保使用None
而不是構(gòu)造函數(shù)(例如arg_name = []
)。由于Python
在定義的位置創(chuàng)建函數(shù)對象,因此提供的空白列表將被函數(shù)對象“卡住”。換句話說,調(diào)用函數(shù)對象時不會立即創(chuàng)建它。相反,我們將在內(nèi)存中處理相同的函數(shù)對象,包括其最初創(chuàng)建的默認(rèn)可變對象,這可能會導(dǎo)致意外行為。
8.使用計(jì)數(shù)器進(jìn)行元素計(jì)數(shù)
當(dāng)我們在列表、元組或字符串中有多個項(xiàng)目時(例如,多個字符),我們經(jīng)常想計(jì)算每項(xiàng)中有多少個元素。為此,可以為此功能編寫一些乏味的代碼。
>>> words = ['an', 'boy', 'girl', 'an', 'boy', 'dog', 'cat', 'Dog', 'CAT', 'an','GIRL', 'AN', 'dog', 'cat', 'cat', 'bag', 'BAG', 'BOY', 'boy', 'an']
... unique_words = {x.lower() for x in set(words)}
... for word in unique_words:
... print(f"* Count of {word}: {words.count(word)}")
...
* Count of cat: 3
* Count of bag: 1
* Count of boy: 3
* Count of dog: 2
* Count of an: 5
* Count of girl: 1
如上所示,我們首先必須創(chuàng)建一個僅包含唯一單詞的集合。然后,我們迭代單詞集,并使用該count()
方法找出每個單詞的出現(xiàn)情況。但是,有一種更好的方法可以使用Counter
類來完成此計(jì)數(shù)任務(wù)。
>>> from collections import Counter
...
... word_counter = Counter(x.lower() for x in words)
... print("Word Counts:", word_counter)
...
Word Counts: Counter({'an': 5, 'boy': 4, 'cat': 4, 'dog': 3, 'girl': 2, 'bag': 2})
該計(jì)數(shù)器類是在collections
模塊中可用的。要使用該類,我們只需創(chuàng)建一個generator:
,x.lower() for x in words
每個項(xiàng)目都將被計(jì)數(shù)。如我們所見,Counter
對象是類似dict
的映射對象,每個鍵對應(yīng)于單詞列表的唯一項(xiàng),而值是這些項(xiàng)的計(jì)數(shù)。
此外,如果我們有興趣找出單詞列表中最頻繁出現(xiàn)的項(xiàng)目,我們可以利用Counter
對象的most_common()
方法。以下代碼展示了這種用法。我們只需要指定一個整數(shù)(N),即可從列表中找出最頻繁的 N 個項(xiàng)目。附帶說明,該對象還將與其他序列數(shù)據(jù)一起使用,例如字符串和元組。
>>> # Find out the most common item
... print("Most Frequent:", word_counter.most_common(1))
Most Frequent: [('an', 5)]
>>> # Find out the most common 2 items
... print("Most Frequent:", word_counter.most_common(2))
Most Frequent: [('an', 5), ('boy', 4)]
9.按不同的訂單要求排序
在許多項(xiàng)目中,對列表中的項(xiàng)目進(jìn)行排序是一項(xiàng)普遍的任務(wù)。最基本的排序基于數(shù)字或字母順序,我們可以使用內(nèi)置sorted()
函數(shù)。默認(rèn)情況下,該sorted()
函數(shù)將按升序?qū)α斜磉M(jìn)行排序(實(shí)際上,它可以是可迭代的)。如果將reverse
參數(shù)指定為True
,則可以按降序獲得項(xiàng)目。一些簡單的用法如下所示。
>>> # A list of numbers and strings
... numbers = [1, 3, 7, 2, 5, 4]
... words = ['yay', 'bill', 'zen', 'del']
... # Sort them
... print(sorted(numbers))
... print(sorted(words))
...
[1, 2, 3, 4, 5, 7]
['bill', 'del', 'yay', 'zen']
>>> # Sort them in descending order
... print(sorted(numbers, reverse=True))
... print(sorted(words, reverse=True))
...
[7, 5, 4, 3, 2, 1]
['zen', 'yay', 'del', 'bill']
除了這些基本用法外,我們還可以指定key
參數(shù),以便可以對復(fù)雜項(xiàng)進(jìn)行排序,例如元組列表??紤]這種情況的以下示例。
>>> # Create a list of tuples
... grades = [('John', 95), ('Aaron', 99), ('Zack', 97), ('Don', 92), ('Jennifer', 100), ('Abby', 94), ('Zoe', 99), ('Dee', 93)]
>>> # Sort by the grades, descending
... sorted(grades, key=lambda x: x[1], reverse=True)
[('Jennifer', 100), ('Aaron', 99), ('Zoe', 99), ('Zack', 97), ('John', 95), ('Abby', 94), ('Dee', 93), ('Don', 92)]
>>> # Sort by the name's initial letter, ascending
... sorted(grades, key=lambda x: x[0][0])
[('Aaron', 99), ('Abby', 94), ('Don', 92), ('Dee', 93), ('John', 95), ('Jennifer', 100), ('Zack', 97), ('Zoe', 99)]
上面的代碼通過利用傳遞給key
參數(shù)的lambda
函數(shù),向我們展示了兩個高級排序的示例。第一個使用降序?qū)?xiàng)目進(jìn)行排序,第二個使用默認(rèn)的升序?qū)?xiàng)目進(jìn)行排序。我們要結(jié)合這兩個要求,如果考慮使用該reverse
參數(shù),則可能會得到一個錯誤的排序樹,因?yàn)槿绻麌L試按多個條件進(jìn)行排序,則反向參數(shù)將適用于所有參數(shù)。請參見下面的代碼段。
>>> # Requirement: sort by name initial ascending, and by grades, descending
... # Both won't work
... sorted(grades, key=lambda x: (x[0][0], x[1]), reverse=True)
[('Zoe', 99), ('Zack', 97), ('Jennifer', 100), ('John', 95), ('Dee', 93), ('Don', 92), ('Aaron', 99), ('Abby', 94)]
>>> sorted(grades, key=lambda x: (x[0][0], x[1]), reverse=False)
[('Abby', 94), ('Aaron', 99), ('Don', 92), ('Dee', 93), ('John', 95), ('Jennifer', 100), ('Zack', 97), ('Zoe', 99)]
>>> # This will do the trick
... sorted(grades, key=lambda x: (x[0][0], -x[1]))
[('Aaron', 99), ('Abby', 94), ('Dee', 93), ('Don', 92), ('Jennifer', 100), ('John', 95), ('Zoe', 99), ('Zack', 97)]
如您所見,通過將reverse
參數(shù)設(shè)置為True
或False
,都無效。取而代之的是,技巧是取反分?jǐn)?shù),因此,當(dāng)您按默認(rèn)的升序排序時,由于這些值的取反,分?jǐn)?shù)將反向排序。但是,此方法有一個警告,因?yàn)槿》粗荒苡糜跀?shù)字值,而不能用于字符串。
10.不要忘記defaultdict
字典是一種有效的數(shù)據(jù)類型,它使我們能夠以鍵值對的形式存儲數(shù)據(jù)。它要求所有鍵都是可哈希的,存儲這些數(shù)據(jù)可能涉及哈希表的使用。這種方法允許以 O(1) 效率實(shí)現(xiàn)數(shù)據(jù)檢索和插入。但是,應(yīng)注意,除了內(nèi)置的dict
類型外,我們還有其他可用的字典。其中,我想討論defaultdict
類型。與內(nèi)置dict
類型不同,defaultdict
允許我們設(shè)置默認(rèn)工廠函數(shù),該工廠函數(shù)在鍵不存在時創(chuàng)建元素。
>>> student = {'name': "John", 'age': 18}
... student['gender']
...
Traceback (most recent call last):
File "<input>", line 2, in <module>
KeyError: 'gender'
假設(shè)我們正在處理單詞,并且想要將與列表相同的字符分組,并且這些列表與作為鍵的字符相關(guān)聯(lián)。這是使用內(nèi)置dict
類型的幼稚實(shí)現(xiàn)。值得注意的是,檢查dict
對象是否具有letter
鍵是至關(guān)重要的,因?yàn)槿绻I不存在,則調(diào)用該append()
方法會引發(fā)KeyError
異常。
>>> letters = ["a", "a", "c", "d", "d", "c", "a", "b"]
... final_dict = {}
... for letter in letters:
... if letter not in final_dict:
... final_dict[letter] = []
... final_dict[letter].append(letter)
...
... print("Final Dict:", final_dict)
...
Final Dict: {'a': ['a', 'a', 'a'], 'c': ['c', 'c'], 'd': ['d', 'd'], 'b': ['b']}
讓我們看看如何使用defaultdict
編寫更簡潔的代碼。盡管該示例很簡單,但是它只是為我們提供了有關(guān)defaultdict
類的一些想法,這使我們不必處理字典對象中不存在的鍵。
>>> from collections import defaultdict
...
... final_defaultdict = defaultdict(list)
... for letter in letters:
... final_defaultdict[letter].append(letter)
...
... print("Final Default Dict:", final_defaultdict)
...
Final Default Dict: defaultdict(<class 'list'>, {'a': ['a', 'a', 'a'], 'c': ['c', 'c'], 'd': ['d', 'd'], 'b': ['b']})
(推薦微課:python3基礎(chǔ)微課)
結(jié)論
在閱讀本文之前,我們可能已經(jīng)了解了一些技巧,但是希望仍然對這些技巧有所了解。在項(xiàng)目中實(shí)踐這些慣用用法將使您的Python
代碼更具可讀性和性能。
文章來源:公眾號 - 小白學(xué)視覺
作者:花生
以上就是關(guān)于10個加快Python編程的小技巧的相關(guān)介紹了,希望對大家有所幫助。