所謂序列，指的是一塊可存放多個值的連續內存空間，這些值按一定順序排列，可通過每個值所在位置的索引訪問它們。為了更形象的認識序列，可以將它看做是一家旅店，那么店中的每個房間就如同序列存儲數據的一個個內存空間，每個房間所特有的房間號就相當於索引值。也就是說，通過房間號（索引）我們可以找到這家旅店（序列）中的每個房間（內存空間）。在Python 中，序列類型包括字符串、列表、元組、集合和字典。
(1)通用操作
Python提供了幾個內置函數，可用於實現與序列相關的一些常用操作。如表所示
| 函 數 |
作 用 |
| len() |
計算序列的長度，即返回序列中包含多少個元素。 |
| max() |
找出序列中的最大元素。 |
| min() |
找出序列中的最小元素。 |
| list() |
將序列轉換為列表。 |
| str() |
將序列轉換為字符串。 |
| sum() |
計算元素和。 |
| sorted() |
對元素進行排序。 |
| reversed() |
反向序列中的元素。 |
注意：max()、min()與sum()都需要序列內元素為數字類型，若出現字符串等類型將提示錯誤。通用操作示例如下：
#列表a a=[1,2,3,6,5,4] #輸出列表a的數據類型 #輸出結果<class 'list'> print(type(a)) #輸出列表a的長度 #輸出結果6 print(len(a)) #輸出列表a的最大值 #輸出結果6 print(max(a)) #輸出列表a的最小值 #輸出結果1 print(min(a)) #輸出列表a的所有元素和 #輸出結果21 print(sum(a)) #輸出列表a #輸出結果[1, 2, 3, 6, 5, 4] print(a) #輸出列表a排序結果 #輸出結果[1, 2, 3, 4, 5, 6] print(sorted(a)) #輸出列表a轉化成字符串類型 #輸出結果<class 'str'> print(type(str(a)))
(1)列表（list）
列表是最常用的Python數據類型，它可以作為一個方括號內的逗號分隔值出現。列表的數據項不需要具有相同的類型創建一個列表，只要把逗號分隔的不同的數據項使用方括號括起來即可。如下所示：
#空數據 list_a=[] #以數字為元素 list_b=[1,2,3] #以字符為元素 list_c=["a","b","c"] #多種數據類型混合 list_d=[1,2,"a","b",{},list_a] #通過list函數來創建列表 list_e=list()
集合常見的訪問方式一為通過下標（索引）訪問，列表的元素以0開始按順序排放安置，可直接通過下標來訪問列表，格式為：list_name[i]。另一方法為切片方式訪問，方法為：list_name[start : end : step]，其中start為起始下標、end為終止下標、step為步長。
舉例說明如下圖所示：
上圖所示為列表隨意創建列表list_a的示意圖，訪問下標有兩種情況，一種為正序訪問，此時下標為從零開始到列表結束，另一種為倒序訪問，以列表最后一個元素為-1開始，到列表第一個元素為止。良好總下標訪問結果是等效的，比如說訪問元素“a”，可以采用list_[3]與list_a[-7]是等效的。另外由於列表元素可以為其他序列，比如[1,2]就是以一個列表作為元素，若訪問元素列表中的元素就需要在原有的基礎上再次訪問，格式為：list_name[i][j]。
列表另一種方法切片訪問，原理為選取從開頭下標到結尾下標中步長為單位的元素作為一個整體來提取。以從元素2到元素7步長為2來簡單理解這一過程，首先找到下標為2的元素，然后開始截取直到下標7的元素截止，步長為2則以兩個元素作為一組，然后以每一組元素的第一個為整體輸出。例子中下標2為2.2、下標7為元素{}期間共有6個元素，以2個元素為一組的方式可以分為三組，然后每一組的第一個作為一個整體，訪問如下所示：
list_x=[] list_a=[1,5,2.2,"a","s",[],[1,2],{},{1,2},list_x] print(list_a[2:7:2]) #運行結果： [2.2, 's', [1, 2]]
示意圖如下圖2.5所示：
列表的操作函數如下表所示：
| 功能 |
函數 |
描述 |
| 添加元素 |
list_name.append(obj) |
obj表示添加到列表末尾的數據，它可以是單個元素，也可以是列表、元組等。 |
| list_name.extend(obj) |
obj表示添加到列表末尾的數據， |
|
| list_name.insert(index,obj) |
index表示插入位置，obj表示添加元素，可以指定添加位置的函數。 |
|
| 刪除元素 |
list_name.pop(index) |
index表示刪除元素位置，函數可以刪除指定位置的元素，之后的元素將會補充到刪除的位置。 |
| list_name.remove(obj) |
obj表示刪除元素的值必須保證該元素是存在的，否則會引發 ValueError 錯誤。 |
|
| list_name.clear() |
刪除列表的所有元素，也即清空列表， |
|
| 查找元素 |
list_name.index(obj,start, end) |
ndex() 方法用來查找某個元素在列表中出現的位置（也就是索引），如果該元素不存在，則會導致 ValueError 錯誤。 |
| list_name.count(obj) |
count()方法用來統計某個元素在列表中出現的次數 |
添加元素就是在指定位置添加指定元素，位置一般默認為最后一位，若需要強調位置則需要使用insert()函數。末尾添加元素的兩個函數一定程度上是等效的，兩者的區別主要體現在添加元素為序列的時候，append()函數添加序列是將序列作為一整個元素添加到列表末尾，而extend()函數則是將序列拆開，將序列的元素拼接進去，3種添加方式實例如下：
list_add=[1,2,3] #顯示結果：[1, 2, 3] print(list_add) list_add.append([1,2]) #顯示結果：[1, 2, 3, [1, 2]] print(list_add) list_add.extend([1,2]) #顯示結果：[1, 2, 3, [1, 2], 1, 2] print(list_add) list_add.insert(2,"a") #顯示結果：[1, 2, 'a', 3, [1, 2], 1, 2] print(list_add)
刪除元素除了列表中的3中函數外還可以使用關鍵詞del，使用方法為：del list_name[i]，而且通過關鍵字刪除可以和訪問一樣，可以通過切片方式刪除實例如下所示：
list_delate=[0,1,2,3,4,5,6] #操作為：顯示列表 #輸出結果：[0, 1, 2, 3, 4, 5, 6] print(list_delate) #操作為：刪除列表中下標為1的元素 #輸出結果：[0, 2, 3, 4, 5, 6] del list_delate[1] print(list_delate) #操作為：刪除下標為0到2的元素 #輸出結果：[3, 4, 5, 6] del list_delate[0:2] print(list_delate) #操作為：刪除下標為3的元素 #輸出結果：[3, 4, 5] list_delate.pop(3) print(list_delate) #操作為：刪除值等於3的元素 #輸出結果：[4, 5] list_delate.remove(3) print(list_delate) #操作為：清空列表 #輸出結果：[] list_delate.clear() print(list_delate)
修改列表操作為對原有列表進行再賦值操作，先訪問數據然后再重新賦值即可，示例如下：
list_change=[0,1,2,3,4] #顯示結果：[0, 1, 2, 3, 4] print(list_change) #修改下標為3的元素，值為5 list_change[3]=5 #顯示結果：[0, 1, 2, 5, 4] print(list_change)
查找列表元素方法，index()為查找指定內容的索引,也就是提供該元素的下標，當一個列表中出現多個相同的元素，則只返回第一個元素的下標，若未有指定元素則報錯。而count()函數則是查詢指定元素在列表中出現次數。所以一般兩個函數一起用。示例如下：
list_find=[1,2,3,4,1] #列表中有2個元素1，返回結果 print(list_find.count(1)) #列表中第一個元素1在下標為0的位置上，返回結果為0 print(list_find.index(1))
(2)元組（typle）
元組（tuple）是 Python 中另一個重要的序列結構，和列表類似，元組也是由一系列按特定順序排序的元素組成。元組和列表的不同之處在於操作上，列表是可變的、可以進行添加修改等操作的，而元組元組是不可變序列，一旦被創建元素就不可更改了。從存儲內容上看，元組可以存儲整數、實數、字符串、列表、元組等任何類型的數據，並且在同一個元組中，元素的類型可以不同。
元組的創建為小括號（（）），元素以逗號（，）作為分隔。也可以使用函數tuple()來創建，示例如下：
tuple_a=(1,2,3,4) tuple_b=("a","b,","c") tuple_c=(1,2,"a",[],()) tuple_d=tuple() tuple_e=("abcde") print(type(tuple_e)) tuple_f=("abcde",) print(type(tuple_f)) #運行結果 <class 'str'> <class 'tuple'>
這里注意，創建元組tuple_e的時候發現當元組只含有一個元素，而且元素為字符串的時候，創建方式與創建字符串變量時相同，所以為了方便區分，在之后加一個逗號以表元組類型的意思，如tuple_f的形式。
元組的訪問同列表所示，通過下標訪問和奇瑞片訪問，格式：tuple_nam[i]與tuple_nam[start，end，step]。
元組屬於不可變序列，所以一旦需要變動，思路就是創建新的元組，接收舊的元組和需要改動的變化。而元組的刪除則通過關鍵詞del。
(3)字典（dict）
列表中查找是通過整數的索引（元素在列表中的序號）來實現查找功能。但很多應用程序需要更加靈活的查找方式，即表示索引的鍵和對應的值組成。比如說：通過“用戶名”查找“手機號”，通過“學號”查找“學院班級”等等。通過任意鍵信息查找一組數據中值信息的過程叫“映射”，在Python語言中，通過字典來實現映射。字典（dict）是一種無序的、可變的序列，它的元素以“鍵值對（key-value）”的形式存儲。簡單理解為，字典為處理信息與信息相對應映射關系的組合數據類型。
列表、元組通常會將索引值0對應的元素稱為第一個元素，而字典中的元素是無序的。字典中，不支持同一個鍵出現多次，否則只會保留最后一個鍵值對。注意字典中的值是不可變的，只能使用數字、字符串或者元組，不能使用列表。
字典類型的創建由於字典中每個元素都包含兩部分，分別是鍵（key）和值（value），因此在創建字典時，鍵和值之間使用冒號（：）分隔，相鄰元素之間使用逗號（，）分隔，所有元素放在大括號{}中。同樣也可以使用指定函數fromkeys()來創建，使用方法為：dictname = dict.fromkeys(list，value=None)，其中，list 參數表示字典中所有鍵的列表（list）；value 參數表示默認值，如果不寫則為空值None。或者采用函數dict()函數創建字典。以下三種創建方式是等效的。創建代碼如下所示：
dict_a={"a":1,"b":1}
print(dict_a)
key_b=["a","b"]
dict_b=dict.fromkeys(key_b,1)
print(dict_b)
key_c=["a","b"]
value_c=[1,1]
dict_c=dict(zip(key_c,value_c))
print(dict_c)
字典訪問如同其他序列一樣，可以通過下標來訪問，但是注意下標並非是數字而是鍵，格式：dict_name[key]，dictname 表示字典變量的名字，key 表示鍵名。注意，鍵必須是存在的，否則會拋出異常。除了上面這種方式外，Python 更推薦使用dict類型提供的get()方法來獲取指定鍵對應的值。當指定的鍵不存在時，get() 方法不會拋出異常。get() 方法的語法格式為：dict_name.get(key[,default])其中，key 表示指定的鍵；default用於指定要查詢的鍵不存在時，此方法返回的默認值，默認會返回None。示例如下：
dict_a={"a":1,"b":1}
print(dict_a["a"])
print(dict_a.get("b"))
字典類型進行添加過程為對元素進行賦值，格式：dict_name[key] = value，實例如下：
d={"中國":"北京","美國":"華盛頓"}
d["法國"]="巴黎"
print(d)
#結果：{'中國': '北京', '美國': '華盛頓', '法國': '巴黎'}
這里需要注意一點，字典和集合都具有無序性，所以返回結果可能和輸入順序有所差別，字典類型主要結構為 ：鍵對應值，所以只要做到鍵值對一一對應即可。
字典的修改與添加操作無異，訪問對象直接修改。列舉字典常見操作如表所示：
| 函 數 |
作 用 |
| keys() |
函數作用為返回所有“鍵”信息 |
| values() |
與keys()函數作用相似，作用為返回字典的值信息 |
| items() |
作用為返回字典所有的鍵值對 |
| get(<key>,<default>) |
返回指定鍵或者值 |
| pop(<key>,<default>) |
判斷鍵是否有對應的值，有則刪除 |
| popitem() |
隨機從字典中選取一個鍵值對,刪除 |
| clear() |
作用為刪除所有的鍵值對,也就是清空字典內部所有數據 |
| del<d>[<key>] |
操作為傳入鍵,刪除對應的鍵值對. |
| <key>in<d> |
屬於判斷函數，若鍵在字典中為則返回true 否則返回false |
| copy() |
返回一個字典的拷貝，也即返回一個具有相同鍵值對的新字典 |
| update() |
可以使用一個字典所包含的鍵值對來更新己有的字典 |
注意：1.items()與直接打印字典有所不同，items()返回以鍵值對為單位的原則，而字典則為呈現。2.get()與pop()函數不同體現在是否存在鍵值對，若指定鍵值對存在get()函數將會返回而pop()函數將會刪除，若無對應鍵值對則報錯返回異常。3.注意，copy()方法所遵循的拷貝原理，字典采用深拷貝而列表等所使用的為淺拷貝4.在執行 update() 方法時，如果被更新的字典中己包含對應的鍵值對，那么原 value 會被覆蓋；如果被更新的字典中不包含對應的鍵值對，則該鍵值對被添加進去。5.其實，說 popitem() 隨機刪除字典中的一個鍵值對是不准確的，雖然字典是一種無須的列表，但鍵值對在底層也是有存儲順序的，popitem() 總是彈出底層中的最后一個 key-value，這和列表的 pop() 方法類似，都實現了數據結構中“出棧”的操作。
實戰演練效果、代碼如下所示：
#創建字典a dict_a={"中國":"北京","美國":"華盛頓"} #添加新元素 dict_a["法國"]="巴黎" #操作：顯示字典a的鍵 #顯示結果:dict_keys(['中國', '美國', '法國']) print(dict_a.keys()) #操作：顯示字典a的值 #顯示結果:dict_values(['北京', '華盛頓', '巴黎']) print(dict_a.values()) ##操作：顯示字典a的鍵值對 #顯示結果1:dict_items([('中國', '北京'), ('美國', '華盛頓'), ('法國', '巴黎')]) #顯示結果2:{'中國': '北京', '美國': '華盛頓', '法國': '巴黎'} print(dict_a.items()) print(dict_a) #操作：顯示字典a中法國對應的值 #顯示結果1:巴黎 print(dict_a.get("法國")) ##操作：顯示字典a中法國對應的值並刪除 #顯示結果1:巴黎 #顯示結果2:{'中國': '北京', '美國': '華盛頓'} print(dict_a.pop("法國")) print(dict_a) ##操作：拷貝字典a #顯示結果:{'中國': '北京', '美國': '華盛頓'} dict_b=dict_a.copy() print(dict_b) ##操作：刪除美國的鍵值對 #顯示結果:{'中國': '北京'} del dict_a["美國"] print(dict_a) ##操作：清空字典a #顯示結果:None print(dict_a.clear())
(4)集合（set）
Python 中的集合，和數學中的集合概念一樣，用來保存不重復的元素，即集合中的元素都是唯一的，互不相同。從形式上看和字典類似，從內容上看，同一集合中只能存儲不可變的數據類型，包括整形、浮點型、字符串、元組，無法存儲列表、字典、集合這些可變的數據類型，否則 Python 解釋器會拋出 TypeError 錯誤。
Python的創建集合方式為將所有元素放在一對大括號（{}）中，相鄰元素之間用（，）分隔。另一種方式則是通過內置函數set()，set()函數為Python的內置函數，其功能是將字符串、列表、元組、range 對象等可迭代對象轉換成集合。由於集合與字典均為無序，而集合不像是字典一樣有鍵值對，所以訪問只能通過循環來遍歷。
集合常見操作如下所示
| 函 數 |
作 用 |
| setname.add(element) |
向集合中添加元素 |
| setname.remove(element) |
刪除集合中的元素 |
| & |
交集、取兩個集合的共有元素 |
| | |
並集、取兩集合全部的元素 |
| - |
差、取一個集合中另一集合沒有的元素 |
| ^ |
對稱差集、取集合 A 和 B 中不屬於 A&B 的元素 |
| setname.copy() |
復制 |
示例如下：
set_1={1,2,3,4}
set_2={1,3,5,7}
#操作：向集合1中添加元素x
#結果：{1, 2, 3, 4, 'x'}
set_1.add("x")
print(set_1)
#操作：向集合2中刪除元素7
#結果：{1, 3, 5}
set_2.remove(7)
print(set_2)
#操作：顯示集合1與集合2的交集
#結果：{1, 3}
print(set_1&set_2)
#操作：顯示集合1與集合2的並集
#結果：{1, 2, 3, 4, 5, 'x'}
print(set_1|set_2)
#操作：顯示集合1與集合2的差
#結果：{2, 4, 'x'}
print(set_1-set_2)
#操作：顯示集合1與集合2的對稱差集
#結果：{2, 4, 5, 'x'}
print(set_1^set_2)
#操作：復制拷貝集合1
#結果：{1, 2, 3, 4, 'x'}
set_3=set_1.copy()
print(set_3)