本學習筆記為阿里云天池龍珠計劃Python訓練營的學習內容，學習鏈接為：https://tianchi.aliyun.com/specials/promotion/aicamppython?spm=5176.22758685.J_6770933040.1.6f103da1tESyzu

一、學習知識點概要

二、學習內容

I.列表（list）

1.定義

2.創建列表

?3.列表的添加、刪除操作

4.列表元素選取

5.列表常用操作符

6.列表的其他方法

II.元組（tuple）

1.定義

2.創建元組

?3.元組的更新和刪除

4. 元組常用操作符

5.元組的內置方法

6.解壓元組

III.字符串（str）

1.定義

2.字符串常用轉義字符

3.字符串的索引和切片

4.字符串的操作符

5.字符串的內置方法

6.字符串格式化

IV.字典（dict）

1.定義

2.創建和索引

3.字典的內置方法

V.集合（set）

1.定義

2.創建

2.訪問集合中的值

3.集合的內置方法

4.不可變集合（frozenset）

VI.序列

三、學習問題與解答

四、學習思考與總結

一、學習知識點概要

本次主要學習Python中的容器（序列）類型，包括：

列表（list）
元組（tuple）
字符串（str）
字典（dict）
集合（set）

二、學習內容

I.列表（list）

1.定義

列表(list)為有序集合，可以保存任意類型的對象，語法為[元素1,元素2,……,元素n]。列表的語法點在于用中括號“[]”將元素放在一起，用逗號“,”將元素隔開

2.創建列表

列表可以通過直接賦值創建，也可以用內置方法list(sub)把可迭代對象sub轉化為列表，其中sub可以為range對象、字符串等。此外，在上次的學習中學習的列表推導式也可以用于創建列表,例如：

a=[1,2,'Python',True]   #直接賦值創建列表，元素為任意對象，列表中保存的是對象的引用
print(a,type(a))#運行結果：#[1,2,'Pthon',True] <class'list'>b=list(range(1,11))    #通過list()方法將range對象轉換為列表
print(b,type(b))#運行結果：#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] <class 'list'>c=[i*2 for i in b]     #通過推導式創建列表
print(c,type(c))#運行結果：#[2, 4, 6, 8, 10, 12, 14, 16, 18, 20] <class 'list'>d=[]    #創建空列表，之后可以用list類的內置方法添加元素，詳見下文f=[[1,2,3]]*3          #列表的元素也可以是容器類型
print(f,type(f))       #*3的操作意為將創建了3份原列表的引用，看似是3個相同的列表拼在了一起
f[0][1]=5              #其實這3個相同列表的引用都是一樣的，都指向原列表
print(f,type(f))       #只要一個列表產生變化，原列表就會變化，其他被拼接起來的列表也會變化#運行結果：#[[1, 2, 3], [1, 2, 3], [1, 2, 3]] <class 'list'>#[[1, 5, 3], [1, 5, 3], [1, 5, 3]] <class 'list'>

?3.列表的添加、刪除操作

列表中有一些內置方法，可對列表進行添加或刪除元素的操作。這些操作對列表的id不產生影響，這表明列表是可變的。字典和集合也是可變的，而數值、元組、字符串是不可變的。

判斷一個數據可不可變可以用hash()方法判斷，如果參數的數據類型是可變的，那么就會報錯。

(1)添加元素

list.append(obj)在列表末尾添加新的對象，只接受一個參數，參數可以是任何數據類型，被追加的元素在 list 中保持著原結構類。append()方法一次只添加一個元素，若參數obj為一個列表，那么這個列表會作為一個整體添加到 list 中；
list.extend(seq)在列表末尾一次性追加另一個序列中的多個值，參數seq為列表，此方法用新列表seq拓展原列表list。相當于把seq接到list的末尾，是對list的操作，無返回值；
list.insert(index,obj)在編號index的位置插入元素obj。對參數obj的要求和append()一樣，index表示第幾個間隔，index從0數起。

例程：

