九色国产,午夜在线视频,新黄色网址,九九色综合,天天做夜夜做久久做狠狠,天天躁夜夜躁狠狠躁2021a,久久不卡一区二区三区

昨晚見(jiàn)到大神 Aurélien Géron 真人講 Tensorflow 2.0 的 autograph，會(huì)后和他聊天得知他已經(jīng)搬到新加坡了，而且在這邊也有一個(gè) AI consulting 的初創(chuàng)公司。大神非常謙遜，講東西一針見(jiàn)血，現(xiàn)在在忙于他的經(jīng)典書(shū)《Hands-On Machine Learning with Scikit-Learn and TensorFlow》的第二版，里面加了很多 Tensorflow 2.0 的新東西。他的書(shū)和 youtube 上的幾個(gè)視屏都是精品，我自認(rèn)為寫(xiě)的最好的文章「膠囊網(wǎng)絡(luò)」是受他的那個(gè) capsule network 的視屏的啟發(fā)而作。

大神的事業(yè)已經(jīng)非常成功，問(wèn)他寫(xiě)書(shū)的動(dòng)力在哪 (因?yàn)槲易约阂矊?xiě)，深知要犧牲很多個(gè)人時(shí)間)，他很簡(jiǎn)單地說(shuō)他就喜歡一直學(xué)習(xí)，通過(guò)寫(xiě)書(shū)可以明晰自己的對(duì)知識(shí)的理解，通過(guò)親自寫(xiě)代碼可以一直緊跟那些深度學(xué)習(xí)框架的發(fā)展。大神博學(xué)、謙遜、講東西接地氣，值得我學(xué)習(xí)，獻(xiàn)上我和他合照一張 :)

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

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

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

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

魔法來(lái)了 (這一行代碼有些長(zhǎng)，用手機(jī)的建議橫屏看)

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é)者一看只會(huì)說(shuō)“好酷啊，但看不懂”，看完本帖和下帖后，我保證你會(huì)說(shuō)“我也會(huì)這樣用了，真酷！”

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

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

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

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

dir(int)

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

a.bit_length()

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

簡(jiǎn)單來(lái)說(shuō)，浮點(diǎn)型 (float) 數(shù)就是實(shí)數(shù)， 例子如下：

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

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

import decimalfrom decimal import Decimal

Python 里面有很多用途廣泛的包 (package)，用什么你就引進(jìn) (import) 什么。包也是對(duì)象，也可以用上面提到的dir(decimal) 來(lái)看其屬性和方法。比如 getcontext() 顯示了 Decimal 對(duì)象的默認(rèn)精度值是 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 位長(zhǎng)什么樣？

Decimal('0.3333333333333333333333333333')

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

Decimal('0.3333')

高精度的 float 加上低精度的 float，保持了高精度，沒(méi)毛病。

Decimal('0.6666333333333333333333333333')

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

3
-8

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

• 基本類(lèi)型：整型、浮點(diǎn)型、布爾型

• 容器類(lèi)型：字符、元組、列表、字典和集合

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

bool 作用在基本類(lèi)型變量的總結(jié)：X 只要不是整型 0、浮點(diǎn)型 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 作用在容器類(lèi)型變量的總結(jié)：X 只要不是空的變量，bool(X) 就是 True，其余就是 False。

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

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

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

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

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

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

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

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

• 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

知識(shí)點(diǎn)

Python 里面索引有三個(gè)特點(diǎn) (經(jīng)常讓人困惑)：

1. 從 0 開(kāi)始 (和 C 一樣)，不像 Matlab 從 1 開(kāi)始。

2. 切片通常寫(xiě)成 start:end 這種形式，包括「start 索引」對(duì)應(yīng)的元素，不包括「end索引」對(duì)應(yīng)的元素。因此 s[2:4] 只獲取字符串第 3 個(gè)到第 4 個(gè)元素。

3. 索引值可正可負(fù)，正索引從 0 開(kāi)始，從左往右；負(fù)索引從 -1 開(kāi)始，從右往左。使用負(fù)數(shù)索引時(shí)，會(huì)從最后一個(gè)元素開(kāi)始計(jì)數(shù)。最后一個(gè)元素的位置編號(hào)是 -1。

