python中的集合和序列

python 訓練營打卡第六天

集合 序列

• python 訓練營打卡第六天
• 集合
• • 1. 集合的建立
  • 2. 通路集合中的值
  • 3. 集合的内置方法
  • 4. 集合的轉換
  • 5. 不可變集合
  • 序列
  • 1. 針對序列的内置函數

集合

Python 中

set

與

dict

類似，也是一組

key

的集合，但不存儲

value

。由于

key

不能重複，是以，在

set

中，沒有重複的

key

。

注意，

key

為不可變類型，即可哈希的值。

1. 集合的建立

• 先建立對象再加入元素。
• 在建立空集合的時候隻能使用

  s = set()

  ，因為

  s = {}

  建立的是空字典。

basket = set()
basket.add('apple')
basket.add('banana')
print(basket)  # {'banana', 'apple'}
           

直接把一堆元素用花括号括起來

{元素1, 元素2, ..., 元素n}

。

• 重複元素在

  set

  中會被自動被過濾。
• 使用

  set(value)

  工廠函數，把清單或元組轉換成集合。

a = set('abracadabra')
print(a)  
# {'r', 'b', 'd', 'c', 'a'}

b = set(("Google", "Lsgogroup", "Taobao", "Taobao"))
print(b)  
# {'Taobao', 'Lsgogroup', 'Google'}

c = set(["Google", "Lsgogroup", "Taobao", "Google"])
print(c)  
# {'Taobao', 'Lsgogroup', 'Google'}
           

解釋set

lst = [0, 1, 2, 3, 4, 5, 5, 3, 1]

temp = []
for item in lst:
    if item not in temp:
        temp.append(item)

print(temp)  # [0, 1, 2, 3, 4, 5]

a = set(lst)
print(list(a))  # [0, 1, 2, 3, 4, 5]
從結果發現集合的兩個特點：無序 (unordered) 和唯一 (unique)。

由于 `set` 存儲的是無序集合，是以我們不可以為集合建立索引或執行切片(slice)操作，也沒有鍵(keys)可用來擷取集合中元素的值，但是可以判斷一個元素是否在集合中。
           

2. 通路集合中的值

• 可以使用

  len()

  內建函數得到集合的大小。

s = set(['Google', 'Baidu', 'Taobao'])
print(len(s))  # 3
           

• 可以使用

  for

  把集合中的資料一個個讀取出來。

s = set(['Google', 'Baidu', 'Taobao'])
for item in s:
    print(item)
    
# Baidu
# Google
# Taobao
           

• 可以通過

  in

  或

  not in

  判斷一個元素是否在集合中已經存在

• 3. 集合的内置方法

• set.add(elmnt)

  用于給集合添加元素，如果添加的元素在集合中已存在，則不執行任何操作。

• set.update(set)

  用于修改目前集合，可以添加新的元素或集合到目前集合中，如果添加的元素在集合中已存在，則該元素隻會出現一次，重複的會忽略。

x = {"apple", "banana", "cherry"}
y = {"google", "baidu", "apple"}
x.update(y)
print(x)
# {'cherry', 'banana', 'apple', 'google', 'baidu'}

y.update(["lsgo", "dreamtech"])
print(y)
# {'lsgo', 'baidu', 'dreamtech', 'apple', 'google'}
           

• set.remove(item)

  用于移除集合中的指定元素。如果元素不存在，則會發生錯誤。

• • set.discard(value)

    用于移除指定的集合元素。

    remove()

    方法在移除一個不存在的元素時會發生錯誤，而

    discard()

    方法不會。

• set.pop()

  用于随機移除一個元素。
• 由于 set 是無序和無重複元素的集合，是以兩個或多個 set 可以做數學意義上的集合操作。

• set.intersection(set1, set2)

  傳回兩個集合的交集。

• set1 & set2

  傳回兩個集合的交集。

• set.intersection_update(set1, set2)

  交集，在原始的集合上移除不重疊的元素。

a = set('abracadabra')
b = set('alacazam')
print(a)  # {'r', 'a', 'c', 'b', 'd'}
print(b)  # {'c', 'a', 'l', 'm', 'z'}

c = a.intersection(b)
print(c)  # {'a', 'c'}
print(a & b)  # {'c', 'a'}
print(a)  # {'a', 'r', 'c', 'b', 'd'}

a.intersection_update(b)
print(a)  # {'a', 'c'}
           

• set.union(set1, set2)

  傳回兩個集合的并集。

• set1 | set2

  傳回兩個集合的并集。

• set.difference(set)

  傳回集合的差集。

• set1 - set2

  傳回集合的差集。

• set.difference_update(set)

  集合的差集，直接在原來的集合中移除元素，沒有傳回值。

• set.symmetric_difference(set)

  傳回集合的異或。

• set1 ^ set2

  傳回集合的異或。

• set.symmetric_difference_update(set)

  移除目前集合中在另外一個指定集合相同的元素，并将另外一個指定集合中不同的元素插入到目前集合中。

• set.issubset(set)

  判斷集合是不是被其他集合包含，如果是則傳回 True，否則傳回 False。

• set1 <= set2

  判斷集合是不是被其他集合包含，如果是則傳回 True，否則傳回 False。

• set.issuperset(set)

  用于判斷集合是不是包含其他集合，如果是則傳回 True，否則傳回 False。

• set1 >= set2

  判斷集合是不是包含其他集合，如果是則傳回 True，否則傳回 False。

