微信公眾號終于可以插代碼了，Python 可以走一波了。首先我承認不是硬核搞 IT 的，太高級的玩法也玩不來，講講下面基本的還可以，之后帶點機器學(xué)習(xí)、金融工程和量化投資的實例也是可以。

這個系列力求精簡和實用 (可能不會完整，但看完此貼舉一反三也不要完整，追求完整的建議去看書)，到了「難點處」我一定會畫圖幫助讀者理解。Python 系列的入門篇的目錄如下，本帖是上篇，只涵蓋前三個節(jié)，下篇接著后兩節(jié)。

對于任何一種計算機語言，我覺得最重要的就是「數(shù)據(jù)類型」「條件語句 & 迭代循環(huán)」和「函數(shù)」，這三方面一定要打牢基礎(chǔ)。此外 Python 非常簡潔，一行代碼 (one-liner) 就能做很多事情，很多時候都用了各種「解析式」，比如列表、字典和集合解析式。

在學(xué)習(xí)本貼前感受一下這個問題：如何把以下這個不規(guī)則的列表 a 里的所有元素一個個寫好，專業(yè)術(shù)語叫打平 (flatten)?

魔法來了 (這一行代碼有些長，用手機的建議橫屏看)

fn = lambda x: [y for l in x for y in fn(l)] if type(x) is list else [x]fn(a) 

這一行代碼，用到了迭代、匿名函數(shù)、遞推函數(shù)、解析式這些技巧。初學(xué)者一看只會說“好酷啊，但看不懂”，看完本帖和下帖后，我保證你會說“我也會這樣用了，真酷！”

Python 里面有自己的內(nèi)置數(shù)據(jù)類型 (build-in data type)，本節(jié)介紹基本的三種，分別是整型 (int)，浮點型 (float)，和布爾型 (bool)。

整數(shù) (integer) 是最簡單的數(shù)據(jù)類型，和下面浮點數(shù)的區(qū)別就是前者小數(shù)點后沒有值，后者小數(shù)點后有值。例子如下：

a = 1031print( a, type(a) )

通過 print 的可看出 a 的值，以及類 (class) 是 int。Python 里面萬物皆對象(object)，「整數(shù)」也不例外，只要是對象，就有相應(yīng)的屬性 (attributes) 和方法 (methods)。

dir(int)

紅色的是 int 對象的可用方法，藍色的是 int 對象的可用屬性。對他們你有個大概印象就可以了，具體怎么用，需要哪些參數(shù) (argument)，你還需要查文檔?？磦€bit_length的例子

a.bit_length()

該函數(shù)是找到一個整數(shù)的二進制表示，再返回其長度。在本例中 a = 1031, 其二進制表示為 ‘10000000111’ ，長度為 11。

簡單來說，浮點型 (float) 數(shù)就是實數(shù)， 例子如下：

print( 1, type(1) )print( 1., type(1.) )

加一個小數(shù)點 . 就可以創(chuàng)建 float，不能再簡單。有時候我們想保留浮點型的小數(shù)點后 n 位。可以用 decimal 包里的 Decimal 對象和 getcontext() 方法來實現(xiàn)。

import decimalfrom decimal import Decimal

Python 里面有很多用途廣泛的包 (package)，用什么你就引進 (import) 什么。包也是對象，也可以用上面提到的dir(decimal) 來看其屬性和方法。比如 getcontext() 顯示了 Decimal 對象的默認精度值是 28 位 (prec=28)，展示如下：

Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999,
Emax=999999, capitals=1, clamp=0, flags=[],
traps=[InvalidOperation, DivisionByZero, Overflow])

讓我們看看 1/3 的保留 28 位長什么樣？

Decimal('0.3333333333333333333333333333')

那保留 4 位呢？用 getcontext().prec 來調(diào)整精度哦。

Decimal('0.3333')

高精度的 float 加上低精度的 float，保持了高精度，沒毛病。

Decimal('0.6666333333333333333333333333')

布爾 (boolean) 型變量只能取兩個值，True 和 False。當(dāng)把布爾變量用在數(shù)字運算中，用 1 和 0 代表 True 和 False。

3
-8

除了直接給變量賦值 True 和 False，還可以用 bool(X) 來創(chuàng)建變量，其中 X 可以是

