一、原地交換

Python 提供了一個直觀的在一行代碼中賦值與交換（變數值）的方法

x, y = 10, 20
print(x, y)
 
x, y = y, x
print(x, y)
 
#1 (10, 20)
#2 (20, 10)

原理：賦值的右側形成了一個新的元組，左側立即解析（unpack）那個（未被引用的）元組到變數 <a> 和 <b>。一旦賦值完成，新的元組變成了未被引用狀態並且被標記為可被垃圾回收，最終也完成了變數的交換。

二、鏈狀比較操作符

Python不用很多條件一個一個寫，比較操作符可以聚合。

n = 10
result = 1 < n < 20
print(result)
 
# True
 
result = 1 > n <= 9
print(result)
 
# False

三、三元操作符進行條件賦值

三元操作符是 if-else 語句也就是條件操作符的一個快捷方式：[表達式為真的返回值] if [表達式] else [表達式為假的返回值]

這裡給出一個你可以用來使代碼緊湊簡潔的例子。下面的語句是說「如果 y 是 9，給 x 賦值 10，不然賦值為 20」。

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

在列表推導中：

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

判斷最小值：

def small(a, b, c):
    return a if a <= b and a <= c else (b if b <= a and b <= c else c)

類中：

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

四、多行字元串

這個比c方便多了，c打上換行符再加上轉義，真的很難受

a='''dvfssd
fsdfdsfsd
dsdsfbfdfasf
afasfaf'''
print(a)

五、in判斷

可以直接用來判斷某個變數是否在列表中

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

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

而不是：

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

六、 四種翻轉字元串/列表的方式

# 翻轉列表本身

testList = [1, 3, 5]
testList.reverse()
print(testList)
#-> [5, 3, 1]

# 在一個循環中翻轉并迭代輸出

for element in reversed([1,3,5]):
    print(element)
 
 
#1-> 5
 
#2-> 3
 
#3-> 1

# 一行代碼翻轉字元串

"Test Python"[::-1]

#輸出 「nohtyP tseT」

# 使用切片翻轉列表

[1, 3, 5][::-1]
 
 
 
#輸出 [5,3,1]。

七、一次性初始化多個變數

可以直接賦值：

a,b,c,d=1,2,3,4

可以利用列表：

List = [1,2,3]
x,y,z=List
print(x, y, z)
#-> 1 2 3

（元素個數應與列表長度相同）

八、列印模塊路徑

import socketprint(socket)#<module 'socket' from '/usr/lib/python2.7/socket.py'>

九、字典推導

Python不光列表用推導式，字典/集合也有

#列表
l=[[0 for i in range(4)] for i in range(4)]#生成二維列表
print(l)
#  [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

