1. 切片

1a = "hello world"
2print(a[::-1])
3# dlrow olleh

2. 原地交換 / 同時賦值

1a = 1
 2b = 2
 3print(f"First: {a, b}")
 4# First: (1, 2)
 5
 6a, b = b, a + 2
 7print(f"Second: {a, b}")
 8# Second: (2, 3)
 9
10a, b* = 1, 2, 3
11print(a, b)
12# 1 [2, 3]

3. 列表和元組

1import sys
 2
 3a = [1, 2, 3, 4, 5]
 4b = (1, 2, 3, 4, 5)
 5
 6print(f"List size: {sys.getsizeof(a)} bytes")
 7print(f"Tuple size: {sys.getsizeof(b)} bytes")
 8
 9'''
10List size: 104 bytes
11Tuple size: 80 bytes
12'''

列表是可變的，元組不可變。在列表中，額外的內存會被分配以防我們擴展，被稱為動態內存分配。而在不希望更改數據的場景中，出于內存方面原因，元組數據結構應該優先于列表，元組也比列表快。

4. 生成器

1a = [x * 2 for x in range(10)]
 2b = (x * 2 for x in range(10))
 3
 4print(a)
 5print(b)
 6
 7"""
 8[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
 9

列表解析是從另一個可迭代對象創建列表的Python方式--它比使用for循環快得多。但是如果不小心將方括號從[]改為（），將得到一個生成器對象。每個元素只在請求時使用，也就是惰性計算，使用生成器的主要好處是，它使用的內存較少，因為整個序列不是一次構建的。

5. 混疊

1a = [1, 2, 3, 4 ,5]
 2b = a
 3
 4b[4] = 7
 5
 6print(id(a))
 7print(id(b))
 8print(a) 
 9
10"""
112278459070720
122278459070720
13[1, 2, 3, 4, 7]
14"""

Python是一種面向對象的編程語言--一切都是對象。因此，將對象分配給標識符就是創建對該對象的引用。

當我們將一個標識符賦給另一個標識符時，我們最終得到引用同一對象的兩個標識符。這是一個稱為混疊的概念。更改一個別名將影響另一個別名。有時候，這種行為是我們想要的，但通常，它讓我們措手不及。

一種解決方法是在使用可變對象時避免別名。另一個解決方案是創建原始對象的克隆，而不是引用。

創建克隆最直接的方法是利用切片：

1b = a[:]

6. 'not' 操作符

1a = []
2print(not a)
3
4"""
5True
6"""

下一個Python技巧是使用not操作符檢查數據結構是否為空的最簡單方法。Python內置的not是一個邏輯運算符，如果表達式不為真，它返回True，否則返回False

另一種使用方式是在if語句中：

1if not a:
2    # do something...

7. F-字符串

1first_name = "John"
2age = 19
3
4print(f"Hi, I'm {first_name} and I'm {age} years old!")
5
6"""
7Hi, I'm John and I'm 19 years old!
8"""

也可以使用：

1print("Hi, I'm {} and I'm {} years old!".format(first_name, age))

8. print函數中'end'參數

1a = ["english", "french", "spanish", "german", "twi"]
2for language in a:
3    print(language, end=" ")
4
5"""
6english french spanish german twi
7"""

使用print語句而不定義任何可選參數是很常見的。

我們可以更改的一個可選參數是end。end參數指定在調用print語句結束時應顯示的內容。

end的默認值是“\\n”，它告訴Python開始一個新行。在上面的代碼中，我們將其更改為空格。因此，返回的輸出中列表的所有元素都打印在同一行上。

9. 追加數據到元組

1a = (1, 2, [1, 2, 3])
2a[2].append(4)
3print(a)
4
5"""
6(1, 2, [1, 2, 3, 4])
7"""

我們已經知道元組是不可變的。嘗試更改元組的狀態將引發TypeError。但是，如果您將元組對象看作是綁定到不能更改的對象的名稱序列，元組的前兩個元素是整數--它們是不可變的。元組的最后一個元素是一個列表，在Python中是一個可變對象。

如果我們認為列表只是序列中的另一個名稱，它綁定到一個不能更改的對象，那么我們會意識到列表仍然可以從元組中修改。

10. 合并字典

1a = {"a": 1, "b": 2}
2b = {"c": 3, "d": 4}
3
4a_and_b = a | b
5print(a_and_b)
6
7"""
8{"a": 1, "b": 2, "c": 3, "d": 4}
9"""

在Python 3.9及更高版本中，可以使用 |。關于這個特殊的Python技巧，除了它是一個可讀性更強的解決方案之外，沒有什么可說的！

11. 三元運算符 / 條件表達式

1condition = True
2name = "John" if condition else "Doe"
3
4print(name)
5
6"""
7John
8"""

12. 從列表中去掉重復項

1a = [1, 1, 2, 3, 4, 5, 5, 5, 6, 7, 2, 2]
2print(list(set(a)))
3
4"""
5[1, 2, 3, 4, 5, 6, 7]
6"""

從列表中刪除重復元素的最簡單方法是將列表轉換為集合（如果愿意，然后再轉換回列表）。

集合和列表之間的關鍵區別是集合不能包含重復項。

13. 單獨下劃線

1>>> print(_)
2Traceback (most recent call last):
3  File "

下劃線(_)是Python中的合法的標識符，因此，可以使用它來引用對象。但強調還有另一個責任：以存儲最后的結果。文檔指出，“交互式解釋器使最后一次求值的結果在變量中可用。“

因為我們在第一行調用對象之前沒有給它賦值下劃線，所以我們得到了一個錯誤。但是，當我們計算1 + 2的輸出時，交互式解釋器為我們將結果存儲在_中。

14. 用下劃線表示忽略的值

1for _ in range(100):
2    print("The index doesn't matter")
3
4"""
5The index doesn't matter
6The index doesn't matter
7...
8"""

我們也可以用它來表示我們不關心的對象，或者在程序的后面不會使用的對象。

15. 尾部下劃線

1list_ = [0, 1, 2, 3, 4]
2global_ = "Hi there"

繼續前兩個技巧，Python的下劃線(_)用法，它的另一個目的是避免與Python關鍵字沖突。PEP8提到尾部下劃線（）應該按照約定使用，以避免與Python關鍵字沖突。它還指出，“通常最好附加一個尾隨下劃線，而不是使用縮寫。”因此list_優于lst。

16. 前置下劃線

1class Example:
2    def __init__(self):
3        self._internal = 2
4        self.external = 20

你經常會發現有經驗的Python程序員傾向于在標識符或方法名前面加上下劃線--這是有原因的。

標識符或方法前面的下劃線具有隱藏的含義：此變量或方法僅用于內部使用。本質上，它是對其他程序員的免責聲明，這些程序員在PEP 8中已經定義，但Python沒有強制執行。因此，前置下劃線是弱指示符。

17. 下劃線用于數字顯示

1number = 1_500_000
2print(number)
3
4"""
515000000
6"""

我們可以使用下劃線的另一種方式是作為整數、浮點數和復數常量中數字分組的可視分隔符--這是在Python 3.6中引入的。這樣做的目的是為了提高長文本的可讀性。

18. name == " main "

1if __name__ == "__main__":
2    print("Read on to understand what is going on when you do this.")
3
4"""
5print("Read on to understand what is going on when you do this.")
6"""

你很有可能在幾個Python程序中見過這種語法;Python使用一個特殊的名稱__main__，如果運行的Python文件是主程序，則將其設置為一個名為__name__的標識符。如果我們決定將當前顯示的模塊導入到另一個模塊（Python文件）中并運行該文件，則代碼中表達式的值將為false。這是因為當我們從另一個模塊導入時，__name__標識符被設置為模塊（Python文件）的名稱。

19. setdefault 方法

1import pprint
 2
 3text = "It's the first of April. It's still cold in the UK. But I'm going to the museum so it should be a wonderful day"
 4
 5counts = {}
 6for word in text.split():
 7    counts.setdefault(word, 0)
 8    counts[word] += 1
 9
10pprint.pprint(counts)
11
12"""
13{'April.': 1,
14"It's": 2,
15'UK.': 1,
16...
17'still': 1,
18'the': 3,
19'to': 1,
20'wonderful': 1}
21"
22