• 基本類型：整型、浮點型、布爾型

• 容器類型：字符、元組、列表、字典和集合

<class 'int'> False True
<class 'float'> False True
<class 'bool'> False True

bool 作用在基本類型變量的總結(jié)：X 只要不是整型 0、浮點型 0.0，bool(X) 就是 True，其余就是 False。

<class 'str'> False True
<class 'tuple'> False True
<class 'list'> False True
<class 'dict'> False True
<class 'set'> False True

bool 作用在容器類型變量的總結(jié)：X 只要不是空的變量，bool(X) 就是 True，其余就是 False。

此外兩個布爾變量 P 和 Q 的邏輯運算的結(jié)果總結(jié)如下表：

上節(jié)介紹的整型、浮點型和布爾型都可以看成是單獨數(shù)據(jù)，而這些數(shù)據(jù)都可以放在一個容器里得到一個「容器類型」的數(shù)據(jù)，比如：

• 字符 (str) 是一容器的字節(jié) char，注意 Python 里面沒有 char 類型的數(shù)據(jù)，可以把單字符的 str 當(dāng)做 char。

• 元組 (tuple)、列表 (list)、字典 (dict) 和集合 (set) 是一容器的任何類型變量。

字符用于處理文本 (text) 數(shù)據(jù)，用「單引號 ’」和「雙引號 “」來定義都可以。

i love Python! <class 'str'>
I love Python! <class 'str'>

字符中常見的內(nèi)置方法 (可以用 dir(str) 來查) 有

• capitalize()：大寫句首的字母

• split()：把句子分成單詞

• find(x)：找到給定詞 x 在句中的索引，找不到返回 -1

• replace(x, y)：把句中 x 替代成 y

• strip(x)：刪除句首或句末含 x 的部分

'I love python!'

['I', 'love', 'Python!']

2
-1

'I hate R!'

www.python.org
http://www.python

Python
th
yth
t
n

正則表達式 (regular expression) 主要用于識別字符串中符合某種模式的部分，什么叫模式呢？用下面一個具體例子來講解。

'\n'06/18/2019 13:00:00', 100, '1st';
 \n'06/18/2019 13:30:00', 110, '2nd';
 \n'06/18/2019 14:00:00', 120, '3rd'\n'

假如你想把上面字符串中的「時間」的模式來抽象的表示出來，對照著具體表達式 '06/18/2019 13:00:00' 來看，我們發(fā)現(xiàn)該字符串有以下規(guī)則：

1. 開頭和結(jié)束都有個單引號 '

2. 里面有多個 0-9 數(shù)字

3. 里面有多個正斜線 / 和分號 : 

4. 還有一個空格

因此我們用下面這樣的模式

再看這個抽象模式表達式 '[0-9/:\s]+'，里面符號的意思如下：

• 最外面的兩個單引號 ' 代表該模式以它們開始和結(jié)束

• 中括號 [] 用來概括該模式涵蓋的所有類型的字節(jié)

• 0-9 代表數(shù)字類的字節(jié)

• / 代表正斜線

• : 代表分號

• \s 代表空格

• [] 外面的加號 + 代表 [] 里面的字節(jié)出現(xiàn)至少 1 次

有了模式 pattern，我們來看看是否能把字符串中所有符合 pattern 的日期表達式都找出來。

pattern.findall(input)

結(jié)果是對的，之后你想怎么盤它就是你自己的事了，比如把 / 換成 -，比如用 datetime 里面的 striptime() 把日期里年、月、日、小時、分鐘和秒都獲取出來。

「元組」定義語法為 

(元素1, 元素2, ..., 元素n)

關(guān)鍵點是「小括號 ()」和「逗號 ,」

• 小括號把所有元素綁在一起

• 逗號將每個元素一一分開

創(chuàng)建元組的例子如下：

t1 = (1, 10.31, 'python')t2 = 1, 10.31, 'python'print( t1, type(t1) )print( t2, type(t2) )

print( type( ('OK') ) )  # 沒有逗號 , print( type( ('OK',) ) ) # 有逗號 ,

當(dāng)然也可以創(chuàng)建二維元組：

nested = (1, 10.31, 'python'), ('data', 11)nested

