第一章 基礎知識
第二章 列表和元組
-
序列概覽
- 6種內建的序列： 列表，元組，字符串，Unicode字符串，buffer對象 和 xrange對象
- 容器( container )數據結構：容器基本上是包含其他對象的任意對象。
- 序列（如列表和元組）和映射（如字典）是兩類主要的容器。 至于即不是序列，也不是映射的容器類型，集合(set)就是一個例子。
-
通用序列操作
索引（indexing），分片（sliceing），加（adding），乘（multiplying）
以及檢查某個元素是否屬于序列的成員（成員資格）。
此外還有，序列長度，最大元素，最小元素 的內建函數。
-
成員資格 in：
- 'w' in 'rw'
- True
-
列表： Python 的 “苦力”
- list函數 ，根據字符串創建列表
- list('hello')
- ['h','e','l','l','o']
- 【注】 list適用于所有類型的序列，不只是字符串
- 基本的列表操作：
- 改變列表，元素賦值 （不能為不存在的元素賦值）
- 刪除元素
- names = ['alice', 'bill']
- del names[0]
- ['bill']
- 分片賦值
- name = list('Perl')
- name[1:] = list('ython')
- ['P', 'y', 't', 'h', 'o', 'n']
- 列表方法
- append 在列表末尾追加新的對象
- a = [1,2,3]
- b = [4,5,6]
- a.append(b)
- [1,2,3 , [4,5,6] ]
- count 統計某個元素在列表中出現的次數
- extend 在列表末尾追加另外一個序列中的多個值，類似加法，但會改變序列值
- a = [1,2,3]
- b = [4,5,6]
- a.extend(b)
- [1,2,3 ,4,5,6 ]
- #########################
- a = [1,2,3]
- b = [4,5,6]
- a + b ## [1,2,3 ,4,5,6 ]
-
a 的值沒有改變
-
a = a + b 連接操作的效率會比 extend 方法低。
- index 從列表中找出某個值的第一個匹配項的索引
- name = ['i' , 'we' , 'you', 'we']
- name.index('we')
- 1
- insert 將對象插入到列表中
- name = [1,2,3,4,5]
- name.insert(3,'four')
- [1,2,3, 'four' ,4,5]
- pop 移除列表中的一個元素（默認是最后一個），且返回該元素值
- x = [1,2,3]
- x.pop()
- 3
- x
- [1,2]
- 【注】 pop 方法是唯一一個既能修改列表又返回元素值（除了None）的列表方法
- 使用pop可以實現一種常見的數據結構--棧。 LIFO 先進先出
- remove 移除列表中某個值的第一個匹配項
- x = ['to', 'be' , 'or', 'be']
- x.remove('be')
- x
- ['to', 'or', 'be']
-
remove 是一個沒有返回值的原位置改變方法，它修改了列表卻沒有返回值，這與pop方法相反。
- reverse 將列表中的元素反向存放
- x = [1,2,3]
- x.reverse()
- x
- [3,2,1]
-
如需對一個序列進行反向迭代，可以試用reversed函數。這個函數并不返回一個列表，而是返回一個迭代器(iterator)對象。 可以試用list函數把返回的對象轉換成列表也是可行的。
- sort 在原位置對列表進行排序。
- “原位置排序”意味著改變原來的列表，而不是簡單的返回一個已排序的副本。
- x = [1,3,2,4]
- x.sort()
- x
- [1,2,3,4]
-
sort 返回空值
- x = [1,3,2,4]
- y = x.sort() # Don't do this !
- print y
- None
-
正確的獲得x副本的做法
- x = [1,3,2,4]
- y = x[:]
- y.sort()
- x
- [1,3,2,4]
- y
- [1,2,3,4]
-
調用 x[:]得到包含了x所有元素的分片，是一種很有效率的復制整個列表的方法。
-
只是簡單的把x賦值給y是沒用的，因為這樣，x和y都指向同一個列表了。
- 另一種獲取已排序的列表副本的方法是，使用sorted函數：
- x = [1,3,2,4]
- y = sorted(x)
- x
- [1,3,2,4]
- y
- [1,2,3,4]
- sorted實際上可以用于任何序列，卻總是返回一個列表
- sorted('Python')
- ['P','h','n','o','t','y']
-
如果想相反的順序排序，可以調用 reverse 方法。
- 高級排序
- 可以為 sort 或 sorted 函數指定參數，來自定義排序
-
比較函數 ,可自定義
- cmp(42,32)
- 1
- cmp(99,100)
- -1
- cmp(10,10)
- 0
- num = [5,2,9,7]
- num.sort(cmp)
- num
- [2,5,7,9]
-
sort 返回還有另外兩個可選的參數-- key 和 reverse
- 參數key和 參數cmp類似，必須提供一個在排序過程中使用的函數
- x = ['bb' , 'a' , 'aaaa']
- x.sort(key=len)
- x
- ['a', 'bb', 'aaa']
- reverse是簡單的布爾值，指明列表是否要進行反向排序。
- append 在列表末尾追加新的對象
- 元組： 不可變序列
- 元組創建
-
也可以不用括號
- 1，2，3
- (1，2，3)
-
用括號也可以
- (1，2，3)
- (1，2，3)
-
一個值的元組 , 逗號很重要
- 42
- 42
- 42，
- (42,)
- (42,)
- (42,)
-
(42)和42是完全一樣的，但是，一個逗號卻能徹底改變表達式的值
- 3*(40+2)
- 126
- 3*(40+2,)
- (42,42,42)
-
- tuple 函數
- 與list函數基本是一樣的，以一個序列作為參賽，并把它轉換為元組
- 如果參數數元組，則原樣返回
- tuple([1,2,3])
- (1,2,3)
- tuple('abc')
- ('a','b','c')
- tuple((1,2,3))
- (1,2,3)
- 基本元組操作
- 元組其實并不復雜，除了元組創建和訪問元組元素之外，沒有太多其他操作。
- x = 1,2,3
- x[1]
- 2
- x[0:2]
- (1,2)
-
元組的分片還是元組
- 元組，意義何在
- 有兩個重要原因，元組是不可替代的
- 元組可以在映射(和集合的成員)中當作鍵使用-- 而列表則不行
- 元組作為很多內建函數和方法的返回值存在，也就是說你必須對元組進行處理。
只有不嘗試修改元組，那么“處理”元組在絕大多數情況下就是把他們當作列表來進行操作。
- 有兩個重要原因，元組是不可替代的
- 元組創建
- list函數 ，根據字符串創建列表
第三章 使用字符串
- a
- b
第四章 字典：當索引不好用時
-
dict函數
- 可以用 dict，通過其他映射(比如其他字典)或者 (鍵,值)這樣的序列建立字典。
- items = [('name','Gumby'), ('age', 42)]
- d = dict(items)
- d
- {'name':'Gumby', 'age':42}
-
還可以通過關鍵字來創建字典
- d = dict(name='Gumby', age=42)
- d
- {'age':42, 'name':'Gumby'}
- 可以用 dict，通過其他映射(比如其他字典)或者 (鍵,值)這樣的序列建立字典。
-
基本字典操作
字典的基本行為在很多方面與序列(sequence)類似：
len(d)
d[k]
d[k] = v
del d[k]
k in d
重要區別
鍵類型： 整數類型，或者其他不可變類型，比如：浮點型，字符串或者元組
自動添加：可以為不存在的鍵分配值，會建立新的項。
成員資格：表達式 k in d 查找的是鍵，而不是值。
提示： 在字典中檢查成員資格比在列表中更高效，數據越大，差距越明顯。
-
字典的格式化字符串
- phonebook
- {'Beth':'9102' , 'Cecil':'3258'}
- "Cecil's phone number is %(Cecil)s." % phonebook
- "Cecil's phone number is 3258."
-
字典方法
-
clear 清楚字典中的所有的項。 原地操作，所以無返回值（或者說返回None）
x = {}
- >>> y = x
- >>> x['key'] = 'v'
- >>> y
- {'key': 'v'}
- >>> x = {}
- >>> y
- {'key': 'v'}
- ###########################
- >>> x = {}
- >>> y = x
- >>> x['key'] = 'v'
- >>> y
- {'key': 'v'}
- >>> x.clear()
- >>> y
- {}
-
copy 返回一個具有相同鍵-值對的新字典。 （這個方法實現的是淺復制（shallow copy），因為值本身就是相同的，而不是副本）。
x = {'username': 'admin', 'machines': ['foo', 'bar', 'baz']}
- >>> y = x.copy()
- >>> y['username'] = 'mlh'
- >>> y['machines'].remove('bar')
- >>> y
- {'username': 'mlh', 'machines': ['foo', 'baz']}
- >>> x
- {'username': 'admin', 'machines': ['foo', 'baz']}
- 可以看到，當在副本中替換值的時候，原始字典不受影響，但是，如果修改了某個值（原地修改，而不是替換），原始的字典也會改變，因為同樣的值也存儲在原字典中。
- 避免這個問題的一種方法可以試用深復制（deep copy）
-
fromkeys 使用給定的鍵建立新的字典，每個鍵默認對應的值為None
- {}.fromkeys(['name', 'age'])
- {'aget': None, 'name': None}
- #######
- {}.fromkeys(['name', 'age'], 'unknown')
- {'aget': 'unknown', 'name': 'unknown'}
-
get 是一個更寬松的訪問字典項的方法。 訪問不存在的項時不會出錯
- d = {}
- print d.get('name')
- None
-
還可以自定義‘默認’值
- print d.get('name' , 'N/A')
- 'N/A'
has_key 檢查字典中是否含有給出的鍵。相當于 k in d. 但python3.0不包括這個函數
-
items 和 iteritems
- items 將所有的字典項以列表方式返回，列表的每一項都來自于(鍵，值).但返回時沒有特殊順序。
- iteritems 的作用大致相同，但是會返回一個迭代器對象而不是列表。
-
很多情況下使用 iteritems 更高效。
-
keys 和 iterkeys
- 將字典中的鍵以列表形式返回
- iterkeys 則返回針對鍵的迭代器
-
pop 獲取對應于給定鍵的值，然后將這個鍵-值對從字典中刪除。
d = {'x':1, 'y':2}
- >>> d.pop('x')
- 1
- >>> d
- {'y': 2}
- >>>
popitem 類似于list.pop,后者會彈出列表的最后一個元素。但不同的是，popitem彈出隨機的項，因為字典并沒有'最后的元素'
setdefault 類似get方法，就是能獲取與給定鍵相關的值，除此之外，還能在字典中不含有給定鍵的情況下設定相應的鍵值。
-
update 可以利用一個字典項更新另外一個字典：
d = {'x':1, 'y':2}
- >>> e = {'y':3}
- >>> d.update(e)
- >>> d
- {'y': 3, 'x': 1}
values 和 itervalues 以列表的形式返回字典中的值（itervalues返回值的迭代器）。 與返回鍵不同的是，返回值的列表中可以包含重復的元素。
-
