Python編程的若干個經典小技巧

1. 原地交換兩個數字

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

x,y= 10,20

print(x,y)

x,y= y,x

print(x,y)

#1 (10, 20)

#2 (20, 10)

賦值的右側造成了一個新的元組，左側當即解析（unpack）那個（未被引用的）元組到變量 <a> 和 <b>。

一旦賦值完成，新的元組變成了未被引用狀態而且被標記爲可被垃圾回收，最終也完成了變量的交換。

2. 鏈狀比較操做符

比較操做符的聚合是另外一個有時很方便的技巧：

n= 10

result= 1< n< 20

print(result)

# True

result= 1> n<= 9

print(result)

# False

3. 使用三元操做符來進行條件賦值

三元操做符是 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 是兩個類，其中一個類的構造函數會被調用。

下面是另外一個多個條件表達式連接起來用以計算最小值的例子：

def small(a,b,c):

returnaifa<= banda<= celse(bifb<= aandb<= celsec)

print(small(1,0,1))

print(small(1,2,2))

print(small(2,2,3))

print(small(5,4,3))

#Output

#0 #1 #2 #3

咱們甚至能夠在列表推導中使用三元運算符：

[m**2 if m > 10 else m**4 for m in range(50)]

#=> [0, 1, 16, 81, 256, 625, 1296, 2401, 4096, 6561, 10000, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 729, 784, 841, 900, 961, 1024, 1089, 1156, 1225, 1296, 1369, 1444, 1521, 1600, 1681, 1764, 1849, 1936, 2025, 2116, 2209, 2304, 2401]

4. 多行字符串

基本的方式是使用源於 C 語言的反斜槓：

multiStr= 「select * from multi_row

where row_id < 5」

print(multiStr)

# select * from multi_row where row_id < 5

另外一個技巧是使用三引號：

multiStr= 「」」select * from multi_row

where row_id < 5″」」

print(multiStr)

#select * from multi_row

#where row_id < 5

上面方法共有的問題是缺乏合適的縮進，若是咱們嘗試縮進會在字符串中插入空格。因此最後的解決方案是將字符串分爲多行而且將整個字符串包含在括號中：

multiStr= (「select * from multi_row 」

「where row_id < 5 」

「order by age」)

print(multiStr)

#select * from multi_row where row_id < 5 order by age

5. 存儲列表元素到新的變量中

咱們能夠使用列表來初始化多個變量，在解析列表時，變量的數目不該該超過列表中的元素個數：【譯者注：元素個數與列表長度應該嚴格相同，否則會報錯】

testList= [1,2,3]

x,y,z= testList

print(x,y,z)

#-> 1 2 3

6. 打印引入模塊的文件路徑

若是你想知道引用到代碼中模塊的絕對路徑，能夠使用下面的技巧：

import threading

import socket

print(threading)

print(socket)

#1- <module ‘threading’ from ‘/usr/lib/python2.7/threading.py’>

#2- <module ‘socket’ from ‘/usr/lib/python2.7/socket.py’>

7. 交互環境下的 「_」 操做符

這是一個咱們大多數人不知道的有用特性，在 Python 控制檯，不論什麼時候咱們測試一個表達式或者調用一個方法，結果都會分配給一個臨時變量： _（一個下劃線）。

>>> 2+ 1

3

>>> _

3

>>> print_

3

「_」 是上一個執行的表達式的輸出。

8. 字典/集合推導

與咱們使用的列表推導類似，咱們也能夠使用字典/集合推導，它們使用起來簡單且有效，下面是一個例子：

testDict= {i: i *iforiinxrange(10)}

testSet= {i *2foriinxrange(10)}

print(testSet)

print(testDict)

#set([0, 2, 4, 6, 8, 10, 12, 14, 16, 18])

#{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

注：兩個語句中只有一個 <:> 的不一樣，另，在 Python3 中運行上述代碼時，將 <xrange> 改成 <range>。

9. 調試腳本

咱們能夠在 <pdb> 模塊的幫助下在 Python 腳本中設置斷點，下面是一個例子：

import pdb

pdb.set_trace()

咱們能夠在腳本中任何位置指定 <pdb.set_trace()> 而且在那裏設置一個斷點，至關簡便。

10. 開啓文件分享

Python 容許運行一個 HTTP 服務器來從根路徑共享文件，下面是開啓服務器的命令：

# Python 2

python -m SimpleHTTPServer

# Python 3

python3 -m http.server

上面的命令會在默認端口也就是 8000 開啓一個服務器，你能夠將一個自定義的端口號以最後一個參數的方式傳遞到上面的命令中。

