變數並不是一塊記憶體空間的標籤，只是物件的名字，是沒有型別的，相當於一個可以指向任何物件void指標。型別屬於物件，而不是變數。

1. type(L) == type([])

2. type(L) == list

3. isinstance(L,list)

儘管支援型別檢測，但這並不是一個“Python式”的思維方式，破壞了程式碼的靈活性。

基本賦值、元組賦值、列表賦值和多目標賦值。在賦值語句中，即使沒有圓括號，也能識別出來這是一個元組。

序列賦值語句:支援右側任何可迭代物件（左右元素數目相同）

[a,b,c] = (1,2,3)或 [a,b,c] = '123'或 red,green,blue = range(3)

交換值不需要中間變數

需要注意引用的陷阱：

對於支援原地修改的物件而言，增強賦值語句會執行原地修改運算L.append(4) L.extend([7,8])，比合並（複製過程）L = L + [4] 執行得更快.

隱式賦值語句：模組匯入import,from;函式和類的定義def,class;for迴圈變數;函式引數

在函式中接收元組和列表

當要使函式接收元組或字典形式的引數的時候，有一種特殊的方法，它分別使用*和**字首。這種方法在函式需要獲取可變數量的引數的時候特別有用。

>>> def powersum(power, *args):
...     '''Return the sum of each argument raised to specified power.'''
...     total = 0
...     for i in args:
...          total += pow(i, power)
...     return total
...
>>> powersum(2, 3, 4)
25

>>> powersum(2, 10)
100

在 Python 中所有賦值操作都是“引用傳遞”。當把一個物件賦給一個數據結構元素或者變數名時，Python總是會儲存物件的引用，而不是物件的一個拷貝（除非明確要求拷貝）。

通過將一些基本資料型別（數值、字串、元組）設為不可改變物件，可以模擬“值傳遞”，例如：

userName = ‘tonyseek’   #字串物件為不可變物件，保護完整性
otherUserName = userName  #指向新建立的另一個字串物件

otherUserName = ‘It’s not tonyseek’  #改變的不是userName指向的內容

列表和元組都被認為是“物件引用”的陣列(在標準Python直譯器內部，就是C陣列而不是連結結構，索引速度較快)。

淺拷貝和深拷貝

淺拷貝只拷貝頂層結構，深拷貝是遞迴的拷貝。

如果你想要複製一個列表或者類似的序列或者其他複雜的物件（不是如整數那樣的簡單物件 ），那麼你可以使用切片操作符來取得拷貝。如果你只是想要使用另一個變數名，兩個名稱都 參考 同一個物件，那麼如果你不小心的話，可能會引來各種麻煩。

X = [1,2,3]

L1 = [X,X,X]

L2 = [X[:],list(X),copy.copy()] #頂層複製

L.append(L) #無限迴圈物件，複合物件包含指向自身的引用·

當最後一次引用物件後（例如，將這個變數用其他的值進行賦值），這個物件所有佔用的記憶體空間將會自動清理掉

絕對值

abs(x)

若x位複數，返回複數模

x的y次幕(x ** y ) x % modulo

返回值型別與x同

將x做實部，y做虛部建立複數

將字串和數字轉換為整數,對浮點進行舍位而非舍入

long(x)

將字串和數字轉換為長整形

將str和num轉換為浮點物件

hex(x) 將整數或長整數轉換為十六進位制字串

oct(x) 將整數或長整數轉換為八進位制字串

>>> random.random()   #浮點數，x in the interval [0, 1)
0.8759095262051569

>>> random.getrandbits(16) #a python long int with k random bits

9213L

>>> random.uniform(1,1000) #浮點數in the range [a, b) or [a, b]

400.88489201157114

>>> random.randint(1,1000) #整數random integer in range [a, b] 不推薦使用

817

>>> random.randrange(0,1001,2) #整數from range([start,] stop[, step]) 推薦使用

822

隨機：序列操作sequences
---------
pick random element
random sampling without replacement

generate random permutation

>>> random.choice([0,1,2,3]) #a random element
2

>>> random.sample(xrange(10000000), 3) #unique random elements
[9435040, 5756107, 8741537]