x=list(range(1,6))
print(x)               #運行結果:[1,2,3,4,5]x.append(6)            #在末尾添加元素6
print(x)               #運行結果:[1,2,3,4,5,6]x.append([7,8])        #參數obj為列表，將列表整體當作一個元素添加到末尾
print(x)               #運行結果:[1,2,3,4,5,6,[7,8]]x.extend([9,10])       #用列表[9,10]拓展x，即將[9,10]中的所有元素添加到x的末尾
print(x)               #運行結果:[1,2,3,4,5,6,[7,8],9,10]x.insert(0,'Numbers')  #在第0個間隔之間(即最左端)插入字符串'Numbers'
print(x)               #運行結果:['Numbers',1,2,3,4,5,6,[7,8],9,10]

(2)刪除元素

list.remove(obj)刪除列表中第一個與obj相同的元素。remove()方法為對list的一項操作，無返回值；
list.pop([index=-1])返回并刪除列表中index位置的元素。index為可選參數，表示列表的索引，索引相關詳見下文。pop()方法默認取出列表中的最后一個元素；
del語句可以用于刪除單個或多個列表對象。具體用法為 del list[var1]，或del list[start:end:step]。del 語句原本就可以用于刪除變量，若del 后面寫的是列表則刪除整個列表，若寫的是列表的切片則刪除列表中相對應的元素。

例程：

x=['I','Love','Python',1,2,3]
print(x,type(x))                   #運行結果:['I','Love','Python',1,2,3] class<'list'>x.remove('I')                      #刪除x中的'I'
print(x)                           #運行結果:['Love', 'Python', 1, 2, 3]y=x.pop()                          #從x中取出最后一個元素賦給y
print('x=',x,'\ny=',y,sep="")      #運行結果:x=['Love', 'Python', 1, 2]#         y=3del x[2],x[2]                      #刪除x中的第3個元素，依次執行
print(x)                           #注意：del語句后的刪除對象是依次執行的，先執行完一次#刪除x[2]后x[3]就沒有了，然后再執行一次刪除x[2]
#運行結果：['Love', 'Python']

4.列表元素選取

(1)索引

可以通過list[index]的方式表示列表list中的元素，index為索引值，整數，從0開始。

若index為負數，則從右到左數起。例如list[-1]是列表list的最后一個元素，list[-2]是列表list的倒數第二個元素。

(2)切片

切片是一種一次性從列表里進行多個索引的方式，寫法為list[start:end:step=1]，start為選取的第一個元素，end為選取的最后一個元素，step為步長，默認為1。切片有四種用法：

list[start:]? 從start位置開始，選取后面的所有元素
list[:end]? 從第一個元素開始，選取到end位置的前一個元素（含頭不含尾）
list[start:end]? 從start位置開始，選取到end位置的前一個元素
list[start:end:step]? 從start位置開始，每隔step個間隔選取一個元素，直到end位置為止（不含end位置上的元素）
list[:]? 選取所有元素，進行淺拷貝

例如：

x=list(range(1,11))
print(x)                     #[1,2,3,4,5,6,7,8,9,10]
print(x[5:])                 #[6,7,8,9,10]
print(x[:7])                 #[1,2,3,4,5,6,7]
print(x[2:7])                #[3,4,5,6,7]
print(x[0:8:2])              #[1,3,5,7]y=x[:]                       #y為x的淺拷貝
z=x                          #z為x的深拷貝
x[0]=11
print(y)                     #[1,2,3,4,5,6,7,8,9,10]
print(z)                     #[11,2,3,4,5,6,7,8,9,10]

淺拷貝是將列表的各個元素的引用依次給新的列表，而深拷貝則是將列表的引用直接賦給新的列表，這就導致對原本的列表進行操作時，淺拷貝出來的列表不會受到影響，而深拷貝出來的列表會和原列表一致。

5.列表常用操作符