這些特點(diǎn)引起讀者對(duì)切片得到什么樣的元素感到困惑。有個(gè)小竅門(mén)可以幫助大家快速鎖定切片的元素，如下圖。

與其把注意力放在元素對(duì)應(yīng)的索引，不如想象將元素分開(kāi)的隔欄，顯然 6 個(gè)元素需要 7 個(gè)隔欄，隔欄索引也是從 0 開(kāi)始，這樣再看到 start:end 就認(rèn)為是隔欄索引，那么獲取的元素就是「隔欄 start」和「隔欄 end」之間包含的元素。如上圖：

• string[2:4] 就是「隔欄 2」和「隔欄 4」之間包含的元素，即 th

• string[-5:-2] 就是「隔欄 -5」和「隔欄 -2」之間包含的元素，即 yth

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

'\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'

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

1. 開(kāi)頭和結(jié)束都有個(gè)單引號(hào) '

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

3. 里面有多個(gè)正斜線(xiàn) / 和分號(hào) : 

4. 還有一個(gè)空格

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

再看這個(gè)抽象模式表達(dá)式 '[0-9/:\s]+'，里面符號(hào)的意思如下：

• 最外面的兩個(gè)單引號(hào) ' 代表該模式以它們開(kāi)始和結(jié)束

• 中括號(hào) [] 用來(lái)概括該模式涵蓋的所有類(lèi)型的字節(jié)

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

• / 代表正斜線(xiàn)

• : 代表分號(hào)

• \s 代表空格

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

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

pattern.findall(input)

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

「元組」定義語(yǔ)法為 

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

關(guān)鍵點(diǎn)是「小括號(hào) ()」和「逗號(hào) ,」

• 小括號(hào)把所有元素綁在一起

• 逗號(hào)將每個(gè)元素一一分開(kāi)

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

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

print( type( ('OK') ) )  # 沒(méi)有逗號(hào) , print( type( ('OK',) ) ) # 有逗號(hào) ,

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

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

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

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

再看看切片的代碼：

nested[0][0:2] 

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

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

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

t[1].append(3)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

缺點(diǎn)：不能添加和更改元素。

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

后面那些安全性的東西我也不大懂，性能優(yōu)化這個(gè)我可以來(lái)測(cè)試一下列表和元組。列表雖然沒(méi)介紹，但是非常簡(jiǎn)單，把元組的「小括號(hào) ()」該成「中括號(hào) []」就是列表了。我們從創(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) 險(xiǎn)勝列表 (507 μs)。

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

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

「列表」定義語(yǔ)法為 

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

關(guān)鍵點(diǎn)是「中括號(hào) []」和「逗號(hào) ,」

• 中括號(hào)把所有元素綁在一起

• 逗號(hào)將每個(gè)元素一一分開(kāi)

創(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 )

嚴(yán)格來(lái)說(shuō) append 是追加，把一個(gè)東西整體添加在列表后，而 extend 是擴(kuò)展，把一個(gè)東西里的所有元素添加在列表后。對(duì)著上面結(jié)果感受一下區(qū)別。

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

insert(i, x) 在編號(hào) i 位置前插入 x。對(duì)著上面結(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 都可以刪除元素

• 前者是指定具體要?jiǎng)h除的元素，比如 'python'

• 后者是指定一個(gè)編號(hào)位置，比如 3，刪除 l[3] 并返回出來(lái)

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

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

對(duì)照上圖看下面兩個(gè)例子 (順著數(shù)和倒著數(shù)編號(hào))：

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

l[-4:]

列表可更改，因此可以用切片來(lái)賦值。

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

切片的通用寫(xiě)法是

start : stop : step

這三個(gè)在特定情況下都可以省去，我們來(lái)看看四種情況：

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

以 step 為 1 (默認(rèn)) 從編號(hào) start 往列表尾部切片。

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

以 step 為 1 (默認(rèn)) 從列表頭部往編號(hào) stop 切片。

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

以 step 為 1 (默認(rèn)) 從編號(hào) start 往編號(hào) stop 切片。

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

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

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

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

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

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

「字典」定義語(yǔ)法為 

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

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

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

• 大括號(hào)把所有元素綁在一起

• 逗號(hào)將每個(gè)鍵值對(duì)一一分開(kāi)

