Python 是一種通用編程語言，因其可讀性、面向對象的特性和強大的社區(qū)支持而廣受歡迎。除了用于 Web 應用程序之外，Python 還用于數(shù)據(jù)科學、人工智能、科學計算等各個領域。因此，如果你一直在考慮進入編程領域并尋找一種通用語言，那么 Python 可能適合你。在本文中將分享一些高級 Python 概念，這些概念將幫助你在扎根的同時取得成功。閱讀本文可以不必是經(jīng)驗豐富的 Python 程序員；它只會幫助你更好地理解語言并使你成為更好的開發(fā)人員。
推導式
推導式分為三種類型：列表推導、字典推導和集合推導。如果你想從現(xiàn)有的可迭代對象中創(chuàng)建新的列表、字典或集合，請使用推導式。以下代碼片段展示了這些用法
# 創(chuàng)建一個用于推導式的列表
numbers = [1, 2, 3, -3, -2, -1]
# 創(chuàng)建一個包含這些數(shù)字的方格的新列表
mylist = [x*x for x in numbers][1, 4, 9, 9, 4, 1]
# 為這些數(shù)字的冪創(chuàng)建一個新字典
mydict = {x: pow(10, x) for x in numbers}
# 輸出 {1: 10, 2: 100, 3: 1000, -3: 0.001, -2: 0.01, -1: 0.1}
# 創(chuàng)建一組這些數(shù)字的絕對值
myset = {abs(x) for x in numbers}
# 輸出 {1, 2, 3}
這些推導具有相似的語法。以下是對不同形式的簡要概述。值得注意的是可以設置條件以確保保留所需的元素
列表推導： [expr for x in iterable]
字典推導： {key_expr: value_expr for x in iterable}
集合推導： {expr for x in iterable}
可選條件：
[expr for x in iterable if condition]
{key_expr: value_expr for x in iterable if condition}
{expr for x in iterable if condition}
異常處理
異常是在程序執(zhí)行期間出現(xiàn)并導致程序中斷的情況。它可能由各種原因而發(fā)生。假設正在構建一個除法程序，并且分母包含 0，從而導致 ZeroDivisionError。導入不存在的庫或訪問不在列表索引中的元素是另外兩個實例。Python 帶有大約 30 個內置異常。 try和except塊用于處理python中的異常。except當我們需要同時處理多個異常時，我們可以使用多個塊。try塊是要執(zhí)行的指令。except塊包含執(zhí)行try失敗時執(zhí)行的代碼。還有else和finally塊。else塊僅在try成功執(zhí)行塊時執(zhí)行。finally無論前一個塊的結果如何，finally塊將始終執(zhí)行。
try:
a = int(input("Enter numerator:")
b = int(input("Enter denominator:")
c = a / b
print(c)
except ZeroDivisionError as e:
print(e, " please provide a non zero denominator")
import sys
try:
f = open('myfile.txt')
s = f.readline()
i = int(s.strip())
except OSError as err:
print("OS error: {0}".format(err))
except ValueError:
print("Could not convert data to an integer.")
except:
print("Unexpected error:", sys.exc_info()[0])
raise
finally:
print("Operation Successfully Done!!")(Example Taken From Official Python Docs)
集合庫
將可迭代對象作為輸入并返回一個字典，其中鍵是可迭代元素，值是它們各自在原始可迭代對象中出現(xiàn)的次數(shù)。
from collections import Counter
data = [1,1,1,1,2,3,4,3,3,5,6,7,7]
count = Counter(data)
print(count)
## Counter({1: 4, 3: 3, 7: 2, 2: 1, 4: 1, 5: 1, 6: 1})
生成可以使用名字來訪問元素內容的tuple子類，命名元組賦予每個位置一個含義，提供可讀性和自文檔性。
from collections import namedtuple
Direction = namedtuple('Direction','N,S,E,W')
dt = Direction(4,74,0,0)
print(dt)
# Direction(N=4, S=74, E=0, W=0)
這是一個記憶鍵插入順序的字典結構。最新版本的 python 中字典已經(jīng)包含了這個特性。
from collections import OrderedDict
dictt = OrderedDict()
dictt['a'] = 5
dictt['d'] = 2
dictt['c'] = 1
dictt['b'] = 3
print(dictt)
# OrderedDict([('a', 5), ('d', 2), ('c', 1), ('b', 3)])
這是一個字典結構，當訪問結構中不存在的鍵時將返回默認值，而不是引發(fā)錯誤。
from collections import defaultdict
dictt = defaultdict(int)
dictt['a'] = 2
print(dictt['a']) ##返回值
print(dictt['b']) ##返回默認值
# 2
# 0
雙端隊列，可以快速的從另外一側追加和推出對象,deque是一個雙向鏈表，針對list連續(xù)的數(shù)據(jù)結構插入和刪除進行優(yōu)化。它提供了兩端都可以操作的序列，這表示在序列的前后你都可以執(zhí)行添加或刪除操作。
from collections import deque
d = deque('abc')
d.append('d')
print(d)
# deque(['a', 'b', 'c', 'd'])
# appendleft 添加元素到左端
d.appendleft('e')
print(d)
# deque(['e','a', 'b', 'c', 'd'])
# clear 清除所有元素
d.clear()
print(d)
# deque([])
還有一些經(jīng)常用的方法比如pop,copy,count,extend,index,insert,popleft,remove,reverse,maxlen
迭代工具
Python itertools 模塊提供了適用于迭代器的各種函數(shù)。
- product(iterable,iterable) 兩個迭代的笛卡爾積。
- permutation(iterable) 沒有重復元素的所有可能排列。
- combinations(iterable,n) 來自可迭代的 n 個元素的所有可能組合，無需替換。
- combinations_with_replacement(iterable,n) 來自可迭代的 n 個元素的所有可能組合與替換。
- accumulate(iterable) 返回可迭代的元素的累積和。
- groupby(iterable, key=FUNC) 從可迭代對象中返回具有連續(xù)鍵和組的迭代器。
裝飾器
裝飾器是 Python 中修改函數(shù)和類行為的一種方式。它們允許你通過添加方法或更改參數(shù)來更改功能，或通過添加屬性來更改類。
例如，如果想在每次調用“my_function”函數(shù)時記錄日志，可以這樣編寫代碼：
def logging_func(original_func):
def wrapper(*args, **kwargs):
print(f"Called {original_func.__name__} with", args, kwargs)
return original_func(*args, **kwargs)
return wrapper
@logging_func
def add(a, b):
return a + b
result = add(5, 6)
print(result)
讓我們解釋上面的裝飾器的例子——首先，我們有一個函數(shù)名add，它的工作是獲取兩個變量并返回它們的總和。現(xiàn)在經(jīng)過一段時間的工作，我們意識到需要將功能記錄到相同的函數(shù)中?，F(xiàn)在我們有兩個選擇，第一個是在同一個add函數(shù)中添加函數(shù)調用日志代碼，或者我們可以使用裝飾器添加功能而不顯式更改函數(shù)。為了使用裝飾器，我們首先定義了一個裝飾器函數(shù)。該函數(shù)original_func作為輸入。然后，我們有另一個功能。它是一個具有*args, **kwargs函數(shù)參數(shù)的包裝函數(shù)。有了這些，現(xiàn)在都定義為參數(shù)，我們可以在函數(shù)內傳遞任意數(shù)量的參數(shù)。在包裝函數(shù)的主體中，我們有日志功能的邏輯。當我們add使用一些參數(shù)調用函數(shù)時add(5,6)，輸出將是：
生成器
生成器是一個返回可迭代值序列的函數(shù)。與一次返回所有元素并消耗整個列表長度的內存的列表不同，生成器會一個一個地生成項目。它至少包含一個yield聲明。yield是python中的一個關鍵字，用于從函數(shù)返回值而不破壞其當前狀態(tài)或對局部變量的引用。帶有yield關鍵字的函數(shù)稱為生成器。
比如最經(jīng)典的面試題斐波那契數(shù)列
def fibon(limit):
a,b = 0,1
while a < limit:
yield a
a, b = b, a + bfor x in fibon(10):
print (x)
魔術方法
Magic方法，__方法名前后有兩個下劃線。在某個動作上，這些方法直接從類中調用。當使用*a 符號將兩個數(shù)字相乘時，將__mul__調用內部過程。
num = 5
num*6
>> 30
num.__mul__(6)
>>30
通常，這些方法用于重載預定義的運算符。例如，數(shù)字運算符+,-,*,/必須在數(shù)字對象周圍使用，但+也可以用于連接兩個字符串。因此，我們可能會爭辯說+號操作符在執(zhí)行字符串連接消耗的內存大。
5+6
>>11
"python"+"programming"
>> 'pythonprogramming'
哈希性
在學習 Python 字典時，我們了解到鍵必須是可散列的。可哈希是什么意思？Hashable 基本上表示一個 Python 對象可以被散列，也就是散列的行為。下圖描述了散列的工作流程。
散列是使用散列函數(shù)（也稱為散列器）（在圖中稱為散列）將 Python 對象（在圖中稱為鍵）轉換為數(shù)字散列值的過程。使用內置的 hash() 方法來獲取 Python 對象的哈希值是一種判斷它是否存在的簡單方法。如果對象不可散列，Python 將拋出 TypeError 異常。
# Get an string object’s hash value
hash("This is me")
5361907397716593195
# Get a tuple object’s hash value
hash((1,2))
-3550055125485641917
# Get a list object’s hash value
hash([1, 2, 3])
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
TypeError: unhashable type: ‘list’
# Get a dict object’s hash value
hash({“a”: 1, “b”: 2})
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
TypeError: unhashable type: ‘dict’
特別是散列需要時間，并且比構造列表和元組要慢。
那么，為什么我們首先要費心使用散列創(chuàng)建字典呢？
在類似的問題上，你可能聽說過設置項也必須是可散列的。字典和集合都需要在底層創(chuàng)建哈希表。以下代碼片段演示了特定對象的哈希性如何影響它們作為字典鍵的適用性。哈希最顯著的好處是它們在檢索字典元素時提供即時查找時間（即 O(1) 時間復雜度）。檢查特定項目是否在集合中需要相同的時間。換句話說，使用散列作為實現(xiàn)機制減少了在后臺使用散列表的開銷，同時提高了一些常見操作（如項目檢索、項目插入和項目驗證）的效率。
import random
import timeit
# Create a function to check the look up time
def dict_look_up_time(n):
numbers = list(range(n))
random.shuffle(numbers)
d0 = {x: str(x) for x in numbers}
random_int = random.randint(0, n — 1)
t0 = timeit.timeit(lambda: d0[random_int], number=10000)
return t0
for n in (10, 100, 1000, 10000, 100000):
elapse_time = dict_look_up_time(n)
print(f”*** N = {n:<8}: {elapse_time:.5f}”)
*** N = 10 : 0.00114
*** N = 100 : 0.00256
*** N = 1000 : 0.00291
*** N = 10000 : 0.00207
*** N = 100000 : 0.00286
上面的代碼生成一些隨機整數(shù)來確定項目獲取的平均查找時間，來模擬真實情況。如你所見，即使字典中有 100,000 個條目，查找時間也幾乎相同，這證明了使用哈希表作為字典存儲機制的好處。
本文轉載自微信公眾號「樹哥會編程」，可以通過以下二維碼關注。轉載本文請聯(lián)系樹哥會編程公眾號。
