集合

Python 中set與dict類似，也是一組key的集合，但不存儲value。由于key不能重復，所以，在set中，沒有重復的key。

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

num = {} print(type(num)) # <class 'dict'> num = {1, 2, 3, 4} print(type(num)) # <class 'set'>

集合的兩個特點：

無序（unordered）和唯一（unique）

1、集合的創建

• 先創建對象再加入元素。
• 在創建空集合的時候只能使用s = set()，因為s = {}創建的是空字典。

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

• 直接把一堆元素用花括號括起來{元素1, 元素2, …, 元素n}。
• 重復元素在set中會被自動被過濾。

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'} print(basket) # {'banana', 'apple', 'pear', 'orange'}

• 使用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'}

• 去掉列表中重復的元素

#常規更改 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]

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

2、訪問集合中的值

• 使用len()內建函數得到集合的大小

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

• 可以通過in或not in判斷一個元素是否在集合中已經存在

s = set(['Google', 'Baidu', 'Taobao']) print('Taobao' in s) # True print('Facebook' not in s) # True

3、集合的內置方法

• set.add(elmnt)用于給集合添加元素，如果添加的元素在集合中已存在，則不執行任何操作。

fruits = {"apple", "banana", "cherry"} fruits.add("orange") print(fruits) # {'orange', 'cherry', 'banana', 'apple'}#添加已存在的元素 fruits.add("apple") print(fruits) # {'orange', 'cherry', 'banana', 'apple'}

• set.update(set)用于修改當前集合，可以添加新的元素或集合到當前集合中，如果添加的元素在集合中已存在，則該元素只會出現一次，重復的會忽略。

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

• set.remove(item)用于移除集合中的指定元素。如果元素不存在，則會發生錯誤。

fruits = {"apple", "banana", "cherry"} fruits.remove("banana") print(fruits) # {'apple', 'cherry'}

• set.discard(value)用于移除指定的集合元素。remove()方法在移除一個不存在的元素時會發生錯誤，而 discard()方法不會。

fruits = {"apple", "banana", "cherry"} fruits.discard("orange") print(fruits) # {'apple', 'cherry'}

• set.pop()用于隨機移除一個元素。

fruits = {"apple", "banana", "cherry"} x = fruits.pop() print(fruits) # {'cherry', 'apple'} print(x) # banana

由于 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 返回兩個集合的并集。

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

• set.difference(set)返回集合的差集。
• set1 - set2 返回集合的差集。
• set.difference_update(set) 集合的差集，直接在原來的集合中移除元素，沒有返回值。

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

• set.symmetric_difference(set)返回集合的異或。
• set1 ^ set2返回集合的異或。
• set.symmetric_difference_update(set)移除當前集合中在另外一個指定集合相同的元素，并將另外一個指定集合中不同的元素插入到當前集合中。

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

• set.issubset(set)判斷集合是不是被其他集合包含，如果是則返回 True，否則返回 False。
• set1 <= set2 判斷集合是不是被其他集合包含，如果是則返回 True，否則返回 False。

x = {"a", "b", "c"} y = {"f", "e", "d", "c", "b", "a"} z = x.issubset(y) print(z) # True print(x <= y) # Truex = {"a", "b", "c"} y = {"f", "e", "d", "c", "b"} z = x.issubset(y) print(z) # False print(x <= y) # False

• set.issuperset(set)用于判斷集合是不是包含其他集合，如果是則返回 True，否則返回 False。
• set1 >= set2判斷集合是不是包含其他集合，如果是則返回 True，否則返回 False。

x = {"f", "e", "d", "c", "b", "a"} y = {"a", "b", "c"} z = x.issuperset(y) print(z) # True print(x >= y) # Truex = {"f", "e", "d", "c", "b"} y = {"a", "b", "c"} z = x.issuperset(y) print(z) # False print(x >= y) # False

• set.isdisjoint(set)用于判斷兩個集合是不是不相交，如果是返回 True，否則返回 False。

x = {"f", "e", "d", "c", "b"} y = {"a", "b", "c"} z = x.isdisjoint(y) print(z) # Falsex = {"f", "e", "d", "m", "g"} y = {"a", "b", "c"} z = x.isdisjoint(y) print(z) # True

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)把一個可迭代對象轉換為元組。

a = tuple() print(a) # ()b = 'I Love LsgoGroup' b = tuple(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 = tuple(c) print(c) # (1, 1, 2, 3, 5, 8)

• str(obj)把obj對象轉換為字符串

a = 123 a = str(a) print(a) # 123

• len(s) 返回對象（字符、列表、元組等）長度或元素個數。
• s– 對象。

a = list() print(len(a)) # 0b = ('I', ' ', 'L', 'o', 'v', 'e', ' ', 'L', 's', 'g', 'o', 'G', 'r', 'o', 'u', 'p') print(len(b)) # 16

• max(sub)返回序列或者參數集合中的最大值

print(max(1, 2, 3, 4, 5)) # 5 print(max([-8, 99, 3, 7, 83])) # 99 print(max('IloveLsgoGroup')) # v

• min(sub)返回序列或參數集合中的最小值

print(min(1, 2, 3, 4, 5)) # 1 print(min([-8, 99, 3, 7, 83])) # -8 print(min('IloveLsgoGroup')) # G

• sum(iterable[, start=0])返回序列iterable與可選參數start的總和。

print(sum([1, 3, 5, 7, 9])) # 25 print(sum([1, 3, 5, 7, 9], 10)) # 35 print(sum((1, 3, 5, 7, 9))) # 25 print(sum((1, 3, 5, 7, 9), 20)) # 45

• sorted(iterable, key=None, reverse=False)對所有可迭代的對象進行排序操作。

  iterable -- 可迭代對象。key -- 主要是用來進行比較的元素，只有一個參數，具體的函數的參數就是取自于可迭代對象中，指定可迭代對象中的一個元素來進行排序。reverse -- 排序規則，reverse = True 降序 ， reverse = False 升序（默認）。返回值 -- 返回重新排序的列表。

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']

• 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]

總結

以上是生活随笔為你收集整理的Python 集合、序列基础知识的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。