前言

先收藏，再點贊，今后好運定不斷！

各位CSDN上的朋友們大家好，先厚臉皮討要個三連支持吧！希望這篇文章能幫助到你！

好了！廢話不多說，直接上干貨：

1、使用字典來存盤選擇操作

我們能構造一個字典來存盤運算式：

In [70]: stdacl = { 
    ...: 'sum':lambda x,y : x + y,
    ...: 'subtract':lambda x,y : x - y 
    ...: } 
 
In [73]: stdacl['sum'](9,3) 
Out[73]: 12
 
In [74]: stdacl['subtract'](9,3) 
Out[74]: 6

2、一行代碼計算任何數的階乘

python3環境：

In [75]: import functools
 
In [76]: result = ( lambda k : functools.reduce(int.__mul__,range(1,k+1),1))(3) 
 
In [77]: result
Out[77]: 6

3、找到串列中出現最頻繁的數

 
In [82]: test = [1,2,3,4,2,2,3,1,4,4,4] 
 
In [83]: print(max(set(test),key=test.count)) 
4

4、重置遞回限制

Python 限制遞回次數到 1000，我們可以重置這個值：

import sys
 
x=1001
print(sys.getrecursionlimit())
 
sys.setrecursionlimit(x)
print(sys.getrecursionlimit())
 
#1-> 1000
#2-> 100

5、原地交換兩個數字

Python 提供了一個直觀的在一行代碼中賦值與交換（變數值）的方法，請參見下面的示例：

In [1]: x,y = 10 ,20 
 
In [2]: print(x,y)
10 20
 
In [3]: x, y = y, x 
 
In [4]: print(x,y)
20 10

賦值的右側形成了一個新的元組，左側立即決議（unpack）那個（未被參考的）元組到變數 和 ，

一旦賦值完成，新的元組變成了未被參考狀態并且被標記為可被垃圾回收，最終也完成了變數的交換，

6、鏈狀比較運算子

比較運算子的聚合是另一個有時很方便的技巧：

In [5]: n = 10 
 
In [6]: result = 1 < n < 20 
 
In [7]: result 
Out[7]: True
 
In [8]: result = 1 > n <= 9 
 
In [9]: result 
Out[9]: False

7、使用三元運算子來進行條件賦值

三元運算子是 if-else 陳述句也就是條件運算子的一個快捷方式：

[運算式為真的回傳值] if [運算式] else [運算式為假的回傳值]

這里給出幾個你可以用來使代碼緊湊簡潔的例子，下面的陳述句是說“如果 y 是 9，給 x 賦值 10，不然賦值為 20”，如果需要的話我們也可以延長這條操作鏈，

x = 10 if (y == 9) else 20

同樣地，我們可以對類做這種操作：

x = (classA if y == 1 else classB)(param1, param2)

在上面的例子里 classA 與 classB 是兩個類，其中一個類的建構式會被呼叫.

下面是另一個多個條件運算式鏈接起來用以計算最小值的例子:

In [10]: def small(a,b,c):
    ...:     return a if a<=b and a<=c else ( b if b<=a and b<=c else c) 
    ...: 
 
In [11]: small(1,0,1)
Out[11]: 0
 
In [12]: small(1,2,3)
Out[12]: 1

我們甚至可以在串列推導中使用三元運算子：

In [14]: [ m**2 if m > 10 else m**4 for m in range(20) ] 
Out[14]: 
[0,1,16,81,256,625,1296,2401,4096,6561,10000,121,144,169,196,225,256,289,324,61]

8、檢查一個物件的記憶體使用

在 Python 2.7 中，一個 32 位元的整數占用 24 位元組，在 Python 3.5 中利用 28 位元組，為確定記憶體使用，我們可以呼叫 getsizeof 方法：

python2.7：


    import sys
    x=1
    print(sys.getsizeof(x))
     
    #-> 24

python3：

    In [86]: import sys 
     
    In [87]: x = 1
     
    In [88]: sys.getsizeof(x) 
    Out[88]: 28

9、使用slots來減少記憶體開支

你是否注意到你的 Python 應用占用許多資源特別是記憶體？有一個技巧是使用 slots 類變數來在一定程度上減少記憶體開支，