>>> random.shuffle(list)  #洗牌，就地shuffle list，無返回值.可選引數random是一個返回[0.0, 1.0)間浮點數的無參函式名，預設為random.random.

>>> range(0,10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(9,-1,-1)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

同時遍歷多個序列：zip(L1,L2)/map(None,L1,L2)

zip函式轉置二維列表：

>>> l = [[1, 2, 3], [4, 5, 6]]
>>> zip(*l)
[(1, 4), (2, 5), (3, 6)]

列表解析替代巢狀迴圈：for迴圈和列表解析（通常比對應的for迴圈執行得更快）都是通用迭代工具，都能工作於遵守迭代協議的任意物件（可遍歷物件，包括可自逐行讀取的檔案）

>>> M = [[1,2,3],[4,5,6],[7,8,9]]
>>> column = [row[1] for row in M if row[1]%2 == 0]
>>> column
[2, 8]
>>> diag = [M[i][i] for i in [0,1,2]]
>>> diag
[1, 5, 9]

>>> squares = [x**2 for x in [1,2,3,4,5]]

>>> squares

[1, 4, 9, 16, 25]

列表解析也可用於元組的轉換：

>>> T = (1,2,3,4,5)

>>> L = [x+20 for x in T]

>>> L

[21, 22, 23, 24, 25]

>>> [line.upper() for line in open('script1.py')]

>>> set('abcde')
set(['a', 'c', 'b', 'e', 'd'])

>>> s = "a\0b\tc\c" 
>>> s
'a\x00b\tc\\c'
>>> len(s)
7

1 合併、分片、索引 
where = S.find('SPAM')
S = S[:where] + 'EGGS' +S[(where+4):]
2 字串方法 
S = S.replace('pl','pamal') #replace all
S = S.replace('pl','pamal',1) #replace once
role,words = line.split(':',1) #split([sep[,maxsplit]]) ->list of strings

3 轉化為可變物件
L = list(S)
L[3] = 'x'
S = ''.jion(L)
line = 'bob,hacker,40\n'
line.rstrip()
line.split(',')
[bob,hacker,40]

>>> import re
>>> match = re.match('[/]usr/(.*)/(.*)','/usr/home/jack')
>>> type(match)
<type '_sre.SRE_Match'>
>>> match.groups()
('home', 'jack')

元組的不可變性只適用於元組本身的頂層結構而並非其內容：

>>>T = (1,[2,3],4)

>>> T[1] = 'spam'
TypeError: 'tuple' object does not support item assignment

>>> T[1][0] = ‘spam’

>>> T

(1, ['spam', 3], 4)

C++（for語句+迭代器）遍歷並修改列表（輸出222）

vector<int> vint;
vector<int>::iterator i;
vint.resize(3,1);
for(i = vint.begin(); i != vint.end();++i)    *i += 1;
for(i = vint.begin(); i != vint.end();++i)    cout << *i;

Python的for語句（這種foreach概念在C++中是沒有的）不行：

Python的dict實現，其實就是一個hash map，因此要求Key是hashable的

鍵為不可變物件：數字和字串，只包括(像數字和字串這樣的)不可變引數的元組，才可以作為字典中有效的鍵。大多數Python物件可以作為鍵；但它們必須是可雜湊的物件。

像列表和字典這樣的可變型別，由於它們不是可雜湊的，所以不能作為鍵。 也有一些可變物件(很少)是可雜湊的。

update(x2) 用字典x2中的鍵/值對新增到原字典。重複鍵所對應的原有條目的值將被新鍵所對應的值所覆蓋。

get(x[,y]) 返回鍵x對應的值。若未找到返回default的值(注意，引數default的預設值為None)。get()方法和鍵查詢(key-lookup)操作符( [ ] )相似，不同的是它允許你為不存在的鍵提供預設值。如果該鍵不存在，也未給出它的預設值，則返回None。此方法比採用鍵查詢(key-lookup)更靈活，因為你不必擔心因鍵不存在而引發異常。

pop(key) ,del d[key]

clear() 刪除詞典的所有條目。

D0 = {'name' = 'Bob', 'age' = 42}

D1 = dict(name = 'Bob', age = 42)

D2 = dict.fromkeys(seq, val=None) 建立並返回一個新字典，以seq中的元素做該字典的鍵，val做該字典中所有鍵對應的初始值(如果不提供此值，則預設為None)

D3 = dict(zip(keylist,vallist))

copy() 淺拷貝：返回字典的高層結構的拷貝，但不復制嵌入結構，而複製那些結構的引用。

copy模組：copy.copy(x) copy.deepcopy(x)

'r', 'w' or 'a' for reading (default),writing or appending. 寫或追加模式下若檔案不存在則建立它。

字串尾部加’b’可以進行二進位制資料處理（行末轉換關閉）;加‘+’同時為輸入輸出開啟；加‘U’實現input file的universal newline support(不能與'w' or '+'同時使用) 
buffering引數：

控制輸出快取,0 代表無快取（寫入方法呼叫時立即傳給外部檔案）0 means unbuffered, 1 means line buffered, and larger numbers specify the buffer size.

返回空字串：檔案底部; 返回包含新行符的字串：空行
for line in open('test.txt').readlines():print line #比檔案迭代器麻煩
while ... :   #效率比for差
   line  = file.readline()
   if not line:break 

寫入方法不新增行終止符

import sys
sys.stdout = open('log.txt', 'a') # Redirects prints to a file
...
print(x, y, x) # Shows up in log.txt

暫時重定向

log = open('log.txt', 'a') # 2.6
print >> log, x, y, z # Print to a file-like object
print a, b, c # Print to original stdout

print >> sys.stderr, 'Bad'*8

0,'',(),[],{},None

false

'string',>1,<-1

true

面向物件

基本概念一樣，this由代替self， 而且這個名字不一定要寫成self，任何名字都可以，這也帶來了一個缺點，你必須在形參裡面指定，呼叫函式時不用傳遞該引數。
建構函式：__init__(self, ......)
解構函式：__del__ 物件滅亡時或者呼叫del時被呼叫
Python中所有的類成員（包括資料成員）都是公共的 ，所有的方法都是有效的 。只有一個例外：如果你使用的資料成員名稱以 雙下劃線字首 比如__privatevar，Python的名稱管理體系會有效地把它作為私有變數。

儲存器

cPickle和pickle是叫做儲存器的重要模組，可以非常方便地將一個物件儲存到一個檔案，然後再取儲存從檔案中取出來pickle.dump(object, file object)，構造物件時，pickle.load(file object) [儲存、取儲存]

異常

raise，except,try...finally

lambda語句被用來建立新的函式物件，並且在執行時返回它們。lambda語句用>來建立函式物件。本質上，lambda需要一個引數，後面僅跟單個表示式作為函式體，而表示式的值被這個新建的函式返回。

注意，即便是print語句也不能用在lambda形式中，只能使用表示式。

distributions on the real line:
------------------------       uniform
       triangular
       normal (Gaussian)
       lognormal
       negative exponential
       gamma
       beta
       pareto
       Weibull
distributions on the circle (angles 0 to 2pi)
------------------------       circular uniform
       von Mises

uniform(self, a, b)

|      Get a random number in the range [a, b) or [a, b].

triangular(self, low=0.0, high=1.0, mode=None)
|      Triangular distribution.

gauss(self, mu, sigma)
|      Gaussian distribution.

normalvariate(self, mu, sigma)
|      Normal distribution.

lognormvariate(self, mu, sigma)
|      Log normal distribution.

expovariate(self, lambd)
|      Exponential distribution.

gammavariate(self, alpha, beta)
|      Gamma distribution.  Not the gamma function!

betavariate(self, alpha, beta)
|      Beta distribution.

paretovariate(self, alpha)
|      Pareto distribution. 

weibullvariate(self, alpha, beta)
|      Weibull distribution.

vonmisesvariate(self, mu, kappa)
|      Circular data distribution.

internal state

seed(self, a=None)
|      Initialize internal state from hashable object.

setstate(self, state)
|      Restore internal state from object returned by getstate().

getstate(self)
|      Return internal state; can be passed to setstate() later.

jumpahead(self, n)
|      Change the internal state to one that is likely far away
|      from the current state.  This method will not be in Py3.x,
|      so it is better to simply reseed.