• 分號(hào)將鍵和值分開(kāi)

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

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

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

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

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

比如加一個(gè)「總部：深圳」

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

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

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

比如更新騰訊的股價(jià)到 359 港幣

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

比如去掉股票代碼 (code)

del d['Code']d

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

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

字典里的鍵是不可更改的，因此只有那些不可更改的數(shù)據(jù)類(lèi)型才能當(dāng)鍵，比如整數(shù) (雖然怪怪的)、浮點(diǎn)數(shù) (雖然怪怪的)、布爾 (雖然怪怪的)、字符、元組 (雖然怪怪的)，而列表卻不行，因?yàn)樗筛摹？磦€(gè)例子

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

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

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

那么如何快速判斷一個(gè)數(shù)據(jù)類(lèi)型 X 是不是可更改的呢？?jī)煞N方法：

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

2. 便捷方法：用 hash(X)，只要不報(bào)錯(cuò)，證明 X 可被哈希，即不可更改，反過(guò)來(lái)不可被哈希，即可更改。

先看用 id() 函數(shù)的在整數(shù) i 和列表 l 上的運(yùn)行結(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 和之前不一樣，因此加完之后的這個(gè) i (雖然名字沒(méi)變)，但是不是加前的那個(gè) i 了，因此整數(shù)是不可更改的。

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

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

hash('Name')

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

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

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

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

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

「集合」有兩種定義語(yǔ)法，第一種是

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

關(guān)鍵點(diǎn)是「大括號(hào) {}」和「逗號(hào) ,」

• 大括號(hào)把所有元素綁在一起

• 逗號(hào)將每個(gè)元素一一分開(kāi)
  

第二種是用 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)集合的兩個(gè)特點(diǎn)：無(wú)序 (unordered) 和唯一 (unique)。由于 set 存儲(chǔ)的是無(wú)序集合，所以我們沒(méi)法通過(guò)索引來(lái)訪(fǎng)問(wèn)，但是可以判斷一個(gè)元素是否在集合中。

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)點(diǎn)：不用判斷重復(fù)的元素

缺點(diǎn)：不能存儲(chǔ)可變對(duì)象

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

在編寫(xiě)程序時(shí)，我們要

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

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

條件語(yǔ)句太簡(jiǎn)單了，大體有四種格式

1. if 語(yǔ)句

2. if-else 語(yǔ)句

3. if-elif-else 語(yǔ)句

4. nested 語(yǔ)句

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

if

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

給定二元條件，滿(mǎn)足做事，不滿(mǎn)足不做事。

if-else

if x % 2 == 0:print( 'x is even' )else :print( 'x is odd' )

給定二元條件，滿(mǎn)足做事 A，不滿(mǎn)足做事 B。

if-elif-else

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' )

給定多元條件，滿(mǎn)足條件 1 做事 A₁，滿(mǎn)足條件 2 做事 A₂，..., 滿(mǎn)足條件 n 做事 A_n。直到把所有條件遍歷完。

Nested if

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

給定多元條件，滿(mǎn)足條件 1 做事 A₁，不滿(mǎn)足就

    給定多元條件，滿(mǎn)足條件 2 做事 A₂，不滿(mǎn)足就

        ...

直到把所有條件遍歷完。

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

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

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

一般來(lái)說(shuō)，在 「while 循環(huán)」中，迭代的次數(shù)事先是不知道的，因?yàn)橥ǔＤ悴恢?while 后面的語(yǔ)句從 True 變成 False了。

更多時(shí)候我們希望事先直到循環(huán)的次數(shù)，比如在列表、元組、字典等容器類(lèi)數(shù)據(jù)上遍歷一遍，在每個(gè)元素層面上做點(diǎn)事情。這時(shí)候就需要「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 是個(gè)可迭代數(shù)據(jù) (list, tuple, dic, set)，a 是 A 里面的每個(gè)元素，上句翻譯成中文是

    對(duì)于 A 里面的每個(gè) a

        對(duì) a 搞點(diǎn)事

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

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

    for i, a in enumerate(A)

        do something with a  

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

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

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

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

• 單獨(dú)類(lèi)型：整型、浮點(diǎn)型、布爾型

• 容器類(lèi)型：字符、元組、列表、字典、集合

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

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

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

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

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

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