? ? ? ? ? ? ? ? ? ? ? ? ? ? ? Python基礎（三）--序列

1 序列相關的概念

1.1 什么是序列

序列是一種可迭代對象，可以存儲多個數據，并提供數據的訪問。

序列中的數據稱為元素，Python內置的序列類型有：列表（list），元組（tuple），字符串（str），字節（bytes）。

1.2 序列支持的通用操作

（1）索引：通過索引可以訪問序列中指定位置的單個元素

（2）切片：通過切片可以訪問序列中一個區間的多個元素

（3）迭代：因為序列是可迭代對象，所以可以通過for循環進行遍歷

（4）長度：可以通過len函數獲取序列的長度，即序列中含有元素的個數

（5）運算：序列支持+，*，in，not in，比較，布爾運算符等

2 列表

2.1 什么是列表

列表是一種可變的序列類型。能夠存儲多個元素。

2.2 創建列表

定義列表非常簡單，使用一對[]即可。例如：li=[]，也可以定義非空的列表，元素之間使用逗號分隔，如：li = [1,2,3]。也可以使用列表推導式創建列表，在下面介紹。

注意：在Python中，列表中的元素也可以是不同的，如：li = [6.6,8,"people"]

del除了可以刪除變量名，也可以用來刪除列表的元素

del li：刪除整個列表

del li[0]：刪除列表中指定索引的元素

del[0:3]：刪除列表中指定區間的元素

2.3 索引

（1）訪問列表元素

列表定義好后，我們就可以通過索引來訪問列表的元素，訪問的方式為：列表名[索引值]

索引是從0開始編號的，最大索引值為列表的長度- 1，列表（序列）的長度可以通過len函數獲得。

注意：在Python中，列表的索引也支持負值，表示倒數第n個位置。例如：li[-1]表示倒數第一個（最后一個）元素（假設li為列表類型）。列表的有效索引值區間為[-length, length - 1]（length為列表的長度）。如果索引不在有效區間，將會產生錯誤。

列表是可變的序列類型，除了可以通過索引獲取元素的值，也可以改變元素的值。

li1 = [] li2 = [1,2,3] li3 = [6.6,8,"people"] print(li1,li2,li3) # 索引指的就是元素的下標，即元素的序號，從0開始 print(li3[0],li3[2]) # 索引也支持負數，-1代表倒數第1個元素，最后一個元素為-1 print(li3[-1],li3[-2])

（2）列表的遍歷

因為列表有索引，所以可以用while循環遍歷

因為序列是可迭代對象，所以列表可以在for循環中進行遍歷

index = 0 li = [6.6,8,"people"] # while循環遍歷 while index < len(li):print(li[index],end=" ")index += 1 # for循環遍歷 print() for item in li:print(item,end=" ")

（3）列表的嵌套

列表是可以嵌套的，即列表中的元素依然是列表類型。

# 列表嵌套 li = [[1,2,3,4],[5,6,7,8]] for item in li:for i in item:print(i,end=" ")

2.4 切片

切片：用來操作列表（序列）一個區間的元素，語法為：

? ? 列表名[start?:?end?:?step]

start，end與step都是可選的，也可以都是負值。注意切片截取元素的方向。當兩個端點同時存在，與兩個端點缺失一個（或全部缺失），表現的不同。也可以通過切片修改列表的某一區間

# 切片語法：[start:end:step] li = [6,8,12,5,66] print(li[0:2],end=" ") # 步長指定增量值 print(li[0:4:2]) # start,end,step是也可以是負值，如果切片的方向與增量的方向相反，則無法獲取任何元素 print(li[-1:-3],end=" ") print(li[-1:-3:-1],end=" ") print(li[-3:-1]) # 省略start或者end，則此時切片沒有方向，具體沿哪個方向切，取決于增量的方向 print(li[:3],end=" ") print(li[3:],end=" ") print(li[:3:-1],end=" ") print(li[::1]) print("原來的列表：",li) # 通過切片修改對應區間的元素 li[1:3] = [111,222,333] print("修改對應區間后的列表：",li) # 相當于刪除指定區間的元素 li[3:4]=[] print("刪除對應區間后的列表：",li) # 相當于插入元素 li[1:1] = [66,88] print("插入元素后的列表：",li)

