1. 程式人生 > >python中列表,元祖,字典,集合的區別

python中列表,元祖,字典,集合的區別

一.前言

一直想寫寫這四種類型的相同點,與不同點在哪裡,以及在什麼情況下應該使用哪種型別。無奈水平不夠,怕寫出來不夠深刻,所以一直拖著。今天想了想還是寫出來吧,如果以後還有新的見解或者技巧我會繼續更上去的。


二.列表(list)

具有以下特點:
1.可以用list()函式或者方括號[]建立,元素之間用逗號’,‘’分隔。
2.列表的元素不需要具有相同的型別
3.使用索引來訪問元素
4.可切片

# 可用list()函式建立
list1 = list((1, 2))
# 用[]建立,可包含不同資料型別
list2 = [1, 3, 'hello', 3.5]
# 可用下標訪問
print(list1[1]) # 切片 print(list2[1:3])
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

結果:

2
[3, 'hello']
  
  • 1
  • 2

方法:

操作 解釋
list.append(): 追加成員
list.count(x): 計算列表中引數x出現的次數
list.extend(L): 向列表中追加另一個列表L
list.index(x): 獲得引數x在列表中的位置
list.insert(): 向列表中插入資料
list.pop(): 刪除列表中的成員(通過下標刪除)
list.remove(): 刪除列表中的成員(直接刪除)
list.reverse(): 將列表中成員的順序顛倒
list.sort(): 將列表中成員排序

三.元組

元組跟列表很像,只不過元組用小括號來實現(),這裡要區分好和生成器的區別,兩者都可用小括號來實現的

具有以下特點:
1.可以用tuple()函式或者方括號()建立,元素之間用逗號’,‘’分隔。
2.元組的元素不需要具有相同的型別
3.使用索引來訪問元素
4.可切片
5.元素的值一旦建立就不可修改!!!!!(這是區別與列表的一個特徵)

# 可用tuple()函式建立
tuple1 = tuple([1, 2])
# 用()建立,可包含不同資料型別
tuple2 = (1, 3, 'hello', 3.5)
# 可用下標訪問
print(tuple1[1])
# 可切片
print(tuple2[1:3])
# 不可以修改元素
tuple1[1] = 10
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

結果:

2
(3, 'hello')
TypeError: 'tuple' object does not support item assignment
  
  • 1
  • 2
  • 3

可進行的操作:元組由於它的不可變性(第五點特點),相比列表的操作少了很多,只保留了index(),count()函式,用法同列表。

當然也可以用內建函式來對他進行操作,這些內建函式對於列表也適用。

操作 解釋
cmp(tuple1, tuple2) 比較兩個元組元素。
len(tuple) 計算元組元素個數。
max(tuple) 返回元組中元素最大值。
min(tuple) 返回元組中元素最小值。
tuple(seq) 將列表轉換為元組。

上面第五點在列表中的操作為(參考上面示例程式碼的第一點):

操作 解釋
list(seq) 將元組轉換為列表。

四.字典(Dictionary)

字典是另一種可變容器模型,且可儲存任意型別物件。

具有以下特點:
1.元素由鍵(key)和值(value)組成
2.可以用dict()函式或者方括號()建立,元素之間用逗號’,‘’分隔,鍵與值之間用冒號”:”隔開
3.鍵必須是唯一的,但值則不必。值可以取任何資料型別,但鍵必須是不可變的,如字串,數字或元組
4.使用鍵(key)來訪問元素

# 用dict()函式建立
dict1 = dict([('name', 'kyda'), ('e', 10)])
# 用{}建立
dict2 = {'name': 'lin', 'age': 21}
print(dict1)
# 使用鍵(key)來訪問元素
print(dict2['name'])
# 使用鍵(key)來訪問元素,並修改元素的值
dict2['age'] = 23
print(dict2)
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

結果:


{'name': 'kyda', 'age': 10}
lin
{'name': 'lin', 'age': 23}
  
  • 1
  • 2
  • 3
  • 4

字典的方法:

操作 解釋
adict.keys() 返回一個包含字典所有KEY的列表;
adict.values() 返回一個包含字典所有value的列表;
adict.items() 返回一個包含所有(鍵,值)元祖的列表;
adict.clear() 刪除字典中的所有項或元素;
adict.copy() 返回一個字典淺拷貝的副本;
adict.fromkeys(seq, val=None) 建立並返回一個新字典,以seq中的元素做該字典的鍵,val做該字典中所有鍵對應的初始值(預設為None);
adict.get(key, default = None) 返回字典中key對應的值,若key不存在字典中,則返回default的值(default預設為None);
adict.has_key(key) 如果key在字典中,返回True,否則返回False。 現在用 in 、 not in;
adict.iteritems() adict.iterkeys() adict.itervalues() 與它們對應的非迭代方法一樣,不同的是它們返回一個迭代子,而不是一個列表;
adict.pop(key[,default]) 和get方法相似。如果字典中存在key,刪除並返回key對應的vuale;如果key不存在,且沒有給出default的值,則引發keyerror異常;
adict.setdefault(key, default=None) 和set()方法相似,但如果字典中不存在Key鍵,由 adict[key] = default 為它賦值;
adict.update(bdict) 將字典bdict的鍵值對新增到字典adict中。

五.集合(set)

具有以下特點:
1.可以用set()函式或者方括號{}建立,元素之間用逗號”,”分隔。
2.與字典相比少了鍵
3.不可索引,不可切片
4.不可以有重複元素