元組中可以用整數(shù)來對它進行索引 (indexing) 和切片 (slicing)，不嚴謹?shù)闹v，前者是獲取單個元素，后者是獲取一組元素。接著上面二維元組的例子，先看看索引的代碼：

nested[0]print( nested[0][0], nested[0][1], nested[0][2] )

再看看切片的代碼：

nested[0][0:2] 

元組有不可更改 (immutable) 的性質(zhì)，因此不能直接給元組的元素賦值，例子如下 (注意「元組不支持元素賦值」的報錯提示)。

t = ('OK', [1, 2], True)t[2] = False

但是只要元組中的元素可更改 (mutable)，那么我們可以直接更改其元素，注意這跟賦值其元素不同。如下例 t[1] 是列表，其內(nèi)容可以更改，因此用 append 在列表后加一個值沒問題。

t[1].append(3)

元組大小和內(nèi)容都不可更改，因此只有 count 和 index 兩種方法。

t = (1, 10.31, 'python')print( t.count('python') )print( t.index(10.31) )

這兩個方法返回值都是 1，但意思完全不同

• count('python') 是記錄在元組 t 中該元素出現(xiàn)幾次，顯然是 1 次

• index(10.31) 是找到該元素在元組 t 的索引，顯然是 1

元組拼接 (concatenate) 有兩種方式，用「加號 +」和「乘號 *」，前者首尾拼接，后者復(fù)制拼接。

(1, 10.31, 'python') + ('data', 11) + ('OK',)(1, 10.31, 'python') * 2