2.5 相關方法

方法名	描述
append(obj)	向列表末尾追加指定的元素
insert(index,obj)	第一個參數指定插入的位置（索引），第二個參數指定插入的值
remove(value)	刪除列表中首次出現的元素（參數指定的元素），如果元素不存在會產生錯誤
clear()	清空整個列表，刪除列表中的所有元素
extend(iterable)	將參數指定的列表或可迭代對象中所有的元素，追加到當前列表的尾部
index(value,[start,[stop]])	返回參數指定的元素在當前列表中首次出現的位置，第二個參數可以指定查找的起始點，第三個參數可以指定查找的結束點。如果元素不存在，將會產生錯誤
count(value)	返回參數元素在列表中出現的次數
copy()	對列表進行淺拷貝，返回拷貝后的列表
sort(key=None,reverse=False)	對列表進行排序，默認升序，如果reverse為True，則進行降序排序
reverse()	對列表進行反轉
pop([index])	可以指定索引，刪除并返回指定位置的索引

2.6 列表推導式

列表推導式是一種創建列表的簡潔方式。

當我們需要創建的一個列表中的每個元素都是通過另一個列表或者可迭代對象中的每個元素或者部分元素，經過運算獲得時，簡而言之就是需要創建的列表元素完全依賴于另一個可迭代對象時，就可以考慮使用列表推導式。

列表推導式的語法為：

? ??[表達式 for 更多的for或if]

注意：列表推導式中聲明的變量僅在列表推導式中有效。for循環中的變量會在for循環后繼續有效

# 列表推導式是創建列表的一種簡介方式 # [對item進行的計算（含有item的表達式） for item in 原有的列表] li = [6,8,66,88,100,120] li2 = [item + 1 for item in li] print(li2)

2.6 賦值，淺拷貝與深拷貝

列表的內存存儲：id函數

賦值：沒有復制對象，僅僅是一個別名而言

淺拷貝：切片，列表的copy方法。copy模塊的copy方法。淺拷貝僅僅拷貝當前的對象，對于對象內部所有管關聯的洽談對象則不會進行拷貝

深拷貝：copy模塊的deepcopy方法。深拷貝不僅拷貝當前對象本身，當前對象內部所引用的可變對象，依然會進行遞歸拷貝。

# 賦值 li = [6,8,12] print("原始列表",li) li2 = li li2[0] = 10 print("賦值操作",li) # 淺拷貝 cli = [6,8,12] li3 = cli.copy() li3[0] = 10 # 因為列表元素是常量，不可變，所以不會影響原來的列表 print("淺拷貝1",cli) cli2 = [[1,2],[3,4]] import copy cli3 = copy.copy(cli2) cli3[0][0] = 100 # 因為列表是變量所以會影響到原來的列表 print("淺拷貝2",cli2) # 深拷貝 dli = [6,8,12] li4 = copy.deepcopy(dli) li4[0] = 10 print("深拷貝",dli)

2.7 列表的運算

列表（序列）也是支持部分運算，因為列表可以包含多個元素，相比之前學習的數值類型（僅包含單個值）來說，其計算規則相對復雜一些。

符號	說明
x +?y	連接x與y兩個列表
x * n	將序列重復n次（所有元素重復n次）。
e in?x	如果e在x中，返回True，否則返回False。
e not in y	如果e不在x中，返回True，否則返回False。
x 比較?y	依次比較兩個序列中的元素（>，>=，<，<=，==，!=）。 判斷兩個列表是否為同一個列表（is，is not）。
x 布爾 y	與數值類型的布爾運算（and或or）規則相同（返回兩個列表中的一個）

