2.5 對序列使用 +和 ×

l = [1,2,3]
print(id(l))
t= l*5
print(id(t))

結果如圖：

• 總結：+ 和 * 都遵循這個規律，不修改原有的操作對象，而是構建一個全新的序列。
• 注意：如果a*n 這個語句中，序列a里面的元素是對其他可變對象的引用的話，這個結果可能會出乎意料。比如，你想用my_list = [[]]*3 來初始化一個由列表組成的列表，但是你得到的列表里面包含的3個元素其實是3個引用，而且這3個引用指向同一個列表。這顯然不是想要的。

建立由列表組成的列表

正確的方式1：

board = [['_'] * 3 for i in range(3)]
print(board)
board[1][2] = 'X'
print(board)

結果如圖：

錯誤的方式1：含有3個指向同一對象的引用的列表是毫無用處的。

weird_board = [['_']*3] *3
print(weird_board)
weird_board[1][2] = '0'
print(weird_board)

結果如圖：

錯誤的方式2：
這個和上一個錯誤的本質是一樣的

row = [' _ ']*3
board = []
for i in range(3):board.append(row)
print(board)
board[1][2] ='0'
print(board)

結果如圖：

正確的方式2：
這里的等同于正確的方式1

board = []
for i in range(3):row = ['_']*3 # 每次迭代中都新建了一個列表，作為新的一行添加到boardboard.append(row)
print(board)
board[1][2] ='0'
print(board)

結果如圖：

2.6序列的增量賦值（+=和×=）

增量賦值運算符+=和*=的表現取決于它們的第一個操作對象，本次的就集中討論（+=）。對其他的增量運算符也同樣適用。
+=背后的特殊方法是__iadd__(用于‘就地加法’)，所謂的‘就地’理解為：不創建新的對象，而是將原來的對象重新賦值。如果一個類沒有實現這個方法的話，python會退一步調用__add__.
我們考慮下面這個簡單的表達式：

• a+=b

• 討論：
  （1）.若a實現了__iadd__方法，就會調用這個方法。同時對于可變序列（list,bytearray和array.array）來說，a會就地變動了，就像調用了a.extend(b)一樣
  （2）.若a沒有實現__iadd__方法，a+=b這個表達式的效果就會根a=a+b一樣了；首先計算a+b，得到一個新的對象，然后賦值給a。

• 總結：
  在這個表達式中，變量名會不會被關聯到新的可變對象，完全取決于這個類型有沒有實現__iadd__這個方法。總的來說，可變序列一般都實現了__iadd__這個方法，因此+=是就地加法。而不可變序列沒有實現這個方法，就會像步驟（2）那樣操作。后者相對應的是__imul__.

例子：

l = [1, 2, 3]
print('before id(l):',id(l))
l *=2
print(l)
print('after id(l):',id(l))
t = (1, 2, 3)
print('before id(t):',id(t))
t *= 2
print('after id(t):',id(t)) # 運用增量懲罰后，新的元組被創建

結果如圖：

關于 +=的謎題

t = (1, 2, [30,40])
t[2] += [50, 60]
print(t)

結果：t[2]被改動了，但是也有異常出現。但是我們可以寫成t[2].extend([50,60])來避免這個異常。

教訓：

• 不要把可變對象放在元組里面
• 增量賦值不是一個原子操。它雖然會拋出異常，但是還是完成了操作
• 查看python的字節碼并不難，它對我們了解代碼背后的運行機制很有幫助。

補充：extend()方法和+有什么區別呢？

a = [1,2,3]
b = [4,5,6]
c = a+bd = [1,2,3]
e = [4,5,6]
d.extend(e)

結果如圖：

結論：
結果是一樣的，但是+號生成的是一個新的對象，而extend則是在原地的修改對象。
extend()的運算效率比+更高。但是， d.extend(e) 的返回結果是None，而不是合并后的序列。d序列是合并后的序列。
c返回的是新的序列。

2.7 list.sort方法和內置函數sorted(排序)

