Python數(shù)據(jù)類型之列表和元組的方法實例詳解
引言
我們前面的文章介紹了數(shù)字和字符串，比如我計算今天一天的開銷花了多少錢我可以用數(shù)字來表示，如果是整形用 int ,如果是小數(shù)用 float ,如果你想記錄某件東西花了多少錢，應(yīng)該使用 str 字符串型,如果你想記錄表示所有開銷的物品名稱，你應(yīng)該用什么表示呢？
可能有人會想到我可以用一個較長的字符串表示，把所有開銷物品名稱寫進去，但是問題來了，如果你發(fā)現(xiàn)你記錄錯誤了，想刪除掉某件物品的名稱，那你是不是要在這個長字符串中去查找到，然后刪除，這樣雖然可行，那是不是比較麻煩呢。
這種情況下，你是不是需要Python給我們提供一種新的數(shù)據(jù)結(jié)構(gòu)，可以存儲很多個字符串，能讓我們方便的添加修改和刪除，就完美了。
列表(list)同字符串一樣都是有序的，因為他們都可以通過切片和索引進行數(shù)據(jù)訪問，列表是可變(mutable)的，你可以修改、更新和刪除。
列表是一組有序項目的集合 ,可變的數(shù)據(jù)類型可 進行增刪改查 ; 列表中可以包含Python中任何數(shù)據(jù)類型和對象，也可包含另一個列表 可任意組合嵌套 列表是以方括號 [] 包圍的數(shù)據(jù)集合,不同成員以 , 分隔,列表可通過序號訪問其中成員。
列表可以裝入Python中所有的對象，看下面的例子就知道:
all_list = [
'nock', # 字符串
1, # 整數(shù)
2.0, # 浮點數(shù)
print('hello'), # 函數(shù)
True, # 布爾值
None, # 空值
[1, 2], # 列表
(3,4), # 元組
{'name': 'nock', 'age': 18} # 字典
]
列表的定義和創(chuàng)建
定義： [] 內(nèi)以逗號分隔，按照索引，存放各種數(shù)據(jù)類型，每個位置代表一個元素
列表的創(chuàng)建:
第一種:
fruit = ['pineapple', 'pear']
第二種:
fruit = list(['pineapple', 'pear'])
其他數(shù)據(jù)類型轉(zhuǎn)為列表:
1、把一個字符串轉(zhuǎn)化成列表
>>> alphabet = 'abcd' >>> alphabet_list = list(alphabet) >>> alphabet_list ['a', 'b', 'c', 'd']
list在把字符串轉(zhuǎn)換成列表的時候，會把字符串用for循環(huán)迭代一下，然后把每個值當(dāng)作list的一個元素。
2、把元組轉(zhuǎn)換成列表
>>> jobs = ('pm', 'dev', 'qa', 'ops')
>>> jobs_list = list(jobs)
>>> type(jobs_list)
<type 'list'>
>>> jobs_list
['pm', 'dev', 'qa', 'ops']
3、把字典轉(zhuǎn)成列表
>>> age = {'tom': 15, 'jim': 18, 'jerry': 20}
>>> age_list = list(age)
>>> type(age_list)
<type 'list'>
>>> age_list
['jim', 'jerry', 'tom']
>>> values_list = list(age.values())
>>> values_list
[18, 20, 15]
list在把字典轉(zhuǎn)換成列表的時候,默認(rèn)循環(huán)的是字典的key，所以會把key當(dāng)作列表的元素;如果指定循環(huán)的是values，那么就會把values當(dāng)作列表的元素。
列表的特點和常用方法
特征：
- 多值: 可存放多個值
- 有序: 按照從左到右的順序定義列表元素，下標(biāo)從0開始順序訪問
3.可變: 可修改指定索引位置對應(yīng)的值
列表的增刪改查:
增加操作:
# 增 插入 可插入到任何位置 >>> fruit = ['pineapple', 'pear'] >>> fruit.insert(1, 'grape') >>> fruit ['pineapple', 'grape', 'pear']
在使用 insert 方法的時候，必須要指定列表中要插入的新元素的位置，插入元素的實際位置是在 指定位置元素的前面的
位置 ，如果指定插入的位置在列表中不存在，實際上也就是超出指定列表的長度，程序運行不會報錯，但是這個元素一定會被放到這個列表的最后位置。
>>> fruit = ['pineapple', 'pear']
>>> fruit.insert(4, 'grape')
>>> fruit
['pineapple', 'pear', 'grape']
# 增 append方法 數(shù)據(jù)會追加到尾部
>>> fruit = ['pineapple', 'pear']
>>> fruit.append('grape')
>>> fruit
['pineapple', 'pear', 'grape']
# 合并 extend 把一個列表的值合并到當(dāng)前一個列表中 >>> fruit_one = ['banana', 'apple', 'orange'] >>> fruit_two = ['pineapple', 'grape', 'pear'] >>> fruit_one.extend(fruit_two) >>> fruit_one ['banana', 'apple', 'orange', 'pineapple', 'grape', 'pear']
刪除操作:
# del 直接刪除
>>> jobs = ['PM', 'UI', 'QA', 'OPS']
>>> del jobs[0]
>>> jobs
['UI', 'QA', 'OPS']
# remove 根據(jù)remove方法，
>>> jobs = ['PM', 'UI', 'QA', 'OPS']
>>> jobs.remove('PM')
>>> jobs
['UI', 'QA', 'OPS']
# pop 默認(rèn)刪除列表最后一個元素
>>> jobs = ['PM', 'UI', 'QA', 'OPS']
>>> jobs.pop() # pop方法，默認(rèn)刪除最后一個，返回刪除元素
'OPS'
>>> jobs
['PM', 'UI', 'QA']
>>> help(jobs.pop)
Help on built-in function pop:
pop(...) method of builtins.list instance
L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
>>> jobs.pop(1) # pop還可以指定元素下標(biāo)，指定刪除
'UI'
>>> jobs
['PM', 'QA']
# clear 方法清空一個列表
>>> jobs = ['PM', 'UI', 'QA', 'OPS']
>>> jobs.clear()
>>> jobs
[]
remove方法刪除一個元素，必須是在列表中的，否則會報錯，del利用下標(biāo)來刪除元素，pop默認(rèn)刪除最后一個元素，也可以指定元素下標(biāo)來刪除。
修改操作:
>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV'] >>> jobs[2] = 'QA' # 把下標(biāo)為2的元素替換成QA，根據(jù)下標(biāo)然后給元素重新賦值 >>> jobs ['PM', 'UI', 'QA', 'OPS', 'DBA', 'DEV'] >>> jobs[-2] = 'Sales' # 把下標(biāo)為12的元素替換成Sales，根據(jù)下標(biāo)然后給元素重新賦值 >>> jobs ['PM', 'UI', 'QA', 'OPS', 'Sales', 'DEV']
查詢操作:
>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV'] >>> jobs[1] 'UI' >>> jobs[2] 'UE' >>> jobs[4] 'DBA' >>> jobs[-2] # 還可以倒數(shù)著來，不過下標(biāo)從-1開始 'DBA'
列表索引:
>>> jobs = ['PM', 'UI', 'OPS', 'UE', 'OPS', 'DBA', 'DEV', 'UE']
>>> jobs.index('OPS')
2
>>> jobs.index('UE')
3
>>> jobs.index('xx')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 'xx' is not in list
>>> if 'OPS' in jobs:
... print(jobs.index('OPS'))
...
2
索引下標(biāo)，只會返回第一個元素的下標(biāo),如果元素不在列表中，會報錯，我們可以利用 in 這個關(guān)鍵之來判斷元素是否在列表中。
列表切片:
>>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV'] >>> jobs[1:4] # 取下標(biāo)從1到4的元素，但是不包括4，列表切片的特征就是左開右閉，也就是左取右棄。 ['UI', 'UE', 'OPS'] >>> jobs[1:-1] # 取下標(biāo)為1到-1的元素，不包括-1，也就是最后一個元素不會被取出來。 ['UI', 'UE', 'OPS', 'DBA'] >>> jobs[:] # 這個在切片符左右沒有下標(biāo)限制，所以就是代表全取 ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV'] >>> jobs[::] # 效果和上面一樣，但是你會發(fā)現(xiàn)有兩切片符，這是因為切片有一個步長的概念 ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV'] >>> jobs[0:3] # 取下標(biāo)0到3的元素，但不包括3 ['PM', 'UI', 'UE'] >>> jobs[:3] # 和上面效果一樣 ['PM', 'UI', 'UE'] >>> jobs[3:] # 從下標(biāo)3開始，到最后一個元素 ['OPS', 'DBA', 'DEV'] >>> jobs[3:-1] # 從下標(biāo)3開始，到最后一個元素，但是不包括最后一個元素 ['OPS', 'DBA'] >>> jobs[0::2] # 從下標(biāo)0開始，按照2個步長取值 ['PM', 'UE', 'DBA'] >>> jobs[::2] # 和上面效果一樣 ['PM', 'UE', 'DBA']
利用下標(biāo)取出的一個單獨元素是str類型，而利用分片取出的是一個list類型。
列表元素統(tǒng)計:
>>> jobs = ['PM', 'UI', 'OPS', 'UE', 'OPS', 'DBA', 'DEV']
>>> jobs.count('OPS') # 因為列表是有序的一種數(shù)據(jù)類型，所以它的元素是可以重疊的，所以有元素統(tǒng)計。
2
列表排序和翻轉(zhuǎn):
>>> jobs = ['PM', 'UI', 'OPS', 'UE', 'OPS', 'DBA', 'DEV', 1, 2, 3]
>>> jobs.sort()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unorderable types: int() < str() # Python3.0里不同數(shù)據(jù)類型不能放在一起排序了，擦
>>> jobs[-1] = '3'
>>> jobs[-2] = '2'
>>> jobs[-3] = '1'
>>> jobs
['DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI', '1', '2', '3']
>>> jobs.sort()
>>> jobs
['1', '2', '3', 'DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI']
>>> jobs.append('#')
>>> jobs.append('&')
>>> jobs.sort()
>>> jobs
['#', '&', '1', '2', '3', 'DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI'] # 可以看出排序的順序 特殊字符->數(shù)字->字母 這么一個優(yōu)先級
>>> jobs.reverse() # 翻轉(zhuǎn)最后到最前面
>>> jobs
['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#']
sort() 方法會修改原列表，而不是創(chuàng)建一個新的有序列表， reverse() 也會修改原列表，但是你希望排序，但是又不希望修改原列表，你只能利用Python中一個名為 sorted() 的內(nèi)置函數(shù)來操作：
>>> jobs = ['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#'] >>> newlist = sorted(jobs) >>> jobs ['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#'] >>> newlist ['#', '&', '1', '2', '3', 'DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI']
列表拷貝:
>>> jobs ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV'] >>> jobs_copy = jobs.copy() # 復(fù)制一份jobs列表 >>> jobs_copy ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV'] >>> jobs = ['PM', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']] # 嵌入式列表 >>> jobs_copy2 = jobs.copy() >>> jobs_copy2 ['PM', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']] >>> jobs[0] = 'HR' # 改變小標(biāo)為0的元素 >>> jobs ['HR', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']] # 改變了 >>> jobs_copy2 ['PM', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']] # 沒變 >>> jobs[-1][0] = 'Sales' # 改變內(nèi)嵌列表的下標(biāo)為0的元素 >>> jobs ['HR', 'UI', 'UE', 'OPS', ['Sales', 'QA', 'DEV']] # 改變了 >>> jobs_copy2 ['PM', 'UI', 'UE', 'OPS', ['Sales', 'QA', 'DEV']] # 改變了
從上面可以看出列表的copy方法是一個淺copy的栗子，只會拷貝第一次，而多層嵌入的話，會隨著源列表的變化為變化，關(guān)于深拷貝和淺拷貝后面詳細(xì)介紹。
列表所有的方法如下：
class list(object): """ list() -> new empty list list(iterable) -> new list initialized from iterable's items """ def append(self, p_object): # real signature unknown; restored from __doc__ """ L.append(object) -> None -- append object to end """ pass def clear(self): # real signature unknown; restored from __doc__ """ L.clear() -> None -- remove all items from L """ pass def copy(self): # real signature unknown; restored from __doc__ """ L.copy() -> list -- a shallow copy of L """ return [] def count(self, value): # real signature unknown; restored from __doc__ """ L.count(value) -> integer -- return number of occurrences of value """ return 0 def extend(self, iterable): # real signature unknown; restored from __doc__ """ L.extend(iterable) -> None -- extend list by appending elements from the iterable """ pass def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__ """ L.index(value, [start, [stop]]) -> integer -- return first index of value. Raises ValueError if the value is not present. """ return 0 def insert(self, index, p_object): # real signature unknown; restored from __doc__ """ L.insert(index, object) -- insert object before index """ pass def pop(self, index=None): # real signature unknown; restored from __doc__ """ L.pop([index]) -> item -- remove and return item at index (default last). Raises IndexError if list is empty or index is out of range. """ pass def remove(self, value): # real signature unknown; restored from __doc__ """ L.remove(value) -> None -- remove first occurrence of value. Raises ValueError if the value is not present. """ pass def reverse(self): # real signature unknown; restored from __doc__ """ L.reverse() -- reverse *IN PLACE* """ pass def sort(self, key=None, reverse=False): # real signature unknown; restored from __doc__ """ L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* """ pass
列表推導(dǎo)式:
列表推導(dǎo)式（又稱列表解析式）提供了一種簡明扼要的方法來創(chuàng)建列表，它的語法簡單，很有實用價值。
它的結(jié)構(gòu)是在一個中括號里包含一個表達式，然后是一個for語句，然后是0個或多個for或者if語句。那個表達式可以是任意的，意思是你可以在列表中放入任意類型的對象。返回結(jié)果將是一個新的列表，在這個以if和for語句為上下文的表達式運行完成之后產(chǎn)生。
列表解析的一般形式：
[expr for item in itratorable] L = [x**2 for x in range(10)] print(L) Result: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
列表解析返回的是列表， 列表的內(nèi)容是表達式執(zhí)行的結(jié)果.
[expr for item in iterable if cond] [x ** 0.5 for x in range(10) if x % 2 == 0] [0.0, 1.4142135623730951, 2.0, 2.449489742783178, 2.8284271247461903] [expr for item in iterable if cond1 if cond2] [x for x in range(10) if x % 2 == 0 if x > 1] [2, 4, 6, 8] [expr for item1 in iterable1 for item2 in iterable2] [(x, y) for x in range(10) for y in range(10) if (x+y) %2 == 0]
列表解析用于對可迭代對象做過濾和轉(zhuǎn)換，返回值是列表.
特性一:代碼變短，可讀性更好
從上圖代碼示例中我們明顯可以看出，列表推導(dǎo)式相比常規(guī)方法，寫出來的代碼更加符合pythonic,更加簡短，可讀性更好。
有些人甚至更喜歡使用它而不是filter函數(shù)生成列表，但是當(dāng)你使用列表推導(dǎo)式效果會更加，列表推導(dǎo)式在有些情況下超贊，特別是當(dāng)你需要使用for循環(huán)來生成一個新列表.
特征二:推導(dǎo)式速度更快
#!/usr/bin/env python3
# author: nock
import timeit
lst = list(range(10))
# 常規(guī)方法
def origin(lst):
plus_one = []
for i in lst:
plus_one.append(i + 1)
return plus_one
# 列表推導(dǎo)式
def fast(lst):
return [ x + 1 for x in lst ]
otime = timeit.timeit('origin(range(10))', globals=globals())
print("func origin exec time is {0}".format(otime))
ftime = timeit.timeit('fast(range(10))', globals=globals())
print("func origin exec time is {0}".format(ftime))
結(jié)果：
func origin exec time is 2.1059355960023822 func origin exec time is 1.6507169340038672
如果你使用map或者filter結(jié)合lambda生成列表，也是沒有列表推導(dǎo)式速度快的，有興趣的可以自己Coding一下。
列表的遍歷
在Python中常用循環(huán)對象來遍歷列表，在這里for循環(huán)自動調(diào)用 next() 方法，將該方法的返回值賦予給循環(huán)對象。循環(huán)檢測到StopIteration的時候才結(jié)束。相對于序列，用循環(huán)對象的好處在于：不用在循環(huán)還沒有開始的時候，就生成好要使用的元素。所使用的元素可以在循環(huán)過程中逐次生成。這樣，節(jié)省了空間，提高了效率，編程更靈活。
1. for循環(huán)遍歷
#!/usr/bin/env python3
map_list = ['China', 'America', 'Japan', 'Korea']
for countries in map_list:
print(countries) # 自動調(diào)用迭代器，自動檢測StopIteration
# 在上面的程序中，無法知道當(dāng)前訪問元素的索引，于是有如下代碼：
for index in range(len(map_list)):
print("key is %s index is %s" % (map_list[index], index))
2. while循環(huán)遍歷
#!/usr/bin/env python3 map_list = ['China', 'America', 'Japan', 'Korea'] index = 0 while index < len(map_list): print(index, map_list[index]) index+=1
3. 拉鏈(zip)方法遍歷
#!/usr/bin/env python3 map_list = ['China', 'America', 'Japan', 'Korea'] for index, value in zip(range(len(map_list)), map_list): print(index, value)
4. 利用Python內(nèi)置函數(shù) enumerate() 列舉
enumerate(iterable [, start ]) 返回枚舉對象, 參數(shù)：
iterable: 一個序列、迭代器或其他支持迭代的對象 start: 下標(biāo)起始位置 #!/usr/bin/env python3 map_list = ['China', 'America', 'Japan', 'Korea'] for value in enumerate(map_list): print(value)
5. 使用 iter() 迭代器
iter(collection [, sentinel ]) 函數(shù)用來生成迭代器，返回迭代對象， 參數(shù):
collection: 支持迭代的集合對象
sentinel: 如果傳遞了第二個參數(shù)，則參數(shù) object 必須是一個可調(diào)用的對象（如，函數(shù)），此時， iter 創(chuàng)建了一個迭代器對象，每次調(diào)用這個迭代器對象的 __next__() 方法時，都會調(diào)用object。
#!/usr/bin/env python3 map_list = ['China', 'America', 'Japan', 'Korea'] for value in iter(map_list): print(value)
由于列表在Python內(nèi)部的組成方式不同于C語言等，其索引的效率相對較為低下。因此在使用python的過程中，如果需要同時用到序號和元素，最好使用enumerate()；當(dāng)我們不需要使用序號時，在列表上直接進行迭代效率最高。
元組
元組其實跟列表差不多，也是存一組數(shù)，只不是它一旦創(chuàng)建，便不能再修改，所以又叫只讀列表。
語法: names = ('tom', 'jack', 'andy')
它只有2個方法，一個是count,一個是index:
class tuple(object): """ tuple() -> empty tuple tuple(iterable) -> tuple initialized from iterable's items If the argument is a tuple, the return value is the same object. """ def count(self, value): # real signature unknown; restored from __doc__ """ T.count(value) -> integer -- return number of occurrences of value """ return 0 def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__ """ T.index(value, [start, [stop]]) -> integer -- return first index of value. Raises ValueError if the value is not present. """ return 0
列表幾種高階常用場景
1. 解壓列表賦值給多個變量
現(xiàn)在有一個包含 N個元素 的元組或者列表，怎樣將它里面的值解壓后同時賦值給 N 個變量？
任何的序列（或者是可迭代對象）可以通過一個簡單的賦值語句解壓并賦值給多個變量。 唯一的前提就是變量的數(shù)量必須跟序列元素的 數(shù)量一致 的。
代碼示例:
>>> jobs = ('hr', 'dev', 'ops')
>>> x, y, z = jobs
>>> print(x, y, z)
hr dev ops
>>> data = ['nock', 8, 24, (2001, 12, 28)]
>>> name, shares, size, date = data
>>> print(name, shares, size, date)
nock 8 24 (2001, 12, 28)
>>> date
(2001, 12, 28)
>>> name, shares, size, (year, mon, day) = data
>>> name
'nock'
>>> print(year, mon, day)
2001 12 28
如果變量個數(shù)和列表元素的個數(shù)不匹配，會產(chǎn)生異常的哦。
代碼示例：
>>> jobs = ('hr', 'dev', 'ops')
>>> x, y = jobs
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)
>>> x, y, z, x = jobs
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 4, got 3)
實際上，這種解壓賦值可以用在任何可迭代對象上面，而不僅僅是列表或者元組。 包括字符串，文件對象，迭代器和生成器。
代碼示例:
>>> name = 'Jim' >>> a, b, c = name >>> a 'J' >>> b 'i'
有時候，你可能只想解壓一部分，丟棄其他的值。對于這種情況 Python 并沒有提供特殊的語法。 但是你可以使用任意變量名去占位，到時候丟掉這些變量就行了。
>>> jobs = [18, 30000, 'duck', 100, (2000, 2, 18)] >>> age, wage, _, num, _ = jobs >>> age 18 >>> wage 30000 >>> _ (2000, 2, 18)
你必須保證你選用的那些占位變量名在其他地方?jīng)]被使用到。
2. 刪除列表中相同元素并保持順序
怎樣讓一個列表保持元素順序的同時消除重復(fù)的值，如果列表上的值都是 hashable 類型，那么可以很簡單的利用集合或者生成器來解決這個問題,比如：
def dedupe(items): seen = set() for item in items: if item not in seen: yield item seen.add(item)
下面是使用上述函數(shù)的例子：
>>> def dedupe(items): ... seen = set() ... for item in items: ... if item not in seen: ... yield item ... seen.add(item) ... >>> nums = [1, 5, 2, 1, 9, 1, 5, 10] >>> list(dedupe(nums)) [1, 5, 2, 9, 10]
這個方法僅僅在序列中元素為 hashable 的時候才管用。 如果你想消除元素不可哈希（比如 dict 類型）的序列中重復(fù)元素的話，你需要將上述代碼稍微改變一下，就像這樣：
def dedupe(items, key=None): seen = set() for item in items: val = item if key is None else key(item) if val not in seen: yield item seen.add(val)
這里的key參數(shù)指定了一個函數(shù)，將序列元素轉(zhuǎn)換成 hashable 類型。下面是它的用法示例：
>>> a = [ {'x':1, 'y':2}, {'x':1, 'y':3}, {'x':1, 'y':2}, {'x':2, 'y':4}]
>>> list(dedupe(a, key=lambda d: (d['x'],d['y'])))
[{'x': 1, 'y': 2}, {'x': 1, 'y': 3}, {'x': 2, 'y': 4}]
>>> list(dedupe(a, key=lambda d: d['x']))
[{'x': 1, 'y': 2}, {'x': 2, 'y': 4}]
如果你想基于單個字段、屬性或者某個更大的數(shù)據(jù)結(jié)構(gòu)來消除重復(fù)元素，第二種方案同樣可以勝任。
如果你僅僅就是想消除重復(fù)元素，通常可以簡單的構(gòu)造一個集合。比如：
>>> a = [1, 5, 2, 1, 9, 1, 5, 10] >>> list(set(a)) [1, 2, 10, 5, 9]
然而，這種方法不能維護元素的順序，生成的結(jié)果中的元素位置被打亂,而上面的方法可以避免這種情況。
我們使用了生成器函數(shù)讓我們的函數(shù)更加通用，不僅僅是局限于列表處理。 比如，如果如果你想讀取一個文件，消除重復(fù)行，你可以很容易像這樣做：
with open(somefile,'r') as f: for line in dedupe(f): ...
上述key函數(shù)參數(shù)模仿了 sorted() , min() 和 max() 等內(nèi)置函數(shù)的相似功能。
3. 統(tǒng)計列表中出現(xiàn)次數(shù)最多的元素
怎樣找出一個列表中出現(xiàn)次數(shù)最多的元素呢， collections.Counter 類就是專門為這類問題而設(shè)計的， 它甚至有一個有用的 most_common() 方法直接給了你答案。
為了演示，先假設(shè)你有一個單詞列表并且想找出哪個單詞出現(xiàn)頻率最高。你可以這樣做：
>>> from collections import Counter
>>> words = [
... 'look', 'into', 'my', 'eyes', 'look', 'into', 'my', 'eyes',
... 'the', 'eyes', 'the', 'eyes', 'the', 'eyes', 'not', 'around', 'the',
... 'eyes', "don't", 'look', 'around', 'the', 'eyes', 'look', 'into',
... 'my', 'eyes', "you're", 'under'
... ]
>>>
>>> word_counts = Counter(words)
>>> top_three = word_counts.most_common(3)
>>> print(top_three)
[('eyes', 8), ('the', 5), ('look', 4)]
作為輸入， Counter 對象可以接受任意的由可哈希( hashable )元素構(gòu)成的序列對象。 在底層實現(xiàn)上，一個 Counter 對象就是一個字典，將元素映射到它出現(xiàn)的次數(shù)上, 比如:
>>> word_counts['not'] 1 >>> word_counts['eyes'] 8
如果你想手動增加計數(shù)，可以簡單的用加法：
>>> morewords = ['why','are','you','not','looking','in','my','eyes'] >>> for word in morewords: ... word_counts[word] += 1 ... >>> word_counts['eyes'] 9
或者你可以使用 update() 方法：
word_counts.update(morewords)
Counter 實例一個鮮為人知的特性是它們可以很容易的跟數(shù)學(xué)運算操作相結(jié)合,比如：
>>> a = Counter(words)
>>> b = Counter(morewords)
>>> a
Counter({'eyes': 8, 'the': 5, 'look': 4, 'into': 3, 'my': 3, 'around': 2,
"you're": 1, "don't": 1, 'under': 1, 'not': 1})
>>> b
Counter({'eyes': 1, 'looking': 1, 'are': 1, 'in': 1, 'not': 1, 'you': 1,
'my': 1, 'why': 1})
>>> # Combine counts
>>> c = a + b
>>> c
Counter({'eyes': 9, 'the': 5, 'look': 4, 'my': 4, 'into': 3, 'not': 2,
'around': 2, "you're": 1, "don't": 1, 'in': 1, 'why': 1,
'looking': 1, 'are': 1, 'under': 1, 'you': 1})
>>> # Subtract counts
>>> d = a - b
>>> d
Counter({'eyes': 7, 'the': 5, 'look': 4, 'into': 3, 'my': 2, 'around': 2,
"you're": 1, "don't": 1, 'under': 1})
毫無疑問， Counter 對象在幾乎所有需要制表或者計數(shù)數(shù)據(jù)的場合是非常有用的工具。 在解決這類問題的時候你應(yīng)該優(yōu)先選擇它，而不是手動的利用字典去實現(xiàn)。
4. 過濾列表元素
你有一個數(shù)據(jù)列表，想利用一些規(guī)則從中提取出需要的值或者是縮短列表,最簡單的過濾序列元素的方法就是使用列表推導(dǎo),比如：
>>> nums = [1, 2, -1, 4, 100, -2] >>> [n for n in nums if n > 0] [1, 2, 4, 100] >>> [n for n in nums if n < 0] [-1, -2]
使用列表推導(dǎo)的一個潛在缺陷就是如果輸入非常大的時候會產(chǎn)生一個非常大的結(jié)果集，占用大量內(nèi)存。 如果你對內(nèi)存比較敏感，那么你可以使用生成器表達式迭代產(chǎn)生過濾的元素,比如：
>>> nums = [1, 2, -1, 4, 100, -2] >>> num = (n for n in nums if n < 0) >>> num <generator object <genexpr> at 0x102210a50> >>> for n in num: ... print(n) ... -1 -2
有時候，過濾規(guī)則比較復(fù)雜，不能簡單的在列表推導(dǎo)或者生成器表達式中表達出來。 比如，假設(shè)過濾的時候需要處理一些異?；蛘咂渌麖?fù)雜情況。這時候你可以將過濾代碼放到一個函數(shù)中， 然后使用內(nèi)建的 filter() 函數(shù),示例如下：
values = ['1', '2', '-3', '-', '4', 'N/A', '5'] def is_int(val): try: x = int(val) return True except ValueError: return False ivals = list(filter(is_int, values)) print(ivals) # Outputs ['1', '2', '-3', '4', '5']
filter() 函數(shù)創(chuàng)建了一個迭代器，因此如果你想得到一個列表的話，就得像示例那樣使用 list() 去轉(zhuǎn)換。
列表推導(dǎo)和生成器表達式通常情況下是過濾數(shù)據(jù)最簡單的方式。 其實它們還能在過濾的時候轉(zhuǎn)換數(shù)據(jù),比如：
>>> mylist = [1, 4, -5, 10, -7, 2, 3, -1] >>> import math >>> [math.sqrt(n) for n in mylist if n > 0] [1.0, 2.0, 3.1622776601683795, 1.4142135623730951, 1.7320508075688772]
過濾操作的一個變種就是將不符合條件的值用新的值代替，而不是丟棄它們。 比如，在一列數(shù)據(jù)中你可能不僅想找到正數(shù)，而且還想將不是正數(shù)的數(shù)替換成指定的數(shù)。 通過將過濾條件放到條件表達式中去，可以很容易的解決這個問題，就像這樣：
>>> mylist = [1, 4, -5, 10, -7, 2, 3, -1] >>> clip_neg = [n if n > 0 else 0 for n in mylist] >>> clip_neg [1, 4, 0, 10, 0, 2, 3, 0] >>> clip_pos = [n if n < 0 else 0 for n in mylist] >>> clip_pos [0, 0, -5, 0, -7, 0, 0, -1]
另外一個值得關(guān)注的過濾工具就是 itertools.compress() ， 它以一個 iterable 對象和一個相對應(yīng)的 Boolean 選擇器序列作為輸入?yún)?shù)。 然后輸出 iterable 對象中對應(yīng)選擇器為 True 的元素。 當(dāng)你需要用另外一個相關(guān)聯(lián)的序列來過濾某個序列的時候，這個函數(shù)是非常有用的。 比如，假如現(xiàn)在你有下面兩列數(shù)據(jù)：
addresses = [ '5412 N CLARK', '5148 N CLARK', '5800 E 58TH', '2122 N CLARK', '5645 N RAVENSWOOD', '1060 W ADDISON', '4801 N BROADWAY', '1039 W GRANVILLE', ] counts = [ 0, 3, 10, 4, 1, 7, 6, 1]
現(xiàn)在你想將那些對應(yīng) count 值大于5的地址全部輸出，那么你可以這樣做：
>>> from itertools import compress >>> more5 = [n > 5 for n in counts] >>> more5 [False, False, True, False, False, True, True, False] >>> list(compress(addresses, more5)) ['5800 E 58TH', '1060 W ADDISON', '4801 N BROADWAY']
這里的關(guān)鍵點在于先創(chuàng)建一個 Boolean 序列，指示哪些元素符合條件。 然后 compress() 函數(shù)根據(jù)這個序列去選擇輸出對應(yīng)位置為 True 的元素。
和 filter() 函數(shù)類似， compress() 也是返回的一個迭代器。因此，如果你需要得到一個列表，那么你需要使用 list() 來將結(jié)果轉(zhuǎn)換為列表類型。
5. 列表上索引值迭代
你想在迭代一個列表的同時跟蹤正在被處理的元素索引，內(nèi)置的 enumerate() 函數(shù)可以很好的解決這個問題：
>>> my_list = ['a', 'b', 'c'] >>> for idx, val in enumerate(my_list): ... print(idx, val) ... 0 a 1 b 2 c
為了按傳統(tǒng)行號輸出(行號從1開始)，你可以傳遞一個開始步長值：
>>> my_list = ['a', 'b', 'c'] >>> for idx, val in enumerate(my_list, 1): ... print(idx, val) ... 1 a 2 b 3 c
這種情況在你遍歷文件時想在錯誤消息中使用行號定位時候非常有用：
def parse_data(filename):
with open(filename, 'rt') as f:
for lineno, line in enumerate(f, 1):
fields = line.split()
try:
count = int(fields[1])
...
except ValueError as e:
print('Line {}: Parse error: {}'.format(lineno, e))
enumerate() 對于跟蹤某些值在列表中出現(xiàn)的位置是很有用的。 所以，如果你想將一個文件中出現(xiàn)的單詞映射到它出現(xiàn)的行號上去，可以很容易的利用 enumerate() 來完成：
word_summary = defaultdict(list)
with open('myfile.txt', 'r') as f:
lines = f.readlines()
for idx, line in enumerate(lines):
# Create a list of words in current line
words = [w.strip().lower() for w in line.split()]
for word in words:
word_summary[word].append(idx)
如果你處理完文件后打印 word_summary ，會發(fā)現(xiàn)它是一個字典(準(zhǔn)確來講是一個 defaultdict )， 對于每個單詞有一個 key ，每個 key 對應(yīng)的值是一個由這個單詞出現(xiàn)的行號組成的列表。 如果某個單詞在一行中出現(xiàn)過兩次，那么這個行號也會出現(xiàn)兩次， 同時也可以作為文本的一個簡單統(tǒng)計。
當(dāng)你想額外定義一個計數(shù)變量的時候，使用 enumerate() 函數(shù)會更加簡單。你可能會像下面這樣寫代碼：
lineno = 1 for line in f: # Process line ... lineno += 1
但是如果使用 enumerate() 函數(shù)來代替就顯得更加優(yōu)雅了：
for lineno, line in enumerate(f): # Process line ...
enumerate() 函數(shù)返回的是一個 enumerate 對象實例， 它是一個迭代器，返回連續(xù)的包含一個計數(shù)和一個值的元組， 元組中的值通過在傳入序列上調(diào)用 next() 返回。
還有一點可能并不很重要，但是也值得注意， 有時候當(dāng)你在一個已經(jīng)解壓后的元組序列上使用 enumerate() 函數(shù)時很容易調(diào)入陷阱。 你得像下面正確的方式這樣寫：
data = [ (1, 2), (3, 4), (5, 6), (7, 8) ] # Correct! for n, (x, y) in enumerate(data): ... # Error! for n, x, y in enumerate(data): ...
6. 同時迭代多個列表
你想同時迭代多個列表，每次分別從一個序列中取一個元素， 為了同時迭代多個序列，使用 zip() 函數(shù),比如：
>>> xpts = [1, 5, 4, 2, 10, 7] >>> ypts = [101, 78, 37, 15, 62, 99] >>> for x, y in zip(xpts, ypts): ... print(x,y) ... 1 101 5 78 4 37 2 15 10 62 7 99
zip(a, b) 會生成一個可返回元組 (x, y) 的迭代器，其中x來自a，y來自b。 一旦其中某個序列到底結(jié)尾，迭代宣告結(jié)束。 因此迭代長度跟參數(shù)中最短序列長度一致。
>>> a = [1, 2, 3] >>> b = ['w', 'x', 'y', 'z'] >>> for i in zip(a,b): ... print(i) ... (1, 'w') (2, 'x') (3, 'y')
如果這個不是你想要的效果，那么還可以使用 itertools.zip_longest() 函數(shù)來代替,比如：
>>> from itertools import zip_longest >>> for i in zip_longest(a,b): ... print(i) ... (1, 'w') (2, 'x') (3, 'y') (None, 'z') >>> for i in zip_longest(a, b, fillvalue=0): ... print(i) ... (1, 'w') (2, 'x') (3, 'y') (0, 'z')
當(dāng)你想成對處理數(shù)據(jù)的時候 zip() 函數(shù)是很有用的。 比如，假設(shè)你headers列表和一個values列表，就像下面這樣：
headers = ['name', 'shares', 'price'] values = ['ACME', 100, 490.1]
使用zip()可以讓你將它們打包并生成一個字典：
s = dict(zip(headers,values))
或者你也可以像下面這樣產(chǎn)生輸出：
for name, val in zip(headers, values): print(name, '=', val)
雖然不常見，但是 zip() 可以接受多于兩個的序列的參數(shù)。 這時候所生成的結(jié)果元組中元素個數(shù)跟輸入序列個數(shù)一樣, 比如:
>>> a = [1, 2, 3] >>> b = [10, 11, 12] >>> c = ['x','y','z'] >>> for i in zip(a, b, c): ... print(i) ... (1, 10, 'x') (2, 11, 'y') (3, 12, 'z')
最后強調(diào)一點就是, zip() 會創(chuàng)建一個迭代器來作為結(jié)果返回。 如果你需要將結(jié)對的值存儲在列表中，要使用 list() 函數(shù),比如：
>>> zip(a, b) <zip object at 0x1007001b8> >>> list(zip(a, b)) [(1, 10), (2, 11), (3, 12)]
7. 展開嵌透的列表
你想將一個多層嵌套的列表展開成一個單層列表, 可以寫一個包含 yield from 語句的遞歸生成器來輕松解決這個問題。比如：
from collections import Iterable def flatten(items, ignore_types=(str, bytes)): for x in items: if isinstance(x, Iterable) and not isinstance(x, ignore_types): yield from flatten(x) else: yield x items = [1, 2, [3, 4, [5, 6], 7], 8] # Produces 1 2 3 4 5 6 7 8 for x in flatten(items): print(x)
在上面代碼中， isinstance(x, Iterable) 檢查某個元素是否是可迭代的。 如果是的話 yield from 就會返回所有子例程的值。最終返回結(jié)果就是一個沒有嵌套的簡單列表了。
額外的參數(shù) ignore_types 和檢測語句 isinstance(x, ignore_types) 用來將字符串和字節(jié)排除在可迭代對象外，防止將它們再展開成單個的字符。 這樣的話字符串?dāng)?shù)組就能最終返回我們所期望的結(jié)果了。比如：
>>> items = ['Dave', 'Paula', ['Thomas', 'Lewis']] >>> for x in flatten(items): ... print(x) ... Dave Paula Thomas Lewis
語句 yield from 在你想在生成器中調(diào)用其他生成器作為子例程的時候非常有用。 如果你不使用它的話，那么就必須寫額外的 for 循環(huán)了,比如：
def flatten(items, ignore_types=(str, bytes)): for x in items: if isinstance(x, Iterable) and not isinstance(x, ignore_types): for i in flatten(x): yield i else: yield x
盡管只改了一點點，但是 yield from 語句看上去感覺更好，并且也使得代碼更簡潔清爽。
之前提到的對于字符串和字節(jié)的額外檢查是為了防止將它們再展開成單個字符。 如果還有其他你不想展開的類型，修改參數(shù) ignore_types 即可。
最后要注意的一點是 yield from 在涉及到基于協(xié)程和生成器的并發(fā)編程中扮演著更加重要的角色。
8. 映射名稱到列表元素
你有一段通過下標(biāo)訪問列表或者元組中元素的代碼，但是這樣有時候會使得你的代碼難以閱讀， 于是你想通過名稱來訪問元素。
·collections.namedtuple()·函數(shù)通過使用一個普通的元組對象來幫你解決這個問題。 這個函數(shù)實際上是一個返回Python中標(biāo)準(zhǔn)元組類型子類的一個工廠方法。 你需要傳遞一個類型名和你需要的字段給它，然后它就會返回一個類，你可以初始化這個類，為你定義的字段傳遞值等。 代碼示例：
>>> from collections import namedtuple
>>> Subscriber = namedtuple('Subscriber', ['addr', 'joined'])
>>> sub = Subscriber('jonesy@example.com', '2012-10-19')
>>> sub
Subscriber(addr='jonesy@example.com', joined='2012-10-19')
>>> sub.addr
'jonesy@example.com'
>>> sub.joined
'2012-10-19'
盡管 namedtuple 的實例看起來像一個普通的類實例，但是它跟元組類型是可交換的，支持所有的普通元組操作，比如索引和解壓。 比如：
>>> len(sub) 2 >>> addr, joined = sub >>> addr 'jonesy@example.com' >>> joined '2012-10-19'
命名元組的一個主要用途是將你的代碼從下標(biāo)操作中解脫出來。 因此，如果你從數(shù)據(jù)庫調(diào)用中返回了一個很大的元組列表，通過下標(biāo)去操作其中的元素， 當(dāng)你在表中添加了新的列的時候你的代碼可能就會出錯了。但是如果你使用了命名元組，那么就不會有這樣的顧慮。
為了說明清楚，下面是使用普通元組的代碼：
def compute_cost(records): total = 0.0 for rec in records: total += rec[1] * rec[2] return total
下標(biāo)操作通常會讓代碼表意不清晰，并且非常依賴記錄的結(jié)構(gòu)。 下面是使用命名元組的版本：
from collections import namedtuple
Stock = namedtuple('Stock', ['name', 'shares', 'price'])
def compute_cost(records):
total = 0.0
for rec in records:
s = Stock(*rec)
total += s.shares * s.price
return total
命名元組另一個用途就是作為字典的替代，因為字典存儲需要更多的內(nèi)存空間。 如果你需要構(gòu)建一個非常大的包含字典的數(shù)據(jù)結(jié)構(gòu)，那么使用命名元組會更加高效。 但是需要注意的是，不像字典那樣，一個命名元組是不可更改的。比如：
>>> s = Stock('ACME', 100, 123.45)
>>> s
Stock(name='ACME', shares=100, price=123.45)
>>> s.shares = 75
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: can't set attribute
如果你真的需要改變屬性的值，那么可以使用命名元組實例的 _replace() 方法， 它會創(chuàng)建一個全新的命名元組并將對應(yīng)的字段用新的值取代。比如：
>>> s = s._replace(shares=75) >>> s Stock(name='ACME', shares=75, price=123.45)
_replace() 方法還有一個很有用的特性就是當(dāng)你的命名元組擁有可選或者缺失字段時候， 它是一個非常方便的填充數(shù)據(jù)的方法。 你可以先創(chuàng)建一個包含缺省值的原型元組，然后使用 _replace() 方法創(chuàng)建新的值被更新過的實例。比如：
from collections import namedtuple
Stock = namedtuple('Stock', ['name', 'shares', 'price', 'date', 'time'])
# Create a prototype instance
stock_prototype = Stock('', 0, 0.0, None, None)
# Function to convert a dictionary to a Stock
def dict_to_stock(s):
return stock_prototype._replace(**s)
下面是它的使用方法：
>>> a = {'name': 'ACME', 'shares': 100, 'price': 123.45}
>>> dict_to_stock(a)
Stock(name='ACME', shares=100, price=123.45, date=None, time=None)
>>> b = {'name': 'ACME', 'shares': 100, 'price': 123.45, 'date': '12/17/2012'}
>>> dict_to_stock(b)
Stock(name='ACME', shares=100, price=123.45, date='12/17/2012', time=None)
最后要說的是，如果你的目標(biāo)是定義一個需要更新很多實例屬性的高效數(shù)據(jù)結(jié)構(gòu)，那么命名元組并不是你的最佳選擇。 這時候你應(yīng)該考慮定義一個包含 slots 方法的類.
總結(jié)
以上所述是小編給大家介紹的Python數(shù)據(jù)類型之列表和元組的方法實例詳解,希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復(fù)大家的。在此也非常感謝大家對腳本之家網(wǎng)站的支持！
如果你覺得本文對你有幫助，歡迎轉(zhuǎn)載，煩請注明出處，謝謝！
相關(guān)文章
基于python解析XML文件并將數(shù)據(jù)存儲到MongoDB的代碼示例
在軟件開發(fā)中,我們經(jīng)常需要處理各種格式的數(shù)據(jù),XML 是一種常用的數(shù)據(jù)交換格式,它可以存儲和傳輸結(jié)構(gòu)化數(shù)據(jù),很多網(wǎng)站會提供 XML 格式的數(shù)據(jù)接口,以便其他系統(tǒng)可以方便地獲取數(shù)據(jù),本文介紹了基于python解析XML文件并將數(shù)據(jù)存儲到MongoDB的代碼示例,需要的朋友可以參考下2024-06-06
這篇文章主要介紹了Python三級目錄展示的實現(xiàn)方法的相關(guān)資料,本文通過圖文并茂的方式給大家介紹，非常不錯，具有參考借鑒價值，需要的朋友可以參考下2016-09-09
pyqt5對用qt designer設(shè)計的窗體實現(xiàn)彈出子窗口的示例
今天小編就為大家分享一篇pyqt5對用qt designer設(shè)計的窗體實現(xiàn)彈出子窗口的示例，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2019-06-06
這篇文章主要為大家詳細(xì)介紹了Pytorch實現(xiàn)邏輯回歸分類，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-07-07
pygame是Python的第三方庫，里面提供了使用Python開發(fā)游戲的基礎(chǔ)包。本文將介紹如何通過Pygame實現(xiàn)鼠標(biāo)進行圖片的移動與縮放，感興趣的可以關(guān)注一下2021-12-12
今天小編就為大家分享一篇關(guān)于Python兩個字典鍵同值相加的幾種方法，小編覺得內(nèi)容挺不錯的，現(xiàn)在分享給大家，具有很好的參考價值，需要的朋友一起跟隨小編來看看吧2019-03-03
python統(tǒng)計字母、空格、數(shù)字等字符個數(shù)的實例
今天小編就為大家分享一篇python統(tǒng)計字母、空格、數(shù)字等字符個數(shù)的實例，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2018-06-06
pickle是python語言的一個標(biāo)準(zhǔn)模塊，安裝python后已包含pickle庫，不需要單獨再安裝。這篇文章主要介紹了Python 中Pickle庫的使用詳解,需要的朋友可以參考下2018-02-02
這篇文章主要為大家詳細(xì)介紹了python實現(xiàn)大文本文件分割成多個小文件，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-04-04
這篇文章主要介紹了如何利用Python實現(xiàn)自定義連點器,本文通過實例代碼給大家介紹的非常詳細(xì)，對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值，需要的朋友可以參考下2022-08-08