# 兩種方法建立
set1 = set('kydaa')
set2 = {'abc', 'jaja', 'abc', 'kyda'}
print(set1)
print(set2)
  
  • 1
  • 2
  • 3
  • 4
  • 5

結果:自動將重複元素去除

{'a', 'y', 'd', 'k'}
{'jaja', 'abc', 'kyda'}
  
  • 1
  • 2

關係測試:

>>> x = {1,2,3,4}
>>> y = {3,4,5,6}
>>> x & y        #交集
set([3, 4])
>>> x | y        #並集
set([1, 2, 3, 4, 5, 6])
>>> x - y        #差集,x有但是y沒有的
set([1, 2])    
>>> x ^ y        #對稱差集
set([1, 2, 5, 6])

集合的方法:

操作 解釋
s.issubset(t),s <= t 測試是否 s 中的每一個元素都在 t 中
s.issuperset(t),s >= t 測試是否 t 中的每一個元素都在 s 中
s.union(t),s | t 返回一個新的 set 包含 s 和 t 中的每一個元素
s.intersection(t),s & t 返回一個新的 set 包含 s 和 t 中的公共元素
s.difference(t),s - t 返回一個新的 set 包含 s 中有但是 t 中沒有的元素
s.symmetric_difference(t),s ^ t 返回一個新的 set 包含 s 和 t 中不重複的元素
s.copy() 返回 set “s”的一個淺複製

六.同異

1.列表和元組

列表和元組有很多相似的地方,操作也差不多。不過列表是可變序列,元組為不可變序列。也就是說列表主要用於物件長度不可知的情況下,而元組用於物件長度已知的情況下,而且元組元素一旦建立變就不可修改。
例如我們在開啟一個文字時,並不知道里面有多少行文字,所以用列表來儲存。

with open('test.txt', 'r') as f:
    print(f.readlines())
# 結果:
# ['hello world\n', 'hi kyda\n', 'this is my program']

而我們在儲存一個人的資訊(名字,年齡,性別,假定只需要這三種資訊,所以物件長度為3)的時候,就可以用元組來實現。

id = ('kyda', 19, 'man')
print(id)
# 結果:
# ('kyda', 19, 'man')
  
  • 1
  • 2
  • 3
  • 4

2.字典
字典主要應用於需要對元素進行標記的物件,這樣在使用的時候便不必記住元素列表中或者元組中的位置,只需要利用鍵來進行訪問物件中相應的值。

id = {'name': 'kyda', 'age': 19, ‘sex': 'man')
print(id['age'])
# 結果:
# 19

3.集合
集合中的元素不可重複的特點使它被拿來去重。比如我在爬去糗事百科全站的文章連結(存放與列表中)的時候,不可避免的會遇到重複的連結。這是我們只需將列表轉換為集合便能有效的去除重複部分。
比如上面的例程。

4.在海量資料中查詢元素時,最好將資料建立為字典,或者是集合

這是由於字典和集合背後的查詢原理是雜湊(雜湊)表。由於散列表在查詢元素時的時間複雜度基本是O(1),這使查詢時間很短。

5.靈活運用推導來建立
推導可以說是python最靈活的特性之一。
例子:

list1 = [x for x in range(1, 10)]
  
  • 1

元組和集合都可以用上面的推導方式進行簡單建立

對於字典來說我們也可以運用雙重推導(笛卡爾積)來建立:

list1 = ['name', 'age', 'sex']
list2 = ['kyda', 19, 'man']

ID = {x: y for x in list1 for y in list2}
print(ID)
# 結果
# {'name': 'man', 'age': 'man', 'sex': 'man'}

當然上面還可以運用zip()函式簡化為:

ID = {x: y for x, y in zip(list1, list2)} 
  
  • 1

列表和元組也可以運用雙重推導(笛卡爾積)來建立。比如我們要生成一個二維座標陣列:

coordinate = [(x, y) for x in range(2)
              for y in range(2)]
print(coordinate)
# 結果
# [(0, 0), (0, 1), (1, 0), (1, 1)]
  
  • 1
  • 2
  • 3
  • 4
  • 5

6.列舉元素

對於列表, 集合,集合都可以運用for…in…來進行列舉

set1 = {'name', 'age', 'sex'}

for tmp in set1:
    print(tmp)

# 結果
# name
# age
# sex
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

有時候,我們需要用到元素的索引:

index = 0
for tmp in set1:
    print(tmp, index)
    index += 1
  
  • 1
  • 2
  • 3
  • 4

這樣寫太過於冗餘,我可以用enumerate()函式來幫組我們實現:

for index, tmp in enumerate(set1):
    print(tmp, index)
  
  • 1
  • 2

效果是一樣的,可這樣看起來更加簡潔了

而對於字典,我們要列舉時就有點麻煩。不過還好,字典的方法中有三個方法幫助我們解決這個問題:

操作 解釋
adict.keys() 返回一個包含字典所有KEY的列表;
adict.values() 返回一個包含字典所有value的列表;
adict.items() 返回一個包含所有(鍵,值)元祖的列表;

示例:

list1 = ['name', 'age', 'sex']
list2 = ['kyda', 19, 'man']

ID = {x: y for x, y in zip(list1, list2)}
for tmp in ID.items():
    print(tmp)
# 結果:
# ('age', 19)
# ('sex', 'man')
# ('name', 'kyda')

轉載地址:https://blog.csdn.net/weixin_37720172/article/details/78769301