==? 用于判斷兩個列表是否相等，只有當對應位置上的元素都相等才返回True
+? ? 用于拼接兩個列表
*? ? ?后面接整數n，用于把原列表重復n次形成新列表，若n小于或等于0則生成空列表
in? ?判斷元素是否在列表內
not in? 判斷元素是否不在列表內

將兩個list相加，需要創建新的 list 對象，從而需要消耗額外的內存，特別是當 list 較大時，盡量不要使用 “+” 來添加list。

6.列表的其他方法

list.count(obj)? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 統計obj元素在list列表中出現多少次
list.index(obj,[start[,end]])? ? ? ? ? ? ? ? ?返回obj元素在list列表里[start:end]范圍內第一次出現的索引值
list.reverse()? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 將列表list里的元素反方向排列，對list直接操作，無返回值
list.sort(key=None,reverse=False)? ? 將列表進行排序。key主要是用來進行比較的元素，只有一個參數，具體的函數的參數就是取自于可迭代對象中，指定可迭代對象中的一個元素來進行排序。reverse排序規則，為True時降序，為False時升序（默認）。

例如：

x=[1,2,3]*4
print(x)                             #[1,2,3,1,2,3,1,2,3,1,2,3]print(x.count(1))                    #計1出現的次數#4print(x.index(2,2,6))                #在下表[2,6]的范圍內檢查2第一次出現的下標#4x.reverse()                          #將x反向排序
print(x)                             #[3,2,1,3,2,1,3,2,1,3,2,1]x.sort()                             #將x排序
print(x)                             #[1,1,1,1,2,2,2,2,3,3,3,3]

II.元組（tuple）

1.定義

與列表類似，不同點在于元組用小括號()將元素綁在一起，元組不可修改。與列表類似，元組也可以用整數進行索引和切片。

2.創建元組

元組可以直接賦值創建，賦值時若有多個元素，可以不加小括號；若只有一個元素，則需要在元素后面加上一個逗號，否則會被認為是其他數據類型
元組可以用內置方法tuple(sub)將可迭代對象對象sub轉化為元組
可以用小括號創建空元組
可以用推導式創建可迭代對象，再轉換成元組

例：

a=(4,5,6)                                 #直接賦值創建元組
print(a,type(a))                          #(4, 5, 6) <class 'tuple'>b=(1,)                                    #單個元素創建元組需要在元素后面加上逗號
c=(1)
d=1,2,3                                   #多個元素時可以不加小括號
print(type(b),type(c),type(d),sep="\n")   #<class 'tuple'>#<class 'int'>#<class 'tuple'>f=tuple(range(1,6))                       #用tuple()方法把range對象轉換為元組
print(f,type(f))                          #(1, 2, 3, 4, 5) <class 'tuple'>g=()                                      #創建空元組
print(g,type(g))                          #() <class 'tuple'>h=tuple((i*3 for i in f))                 #推導式創建可迭代對象，再轉換成元組
print(h,type(h))                          #(3, 6, 9, 12, 15) <class 'tuple'>

?3.元組的更新和刪除

元組有不可更改的性質，因此不能直接給元組的元素賦值，但是只要元組中的元素可更改，那么我們可以直接更改其元素，注意這跟賦值其元素不同。（列表、字典、集合可以改變）

例：

a=(1,2,3,[4,5,6])
a[3][0]=8
print(a,type(a))            #(1, 2, 3, [8, 5, 6]) <class 'tuple'>del a[3][0]
print(a,type(a))            #(1, 2, 3, [5, 6]) <class 'tuple'>

4. 元組常用操作符

元組的常用操作符有「==」，「+」，「*」，「in」，「not in」。用法與列表的操作符相同，此處不作贅述。

5.元組的內置方法

由于元組的不可改變性，元組的內置方法只有count()和index()。用法也與列表的count()和index()相同，此處不作贅述。

6.解壓元組

通過(變量1 , 變量2 , …… , 變量n)=元組 的方式可以將元組中的元素依次付給等號左邊的變量，等號左邊的括號結構要與元組的結構相同（長度、維度）

