2. 程式人生 > >Python序列結構--集合

Python序列結構--集合

阿新 • • 發佈：2019-03-06
tab 適用於 get 基本類 erro cal card 多個 代碼

集合：元素之間不允許重復

  • 集合屬於Python無序可變序列，元素之間不允許重復

集合對象的創建與刪除

  • 直接將值賦值給變量即可創建一個集合

    >>> a = {3,5}
    >>> type(a)
    <class ‘set‘>

  • set()函數將列表、元組、字符串、range對象等其他可叠代對象轉換為集合，如果原來的數據中存在重復元素，則轉換為集合的時候只保留一個；如果原序列或叠代對象中有不可哈希的值，無法轉換為集合，拋出異常

    >>> a_set=set(range(8,14))
    >>> a_set
     
    {8, 9, 10, 11, 12, 13}
    >>> b_set = set([0,1,2,3,0,1,2,3,7,8])
    >>> b_set
    {0, 1, 2, 3, 7, 8}

  • 集合推導式來快速生成集合

    >>> {x.strip() for x in (‘he ‘,‘she  ‘,‘  I‘)}
    {‘I‘, ‘he‘, ‘she‘}
    >>> import random
    >>> x = {random.randint(1,500) for i in range(100)} #生成隨機數，自動去除重復的元素
    >>> len(x)  # 一般而言輸出結果會小於100
     
    94
    >>> {str(x) for x in range(10)}
    {‘1‘, ‘9‘, ‘4‘, ‘8‘, ‘3‘, ‘7‘, ‘2‘, ‘6‘, ‘0‘, ‘5‘}

集合的操作與運算

集合元素的增加和刪除

  • add()方法可以增加新元素，如果該元素已存在則忽略該操作，不會拋出異常；update()方法合並另外一個集合中的元素到當前集合中，並且自動去除重復元素

    >>> s = {1,2,3}
    >>> s.add(3)        # 添加元素，重復元素自動忽略
    >>> s.update({3,4}) # 更新字典，自動忽略重復的元素
     
    >>> s
    {1, 2, 3, 4}

  • pop()方法隨機刪除並返回集合中的一個元素，如果為空則拋出異常；remove()方法刪除集合中的元素，如果指定元素不存在則拋出異常；discard()方法從集合中刪除一個特定的元素，如果元素不存在則忽略該操作；clear()方法清空集合

    >>> s
    {1, 2, 3, 4}
    >>> s.discard(5)        # 刪除元素，不存在則忽略該操作
    >>> s.remove(5)         # 刪除元素，不存在則拋出異常
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    KeyError: 5
    >>> s.pop()     # 刪除並返回元素
    1
    >>> s
    {2, 3, 4}
    >>> s.clear()
    >>> s
    set()
集合運算

  • 內置函數len()、max()、min()、sum()、sorted()、map()、filter()、enumerate()等也適用於集合。另外還支持數學意義上的交集、並集、差集等運算

    >>> a_set = set([8,9,10,11,12,113])
    >>> a_set
    {8, 9, 10, 11, 12, 113}
    >>> b_set = {0,1,2,3,7,8}
    >>> a_set | b_set       # 並集
    {0, 1, 2, 3, 7, 8, 9, 10, 11, 12, 113}
    >>> a_set.union(b_set)  # 並集
    {0, 1, 2, 3, 7, 8, 9, 10, 11, 12, 113}
    >>> a_set & b_set       # 交集
    {8}
    >>> a_set.intersection(b_set)
    {8}
    >>> a_set.difference(b_set) # 差集
    {9, 10, 11, 12, 113}
    >>> b_set.difference(a_set)
    {0, 1, 2, 3, 7}
    >>> a_set - b_set
    {9, 10, 11, 12, 113}
    >>> b_set - a_set
    {0, 1, 2, 3, 7}
    >>> a_set.symmetric_difference(b_set)   # 對稱差集
    {0, 1, 2, 3, 7, 9, 10, 11, 12, 113}
    >>> a_set ^ b_set
    {0, 1, 2, 3, 7, 9, 10, 11, 12, 113}
    >>> x = {1,2,3}
    >>> y = {1,2,5}
    >>> z = {1,2,3,4}
    >>> x < y   # 比較集合大小/包含關系
    False
    >>> x < z   # 真子集True>>> y < zFalse>>> z < zFalse>>> z <= z  # 子集True>>> x.issubset(y) # 測試是否為子集False>>> x.issubset(z)True>>> x.issubset(x)True

不可變集合frozenset

用法與set基本類似，與set類不同的是，frozenset是不可變集合，沒有提供add()、remove()等可以修改集合對象的方法