解壓 (unpack) 一維元組 (有幾個元素左邊括號定義幾個變量）

t = (1, 10.31, 'python')(a, b, c) = tprint( a, b, c )

解壓二維元組 (按照元組里的元組結(jié)構(gòu)來定義變量）

t = (1, 10.31, ('OK','python'))(a, b, (c,d)) = tprint( a, b, c, d )

如果你只想要元組其中幾個元素，用通配符「*」，英文叫 wildcard，在計算機語言中代表一個或多個元素。下例就是把多個元素丟給了 rest 變量。

t = 1, 2, 3, 4, 5a, b, *rest, c = tprint( a, b, c )print( rest )

如果你根本不在乎 rest 變量，那么就用通配符「*」加上下劃線「_」，劉例子如下：

a, b, *_ = tprint( a, b )

優(yōu)點：占內(nèi)存小，安全，創(chuàng)建遍歷速度比列表快，可一賦多值。

缺點：不能添加和更改元素。

等等等，這里有點矛盾，元組的不可更改性即使優(yōu)點 (安全) 有時缺點？確實是這樣的，安全就沒那么靈活，靈活就沒那么安全?？纯创罄辛窝┓逶趺丛u價「不可更改性」吧

后面那些安全性的東西我也不大懂，性能優(yōu)化這個我可以來測試一下列表和元組。列表雖然沒介紹，但是非常簡單，把元組的「小括號 ()」該成「中括號 []」就是列表了。我們從創(chuàng)建、遍歷和占空間三方面比較。

%timeit [1, 2, 3, 4, 5]%timeit (1, 2, 3, 4, 5)

創(chuàng)建速度，元組 (12.9ns) 碾壓列表 (62ns)。

lst = [i for i in range(65535)]tup = tuple(i for i in range(65535))%timeit for each in lst: pass%timeit for each in tup: pass

遍歷速度兩者相當(dāng)，元組 (498 μs) 險勝列表 (507 μs)。

from sys import getsizeofprint( getsizeof(lst) )print( getsizeof(tup) )

列表比元組稍微廢點內(nèi)存空間。

「列表」定義語法為 

[元素1, 元素2, ..., 元素n]

關(guān)鍵點是「中括號 []」和「逗號 ,」

• 中括號把所有元素綁在一起

• 逗號將每個元素一一分開

創(chuàng)建列表的例子如下：

l = [1, 10.31,'python']print(l, type(l))

不像元組，列表內(nèi)容可更改 (mutable)，因此附加 (append, extend)、插入 (insert)、刪除 (remove, pop) 這些操作都可以用在它身上。

l.append([4, 3])print( l )l.extend([1.5, 2.0, 'OK'])print( l )

嚴格來說 append 是追加，把一個東西整體添加在列表后，而 extend 是擴展，把一個東西里的所有元素添加在列表后。對著上面結(jié)果感受一下區(qū)別。

l.insert(1, 'abc') # insert object before the index positionl

insert(i, x) 在編號 i 位置前插入 x。對著上面結(jié)果感受一下。

l.remove('python') # remove first occurrence of objectl

p = l.pop(3) # removes and returns object at index.  Only only pop 1 index position at any time.print( p )print( l ) 

remove 和 pop 都可以刪除元素

• 前者是指定具體要刪除的元素，比如 'python'

• 后者是指定一個編號位置，比如 3，刪除 l[3] 并返回出來

對著上面結(jié)果感受一下，具體用哪個看你需求。

索引 (indexing) 和切片 (slicing) 語法在元組那節(jié)都講了，而且怎么判斷切片出來的元素在字符那節(jié)也講了，規(guī)則如下圖：

對照上圖看下面兩個例子 (順著數(shù)和倒著數(shù)編號)：

l = [7, 2, 9, 10, 1, 3, 7, 2, 0, 1]l[1:5]

l[-4:]

列表可更改，因此可以用切片來賦值。

l[2:4] = [999, 1000]l

切片的通用寫法是

start : stop : step

這三個在特定情況下都可以省去，我們來看看四種情況：

print( l )print( l[3:] )print( l[-4:] )

以 step 為 1 (默認) 從編號 start 往列表尾部切片。

print( l )print( l[:6] )print( l[:-4] )

以 step 為 1 (默認) 從列表頭部往編號 stop 切片。

print( l )print( l[2:4] )print( l[-5:-1] )

以 step 為 1 (默認) 從編號 start 往編號 stop 切片。

print( l )print( l[1:5:2] )print( l[:5:2] )print( l[1::2] )print( l[::2] )print( l[::-1] )

以具體的 step 從編號 start 往編號 stop 切片。注意最后把 step 設(shè)為 -1，相當(dāng)于將列表反向排列。

和元組拼接一樣， 列表拼接也有兩種方式，用「加號 +」和「乘號 *」，前者首尾拼接，后者復(fù)制拼接。

[1, 10.31, 'python'] + ['data', 11] + ['OK'][1, 10.31, 'python'] * 2

優(yōu)點：靈活好用，可索引、可切片、可更改、可附加、可插入、可刪除。

缺點：相比 tuple 創(chuàng)建和遍歷速度慢，占內(nèi)存。此外查找和插入時間較慢。

「字典」定義語法為 

{元素1, 元素2, ..., 元素n}

其中每一個元素是一個「鍵值對」- 鍵:值 (key:value)

關(guān)鍵點是「大括號 {}」,「逗號 ,」和「分號 :」

• 大括號把所有元素綁在一起

• 逗號將每個鍵值對一一分開

• 分號將鍵和值分開

創(chuàng)建字典的例子如下：

d = {'Name' : 'Tencent','Country' : 'China','Industry' : 'Technology','Code': '00700.HK','Price' : '361 HKD'}print( d, type(d) )

字典里最常用的三個內(nèi)置方法就是 keys(), values() 和 items()，分別是獲取字典的鍵、值、對。

print( list(d.keys()),'\n' )print( list(d.values()), '\n' )print( list(d.items()) )

此外在字典上也有添加、獲取、更新、刪除等操作。

比如加一個「總部：深圳」

d['Headquarter'] = 'Shen Zhen'd

比如想看看騰訊的股價是多少 (兩種方法都可以)

print( d['Price'] )print( d.get('Price') )

比如更新騰訊的股價到 359 港幣

d['Price'] = '359 HKD'd

比如去掉股票代碼 (code)

del d['Code']d

或像列表里的 pop() 函數(shù)，刪除行業(yè) (industry) 并返回出來。

print( d.pop('Industry') )d

字典里的鍵是不可更改的，因此只有那些不可更改的數(shù)據(jù)類型才能當(dāng)鍵，比如整數(shù) (雖然怪怪的)、浮點數(shù) (雖然怪怪的)、布爾 (雖然怪怪的)、字符、元組 (雖然怪怪的)，而列表卻不行，因為它可更改?？磦€例子

d = {2 : 'integer key',10.31 : 'float key',True  : 'boolean key',('OK',3) : 'tuple key'}d

雖然怪怪的，但這些 2, 10.31, True, ('OK', 3) 確實能當(dāng)鍵。有個地方要注意下，True 其實和整數(shù) 1 是一樣的，由于鍵不能重復(fù)，當(dāng)你把 2 該成 1時，你會發(fā)現(xiàn)字典只會取其中一個鍵，示例如下：

d = {1 : 'integer key',10.31 : 'float key',True : 'boolean key',('OK',3) : 'tuple key'}d

那么如何快速判斷一個數(shù)據(jù)類型 X 是不是可更改的呢？兩種方法：

1. 麻煩方法：用 id(X) 函數(shù)，對 X 進行某種操作，比較操作前后的 id，如果不一樣，則 X 不可更改，如果一樣，則 X 可更改。

2. 便捷方法：用 hash(X)，只要不報錯，證明 X 可被哈希，即不可更改，反過來不可被哈希，即可更改。

先看用 id() 函數(shù)的在整數(shù) i 和列表 l 上的運行結(jié)果：

i = 1print( id(i) )i = i + 2print( id(i) )

l = [1, 2]print( id(l) )l.append('Python')print( id(l) )

• 整數(shù) i 在加 1 之后的 id 和之前不一樣，因此加完之后的這個 i (雖然名字沒變)，但是不是加前的那個 i 了，因此整數(shù)是不可更改的。

• 列表 l 在附加 'Python' 之后的 id 和之前一樣，因此列表是可更改的。

先看用 hash() 函數(shù)的在字符 s，元組 t 和列表 l 上的運行結(jié)果：

hash('Name')

hash( (1,2,'Python') )

hash( [1,2,'Python'] )

字符 s 和元組 t 都能被哈希，因此它們是不可更改的。列表 l 不能被哈希，因此它是可更改的。

優(yōu)點：查找和插入速度快

缺點：占內(nèi)存大

「集合」有兩種定義語法，第一種是

{元素1, 元素2, ..., 元素n}

關(guān)鍵點是「大括號 {}」和「逗號 ,」

• 大括號把所有元素綁在一起

• 逗號將每個元素一一分開
  

第二種是用 set() 函數(shù)，把列表或元組轉(zhuǎn)換成集合。

set( 列表 或 元組 )

創(chuàng)建集合的例子如下 (用兩者方法創(chuàng)建 A 和 B)：

A = set(['u', 'd', 'ud', 'du', 'd', 'du'])B = {'d', 'dd', 'uu', 'u'}print( A )print( B )

從 A 的結(jié)果發(fā)現(xiàn)集合的兩個特點：無序 (unordered) 和唯一 (unique)。由于 set 存儲的是無序集合，所以我們沒法通過索引來訪問，但是可以判斷一個元素是否在集合中。

B[1]

'u' in B

用 set 的內(nèi)置方法就把它當(dāng)成是數(shù)學(xué)上的集，那么并集、交集、差集都可以玩通了。

print( A.union(B) )     # All unique elements in A or Bprint( A | B )          # A OR B

print( A.intersection(B) )   # All elements in both A and Bprint( A & B )               # A AND B

print( A.difference(B) )     # Elements in A but not in Bprint( A - B )               # A MINUS B

print( B.difference(A) )     # Elements in B but not in Aprint( B - A )               # B MINUS A

print( A.symmetric_difference(B) )   # All elements in either A or B, but not bothprint( A ^ B )                       # A XOR B

優(yōu)點：不用判斷重復(fù)的元素

缺點：不能存儲可變對象

你看集合的「唯一」特性還不是雙刃劍，既可以是優(yōu)點，又可以是缺點，所有東西都有 trade-off 的，要不然它就沒有存在的必要了。

在編寫程序時，我們要

• 在不同條件下完成不同動作，條件語句 (conditional statement) 賦予程序這種能力。

• 重復(fù)的完成某些動作，迭代循環(huán) (iterative loop) 賦予程序這種能力。

條件語句太簡單了，大體有四種格式

1. if 語句

2. if-else 語句

3. if-elif-else 語句

4. nested 語句

看了下面四幅圖 (包含代碼) 應(yīng)該秒懂條件語句，其實任何會說話的人都應(yīng)該懂它。

if x > 0:print( 'x is positive' )

if x < y:print( 'x is less than y' )elif x > y:print( 'x is greater than y' )else:print( 'x and y are equal' )

對于迭代循環(huán)，Python 里面有「while 循環(huán)」和「for 循環(huán)」，沒有「do-while 循環(huán)」。

n = 5while n > 0:print(n)    n = n-1print('I love Python')

While 循環(huán)非常簡單，做事直到 while 后面的語句為 False。上例就是打印從 n (初始值為 5) 一直到 1，循環(huán)執(zhí)行了 5 次。

一般來說，在 「while 循環(huán)」中，迭代的次數(shù)事先是不知道的，因為通常你不知道 while 后面的語句從 True 變成 False了。

更多時候我們希望事先直到循環(huán)的次數(shù)，比如在列表、元組、字典等容器類數(shù)據(jù)上遍歷一遍，在每個元素層面上做點事情。這時候就需要「for 循環(huán)」了。

languages = ['Python', 'R', 'Matlab', 'C++']for language in languages:print( 'I love', language )print( 'Done!' )

讀讀 Python 里面的「for 循環(huán)」是不是很像讀英文。通用形式的 for loop 如下

    for a in A

        do something with a        

其中 for 和 in 是關(guān)鍵詞，A 是個可迭代數(shù)據(jù) (list, tuple, dic, set)，a 是 A 里面的每個元素，上句翻譯成中文是

    對于 A 里面的每個 a

        對 a 搞點事

回到具體例子，for loop 里面的 language 變量在每次循環(huán)中分別取值 Python, R, Matlab 和 C++，然后被打印。

最后介紹一個稍微有點特殊的函數(shù) enumerate()，和 for loop 一起用的語法如下

    for i, a in enumerate(A)

        do something with a  

發(fā)現(xiàn)區(qū)別了沒？用 enumerate(A) 不僅返回了 A 中的元素，還順便給該元素一個索引值 (默認從 0 開始)。此外，用 enumerate(A, j) 還可以確定索引起始值為 j?？聪旅胬?。

languages = ['Python', 'R', 'Matlab', 'C++']for i, language in enumerate(languages, 1):print( i, 'I love', language )print( 'Done!' )

學(xué)習(xí)任何一種都要從最基本開始，基本的東西無外乎數(shù)據(jù)類型、條件語句和遞推循環(huán)。

數(shù)據(jù)類型分兩種：

• 單獨類型：整型、浮點型、布爾型

• 容器類型：字符、元組、列表、字典、集合

按照 Python 里「萬物皆對象」的思路，學(xué)習(xí)每一個對象里面的屬性 (attributes) 和方法 (methods)，你不需要記住所有，有個大概印象有哪些，通過 dir() 來鎖定具體表達式，再去官網(wǎng)上查詢所有細節(jié)。這么學(xué)真的很系統(tǒng)而簡單。此外學(xué)的時候一定要帶著“它的優(yōu)缺點是什么”這樣的問題，所有東西都有 trade-off，一個滿身都是缺點的東西就沒有存在的必要，既然存在肯定有可取之處。

條件語句 (if, if-else, if-elif-else, nested if) 是為了在不同條件下執(zhí)行不同操作，而迭代循環(huán) (while, for) 是重復(fù)的完成相同操作。

抓住上面大框架，最好還要以目標(biāo)導(dǎo)向 (我學(xué) python 就是為了搞量化交易希望能躺著賺錢)，別管這目標(biāo)難度如何，起碼可以保證我累得時候還雞血滿滿不會輕言放棄。這樣我就足夠主動的去學(xué)一樣?xùn)|西并學(xué)精學(xué)深，目標(biāo)越難完成，我主動性就越強。

之后所有的細節(jié)都可以慢慢來，雖然我覺得本篇已經(jīng)挖了不少細節(jié)了，像 hashability，但肯定還有更多等著去挖，半篇帖子就想覆蓋 Python 所有內(nèi)容不是開玩笑嗎？但

抓住大框架，有目標(biāo)導(dǎo)向，對有效學(xué)習(xí)任何內(nèi)容都適用。

下篇接著函數(shù) (function) 和解析式 (comprehension)。Stay Tuned!