可能會碰到這種需求，檢查元素是否存在一個字典中，存在當前值加1，不存在添加當前值并設置其為1，看起來如下：

1counts = {}
2for word in text.split():
3    if word in counts:
4        counts[word] += 1
5    else:
6      counts[word] = 1

更簡潔的方法是在dictionary對象上使用setdefault（）方法。

傳遞給方法的第一個參數是我們要檢查的鍵。傳遞的第二個參數是當鍵在字典中不存在時設置鍵的值-如果鍵存在，則方法將返回鍵值。因此，不會對其進行更改。

20. 正則匹配

1import re
 2
 3number = re.compile(r"(0?)(\\+44)?\\d(10)")
 4num_1 = number.search("My number is +447999999999")
 5num_2 = number.search("My number is 07999999999")
 6
 7print(num_1.group())
 8print(num_2.group())
 9
10"""
11'+447999999999'
12'07999999999'
13"""

21. 正則表達式管道‘|’使用

1import re
 2
 3heros = re.compile(r"Super(man|woman|human)")
 4
 5h1 = heros.search("This will find Superman")
 6h2 =  heros.search("This will find Superwoman")
 7h3 = heros.search("This will find Superhuman")
 8
 9print(h1.group())
10print(h2.group())
11print(h3.group())
12
13"""
14Superman
15Superwoman
16Superhuman
17"""