?

3 元組

3.1 什么是元組

元組是一種不可變的序列。元組一但創建，就無法再進行修改，試圖對元組進行的任何修改均會產生錯誤。

其實元組除了不可變性，元組與列表非常相似，可以近似的認為元組是一種不可變的列表類型

3.2 創建元組

元組使用（）表示，多個元素使用逗號“,”分隔。但是，當元組僅有一個元素時，必須在元素后面加上逗號“,”，否則不是元組類型。

以下情況下元組必須使用（）：①長度為0的元素（空元組）②元組嵌套③元組作為表達式的一部分。但是為了增強可讀性，使用元組時，總是使用（）

3.2 基本操作

# 元素創建, t = (1,) print(type(t)) # 元組的切片與索引 t = (6,7,8,9,10) print(t[0]) print(t[0:2]) print(t[-3:-1]) print(t[::-1]) # 元組的遍歷 for i in t:print(i,end=" ")

3.3 相關方法

因為元組是不可變的序列，因此所有修改序列的方法都不能使用。

方法名	描述
count(value)	?
index(value,[start,[stop]])	?

t = (6,7,8,9,10) print(t.count(6)) print(t.index(8))

3.4 使用元組的意義

元組作為一種不可變序列，可以保證數據在程序運行過程中不會意外由自己或其他人修改（例如在函數參數傳遞中），這樣可以保證數據的完整性。

4 字符串

4.1 字符串的定義

字符串是一種不可變的序列。就是一組字符組成的序列，每個字符就是序列中的一個元素

4.2 基本操作

（1）創建

字符串可以包含零個或多個字符，字符需要使用引號界定。引號可以是：①單引號②雙引號③三引號

引號與雙引號是完全等價的，而三引號可以在字符串內部換行。如果單（雙）引號也需要換行，可以使用續行符“\”，三引號中使用續行符，則不會產生換行。

（2）索引，切片，運算，遍歷等操作

# 單引號與雙引號的區別在于：單引號與雙引號不能換行顯示，但是三引號可以 # 注意：三引號在python中不是多行注釋，是python中的字符串 s = 'aaa' s = "aaa" s = '''aaa''' s = """aaa""" # 如果單引號或雙引號需要換行，可以使用續航符\ s = "abc\def" # 切片與索引 s = "abcdefgh" print(s[6]) print(s[0:6]) # 遍歷 for i in s:print(i,end=" ") # 字符串是不可修改的 # s[0] = "b" 運行會報錯

4.3 相關方法