list.sort方法會就地排序列表，這也是這個方法返回None的原因，按照python的慣例：如果一個函數或者方法對對象進行的是就地改動，那它就應該返回None.
與list.sort相反的是sorted，它會新建一個列表作為返回值。這個方法可以接受人和形式的可迭代對象作為參數，甚至包括不可變序列或者生成器，但是它總是返回一個列表。
不管list.sort或者sorted函數，都有兩個參數，reverse和key

• reverse:默認為False,就是升序排列,True為降序排列
• key:對一些字符串進行排序的時候，key=str.lower來實現忽略大小寫的排序;key=len來顯示根據字符串長度來排序。

例子：

fruits = ['grape', 'raspberry', 'apple', 'banana']
print("未排序：", fruits)
print(sorted(fruits))
print("sorted：", fruits)
print(sorted(fruits,reverse=True))
print(sorted(fruits,key=len))
print(sorted(fruits,key=len,reverse=True))
print(fruits)
fruits.sort()
print(fruits)

結果如下：

可以發現，直到執行了fruits.sort方法，fruits本身才發生了變化。
排好序的序列可以用來進行快速搜索，而標準庫的bisect模塊給我們提供了二分查找算法。

2.8 用bisect來管理已排序的序列

bisect模塊包含類 兩個主要函數，bisect和insert，兩個函數都利用二分查找算法在有序序列中查找或者插入元素。
在有序序列中用bisect查找某個元素的插入位置。
例子1：

import bisect
import sys
HAYSTACK = [1, 4, 5, 6, 8, 12, 15, 20, 21, 23, 23, 26, 29, 30]
NEEDLES = [0, 1, 2, 5, 8, 10, 22, 23, 29, 30, 31]
ROW_FMT = '{0:2d} @ {1:2d}   {2}{0:2d}'
def demo(bisect_fn):for needle in reversed(NEEDLES):position = bisect_fn(HAYSTACK, needle) #返回插入的位置offset = position * '  |'print(ROW_FMT.format(needle, position, offset))# return bisect_fnif __name__ == '__main__':if sys.argv[-1] == 'left':bisect_fn = bisect.bisect_left  #當碰到相等的元素的時候，會放在它左邊（前邊） else:bisect_fn = bisect.bisect #或者是bisect_fn = bisect.bisect_right,當碰到相等的元素的時候，會放在它的右邊（后邊）print('DEMO:', bisect_fn.__name__)print('haystack ->', ' '.join('%2d' % n for n in HAYSTACK))demo(bisect_fn)

例子2：根據分數找到它對應的成績

import bisect
def grade(score,breakpoint = [60,70,80,90],grades='FDCBA'):i = bisect.bisect(breakpoint,score) # 返回i，匹配gradesreturn grades[i]
t = [grade(score) for score in [33,99,77,70,89,91,10]]
print(t)

輸出：

['F', 'A', 'C', 'C', 'B', 'A', 'F']

2.8.2用bisect.insort插入元素

insort(seq,item) 把變量item插入到序列seq中，并能保持seq的升序順序。

import bisect
import random
SIZE = 7
random.seed(1729)
my_list = []
for i in range(SIZE):new_item = random.randrange(SIZE*2)bisect.insort(my_list, new_item)print('%2d ->' % new_item, my_list)

結果如圖：

• 補充： %和format的區別

參考：https://www.cnblogs.com/zhaopanpan/p/8875765.html （%和format的區別）

2.9 當列表不是首選時

2.9.1 數組

2.9.2內存視圖

2.9.3 NumPy和SciPy

科學計算有關的算法

窺探NumPy二維數組的基本操作

import numpy
a = numpy.arange(12)
print(a)
print(type(a))
print(a.shape)#查看維度
a.shape = 3, 4 #變成二維的
print(a)
print(a[2])
print(a[2, 1])
print(a[:, 1])
t = a.transpose() #行列交換,得到**新的數組**
print(t) 

結果如下：

可以發現t是一個新的數組。

2.9.4 雙向隊列和其他的形式的隊列

補充：markdown生成目錄方式，在開頭輸出[toc]