如果你只想要元組其中幾個元素，用通配符「*」，英文叫 wildcard，在計算機語言中代表一個或多個元素。下例就是把多個元素丟給了 rest 變量。如果你根本不在乎 rest 變量，那么就用通配符「*」加上下劃線「_」。

例：

x=(1,2,'Python',[10.2,6])
(a,b,c,[d,f])=x
print(a,b,c,d,f)                 #1 2 Python 10.2 6y=tuple(range(1,6))
q,w,*rest,r=y
print(q,w,r)                     #1 2 5
print(rest)                      #[3, 4]    rest為一個列表t=1,2,3,4,5
a,b,*_=t
print(a,b)                       # 1 2

III.字符串（str）

1.定義

字符串為用引號之間的字符集合，可以用單引號也可以用雙引號。例如 'Python' ，"S-PLUS"都是字符串。

2.字符串常用轉義字符

由于反斜杠「\」、單引號「'」、雙引號「"」在字符串中有特殊性，因此如果要在字符串中出現這三個符號，需要在前面再加上一個反斜杠。

\\? ? ?反斜杠
\'? ? ?單引號
\"? ? 雙引號
\n? ?換行符
\r? ? 回車符
\t? ? 橫向制表符

若要表示原始字符串則只需在字符串之前加上小字母「r」即可。

三引號允許一個字符串跨多行，字符串中可以包含換行符、制表符以及其他特殊字符。

例：

