回味Python2.7——筆記1

1、基本知識

一、一個值能夠同時賦給幾個變量:

>>> x = y = z = 0  # Zero x, y and z
>>> x
0
>>> y
0
>>> z
0

 

二、建立複數

>>> a=1+6j
>>> x=complex(1,3) # x=1+3j
>>> 
3x.real
1
>>>x.imag

 

三、字符串

>>> 'spam eggs'
'spam eggs'
>>> 'doesn\'t'
"doesn't"
>>> "doesn't"
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "\"Yes,\" he said."
'"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'

字符串能夠標識在一對三引號中： """ 或 ''' 。三引號中，不須要行屬轉義，它們已經包含在字符串中。

hello = r"This is a."
print(hello)

字符串也能夠被截取（檢索）

Unicode

>>> u'Hello World !'
u'Hello World !'

>>> str(u"abc")
'abc'

 

四、列表

>>> a = ['spam', 'eggs', 100, 1234]
>>> a
['spam', 'eggs', 100, 1234]

就像字符串索引，列表從 0 開始檢索。列表能夠被切片和鏈接

容許嵌套列表（建立一個包含其它列表的列表）

>>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2

 

五、for語句

Python 的 for 語句依據任意序列（鏈表或字符串）中的子項，按它們在序列中的順序來進行迭代。

>>> # Measure some strings:
... a = ['cat', 'window', 'defenestrate']
>>> for x in a:
...     print x, len(x)
...
cat 3
window 6
defenestrate 12

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

>>> range(5, 10)
[5, 6, 7, 8, 9]
>>> range(0, 10, 3)
[0, 3, 6, 9]
>>> range(-10, -100, -30)
[-10, -40, -70]

 

六、定義函數

全局變量不能在函數中直接賦值（除非用 global 語句命名）

>>> def fib(n): 
...     """Print a Fibonacci series up to n."""
...     a, b = 0, 1
...     while a < n:
...         print a,
...         a, b = b, a+b

函數體的第一行語句能夠是可選的字符串文本，這個字符串是函數的文檔字符串，或者稱爲 docstring 。

　　6.一、Lambda 形式

Lambda 形式能夠用於任何須要的函數對象。

相似於嵌套函數定義，lambda 形式能夠從外部做用域引用變量

>>> def make_incrementor(n):
...     return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43

　　6.二、文檔字符串

第一行應該是關於對象用途的簡介

若是文檔字符串有多行，第二行應該空出來，與接下來的詳細描述明確分隔。

Python 的解釋器不會從多行的文檔字符串中去除縮進，因此必要的時候應當本身清除縮進。

文檔第一行一般空出，若是寫了，__doc__格式不是很好

def test():
    """
    aaaaaaaaaaaaaaaaaaaa
    this is a test document!
    bbbbbbbbbbbbbbbbbbbb
    """
    pass

print test.__doc__
輸出以下：

    aaaaaaaaaaaaaaaaaaaa
    this is a test document!
    bbbbbbbbbbbbbbbbbbbb

 

七、 插曲：編碼風格建議

• 使用 4 空格縮進，而非 TAB。

  在小縮進（能夠嵌套更深）和大縮進（更易讀）之間，4空格是一個很好的折中。TAB 引起了一些混亂，最好棄用。

• 折行以確保其不會超過 79 個字符。

  這有助於小顯示器用戶閱讀，也可讓大顯示器能並排顯示幾個代碼文件。

• 使用空行分隔函數和類，以及函數中的大塊代碼。

• 可能的話，註釋獨佔一行

• 使用文檔字符串

• 把空格放到操做符兩邊，以及逗號後面，可是括號裏側不加空格： a = f(1, 2) + g(3, 4) 。

• 統一函數和類命名。

  推薦類名用 駝峯命名， 函數和方法名用 小寫_和_下劃線。老是用 self 做爲方法的第一個參數（關於類和方法的知識詳見 初識類 ）。

• 不要使用花哨的編碼，若是你的代碼的目的是要在國際化 環境。 Python 的默認狀況下，UTF-8，甚至普通的 ASCII 老是工做的最好。

• 一樣，也不要使用非 ASCII 字符的標識符，除非是不一樣語種的會閱讀或者維護代碼。

 

2、數據結構

1. 關於列表更多的內容

Python 的列表數據類型包含更多的方法。 這裏是全部的列表對象方法：

• list.append(x)　　把一個元素添加到鏈表的結尾
• list.extend(L) 　　將一個給定列表中的全部元素都添加到另外一個列表中
• list.insert(i, x)　　在指定位置插入一個元素。第一個參數是準備插入到其前面的那個元素的索引
• list.remove(x)　　刪除鏈表中值爲 x 的第一個元素。若是沒有這樣的元素，就會返回一個錯誤。
• list.pop([i])　　從鏈表的指定位置刪除元素，並將其返回。若是沒有指定索引， a.pop() 返回最後一個元素。元素隨即從鏈表中被刪除。（方法中 i 兩邊的方括號表示這個參數是可選的，而不是要求你輸入一對方括號，你會常常在 Python 庫參考手冊中遇到這樣的標記。）
• list.index(x)　　返回鏈表中第一個值爲 x 的元素的索引。若是沒有匹配的元素就會返回一個錯誤。
• list.count(x)　　返回 x 在鏈表中出現的次數。
• list.sort()　　對鏈表中的元素就地進行排序
• list.reverse()　　就地倒排鏈表中的元素
• del 語句　　 有個方法能夠從列表中按給定的索引而不是值來刪除一個子項： del 語句。它不一樣於有返回值的 pop() 方法。語句 del 還能夠從列表中刪除切片或清空整個列表（咱們之前介紹過一個方法是將空列表賦值給列表的切片）。del 也能夠刪除整個變量

  >>> a = [-1, 1, 66.25, 333, 333, 1234.5]
  >>> del a[0]
  >>> a
  [1, 66.25, 333, 333, 1234.5]
  >>> del a[2:4]
  >>> a
  [1, 66.25, 1234.5]
  >>> del a[:]
  >>> a
  []

   

 tips:

collections模塊中的deque，能夠實如今首處插入和刪除數據

from collections import deque
a=deque([1,2,3,4,5,6,7])
a.appendleft(0)
print a
a.popleft()
print a

輸出結果：

deque([0, 1, 2, 3, 4, 5, 6, 7])
deque([1, 2, 3, 4, 5, 6, 7])

 二、函數式編程工具

對於鏈表來說，有三個內置函數很是有用: filter(), map(), 以及 reduce()

　　2.一、filter（）

filter(function, sequence) 返回一個 sequence（序列），包括了給定序列中全部調用 function(item) 後返回值爲 true 的元素。（若是可能的話，會返回相同的類型）。若是該 序列（sequence） 是一個 string （字符串）或者 tuple （元組），返回值一定是同一類型，不然，它老是 list 。

>>> def f(x): 
...         return x % 2 != 0 and x % 3 != 0
>>> filter(f, range(2, 25))
[5, 7, 11, 13, 17, 19, 23]    

　　2.二、map()

map(function, sequence) 爲每個元素依次調用 function(item) 並將返回值組成一個鏈表返回。

>>> def cube(x): return x*x*x
...
>>> map(cube, range(1, 11))
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

能夠傳入多個序列，函數也必需要有對應數量的參數，執行時會依次用各序列上對應的元素來調用函數（若是某些序列比其它的短，就用 None 來代替）。若是把 None 作爲一個函數傳入，則直接返回參數作爲替代。

>>> seq = range(8)
>>> def add(x, y): return x+y
...
>>> map(add, seq, seq)
[0, 2, 4, 6, 8, 10, 12, 14]

　　2.三、reduce（）

reduce(function, sequence) 返回一個單值，它是這樣構造的：首先以序列的前兩個元素調用函數 function，再以返回值和第三個參數調用，依次執行下去。

>>> def add(x,y): return x+y
...
>>> reduce(add, range(1, 11))
55

若是序列中只有一個元素，就返回它，若是序列是空的，就拋出一個異常。

 

三、 列表推導式

squares = [x**2 for x in range(10)]

列表推導式由包含一個表達式的括號組成，表達式後面跟隨一個 for 子句，以後能夠有零或多個 for 或 if 子句。 結果是一個列表，由表達式依據其後面的 for 和 if 子句上下文計算而來的結果構成。

>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

等同於：

>>> combs = []
>>> for x in [1,2,3]:
...     for y in [3,1,4]:
...         if x != y:
...             combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

列表推導式可以使用複雜的表達式和嵌套函數:

>>> from math import pi
>>> [str(round(pi, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

matrix=[[1,2,3],[4,5,6]]
[[row[i] for row in matrix] for i in range(3)]

[[1, 4], [2, 5], [3, 6]]

 

四、元組和序列、集合、字典

元組在輸出時老是有括號的，以便於正確表達嵌套結構。在輸入時能夠有或沒有括號，不過常常括號都是必須的（若是元組是一個更大的表達式的一部分）。不能給元組的一個獨立的元素賦值（儘管你能夠經過聯接和切割來模擬）。還能夠建立包含可變對象的元組。元組就像字符串，不可改變。

>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')

集合是一個無序不重複元素的集。基本功能包括關係測試和消除重複元素。集合對象還支持 union（聯合），intersection（交），difference（差）和 sysmmetric difference（對稱差集）等數學運算。大括號或 set() 函數能夠用來建立集合。 注意：想要建立空集合，你必須使用 set() 而不是 {}。後者用於建立空字典。

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> fruit = set(basket)               # create a set without duplicates
>>> fruit
set(['orange', 'pear', 'apple', 'banana'])
>>> 'orange' in fruit                 # fast membership testing
True
>>> 'crabgrass' in fruit
False

字典以 關鍵字 爲索引，關鍵字能夠是任意不可變類型，一般用字符串或數值。

理解字典的最佳方式是把它看作無序的鍵： 值對 （key:value pairs）集合，鍵必須是互不相同的（在同一個字典以內）。一對大括號建立一個空的字典： {} 。

字典的主要操做是依據鍵來存儲和析取值。也能夠用 del 來刪除鍵：值對（key:value）。若是你用一個已經存在的關鍵字存儲值，之前爲該關鍵字分配的值就會被遺忘。試圖從一個不存在的鍵中取值會致使錯誤。

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> tel.keys()
['guido', 'irv', 'jack']
>>> 'guido' in tel
True

dict() 構造函數能夠直接從 key-value 對中建立字典:

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}

此外，字典推導式能夠從任意的鍵值表達式中建立字典:

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

若是關鍵字都是簡單的字符串，有時經過關鍵字參數指定 key-value 對更爲方便:

>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}

 

五、others

在序列中循環時，索引位置和對應值可使用 enumerate() 函數同時獲得:

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe

同時循環兩個或更多的序列，可使用 zip() 總體打包:

>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print 'What is your {0}?  It is {1}.'.format(q, a)
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

 

深刻條件控制

比較操做符 in 和 not in 用來判斷值是否在一個區間以內。操做符 is 和 is not 比較兩個對象是否相同；這隻和諸如鏈表這樣的可變對象有關。全部的比較操做符具備相同的優先級，低於全部的數值操做。

比較操做能夠傳遞。例如 a < b == c 判斷是否 a 小於 b 而且 b 等於 c 。

比較操做能夠經過邏輯操做符 and 和 or 組合，比較的結果能夠用 not 來取反義。這些操做符的優先級又低於比較操做符，在它們之中，not 具備最高的優先級， or 優先級最低，因此 A and not B or C 等於 (A and (notB)) or C 。固然，括號也能夠用於比較表達式。

邏輯操做符 and 和 or 也稱做 短路操做符 ：它們的參數從左向右解析，一旦結果能夠肯定就中止。