11. 檢查 Python 中的對象

咱們能夠經過調用 dir() 方法來檢查 Python 中的對象，下面是一個簡單的例子：

test= [1,3,5,7]

print(dir(test))

[‘__add__’, ‘__class__’, ‘__contains__’, ‘__delattr__’, ‘__delitem__’, ‘__delslice__’, ‘__doc__’, ‘__eq__’, ‘__format__’, ‘__ge__’, ‘__getattribute__’, ‘__getitem__’, ‘__getslice__’, ‘__gt__’, ‘__hash__’, ‘__iadd__’, ‘__imul__’, ‘__init__’, ‘__iter__’, ‘__le__’, ‘__len__’, ‘__lt__’, ‘__mul__’, ‘__ne__’, ‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__reversed__’, ‘__rmul__’, ‘__setattr__’, ‘__setitem__’, ‘__setslice__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘append’, ‘count’, ‘extend’, ‘index’, ‘insert’, ‘pop’, ‘remove’, ‘reverse’, ‘sort’]

12. 簡化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) 操做。

13. 一行代碼計算任何數的階乘

Python 2.x.

result= (lambdak: reduce(int.__mul__,range(1,k+1),1))(3)

print(result)

#-> 6

Python 3.x.

import functools

result= (lambdak: functools.reduce(int.__mul__,range(1,k+1),1))(3)

print(result)

#-> 6

14. 找到列表中出現最頻繁的數

test= [1,2,3,4,2,2,3,1,4,4,4]

print(max(set(test),key=test.count))

#-> 4

15. 重置遞歸限制

Python 限制遞歸次數到 1000，咱們能夠重置這個值：

import sys

x=1001

print(sys.getrecursionlimit())

sys.setrecursionlimit(x)

print(sys.getrecursionlimit())

#1-> 1000

#2-> 1001

請只在必要的時候採用上面的技巧。

16. 檢查一個對象的內存使用

在 Python 2.7 中，一個 32 比特的整數佔用 24 字節，在 Python 3.5 中利用 28 字節。爲肯定內存使用，咱們能夠調用 getsizeof 方法：

在 Python 2.7 中

import sys

x=1

print(sys.getsizeof(x))

#-> 24

在 Python 3.5 中

import sys

x=1

print(sys.getsizeof(x))

#-> 28

17. 使用 __slots__ 來減小內存開支

你是否注意到你的 Python 應用佔用許多資源特別是內存？有一個技巧是使用 __slots__ 類變量來在必定程度上減小內存開支。

import sys

classFileSystem(object):

def __init__(self,files,folders,devices):

self.files= files

self.folders= folders

self.devices= devices

print(sys.getsizeof(FileSystem))

classFileSystem1(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__。只在對應用進行性能分析後才使用它，否則地話，你只是使得代碼難以改變而沒有真正的益處。

【譯者注：在個人 win10 python2.7 中上面的結果是：

#In Python 2.7 win10

#1-> 896

#2-> 1016

因此，這種比較方式是不那麼讓人信服的，使用 __slots__ 主要是用以限定對象的屬性信息，另外，當生成對象不少時花銷可能會小一些，具體能夠參見 python 官方文檔:

The slots declaration takes a sequence of instance variables and reserves just enough space in each instance to hold a value for each variable. Space is saved because dict is not created for each instance. 】

18. 使用 lambda 來模仿輸出方法

import sys

lprint=lambda *args:sys.stdout.write(」 「.join(map(str,args)))

lprint(「python」,」tips」,1000,1001)

#-> python tips 1000 1001

19.從兩個相關的序列構建一個字典

t1= (1,2,3)

t2= (10,20,30)

print(dict(zip(t1,t2)))

#-> {1: 10, 2: 20, 3: 30}

20. 一行代碼搜索字符串的多個先後綴

print(「http://www.google.com」.startswith((「http://」,」https://」)))

print(「http://www.google.co.uk」.endswith((「.com」,」.co.uk」)))

#1-> True

#2-> True

21. 不使用循環構造一個列表

import itertools

test= [[-1,-2],[30,40],[25,35]]

print(list(itertools.chain.from_iterable(test)))

#-> [-1, -2, 30, 40, 25, 35]

22. 在 Python 中實現一個真正的 switch-case 語句

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

def xswitch(x):

returnxswitch._system_dict.get(x,None)

xswitch._system_dict= {‘files’: 10,’folders’: 5,’devices’: 2}

print(xswitch(‘default’))

print(xswitch(‘devices’))

#1-> None

#2-> 2