>>> x = frozenset(range(5))
>>> x
frozenset({0, 1, 2, 3, 4})
>>> x.add(2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: ‘frozenset‘ object has no attribute ‘add‘
>>> x | frozenset(range(5,10))      # 並集
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
>>> x & frozenset(range(4,10))      # 交集
frozenset({4})
>>> x - frozenset(range(4,10))      # 差集
frozenset({0, 1, 2, 3})
>>> frozenset(range(4)) < frozenset(range(5))   # 集合包含關系比較
True

集合應用案例

  • python字典和集合都使用hash表來存儲元素，元素查詢速度快，關鍵字in作用於字典和集合比作用於列表要快得多

    >>> import random
    >>> x1 = list(range(10000))
    >>> x2 = tuple(range(10000))
    >>> x3 = set(range(10000))
    >>> x4 = dict(zip(range(10000),range(10000)))
    >>> r = random.randint(0,9999)
    >>> for t in (x4, x3, x2, x1):
    ...   start = time.time()
    ...   for i in range(9999999):
    ...     flag = (r in t)
    ...   print(type(t),‘time used:‘, time.time() - start)
    ...
    <class ‘dict‘> time used: 0.865715503692627
    <class ‘set‘> time used: 0.9040701389312744
    <class ‘tuple‘> time used: 487.52976393699646
    <class ‘list‘> time used: 488.0697581768036

  • 作為集合快速的具體應用，可以使用集合快速提取序列中單一元素，即提取序列中所有不重復的元素

    >>> import random
    >>> listRandom = [random.choice(range(1000)) for i in range(100)]
    >>> len(listRandom)
    100
    >>> newSet = set(listRandom)
    >>> len(newSet)
    95

  • 返回指定範圍內一定數量的不重復數字

    >>> import random
    >>> def randomNumbers(number,start,end):
    ...   ‘‘‘使用集合生成number個介於start和end之間的不重復隨機數‘‘‘
    ...   data = set()
    ...   while len(data) < number:
    ...     element = random.randint(start,end)
    ...     data.add(element)
    ...   return data
    ...
    >>> randomNumbers(10,1,1000)
    {66, 676, 550, 522, 333, 783, 499, 278, 59, 349}

  • 返回指定範圍內一定數量的不重復數字，使用random模塊的sample()函數更好一些，但是random模塊的sample()函數只支持列表、元組、集合、字符串和range對象，不支持字典以及map、zip、enumerate、filter等惰性求值的叠代對象

    >>> import random
    >>> random.sample(range(1, 700), 10)    # 選取指定分布中選取不重復元素
    [340, 489, 623, 121, 550, 632, 19, 531, 626, 591]

  • 下面兩段代碼用來測試指定列表中是否包含非法數據，很明顯第二段用集合的代碼效率高一些

    >>> import random
    >>> lstColor = (‘red‘,‘green‘,‘blue‘)
    >>> colors = [random.choice(lstColor) for i in range(10000)]
    >>> for item in colors:
    ...   if item not in lstColor:
    ...     print(‘error:‘,item)
    ...     break
    ...
    >>>
    >>> if (set(colors) - set(lstColor)):
    ...   print(‘error‘)
    ...
    >>>

  • 使用字典和集合模擬有向圖結構，並實現了節點的入度和出度計算

    >>> def getDegress(orientedGraph,node):
    ...   outDegree = len(orientedGraph.get(node,[]))
    ...   inDegree = sum(1 for v in orientedGraph.values() if node in v)
    ...   return (inDegree, outDegree)
    ...
    >>> graph = {‘a‘ : set(‘bcdef‘), ‘b‘:set(‘ce‘), ‘c‘:set(‘d‘), ‘d‘: set(‘e‘), ‘e‘:set(‘f‘), ‘f‘:set(‘cgh‘),‘g‘:set(‘fhi‘), ‘h‘:set(‘fgi‘), ‘i‘:set() }
    >>> print(getDegress(graph, ‘h‘))
    (2, 3)
    >>>

序列解包的多種形式和用法

序列解包是Python中非常重要和常用的一個功能，可以使用非常簡潔的形式完成復雜的功能，提高代碼的可讀性，減少了程序員代碼的輸入量

>>> x,y,z = 1,2,3
>>> x
1
>>> y
2
>>> z
3
>>> v_tuple = (False,3.5,‘exp‘)
>>> (x,y,z) = v_tuple
>>> m,n,q = v_tuple
>>> m,n,q = range(2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 3, got 2)
>>> m,n,q = range(3)    # 對range對象進行序列解包
>>> x,y,z = range(4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 3)
>>> x,y,z = iter([1,2,3])   # 使用叠代器對象進行序列解包
>>> x,y,z = map(str,range(3))   # 使用可叠代的map對象進行序列解包
>>> x
‘0‘
>>> y
‘1‘
>>> x,y =y,x    # 交換兩個變量的值
>>> x
‘1‘
>>> y
‘0‘
序列解包還可用於列表、字典、enumerate對象、filter對象等，對字典使用時，默認是對字典“鍵”進行操作，如果對“鍵：值“對進行操作應使用字典的items()方法說明，如果需要對字典”值“進行操作應該使用字典的values()方法明確指定

>>> a = [1,2,3]
>>> b,c,d = a
>>> x,y,z = sorted([1,3,2])
>>> s = {‘a‘:1,‘b‘:2,‘c‘:3}
>>> b,c,d = s.items()
>>> b
(‘a‘, 1)
>>> c
(‘b‘, 2)
>>> d
(‘c‘, 3)
>>> b,c,d = s
>>> b
‘a‘
>>> c
‘b‘
>>> d
‘c‘
>>> b,c,d = s.values()
>>> b
1
>>> c
2
>>> d
3
>>> a,b,c=‘ABC‘
>>> a
‘A‘
>>> b
‘B‘
>>> c
‘C‘
使用序列解包可以很方便地同時遍歷多個序列

>>> keys = [‘a‘,‘b‘,‘c‘,‘d‘]
>>> values = [1,2,3,4]
>>> for k,v in zip(keys,values):
...   print((k,v),end=‘ ‘)
...
(‘a‘, 1) (‘b‘, 2) (‘c‘, 3) (‘d‘, 4) >>>
>>> x = [‘a‘,‘b‘,‘c‘]
>>> for i,v in enumerate(x):
...   print(‘The value on position {0} is {1}‘.format(i,v))
...
The value on position 0 is a
The value on position 1 is b
The value on position 2 is c
>>> s = {‘a‘:1,‘b‘:2,‘c‘:3}
>>> for k,v in s.items():
...   print((k,v),end=‘ ‘)
...
(‘a‘, 1) (‘b‘, 2) (‘c‘, 3) >>>
序列解包的另類用法和錯誤的用法：

>>> print(*[1,2,3])
1 2 3
>>> print(*[1,2,3],4,*(5,6))
1 2 3 4 5 6
>>> *range(4),4
(0, 1, 2, 3, 4)
>>> *range(4)
  File "<stdin>", line 1
SyntaxError: can‘t use starred expression here
>>> {*range(4),4,*(5,6,7)}
{0, 1, 2, 3, 4, 5, 6, 7}
>>> {‘x‘:1,**{‘y‘:2}}
{‘x‘: 1, ‘y‘: 2}
>>> a,b,c,d = range(3),3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 4, got 2)
>>> a,b,c,d = *range(3),3
下面的代碼看起來與序列解包類型，但嚴格來說是序列解包的逆運算，與函數的可變長度參數一樣，用來接收等號右側的多個數值