方法名	描述
count(sub[,start[,end]])	返回參數在字符串中出現的次數，可以指定開始點和結束點，如果沒有指定結束點則一直到字符串的末尾
find/index(sub[,start[,end]])	返回參數在字符串中首次出現的位置（索引），find參數不存在不會報錯返回-1，index參數不存在會報錯
rfind/rindex(sub[,start[,end]])	返回參數在字符串中末尾出現的位置（索引），find參數不存在不會報錯返回-1，index參數不存在會報錯
format(*args,**kwargs)	格式化字符串
join(iterable)	用來拼接可迭代對象中的所有元素，使用調用的str作為分隔符
replace(old.new[,count])	將字符串中第一個參數指定的內容，使用第二個參數進行替換
lstrip/rstrip/strip([chars])	strip默認去除字符串兩端的空白符，可以指定要去掉的字符。lstrip去除字符串左側參數指定的字符，rstrip去除字符串右側參數指定的字符
split/rsplit(sep=None,maxsplit=-1)	split按字符切割，sep為指定的字符。rsplit從右向左切割
splitlines([keepends])	根據換行符進行切割，可通過第一個參數保留換行符，True為保留，默認為False
startswith(prefix[,start[,end]])	判斷字符串是否以指定的字符串進行開頭，是返回True，否則返回False，可以指定開始點和結束點
endwith(sufix[,start[,end]])	判斷字符串是否以指定的字符串進行結尾，是返回True，否則返回False，可以指定開始點和結束點
upper/lower()	upper將字符串轉換成大寫，lower將字符串轉換成小寫
capitalize()	將首字符大寫
partition/rpartition(sep)	返回一個元組，元組含有三個元數。第一個元數為參數之前的內容，第二個元數為參數本身，第三個元數為參數后面的內容
ljust/rjust/center(with[,fillchar])	當字符串長度小于參數（第一個參數）時，進行左對齊調整，默認以空格進行填充，第二個參數可以指定填充符。rjust右對齊，center居中對齊
isalpha()	字符串中的每一個字符都是alpha（字母型字符）中的字符，返回True，否則false
isnumber()	判斷字符串中的每一個字符是否都是數值型字符，是返回True，否則返回False
isdigit()	判斷字符串中的每一個字符是否都是數字型字符，是返回True，否則返回False
isdecimal()	判斷字符串中的每一個字符是否都是十進制字符，是返回True，否則返回False
isdentifier()	判斷字符串是否是合法標識符，是則返回True，否則返回False
islower()/isupper()	islower判斷字符串是否為小寫形式，是則返回True，否則返回False。isupper判斷字符串是否為大寫形式，是則返回True，否則返回False。
isspace()	判斷字符串中每一個字符是否為空白符，是返回True
?	?

5 字節

5.1 字節的定義

bytes是一系列字節組成的序列，是不可改變的。bytes每個元素的值在[0, 255]范圍內（無符號單字節）。

5.2 基本操作

（1）創建字節

bytes常量的創建與字符串相同，只是在字符前使用b或B前綴即可。

（2）相關方法

索引，切片，運算，遍歷等

# 字節類型使用b或B前綴，字節類型使用bytes表示 b = b"abc" print(type(b)) # 注意：字節類型不能含有多字節的字符 # b = b"漢語" 這是錯誤的# 索引與切片 print(b[0]) print(b[0:2]) # 遍歷 for i in b:print(i,end=" ")

5.3 相關方法

與字符串相似，參考字符串中的方法

5.4 字符集與編碼集

（1）字符集

字符集，是一組字符組成的集合。字符集規定了有多少個字符，同時還要定義每個字符映射的那個值。不同字符集含有的個數不一樣，不同字符集映射的碼值不一樣。所謂字符集就是里面定義了一堆字符，同時還定義了映射的法則。常見的字符集有ASCII，BIG5，Unicode，GBK等。字符計算機不能直接存儲，數值的形式才能被二進制保存，那就需要將字符保存為字節的形式才能存儲到計算機里面，這個過程就是編碼

字符集，就是規定了字符與二進制之間如何進行轉換的規則，即編碼與解碼的規則。因此，我們如果對某一個文本文件采用了一種編碼方式保存，在解析該文件內容時，就需要采用相同的編碼方式解碼，否則就很可能造成亂碼的現象，原因就是編碼與解碼的方式不統一造成的。

（2）Unicode字符集與UTF-8

在Python中，字符串str類型使用的字符集是Unicode字符集，是國際組織制定的可以容納世界上所有文字和符號的字符編碼方案。目前Unicode字符集包含1114112個編碼值（0x0?~ 0x10FFFF）。

由于Unicode取值范圍的廣泛性，這可能會對存儲帶來一些問題。對于碼值小的字符，只需要使用1個字節存儲就夠了，但是，對于碼值大的字符，卻需要使用更多的字節去存儲。如果使用定長的方式存儲，這勢必會造成存儲空間的浪費。因此，后來人們創建了UTF-8的編碼方式。UTF-8（8-bit Unicode Transformation Format）是針對Unicode設定的可變長度字符編碼，是對Unicode字符集的一種通用轉換格式。UTF-8編碼使用1 ~ 4個字節來表示Unicode（0x000000?~ 0x10FFFF）區間的值。如下表。