• set.isdisjoint(set)

  用于判斷兩個集合是不是不相交，如果是傳回 True，否則傳回 False。

• 4. 集合的轉換

【例子】

se = set(range(4))
li = list(se)
tu = tuple(se)

print(se, type(se))  # {0, 1, 2, 3} <class 'set'>
print(li, type(li))  # [0, 1, 2, 3] <class 'list'>
print(tu, type(tu))  # (0, 1, 2, 3) <class 'tuple'>
           

5. 不可變集合

Python 提供了不能改變元素的集合的實作版本，即不能增加或删除元素，類型名叫

frozenset

。需要注意的是

frozenset

仍然可以進行集合操作，隻是不能用帶有

update

的方法。

• frozenset([iterable])

  傳回一個當機的集合，當機後集合不能再添加或删除任何元素。

【例子】

a = frozenset(range(10))  # 生成一個新的不可變集合
print(a)  
# frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

b = frozenset('lsgogroup')
print(b)  
# frozenset({'g', 's', 'p', 'r', 'u', 'o', 'l'})
           

序列

在 Python 中，序列類型包括字元串、清單、元組、集合和字典，這些序列支援一些通用的操作，但比較特殊的是，集合和字典不支援索引、切片、相加和相乘操作。

1. 針對序列的内置函數

• list(sub)

  把一個可疊代對象轉換為清單。

【例子】

a = list()
print(a)  # []

b = 'I Love LsgoGroup'
b = list(b)
print(b)  
# ['I', ' ', 'L', 'o', 'v', 'e', ' ', 'L', 's', 'g', 'o', 'G', 'r', 'o', 'u', 'p']

c = (1, 1, 2, 3, 5, 8)
c = list(c)
print(c)  # [1, 1, 2, 3, 5, 8]
           

• tuple(sub)

  把一個可疊代對象轉換為元組。

• • str(obj)

    把obj對象轉換為字元串

• len(s)

  傳回對象（字元、清單、元組等）長度或元素個數。

  • s

    – 對象。

• max(sub)

  傳回序列或者參數集合中的最大值

• min(sub)

  傳回序列或參數集合中的最小值

• • sum(iterable[, start=0])

    傳回序列

    iterable

    與可選參數

    start

    的總和。

• • sorted(iterable, key=None, reverse=False)

    對所有可疊代的對象進行排序操作。

    • iterable

      – 可疊代對象。

    • key

      – 主要是用來進行比較的元素，隻有一個參數，具體的函數的參數就是取自于可疊代對象中，指定可疊代對象中的一個元素來進行排序。

    • reverse

      – 排序規則，

      reverse = True

      降序 ，

      reverse = False

      升序（預設）。

    • 傳回重新排序的清單。

      sorted經常用的到

x = [-8, 99, 3, 7, 83]
print(sorted(x))  # [-8, 3, 7, 83, 99]
print(sorted(x, reverse=True))  # [99, 83, 7, 3, -8]

t = ({"age": 20, "name": "a"}, {"age": 25, "name": "b"}, {"age": 10, "name": "c"})
x = sorted(t, key=lambda a: a["age"])
print(x)
# [{'age': 10, 'name': 'c'}, {'age': 20, 'name': 'a'}, {'age': 25, 'name': 'b'}]
           

• reversed(seq)

  函數傳回一個反轉的疊代器。

  • seq

    – 要轉換的序列，可以是 tuple, string, list 或 range。

【例子】

s = 'lsgogroup'
x = reversed(s)
print(type(x))  # <class 'reversed'>
print(x)  # <reversed object at 0x000002507E8EC2C8>
print(list(x))
# ['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l']

t = ('l', 's', 'g', 'o', 'g', 'r', 'o', 'u', 'p')
print(list(reversed(t)))
# ['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l']

r = range(5, 9)
print(list(reversed(r)))
# [8, 7, 6, 5]

x = [-8, 99, 3, 7, 83]
print(list(reversed(x)))
# [83, 7, 3, 99, -8]
           

• enumerate(sequence, [start=0])

【例子】用于将一個可周遊的資料對象(如清單、元組或字元串)組合為一個索引序列，同時列出資料和資料下标，一般用在 for 循環當中。

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
a = list(enumerate(seasons))
print(a)  
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

b = list(enumerate(seasons, 1))
print(b)  
# [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

for i, element in a:
    print('{0},{1}'.format(i, element))
# 0,Spring
# 1,Summer
# 2,Fall
# 3,Winter
           

• zip(iter1 [,iter2 [...]])

  • 用于将可疊代的對象作為參數，将對象中對應的元素打包成一個個元組，然後傳回由這些元組組成的對象，這樣做的好處是節約了不少的記憶體。
  • 我們可以使用

    list()

    轉換來輸出清單。
  • 如果各個疊代器的元素個數不一緻，則傳回清單長度與最短的對象相同，利用

    *

    号操作符，可以将元組解壓為清單。

【例子】

a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]

zipped = zip(a, b)
print(zipped)  # <zip object at 0x000000C5D89EDD88>
print(list(zipped))  # [(1, 4), (2, 5), (3, 6)]
zipped = zip(a, c)
print(list(zipped))  # [(1, 4), (2, 5), (3, 6)]

a1, a2 = zip(*zip(a, b))
print(list(a1))  # [1, 2, 3]
print(list(a2))  # [4, 5, 6]
           

感覺這個有點超前了。。。