>>> a,*b,c = 1,2,3,4,5
>>> a
1
>>> b
[2, 3, 4]
>>> c
5
>>> a,b,c
(1, [2, 3, 4], 5)
>>> a,*b,c = range(20)
>>> b
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
>>> *b = 1,2,4      # 等號左邊必須為列表、元組或多個變量
  File "<stdin>", line 1
SyntaxError: starred assignment target must be in a list or tuple

Python序列結構--集合

相關推薦

Python序列結構--集合

tab 適用於 get 基本類 erro cal card 多個 代碼 集合：元素之間不允許重復 集合屬於Python無序可變序列，元素之間不允許重復 集合對象的創建與刪除 直接將值賦值給變量即可創建一個集合 >>> a =

python-序列、集合及字典

組合資料型別 1.集合型別 集合是多種元素的無序組合，(元素獨一性) 集合用大括號{}表示，元素用，分隔。 用set函式建立：        A=set(“python123”)      

python資料結構--集合、字典

一、集合set 可變的、無序的、不重複的元素的集合 set的元素要求必須可以hash，set可以迭代，元素不可以索引 定義：s=set()、s=set(iterable) set元素增加： s.add(elem)增加一個元素到set中，如果元素存在，什麼都不做 s.update（*other）合併

Python序列結構--元組

def append python 字符串 std rop 直接 列表 file 元組：輕量級列表 元組創建於元素訪問 >>> x = (1, 2, 3)>>> type(x)<class ‘tuple‘>>>

（python）資料結構---集合

一、描述 set翻譯為集合 set是可變的、無序的、不可重複的 set的元素要求可哈西（不可變的資料型別可哈西，可變的資料型別不可雜湊） set是無序的，因此不可以索引，也不可以修改 線型結構的查詢時間複雜度是O(n)，隨著資料的增大而效率下降；set、dict內部使用hash值作為k

（python）數據結構---集合

結構 pytho 等於 都在 style 參數 要求 集合 復雜度 一、描述 set翻譯為集合 set是可變的、無序的、不可重復的 set的元素要求可哈西（不可變的數據類型可哈西，可變的數據類型不可哈希） set是無序的，因此不可以索引，也不可以修改 線型結構的查詢時間復