testDict = {i: i * i for i in xrange(10)}
testSet = {i * 2 for i in xrange(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}

十、拼接字元串

眾所周知，python中字元串可以相加：

a="i "
b="love "
c="you"
print(a+b+c)

拼接列表中的所有元素為一個字元串

l=['a','b','c']
print(''join(l))
#以join左邊的字元做分割

十一、循環枚舉索引

list = [10, 20, 30]
for i, value in enumerate(list):
    print(i, ': ', value)
 
#1-> 0 : 10
#2-> 1 : 20
#3-> 2 : 30

很方便的找到下標和對應元素

十二、返回多個值

並沒有太多編程語言支持這個特性，然而 Python 中的方法確實（可以）返回多個值

def a():
    return 1,2,3,4,5

十三、開啟文件分享

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

python3 -m http.server

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

十四、調試腳本

我們可以在 <pdb> 模塊的幫助下在 Python 腳本中設置斷點，例子：

import pdb
pdb.set_trace()

十五、直接迭代序列元素

對序列（str、list、tuple等），直接迭代序列元素，比迭代元素的索引速度要更快。

>>> l=[0,1,2,3,4,5]
>>> for i in l:
	print(i)
#快
>>> for i in range(len(l)):
	print(l[i])
#慢

十六、巧用else語句（重要）

python的else 子句不僅能在 if 語句中使用，還能在 for、while 和 try 等語句中使用，這個語言特性不是什麼秘密，但卻沒有得到重視。

for：
l=[1,2,3,4,5]
for i in l:
    if i=='6':
        print(666)
        break
else:
    print(999)

如果不這麼實現，我們只能設置一個變數來記錄了：

l=[1,2,3,4,5]
a=1
for i in l:
    if i=='6':
        print(666)
        a=0
        break
if a:
    print(999)

while和for類似

看一下try：

try:
    a()
except OSError:
    #語句1
else:
    #語句2

僅當 try 塊中沒有異常拋出時才運行 else 塊。

總結一下else：

for:

　　僅當 for 循環運行完畢時（即 for 循環沒有被 break 語句中止）才運行 else 塊。

while:

　　僅當 while 循環因為條件為假值而退出時（即 while 循環沒有被break 語句中止）才運行 else 塊。

try:

　　僅當 try 塊中沒有異常拋出時才運行 else 塊。

即，如果異常或者 return、break 或 continue 語句導致控制權跳到了複合語句的主塊之外，那麼else 子句也會被跳過。

按正常的理解應該是「要麼運行這個循環，要麼做那件事」。可是，在循環中，else 的語義恰好相反：「運行這個循環，然後做那件事。」

十七、except的用法和作用

try/except: 捕捉由PYTHON自身或寫程序過程中引發的異常並恢復

except: 捕捉所有其他異常

except name: 只捕捉特定的異常

except name, value: 捕捉異常及格外的數據(實例)

except (name1,name2) 捕捉列出來的異常

except (name1,name2),value: 捕捉任何列出的異常，並取得額外數據

else: 如果沒有引發異常就運行

finally: 總是會運行此處代碼

十八、Python自省

這個也是python彪悍的特性.自省就是面向對象的語言所寫的程序在運行時,所能知道對象的類型.簡單一句就是運行時能夠獲得對象的類型.比如type(),dir(),getattr(),hasattr(),isinstance().

十九、python容器

列表：元素可變（任何數據類型），有序（可索引），append/insert/pop；

元組：元素不可變，但元素中的可變元素是可變的；有序（可索引）；而且元組可以被散列，例如作為字典的鍵。

集合：無序（不可被索引）、互異

字典：無序，鍵值對（key：value），key唯一不可重複

二十、map（）

map()函數接收兩個參數，一個是函數，一個是Iterable，map將傳入的函數依次作用到序列的每個元素，並把結果作為新的Iterator返回。（重點理解）

舉例說明，比如我們有一個函數f(x)=x2，要把這個函數作用在一個list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()實現如下：

>>> def f(x):
...     return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

map()作為高階函數，事實上它把運算規則抽象了，因此，我們不但可以計算簡單的f(x)=x2，還可以計算任意複雜的函數，比如，把這個list所有數字轉為字元串：

>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

二十一、reduce

reduce把一個函數作用在一個序列[x1, x2, x3, …]上，這個函數必須接收兩個參數，reduce把結果繼續和序列的下一個元素做累積計算

簡單例子：

>>> from functools import reduce
>>> def fn(x, y):
        return x * 10 + y
 
>>> reduce(fn, [1, 3, 5, 7, 9])
13579

結合一下，我們可以自己寫出int（）函數

from functools import reduce
 
a={'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
 
def charnum(s):
    return a[s]
 
def strint(s):
    return reduce(lambda x, y: x * 10 + y, map(charnum, s))

我們繼續說一些好用的函數

二十二、split

Python split() 通過指定分隔符對字元串進行切片，如果參數 num 有指定值，則僅分隔 num 個子字元串。

語法：

str.split(str="", num=string.count(str))

簡化：

str.split("")

二十三、理論結合實際

1）結合第四期所學知識，我們可以寫出這一行代碼

print(" ".join(input().split(" ")[::-1]))

實現功能，leetcode原題：給定一個句子（只包含字母和空格），將句子中的單詞位置反轉，單詞用空格分割，單詞之間只有一個空格，前後沒有空格。比如：（1）「hello xiao mi」 – >「 mi xiao你好「

2）再舉一例：

將兩個整型數組按照升序合併，並且過濾掉重複數組元素

輸入參數：

int* pArray1 ：整型數組1
intiArray1Num：數組1元素個數
int* pArray2 ：整型數組2
intiArray2Num：數組2元素個數

對於python來說，給個數沒什麼卵用。

a,b,c,d=input(),list(map(int,input().split())),input(),list(map(int,input().split()))
print("".join(map(str,sorted(list(set(b+d))))))

3）我們把最近的知識結合起來做一道題：

輸入一個int型整數，按照從右向左的閱讀順序，返回一個不含重複數字的新的整數。

result=""
for i in input()[::-1]:
    if i not in result:
        result+=i
print(result)

還有很多具體的簡潔操作，這裡就不再舉例子了，多體會吧。

好，我們繼續其它函數。

二十四、filter

Python內建的filter()函數用於過濾序列。

和map()類似，filter()也接收一個函數和一個序列。和map()不同的是，filter()把傳入的函數依次作用於每個元素，然後根據返回值是True還是False決定保留還是丟棄該元素。

簡單例子，刪掉偶數：

def is_odd(n):
    return n % 2 == 1
 
list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 結果: [1, 5, 9, 15]

我們可以用所學知識實現埃氏篩：

素數基本（埃氏篩法）

（1）檢查n是否為素數

最簡單思路：所有可能的因數全部試一遍。

int gg(int n)

{

for(int i=2;i<n;i++){

if((n%i)==0)return 0;//有因數就不是素數咯

}

return 1;

}

進一步思考：沒必要枚舉所有的數，每一個小於n^(1/2)的因數i，一定有一個大於n^(1/2)的因數j與之對應，也就是i*j=n，所以枚舉小於等於n^(1/2)的因數即可

int gg(int n)

{

for(int i=2;i*i<=n;i++){

if((n%i)==0)return 0;

}

return 1;

}

（2）約數枚舉

上面已經說過，不需要枚舉所有因數，枚舉出某小因數以後算出對應的大因數即可。

vector<int> gg(int n)

{

vector<int> a;

for(int i=2;i*i<=n;i++){

if((n%i)==0){

a.push_back(i);

if((n/i)!=i)a.push_back(n/i);//根號n的情況不要重複添加

}

}

return a;

}

（3）埃氏篩法

只對一個整數操作，O(N)，已經足夠了，如果對許多整數進行素性檢測，還有更高效的演算法，比如埃氏篩法。

問題：枚舉n以內所有素數

操作：先把所有整數列出來，然後把2的倍數全部剔除，然後是三的，以此類推，遍歷所有素數，把倍數全部划去。

對於每個數字i，如果沒被划去，他一定是素數，因為他不是任何2到i-1數字的倍數。然後就開始劃它的倍數就好。

int a[maxx];

int b[maxx+1];

int gg(int n)

{

int p=0;//記錄素數個數

for(int i=0;i<n+1;i++)b[i]=1;

b[0]=0;

b[1]=0;

//準備完畢

for(int i=2;i<=n;i++){

if(b[i]){

a[p++]=i;//記錄素數和個數

for(int j=2*i;j<=n;j+=i)b[j]=0;//剔除倍數

}

}

return p;//返回素數個數

}

本代碼非原創：

#先構造一個從3開始的奇數序列：
def _odd_iter():
    n = 1
    while True:
        n = n + 2
        yield n
#這是一個生成器，並且是一個無限序列。
 
#篩選函數
def _not_divisible(n):
    return lambda x: x % n > 0
#生成器
def primes():
    yield 2
    it = _odd_iter() # 初始序列
    while True:
        n = next(it) # 返回序列的第一個數
        yield n
        it = filter(_not_divisible(n), it) # 構造新序列

利用filter()不斷產生篩選後的新的序列

Iterator是惰性計算的序列，所以我們可以用Python表示「全體自然數」，「全體素數」這樣的序列，而代碼非常簡潔。

二十五、sorted

>>> sorted([36, 5, -12, 9, -21])
[-21, -12, 5, 9, 36]
#可以接收一個key函數來實現自定義的排序，例如按絕對值大小排序：
>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]

我們再看一個字元串排序的例子：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'])
['Credit', 'Zoo', 'about', 'bob']

默認情況下，對字元串排序，是按照ASCII的大小比較的，由於’Z’ < ‘a’，結果，大寫字母Z會排在小寫字母a的前面。

現在，我們提出排序應該忽略大小寫，按照字母序排序。要實現這個演算法，不必對現有代碼大加改動，只要我們能用一個key函數把字元串映射為忽略大小寫排序即可。忽略大小寫來比較兩個字元串，實際上就是先把字元串都變成大寫（或者都變成小寫），再比較。

這樣，我們給sorted傳入key函數，即可實現忽略大小寫的排序：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about', 'bob', 'Credit', 'Zoo']

要進行反向排序，不必改動key函數，可以傳入第三個參數reverse=True：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']

從上述例子可以看出，高階函數的抽象能力是非常強大的，而且，核心代碼可以保持得非常簡潔。

sorted()也是一個高階函數。用sorted()排序的關鍵在於實現一個映射函數。