取值	占用空間（字節）
0x000000 ~ 0x00007F	1
0x000080 ~ 0x0007FF	2
0x000800 ~ 0x00FFFF	3
0x010000 ~ 0x1FFFFF	4

Python3默認文件的編碼方式為UTF-8編碼（Python2默認為ASCII）。

（3）str與bytes

str（字符串）與bytes（字節）之間進行轉換。通過調用str的encode方法可以返回字符串編碼之后的結果（bytes類型）。同樣，通過調用bytes類型的decode方法，可以將字節序列解碼，轉換回編碼之前的字符串（str類型）。可以通過bytes與str函數，來實現編碼與解碼的操作。

6 轉義序列

（1）轉義序列

轉義序列：就是使用兩個或更多的字符來表示另外一個字符。即轉義序列中的每個字符都不是其本來的含義，而是組合在一起，表示一個新的含義（字符）。Python的轉義列表如下：

符號	說明
\a	響鈴符
\b	退格符
\f	換頁符
\n	換行符
\r	回車符
\t	水平制表符
\v	垂直制表符
\'	單引號'
\"	雙引號"
\\	反斜杠\
\換行	續行符，不會產生換行
\ooo	可以是1 ~ 3位八進制數值，表示該數值對應的值（bytes類型）或字符（str類型）。
\xhh	\h后接兩位16進制數值，表示十六進制數值對應的值（bytes類型）或字符（str類型）
\N{name}	name為Unicode字符數據庫中定義的名字。僅支持str類型。
\uxxxx	\u后接4位十六進制數值，表示該值（16位）對應的字符。僅支持str類型。
\Uxxxxxxxx	\U后接8位十六進制數值，表示該值（32位）對應的字符。僅支持str類型。

（2）原始字符串

如果在字符串常量前使用r或R前綴，則這樣的字符串稱為原始字符串。在原始字符串中，轉義序列不會發生作用，這樣某些情況下，可能會帶來一定的簡便性。

注意：在原始字符串中，末尾的符號不能是\，如果是\，則需要對\進行轉義\\

7 序列相關函數

Python提供了相應的函數，用于根據已經存在的可迭代對象（序列類型都是可迭代類型）創建新的序列類型，相當于進行了類型轉換。

函數名	描述
list()/list(iterable)	創建空的列表/可迭代對象轉換成列表
tuple()/tuple(iterable)	創建字節對象
str()/str(object)	創建字符串
bytes()/bytes(str)	創建字節
len(obj)	長度
max(iterable, *[, default=obj, key=func]) / max(arg1, arg2, *args, *[, key=func])	可以指定若干個元素，返回所有元素中的最大值
min(iterable, *[, default=obj, key=func]) / min(arg1, arg2, *args, *[, key=func])	可以指定若干個元素，返回所有元素中的最小值
sum(iterable, start=0)	對序列求和，可以指定第二個參數，指定求和前的初始值
chr(i)	根據參數指定的編碼值，返回該編碼值對應的字符
ord(c)	根據參數指定的字符，返回該字符對應的編碼值
sorted(iterable, key=None, reverse=False)	返回一個新的列表，不會修改原有的對象。注意：list的sort方法是就地排序，會修改原有的列表對象

8 遍歷序列

可以使用while，for循環對序列進行遍歷。

enumerate與zip函數用于遍歷。

li = [6,66,8,88] # for循環遍歷比while遍歷簡單，但是在遍歷時會丟失索引 # enumerate在遍歷列表時，可以獲得列表的索引 for index,item in enumerate(li):print(index,item,end="\t") print() # zip用來同時遍歷兩個或更多可迭代對象 people = ["張三","李四","王五"] money = [1000,2000,3000] for p,m in zip(people,money):print(p,m,end="\t")

總結

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

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