python-11 資料結構 - 集合

分類 可變集合： 建立 字面量建立 {值} 值： 整形 字串 元組 只能是固定型別，不可以是列表，可以是元組 >>> {1,2,3,} {1, 2, 3} >>> {1,"s"} {1, 's'} >&

python資料結構和序列

1.元祖 元祖是一種固定長度、不可變的Python物件序列。建立元祖最簡單的方法就是用逗號分隔序列值。 tup = 4,5,6 print(tup) #(4,5,6) 用更復雜的表示式來定義元祖時，一般需要用括號將值包起來。 complex_tup = (1,2,3),(

Python中的序列與集合

之前有說到Python中的字串、列表以及元組在很多方面上比較相似，很大程度是因為它們的資料儲存是有序的，也就是我們統稱的序列，這才能讓我們通過序號進行資料的獲取，就像下面這樣。 既然已經有了個統稱，那麼必然它們可以有相同的特性，這裡列舉了幾個常用的方法，針對有序

Cris 複習Python日記（四）：Python 資料結構之序列和列表

1. 簡單認識序列和列表 # 序列 # 序列是Python 中最基本的資料結構，用於儲存一組有序的資料，所有資料都在序列中擁有一個唯一索引，並且按照元素新增的順序來指定序列 # 序列的分類 # 1.

python資料結構之序列及其操作

序列       在Python中最基本的資料結構是序列（sequence）。序列中的每個元素被分配一個序號----即元素的位置，也稱索引。索引從0開始，0,1,2,3，...。也可以從最後一個數開始，標記為-1，依次為-1，-2，-3.... 列表與元組的區別

python資料結構之列表、字典、元組、集合

列表 列表在python裡是有序集合物件型別。列表裡的物件可以是任何物件：數字，字串，列表或者字典，元組。與字串不同，列表是可變物件，支援原處修改的操作python的列表是： 任意物件的有序集合 通過偏移讀取 可變長度、異構以及任意巢狀 屬於可變序列的分組 物件引用陣列 列表的

【流暢的python】系列——python資料結構之序列2

文章內容接上篇 三、切片 《流暢的python》的第2章中，對於切片的簡單用法，只是一帶而過： 在 Python 裡，像列表（list）、元組（tuple）和字串（str）這類序列型別都支援切片操作，但是實際上切片操作比人們所想象的要強大很多。 文中，主要講了切片的3個方面： 1.為什麼在pytho

Python資料結構：序列（列表[]、元組()）與對映（字典{}）語法總結

一、概述： Python中兩種基本的資料結構是序列和對映，序列包含：可變的列表和不可變的元組；而當序列不夠用時就出現了對映：字典。列表中的元素是可以變化的，元組裡面的元素一旦初始化後就不可更改。列表和元組只是一類元資料的集合體，還不能滿足通過名字引用值的資料，故字典就充當

Java集合-Python資料結構比較

Java list與Python list相比較 Java List:有序的，可重複的。（有序指的是集合中物件的順序與新增順序相同） Python list（列表）是有序的，可變的。 Java List分類：    ---ArrayList：底層使用陣列，執行緒不安全，查詢速度快，增刪速度慢    

python —— 資料結構（字串，元組，列表，字典，集合）

Python 識別符號 1、識別符號由字母、數字、下劃線組成。 2、所有識別符號可以包括英文、數字以及下劃線(_)，但不能以數字開頭。 3、識別符號是區分大小寫的。 4、以單下劃線開頭 _foo 的代表不能直接訪問的類屬性，需通過類提供的介面進行

Python學習：集合(set)

pythonpython的set和其他語言類似, 是一個無序不重復元素集, 基本功能包括關系測試和消除重復元素. 集合對象還支持union(聯合), intersection(交), difference(差)和sysmmetric difference(對稱差集)等數學運算. sets 支持 x in s

python序列的方法

更改 第一次 ase 次數 str 如果 center 小寫 pil 1.基本的序列（sequenece）,包括定指表（tuple）和表（list），字符串也是一種特殊的定指表。（表的元素可以更改，定值表一旦建立，其元素就不可以更改） #s為一個序列 len(s) 返回序列

【Python】05、python程序結構控制語句

python一、程序結構程序結構：語句和表達式按照什麽樣的順序執行所有語言無非就三種程序結構： 順序：默認結構 語句從上到下依次一行一行的執行， 分支：選擇一個分支執行，永遠最多只執行一個分支 循環：二、分支結構語句1、Python的比較操作

python,序列化

span ads mars 序列化 serial byte () like div 序列化： 變量從內存中變成可存儲或傳輸的過程 在Python中叫pickling，在其他語言中也被稱之為serialization，marshalling，flattening等等 反序列化