python學習筆記 序列

內置序列

• 容器序列

list, tuple, collections.deque等這些序列能存放不一樣類型的數據

• 扁平序列

str, byte, bytearray, memoryview, array.array, 這些序列只能容納一種類型數據

以上，容器序列存放的是他們所含任意類型對象的引用，而扁平序列存放的是值而不是引用

列表（list）是最基礎也是最重要的序列類型

列表推導

>>> symbols = '中華人民共和國'
>>> codes = [ord(symbol) for symbol in symbols]
>>> codes
[20013, 21326, 20154, 27665, 20849, 21644, 22269]

列表推導由for循環變換而來，加強可讀性的同時，也使得代碼更加簡潔

python會忽略代碼裏[]/()/{}中的換行，在其中能夠省略續行符 "\"

生成器表達式

生成器的語法和列表推導差很少，只是把方括號換成圓括號

>>> symbols = '中華人民共和國'
>>> tuple(ord(symbol) for symbol in symbols)
(20013, 21326, 20154, 27665, 20849, 21644, 22269)
>>> import array
>>> array.array('I', (ord(symbol) for symbol in symbols))
array('I', [20013, 21326, 20154, 27665, 20849, 21644, 22269])

(1) 若是生成器表達式是一個函數惟一的參數，那麼這個參數不須要額外的括號
(2) array的構造方法須要兩個參數，因此生成器表達式須要被括號圍起來

list.sort方法和內置函數sorted

• list.sort 方法的功能是將序列就地排序，即不會從新建立一個數組，將原數組複製過來
• 與list.sort不一樣的是，序列的內置函數sorted的功能雖然也是排序，可是會從新建立一個數組，不會對原數組作任何改動

>>> fruits = ['grape', 'respberry', 'apple', 'banana']
>>> sorted(fruits)
['apple', 'banana', 'grape', 'respberry']
>>> fruits
['grape', 'respberry', 'apple', 'banana']
>>> sorted(fruits, key=len)
['grape', 'apple', 'banana', 'respberry']
>>> sorted(fruits, key=len, reverse=True)
['respberry', 'banana', 'grape', 'apple']
>>> fruits
['grape', 'respberry', 'apple', 'banana']
>>> fruits.sort()
>>> fruits
['apple', 'banana', 'grape', 'respberry']

由以上的例子能夠看出二者的差異，而sorted函數還接受key, reverse兩個參數
其中，參數key表示比較的標準，而reverse表示是否要逆序（True）

利用bisect管理有序序列

利用bisect進行搜索

函數bisect(haystack, needle)可實如今haystack（乾草堆，一個有序序列）中找到needle（針）的位置，該位置知足的條件是，把needle插入該函數所搜索到的位置後，整個haystack依然保持有序

import bisect
import sys
import random


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


if __name__ == '__main__':

    if sys.argv[-1] == 'left':
        bisect_fn = bisect.bisect_left
    else:
        bisect_fn = bisect.bisect_right

    print('Demo: ', bisect_fn.__name__)
    print('haystack ->', ''.join('%2d' % n for n in haystack))
    demo(bisect_fn)



    print("\n\n#################insort###############")
    size = 7
    # random.seed(1729)
    my_list = []
    for i in range(7):
        new_item = random.randrange(size * 2)
        bisect.insort(my_list, new_item)
        print('%2d ->' % new_item, my_list)
        
    #############運行結果################
Demo:  bisect_right
haystack ->  1 4 5 6 8121520212323262930
31 @ 14     | | | | | | | | | | | | | |31
30 @ 14     | | | | | | | | | | | | | |30
29 @ 13     | | | | | | | | | | | | |29
23 @ 11     | | | | | | | | | | |23
22 @  9     | | | | | | | | |22
10 @  5     | | | | |10
 8 @  5     | | | | |8
 5 @  3     | | |5
 2 @  1     |2
 1 @  1     |1
 0 @  0    0


#################insort###############
 9 -> [9]
 7 -> [7, 9]
 1 -> [1, 7, 9]
 4 -> [1, 4, 7, 9]
 5 -> [1, 4, 5, 7, 9]
12 -> [1, 4, 5, 7, 9, 12]
 5 -> [1, 4, 5, 5, 7, 9, 12]

*bisect實際上是bisect_rihght函數的縮寫，其返回的插入位置是原始序列與被插入元素相等元素位置的 右邊 ，該函數還有一個姊妹函數bisect_left，其返回的插入位置是原始序列與被插入元素相等元素位置的 左邊

書中還有推薦一個網站 Python Tutor ， 是一個對python運行原理進行可視化分析的工具。

注： 以上內容主體均來自於《流暢的python》書中第2章 序列構成的數組