```python
   import sys
    class FileSystem(object):
     
        def __init__(self, files, folders, devices):
            self.files = files
            self.folders = folders
            self.devices = devices
    print(sys.getsizeof( FileSystem ))
     
    class FileSystem1(object):
     
        __slots__ = ['files', 'folders', 'devices']
        def __init__(self, files, folders, devices):
            self.files = files
            self.folders = folders
            self.devices = devices
     
    print(sys.getsizeof( FileSystem1 ))
    #In Python 3.5
    #1-> 1016
    #2-> 888

很明顯，你可以從結果中看到確實有記憶體使用上的節省，但是你只應該在一個類的記憶體開銷不必要得大時才使用 slots，只在對應用進行性能分析后才使用它，不然地話，你只是使得代碼難以改變而沒有真正的益處，

10、使用lambda來模仿輸出方法

 In [89]: import sys 
     
    In [90]: lprint = lambda *args: sys.stdout.write("".join(map(str,args))) 
     
    In [91]: lprint("python","tips",1000,1001) 
    Out[91]: pythontips1000100118

11、從兩個相關的序列構建一個字典

In [92]: t1 = (1,2,3) 
 
In [93]: t2 =(10,20,30) 
 
In [94]: dict(zip(t1,t2)) 
Out[94]: {1: 10, 2: 20, 3: 30}

12、一行代碼搜索字串的多個前后綴

In [95]: print("http://www.google.com".startswith(("http://", "https://")))
True
 
In [96]: print("http://www.google.co.uk".endswith((".com", ".co.uk")))
True

13、在Python中實作一個真正的switch-case陳述句

下面的代碼使用一個字典來模擬構造一個switch-case，

   In [104]: def xswitch(x):
         ...:     return xswitch._system_dict.get(x, None) 
         ...: 
     
    In [105]: xswitch._system_dict = {'files': 10, 'folders': 5, 'devices': 2}
     
    In [106]: print(xswitch('default'))
    None
     
    In [107]: print(xswitch('devices'))
    2

14、多行字串

基本的方式是使用源于 C 語言的反斜杠：

 In [20]: multistr = " select * from multi_row \
        ...: where row_id < 5"
    In [21]: multistr
    Out[21]: ' select * from multi_row where row_id < 5'

另一個技巧是使用三引號

In [23]: multistr ="""select * from multi_row 
    ...: where row_id < 5"""
 
In [24]: multistr
Out[24]: 'select * from multi_row \nwhere row_id < 5'

上面方法共有的問題是缺少合適的縮進，如果我們嘗試縮進會在字串中插入空格，所以最后的解決方案是將字串分為多行并且將整個字串包含在括號中：

In [25]: multistr = ("select * from multi_row "
    ...: "where row_id < 5 " 
    ...: "order by age")  
In [26]: multistr
Out[26]: 'select * from multi_row where row_id < 5 order by age'

15、存盤串列元素到新的變數中

我們可以使用串列來初始化多個變數，在決議串列時，變數的數目不應該超過串列中的元素個數：【譯者注：元素個數與串列長度應該嚴格相同，不然會報錯】

In [27]: testlist = [1,2,3] 
 
In [28]: x,y,z = testlist 
 
In [29]: print(x,y,z) 
1 2 3

16、四種翻轉字串/串列的方式

翻轉串列本身

In [49]: testList = [1, 3, 5] 
 
In [50]: testList.reverse() 
 
In [51]: testList
Out[51]: [5, 3, 1]

在一個回圈中翻轉并迭代輸出

In [52]: for element in reversed([1,3,5]):
    ...:     print(element) 
    ...:     
5
3
1

一行代碼翻轉字串

In [53]: "Test Python"[::-1]
Out[53]: 'nohtyP tseT'

使用切片翻轉串列

[1, 3, 5][::-1]

17.玩轉列舉

使用列舉可以在回圈中方便地找到（當前的）索引：

In [54]: testList= [10,20,30] 
 
In [55]: for i,value in enumerate(testList):
    ...:     print(i,':',value)
    ...:     
0 : 10
1 : 20
2 : 30

18.在python中使用列舉量

我們可以使用下面的方式來定義列舉量：

In [56]: class Shapes:
    ...:     Circle,Square,Triangle,Quadrangle = range(4) 
    ...:     
 
In [57]: Shapes.Circle
Out[57]: 0
 
In [58]: Shapes.Square
Out[58]: 1
 
In [59]: Shapes.Triangle
Out[59]: 2
 
In [60]: Shapes.Quadrangle
Out[60]: 3

19.從方法中回傳多個值

并沒有太多編程語言支持這個特性，然而 Python 中的方法確實（可以）回傳多個值，請參見下面的例子來看看這是如何作業的：

In [61]: def x():
    ...:     return 1,2,3,4 
    ...: 
 
In [62]: a,b,c,d = x()
 
In [63]: print(a,b,c,d) 
1 2 3 4

20.列印引入模塊的檔案路徑

如果你想知道參考到代碼中模塊的絕對路徑，可以使用下面的技巧：

In [30]: import threading 
 
In [31]: import socket 
 
In [32]: print(threading)
<module 'threading' from '/usr/local/lib/python3.5/threading.py'>
 
In [33]: print(socket) 
<module 'socket' from '/usr/local/lib/python3.5/socket.py'>

21.互動環境下的"_"運算子

這是一個我們大多數人不知道的有用特性，在 Python 控制臺，不論何時我們測驗一個運算式或者呼叫一個方法，結果都會分配給一個臨時變數： _（一個下劃線），

In [34]: 2 + 3 
Out[34]: 5
 
In [35]: _
Out[35]: 5
 
In [36]: print(_) 
5

“_” 是上一個執行的運算式的輸出，

22.字典/集合推導式

與我們使用的串列推導相似，我們也可以使用字典/集合推導，它們使用起來簡單且有效，下面是一個例子：

In [37]: testDict = {i : i*i for i in range(5)} 
 
In [38]: testSet = { i*2 for i in range(5)} 
 
In [39]: testDict
Out[39]: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
 
In [40]: testSet
Out[40]: {0, 2, 4, 6, 8}

注：兩個陳述句中只有一個 <:> 的不同，另，在 Python3 中運行上述代碼時，將 改為 ，

23、除錯腳本

我們可以在 模塊的幫助下在 Python 腳本中設定斷點，下面是一個例子：

import pdb
pdb.set_trace()

我們可以在腳本中任何位置指定 <pdb.set_trace()> 并且在那里設定一個斷點，相當簡便，

24、開啟檔案分享

Python 允許運行一個 HTTP 服務器來從根路徑共享檔案，下面是開啟服務器的命令：（python3環境）

python3 -m http.server

上面的命令會在默認埠也就是 8000 開啟一個服務器，你可以將一個自定義的埠號以最后一個引數的方式傳遞到上面的命令中，

Paste_Image.png

25、檢查Python中的物件

我們可以通過呼叫 dir() 方法來檢查 Python 中的物件，下面是一個簡單的例子：

In [41]: test = [1,3,5,7]
 
In [42]: print(dir(test)) 
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

會列出物件的屬性方法，

26、簡化if陳述句

我們可以使用下面的方式來驗證多個值：

 if m in [1,3,5,7]:

而不是

if m==1 or m==3 or m==5 or m==7:

或者，對于 in 運算子我們也可以使用 ‘{1,3,5,7}’ 而不是 ‘[1,3,5,7]’，因為 set 中取元素是 O(1) 操作，

27、運行時檢測Python版本

當正在運行的 Python 低于支持的版本時，有時我們也許不想運行我們的程式，為達到這個目標，你可以使用下面的代碼片段，它也以可讀的方式輸出當前 Python 版本：

import sys
 
#Detect the Python version currently in use.
if not hasattr(sys, "hexversion") or sys.hexversion != 50660080:
    print("Sorry, you aren't running on Python 3.5n")
    print("Please upgrade to 3.5.n")
    sys.exit(1)
 
#Print Python version in a readable format.
print("Current Python version: ", sys.version)

或者你可以使用 sys.version_info >= (3, 5) 來替換上面代碼中的 sys.hexversion != 50660080，這是一個讀者的建議，

python3運行結果：

Python 3.5.1 (default, Dec 2015, 13:05:11)
[GCC 4.8.2] on linux
 
Current Python version:  3.5.2 (default, Aug 22 2016, 21:11:05) 
[GCC 5.3.0]

28、組合多個字串

如果你想拼接串列中的所有記號，比如下面的例子：

In [44]: test = ['I', 'Like', 'Python', 'automation']
 
In [45]: ''.join(test)
Out[45]: 'ILikePythonautomation'

29、 不使用回圈構造一個串列

In [101]: test = [[-1, -2], [30, 40], [25, 35]] 
 
In [102]: import itertools
 
In [103]: print(list(itertools.chain.from_iterable(test)))
[-1, -2, 30, 40, 25, 35]