print("I\nLove\nPython")
#I
#Love
#Pythonprint(r"I\nLove\nPython")
#I\nLove\nPythonpara_str = """這是一個多行字符串的實例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用換行符 [ \n ]。
"""
print(para_str)
# 這是一個多行字符串的實例
# 多行字符串可以使用制表符
# TAB (    )。
# 也可以使用換行符 [
#  ]。

3.字符串的索引和切片

字符串的索引和切片與列表和元組的類似，每一個字符都為字符串的元素，此處不作贅述。

4.字符串的操作符

字符串的操作符也為「==」，「+」，「*」，「in」，「not in」，用法與列表和元組相同。

5.字符串的內置方法

str.capitalize()? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ??返回一個新字符串，將字符串的第一個字符轉換為大寫，其他的轉為小寫
str.lower()? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?返回一個新字符串，轉換字符串中所有大寫字符為小寫
str.upper()? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 返回一個新字符串，轉換字符串中所有大寫字符為大寫
str.swapcase()? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?返回一個新字符串，將字符串中大寫轉換為小寫，小寫轉換為大寫
str.count(str1,beg=0,end=len(str))? ? ? ? ? ? ? ? ? ?統計字符串str1在str的指定范圍(beg,end)出現的次數
str.endswith(suffix, beg=0, end=len(string))? ? 檢查指定范圍內的字符串是否以suffix結束
str.startswith(substr, beg=0,end=len(string))? ?檢查指定范圍內的字符串是由以substr開始
str.find(str1, beg=0, end=len(string))? ? ? ? ? ? ? ?從左查找str1在指定范圍字符串內的位置，返回索引值，若str1不在指定范圍內則返回-1
str.rfind(str, beg=0,end=len(string))? ? ? ? ? ? ? ? ?與find()類似，從右開始查找
str.isnumeric()? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 如果字符串中只包含數字字符，則返回 True，否則返回 False
str.ljust(width[,fillchar=" "])? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?返回一個新字符串，用fillchar擴充原字符串至長度width為止，原字符串向左對齊
str.rjust(width[,fillchar=" "])? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 和ljust()類似，原字符串向右對齊
str.lstrip([chars])? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 刪除字符串左邊的空格或指定字符
str.rstrip([chars])? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 刪除字符串右邊的空格或指定字符
str.strip([chats])? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?執行lstrip()和rstrip()
str.partition(sub)?? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?找到子字符串sub，把字符串分為一個元組('左邊的字符串','sub','右邊的字符串')，如果字符串中不包含sub則返回('原字符串','','')
str.rpartition(sub)? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?與partition()類似，從右邊開始查找
str.replace(old,new[,max])? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?把將字符串中的old替換成new，如果max指定，則替換不超過max次
str.split(str=" ",num)? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?不帶參數默認是以空格為分隔符分開字符串，如果num參數有設置，則僅分隔num個子字符串，返回切片后的子字符串拼接的列表
str.splitlines([keepends])? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?如果字符串按照行('\r', '\r\n', \n')分隔，返回一個包含各行作為元素的列表，如果參數keepends為 False，不包含換行符，如果為 True，則保留換行符
str.maketrans(intab,outtab)? ? ? ? ? ? ? ? ? ? ? ? ? ? 創建字符映射的轉換表，第一個參數是字符串，表示需要轉換的字符，第二個參數也是字符串表示轉換的目標。
str.translate(table,deletechars="")? ? ? ? ? ? ? ? ? 根據參數table給出的表，轉換字符串的字符，要過濾掉的字符放到deletechars參數中。

6.字符串格式化

可以用str.format()格式化方法進行格式化，例如：

str8 = "{0} Love {1}".format('I', 'Lsgogroup')  # 位置參數
print(str8)  # I Love Lsgogroupstr8 = "{a} Love {b}".format(a='I', b='Lsgogroup')  # 關鍵字參數
print(str8)  # I Love Lsgogroupstr8 = "{0} Love {b}".format('I', b='Lsgogroup')  # 位置參數要在關鍵字參數之前
print(str8)  # I Love Lsgogroupstr8 = '{0:.2f}{1}'.format(27.658, 'GB')  # 保留小數點后兩位
print(str8)  # 27.66GB

格式化符號：

符號	描述
%c	格式化字符及其ASCII碼
%s	格式化字符串，用str()方法處理對象
%r	格式化字符串，用rper()方法處理對象
%d	格式化整數
%o	格式化無符號八進制數
%x	格式化無符號十六進制數
%X	格式化無符號十六進制數（大寫）
%f	格式化浮點數字，可指定小數點后的精度
%e	用科學計數法格式化浮點數
%E	作用同%e，用科學計數法格式化浮點數
%g	根據值的大小決定使用%f或%e
%G	作用同%g，根據值的大小決定使用%f或%E

例：

print('%c' % 97)  # a
print('%c %c %c' % (97, 98, 99))  # a b c
print('%d + %d = %d' % (4, 5, 9))  # 4 + 5 = 9
print("我叫 %s 今年 %d 歲!" % ('小明', 10))  # 我叫 小明 今年 10 歲!
print('%o' % 10)  # 12
print('%x' % 10)  # a
print('%X' % 10)  # A
print('%f' % 27.658)  # 27.658000
print('%e' % 27.658)  # 2.765800e+01
print('%E' % 27.658)  # 2.765800E+01
print('%g' % 27.658)  # 27.658
text = "I am %d years old." % 22
print("I said: %s." % text)  # I said: I am 22 years old..
print("I said: %r." % text)  # I said: 'I am 22 years old.'

格式化操作符輔助命令：

符號	功能
m.n	m 是顯示的最小總寬度,n 是小數點后的位數（如果可用的話）
-	用作左對齊
+	在正數前面顯示加號( + )
#	在八進制數前面顯示零('0')，在十六進制前面顯示'0x'或者'0X'(取決于用的是'x'還是'X')
0	顯示的數字前面填充'0'而不是默認的空格

例：

print('%5.1f' % 27.658)  # ' 27.7'
print('%.2e' % 27.658)  # 2.77e+01
print('%10d' % 10)  # '        10'
print('%-10d' % 10)  # '10        '
print('%+d' % 10)  # +10
print('%#o' % 10)  # 0o12
print('%#x' % 108)  # 0x6c
print('%010d' % 5)  # 0000000005

IV.字典（dict）

1.定義

字典是無序的，由大括號綁起來的(key:value)鍵值對集合，語法結構為{key1:value1,key2:value2, …… ,key n:value n}
同一字典內的鍵(key)是不重復的
字典用不可變數據作為鍵，而值沒有這個要求
字典內的排放順序與鍵的放入順序無關
字典的每一個元素為(key:value)鍵值對
冒號用于分開鍵和值

2.創建和索引

字典可以通過直接賦值創建，也可以用推導式創建，還可以用dict()創建一個字典。

dict()內的參數可以是n×2維的列表，列表內的元素為二維的元組，這樣會將元組的兩個元素分別作為鍵值對創建字典

也可以直接用dict(key1=value1,key2=value2, ……)的方式創建字典，但是這樣的字典的鍵只能是字符串

例：

dic={'李寧':'一切皆有可能','耐克':' Just do it','阿迪達斯':'Impossible is nothing'}
print('耐克的口號是:',dic['耐克'])# 耐克的口號是: Just do itb={i:i%2==0 for i in range(10) if i % 3 == 0}    #推導式創建
print(b)
# {0: True, 3: False, 6: True, 9: False}c=dict()                                      #創建空字典
c['a']=1
c['b']=2
print(c)
#  {'a':1 ,'b':2}dic2=dict((('apple', 4139), ('peach', 4127), ('cherry', 4098)))
print(dic2)               # {'peach': 4127, 'cherry': 4098, 'apple': 4139}dic = dict(name='Tom', age=10)
print(dic,type(dic))              # {'name': 'Tom', 'age': 10} <class 'dict'>

字典的索引只能通過鍵來索引，語法結構為dict[key]，返回的是對應鍵的值value，如果索引的鍵不存在，則會報錯。

3.字典的內置方法

dict.fromkeys(seq[,value])? ? ? ? ? ? ? ? ? 用于創建一個新字典，以序列seq中元素做字典的鍵，value為字典所有鍵對應的初始值
dict.keys()? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?返回一個可迭代對象，可以使用 list() 來轉換為列表，列表為字典中的所有鍵
dict.values()? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 與keys()類似，不過返回的內容是所有的值
dict.items()? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 以n×2列表的形式返回可遍歷的 (鍵, 值) 元組數組，列表元素為元組
dict.get(key,default=None)? ? ? ? ? ? ? ? ?與dict[key]類似，返回指定鍵的值，但如果值不在字典中則返回默認值default
dict.setdefault(key,default=None)? ? ? 與get()類似，類似，如果鍵不存在于字典中，將會添加鍵并將值設為默認值
in 和 not in 操作符? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 字典也可以使用in和not in 操作符，不過只能檢查鍵key是否在字典中
dict.pop(key[,default])? ? ? ? ? ? ? ? ? ? ? ? 拋出給定鍵key對應的值，若key不存在，則必須設置默認值default并會返回默認值
del dict[key]? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 刪除字典中給定的鍵所在的元素
dict.popitem()? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?隨機拋出字典中的一個值，若字典為空，則會報錯
dict.clear()? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 刪除字典中的所有元素
dict.copy()? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 返回字典的一個淺拷貝
dict.update(dict2)? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?鍵字典型參數dict2中的元素更新到dict中

V.集合（set）

1.定義

集合與字典相似，由大括號將元素綁在一起，但是集合只保存鍵(key)
由于字典中key不可重復，所以集合中也沒有重復的元素
集合中的元素（即key）為不可變型數據

2.創建

集合可以通過直接賦值創建，也可以用推導式創建，還可以用set(value)函數將可迭代對象轉換成集合，重復元素會被自動過濾。

例：

a={1,2,3,4,4}               #直接賦值創建集合，重復元素自動過濾
print(a,type(a))            #{1, 2, 3, 4} <class 'set'>b={i*2 for i in range(1,11) if i%3==0}     #推導式創建集合
print(b,type(b))                           #{18, 12, 6} <class 'set'>c=set(list(range(5,12)))                   #set()將列表轉化為集合
print(c,type(c))                           #{5, 6, 7, 8, 9, 10, 11} <class 'set'>d=set()                                    #創建空集合只能用set()創建
print(d,type(d))                           #{} <class 'set'>

2.訪問集合中的值

由于集合的無序性，我們不能用索引取得集合中的值，但我們仍然可以用一些方法得到一些值

用針對序列的方法len(set)可以返回集合set的大小，即元素的個數
集合作為可迭代對象也可以用for循環一個個讀取出來

例：

b={i*2 for i in range(1,11) if i%3==0}
print(b)                                   #{18, 12, 6}for j in b:print(j)                               #18#12#6

可以用 in 和 not in 操作符判斷一個元素是否在集合里

3.集合的內置方法

set.add(elmnt)? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 用于給集合添加元素，如果添加的元素在集合中已存在，則不執行任何操作
set.update(set2)? ? ? ? ? ? ? ? ? ? ? ? ? ?與字典的update()方法類似，將集合set2中的元素更新到集合set里
set.remove(item)? ? ? ? ? ? ? ? ? ? ? ? ??用于移除集合中的指定元素。如果元素不存在，則會發生錯誤
set.discard(item)? ? ? ? ? ? ? ? ? ? ? ? ? 與remove()類似，但不會報錯
set.pop()? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 隨機拋出一個元素
set.intersection(set2)? ? ? ? ? ? ? ? ? ?返回set與set2的交集，操作與set & set2 相同
set.intersection_update(set2)? ? ? 將set更新為原set和set2的交集
set.union(set2)? ? ? ? ? ? ? ? ? ? ? ? ? ? ?返回set與set2的并集，操作與set | set2 相同
set.difference(set2)? ? ? ? ? ? ? ? ? ? ? 返回set與set2的差集，操作與set - set2 相同
set.difference_update(set2)? ? ? ? ?將set更新為原set和set2的差集
set.symmetric_difference(set2)? ? 返回set與set2的異或，操作與set ^ set2 相同，也與(set | set2) - (set & set2)相同
set.symmetric_difference_update(set2)? 將set與set2的異或更新到set中
set.issubset(set2)? ? ? ? ? ? ? ? ? ? ? ? ?判斷set是否被set2包圍，操作與set <= set2 相同
set.issuperset(set2)? ? ? ? ? ? ? ? ? ? ? 判斷set是否包圍set2，操作與set >= set2相同
set.isdisjoint(set2)? ? ? ? ? ? ? ? ? ? ? ? ?判斷set與set2是否不相交，不相交則返回True

4.不可變集合（frozenset）

普通的集合是可變的，但是Python提供了實現不可變集合的方法，不可變集合與集合不屬于同一類，不可變集合屬于<frozenset>

不可變集合與普通集合類似，但是不能添加或刪除元素，因此不能用代有update的方法

frozenset([iterable])可以將可迭代對象iterable轉換為不可變集合，如果沒有參數則生成不可變的空集

VI.序列

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

一般的有轉換類型的方法如：list()、tuple()和str()等，此外還有一些通用的方法：

len(s)? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 返回序列類型s的元素個數（長度）
max(sub)? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 返回序列或者參數集合中的最大值，若sub為字符串，則比較ASCII碼值
min(sub)? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?返回序列或者參數集合中的最小值
sum(iterable[,start=0])? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 返回序列（可迭代對象）iterable與可選參數start的總和
sorted(iterable,key=None,reverse=Flase)? ? ? ? ? 對所有可迭代對象iterable進行排序操作，key和reverse參數和前文提到的sort()方法相同
reversed(seq)? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?返回一個反轉的可迭代對象
enumerate(sequence[,start=0])? ? ? ? ? ? ? ? ? ? ? ? ? 將可枚舉的對象（序列）組合為一個索引序列，常用在for循環中
zip(iter1 [,iter2 [...]])? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?將對象中對應的元素打包成一個個元組，然后返回由這些元組組成的對象，這樣做的好處是節約了不少的內存。若不同對象的長度不同，則返回的列表長度與最短的對象相同，用*zip()可以將zip對象解壓