正則表達式有一個特殊字符，稱為管道（|），它允許您匹配許多表達式中的一個，并且它們可以在任何地方使用。

22. print函數中‘sep’參數

1day = "04"
 2month = "10"
 3year = "2023"
 4
 5print(day, month, year)
 6print(day, month, year, sep = "")
 7print(day, month, year, sep = ".")
 8
 9"""
1004 10 2023
1104/10/2023
1204.10.2023
13"""

sep參數是print（）函數中的一個可選參數，它允許我們指定在包含多個對象時應該如何分隔對象。

默認情況下是用空格分隔它們。

23. Lambda 函數

1def square(num:int) -> int:
 2    return num ** 2
 3
 4print(f"Function call: {square(4)}")
 5"""
 6Function call: 16
 7"""
 8
 9square_lambda = lambda x: x**2
10print(f"Lambda function: {square_lambda(4)}")
11"""
12Lambda functional: 16
13"""

本質上，lambda關鍵字允許我們在一行中創建小的、受限的、匿名的函數。它們的行為與使用def關鍵字聲明的常規函數相同，只是這些函數沒有名稱。

24. swapcase方法

1string = "SoMe RaNDoM sTriNg"
2print(string.swapcase())
3
4"""
5sOmE rAndOm StRInG
6"""

swapcase（）方法應用于字符串對象，允許我們在一行代碼中將大寫字母改為小寫字母，反之亦然。swapcase（）方法的用例并不多，但了解一下還是很不錯的。

25. isalnum方法

1password = "ABCabc123"
2print(password.isalnum())
3
4"""
5True
6"""

假設我們正在創建一個程序，要求用戶輸入密碼，但密碼必須是數字和字母的組合。我們可以通過調用string實例上的isalnum（）在一行代碼中完成此操作。

該方法檢查所有字符是否都是字母表（A-Za-z）和數字（0 - 9）的一部分。空格或符號（!# %$&？等等）將返回False。

26. 異常處理

1def get_ration(x:int, y:int) -> int:
 2    try:
 3        ratio = x/y
 4    except: ZeroDivisionError:
 5        y = y + 1
 6        ratio = x/y
 7    return ratio
 8
 9print(get_ratio(x=400, y=0))
10
11"""
12400.0
13"""

Python程序在遇到錯誤時終止。

有時候，我們不希望出現這種行為，比如當最終用戶與我們的代碼交互時。如果我們的代碼在這種情況下過早終止，會有多糟糕？

關于如何處理這種例外情況，有幾種思路。大多數Python程序員通常都認為請求原諒比獲得許可更容易。這意味著它們更愿意通過提供能夠處理異常的周圍上下文來捕獲引發的錯誤。這種想法背后的思想是，浪費時間試圖防范所有各種例外情況是沒有意義的。

但這只有在問題發生后有一種處理機制的情況下才成立。

27. 比較兩個的列表差異

1list_1 = [1, 3, 5, 7, 8]
 2list_2 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
 3
 4solution_1 = list(set(list_2) - set(list_1))
 5solution_2 = list(set(list_1) ^ set(list_2))
 6solution_3 = list(set(list_1).symmetric_difference(set(list_2)))
 7
 8print(f"Solution 1: {solution_1}")
 9print(f"Solution 2: {solution_2}")
10print(f"Solution 3: {solution_3}")
11
12"""
13Solution 1: [9, 2, 4, 6]
14Solution 2: [2, 4, 6, 9]
15Solution 3: [2, 4, 6, 9]
16"""

這里有三種不同的方法來比較Python中兩個列表之間的差異。

注意：除非你知道list_1是list_2的子集，否則solution 1和其他兩個solution是不一樣的。

28. Args & Kwargs

1def some_function(*args, **kwargs):
 2    print(f"Args: {args}")
 3    print(f"Kwargs: {kwargs}")
 4
 5some_function(1, 2, 3,  a=4, b=5, c=6)
 6
 7"""
 8Args: (1, 2, 3)
 9Kwargs: {'a': 4, 'b': 5, 'c': 6}
10"""

當我們不知道函數應該包含多少變量時，我們使用 *args和 **kwargs作為函數的參數。參數 *args允許我們在函數沒有關鍵字時（即：我們傳遞的參數不需要相關聯的名稱）。另一方面，kwargs參數使我們能夠向函數傳遞任意數量的關鍵字參數。

事實上，*args和 **kwargs這兩個詞并沒有那么神奇：真正的魔力在于星號（）。這意味著我們可以在星號后面使用任何單詞，但是使用args和kwargs是常見的做法。

29. 省略號

1print(...)
 2
 3"""
 4Ellipsis
 5"""
 6
 7def some_function():
 8    ...
 9
10# Alternative solution
11def another_function():
12    pass

省略號是一個Python對象，可以通過提供三個點（…）的序列來調用它。或者調用對象本身（省略號）。

它最值得注意的用法是訪問NumPy中的多維數組并對其進行切片，例如：

1import numpy as np
 2
 3arr = np.array([[2,3], [1,2], [9,8]])
 4
 5print(arr[...,0])
 6"""
 7[2 1 9]
 8"""
 9print(arr[...])
10
11"""
12[[2 3]
13[1 2]
14[9 8]]
15"""

30. 列表推導式

1even_numbers = [x for x in range(10) if x % 2 == 0 and x != 0]
2print(even_numbers)
3
4"""
5[2, 4, 6, 8]
6"""

Python的最后一個技巧是列表解析，這是一種從另一個序列創建列表的優雅方法。它們允許您執行復雜的邏輯和過濾，就像我們在上面的代碼中所做的那樣。

還有其他方法可以達到同樣的目的;例如，我們可以使用lambda函數，如下所示：

1even_numbers = list(filter(lambda x: x % 2 ==0 and x != 0, range(10)))
2print(even_numbers)
3"""
4[0, 2, 4, 6, 8]
5"""