Python 3 學習筆記：序列

序列

索引

序列是一塊用于放置多個值得連續存儲空間，并且按特定順序排列，每個值（稱為元素）都分配一個整數（由左至右則從 0 開始；由右至左則從 -1 開始），稱為索引（index）或位置，如下所示：

可以根據索引獲取每個元素實際的值

string = "飛流直下三千尺，疑是銀河落九天。"
print(string[5])
復制
則上面的語句的運行結果為“千”。

切片

切片是訪問序列中元素的另一種方法，該方法可以訪問一定范圍內的元素。

1
sequence[startIndex : endIndex : step]
復制
如果 startIndex 未指定，則默認從 0 開始；如果 endIndex 未指定，則默認一直到最后才結束切片；如果 step 未指定，則默認為 1，且其前面的冒號可以省略。

序列相加

在 Python 中支持將多個相同類型的序列相加（或者說拼接更準確），該操作只是單純的將序列拼接在一起，而不進行其他附加的任何運算。

seq_1 = "飛流直下三千尺，"
seq_2 = "疑是銀河落九天。"
print(seq_1 + seq_2)
復制
當然，拼接之后實際上就是得到了一個新的序列，其索引將會重新排序。

序列相乘

數學意義上的乘法就是將一個數重復相加若干次之后得到一個結果，序列的乘法同樣如此，也是將一個序列重復拼接若干次之后得到一個新的序列。

1
2
sequence = "Hello, Python !"
print(sequence * 3)
復制
in

in 關鍵字用于檢查某個元素是否在被檢測的序列中，

1
element in sequence
復制
在 in 的前面加上 not 關鍵字，則表示檢查某個元素是否不在被檢測的序列中，

1
element not in sequence
復制
如果滿足以上兩種操作，則返回 True，否則返回 False。

len()

len() 方法用于計算序列的長度，即序列中元素的個數，

1
len(sequence)
復制
max()

max() 方法用于計算序列中元素的最大值

1
max(sequence)
復制
我們知道數字可以比較大小，那么序列（如字符串、列表等）是如何比較大小的呢？序列在比較大小的時候，會先將元素按照 ASCII 碼表轉換成數字，然后再進行比較，這樣就可以得出最大值或者最小值了，如：

1
2
seq = "Hello, Python!"
print(max(seq))
復制
得到的結果是小寫字母 y 。

max() 函數會先將 seq 的所有元素（每個字母、標點）轉換成 ASCII碼值，然后取出碼值最大的元素打印出來。我們常用的字符，如數字、字母等，在 ASCII 碼表中的碼值大小依次是 數字<大寫字母<小寫字母。當然，ASCII 碼表中不只包含數字、字母，其中還有許多標點符號、特殊符號（具體碼表請自行查找）。

當然，如果我們想驗證 max() 函數得到的結果是否正確，可以使用 ord() 函數獲取 seq 中每個元素的 ASCII 碼值，

seq = "Hello, Python!"
lst = []

for n in range(len(seq)):
lst.append(ord(seq[n]))

print(lst)
復制
得到的結果是 [72, 101, 108, 108, 111, 44, 32, 80, 121, 116, 104, 111, 110, 33]，從中可以看出最大值是 121，然后我們再用 chr() 函數看看 ASCII 碼值 121 對應的字符是什么，

1
print(chr(121))
復制
得到的結果也是小寫字母 y 。

min()

min() 函數用于計算序列中元素的最小值，原理同 max() 函數一樣。

字符串

字符串就是連續的字符序列，可以是計算機能夠表示的所有字符的集合。

字符串不可變，在 Python 編程中，因為沒有設置字符（char）類型，所以字符串通常使用引號（包括單引號、雙引號、三引號）括起來，這三種引號沒有本質上的差別，只是單引號、雙引號中的內容必須在同一行，而三引號可以在連續的多行上。

常用操作

拼接字符串

使用 “+” 運算符可以將多個字符串拼接在一起，從而生成一個字符串。

重復字符串

使用 ”*“ 運算符可以重復字符串，類似數字的乘法。

計算字符串的長度

使用 len() 函數可以獲取字符串中字符的個數，

1
len(string)
復制
其中，string 表示要統計長度的字符串。

en() 函數在計算字符串長度時，不區分符號、數字、英文和漢字，所有字符均按一個字符進行計算。

但是，根據編碼方式的不同，字符所占的字節數也不同（這里主要針對漢字，如采用 GBK/GB2312 編碼，漢字占 2 個字節；而如果采用 UTF-8/unicode 編碼，則漢字占 3 或 4 個字節。在 Python 編程中，數字、英文、符號、下劃線和空格均占一個字節）。所以，如果需要取得字符串實際所占的字節數，就需要通過 encode() 方法指定編碼格式，例如：

print(len("提放有度，自在為人；保持前進，以致更好！".encode("utf-8")))

print(len("提放有度，自在為人；保持前進，以致更好！".encode("gbk")))
復制
根據運行結果可以看出，同一句話，采用 UTF-8 編碼方式每個漢字字符占 3 個字節，而如果采用 GBK 編碼方式則每個漢字字符占 2 個字節。

截取字符串

截取字符串采用切片的方式實現，

1
string[startIndex : endIndex : step]
復制
分割 & 合并字符串

分割字符串
把字符串按照指定的分隔符分成字符串列表，該列表中的元素不包含分隔符，

1
string.split(symbol, maxsplit)
復制
其中，symbol 表示分隔符；maxsplit 表示分割次數，如果不指定則不限制次數。

1
print("提放有度，自在為人，保持前進，以致更好".split("，"))
復制
合并字符串
合并字符串正好與分割相反，是將多個字符串采用固定的分隔符連接在一起，

1
string = symbol.join(sequence)
復制
例如，

1
2
3
list = ["小明", "小紅", "小剛"]
string = "@".join(list)
print(string)
復制
檢索字符串

在 Python 中提供多種語句查找指定字符串的方法。

count()
該方法用于檢索指定字符串在另一個字符串中出現的次數，如果不存在則返回 0，否則返回出現的次數，

1
string.count(substring, startIndex, endIndex)
復制
string 表示被被查找的字符串；substring 表示查找的子串；startIndex 表示起始位置的索引，默認為零；endIndex 表示結束位置的索引，默認為最后一個字符的索引。

1
print(["小明", "小紅", "小剛"].count("小紅"))
復制
find()
該方法用于檢測是否包含指定的子字符串，如果不存在則返回 -1，否則返回首次出現該子字符串的索引，

1
string.find(substring, startIndex, endIndex)
復制
例如，

1
print("小明和小剛一起去小紅家里做客".find("小紅"))
復制
in
該關鍵字用于判斷子字符串是否在目標字符串中存在，是則返回 True，否則返回 False，

1
substring in string
復制
例如，

if "小紅" in ["小明", "小紅", "小剛"]:
print("TRUE")
else:
print("FALSE")
復制
index()
index() 和 find() 方法類似，也是用于檢測目標字符串是否包含指定的子字符串，但是使用 index() 方法檢測時，如果不存在則會拋出異常，

1
string.index(substring, startIndex, endIndex)
復制
例如，

1
print(["小明", "小紅", "小剛"].index("小紅"))
復制
startswith()
該方法檢測目標字符串是否以指定的子字符串開頭，如果是則返回 True，否則返回 False，

1
string.startswith(substring, startIndex, endIndex)
復制
例如，

1
print("小紅邀請小明和小剛來家里做客".startswith("小紅"))
復制
endswith()
該方法檢測目標字符串是否以指定的子字符串結尾，如果是則返回 True，否則返回 False,

1
string.endswith(substring, startIndex, endIndex)
復制
字母大小寫轉換

lower()
該方法用于將字符串中的大寫字母轉換為小寫字母。

1
string.lower()
復制
upper()
該方法用于將字符串中的小寫字母轉換為大寫字母。

1
string.upper()
復制
去除空格 & 特殊字符

strip()
該方法用于去除字符串左、右兩側的空格（包括空格、制表符、回車符、換行符等）和特殊字符,

1
string.strip(symbol)
復制
lstrip()
該方法用于去掉字符串左側的空格和特殊字符

1
string.lstrip(symbol)
復制
rstrip()
該方法用于去掉字符串右側的空格和特殊字符

1
string.rstrip(symbol)
復制
格式化字符串

格式化字符串是指先制定一個模版，在這個模版中預留幾個空位，然后再根據需要填上相應的內容。這些空位需要通過指定的符號標記（即占位符），而這些符號還不會顯示出來。

使用 % 操作符
1
"%[-][+][0][m][.n][symbol]" % strTuple
復制
這種方式是 Python 早期提供的方法，自從 Python 2.6 開始，字符串提供了 format() 方法對字符串進行格式化（目前比較推薦這種方式進行格式化字符串），所以這里就不過多學習了。

format() 方法
基本語法如下，

1
stringTemplate.format(args)
復制
stringTemplate 用于指定字符串的顯示樣式，即模版；args 用于指定替換模版中占位符的實際內容，多個項之間使用逗號分隔。

創建模版時，需要使用大括號和冒號指定占位符，語法如下，

1
{index:[fill][align][sign][#][width][.precsion][type]}
復制

其中，type 的類型如下：

列表

由一系列按特定順序排列的元素組成，這些元素的類型可以是 Python 中的任何數據類型。列表是 Python 中內置的可變序列，在形式上，是將其所有元素放在中括號（[]）中，兩個相鄰的元素使用逗號（,）分隔。列表中的元素可以是不同的數據類型，元素與元素之間互相獨立，互不干擾。

創建列表

只需要給列表指定一個標識符，然后將其元素放入其中即可：

1
list = ["hello", "python", 2019, 7, 31]
復制
當然，在實際編程過程中，我們也可以先創建一個空列表，然后再需要的時候，在其中放入元素，

1
list = []
復制
刪除列表

當我們不在需要某個列表的時候，只需要使用 del 語句即可刪除：

1
del list
復制
訪問列表元素

因為列表也是序列的一種，所以也可以使用索引、切片的方式獲取列表中的元素。

操作列表元素

添加元素

可以使用 append() 方法向列表的結尾處追加一個元素，

1
list.append(element)
復制
該方法只能向列表的結尾處追加元素，如果想要向列表的中間插入一個元素，可以使用如下方法，

1
list.insert(index, element)
復制
insert() 方法會向指定的索引處插入一個元素，原位置的元素及其以后的元素會自動向后退一位，即其原索引加一。

上面的兩種方法都是想列表中添加一個單一的元素，如果想要向一個列表中添加另一個列表，則可以使用如下方法，

1
list.extend(sequence)
復制
該方法會將 sequence 中的元素按原順序依次追加到 list 的結尾處。

示例代碼：

list = ["hello", "python"]

append() 方法

list.append(2019)
print(list)

insert() 方法

list.insert(2, "world")
print(list)

extend() 方法

sequ = ["天下", "興亡"]
list.extend(sequ)
print(list)
復制
修改元素

通過索引定位到要修改的元素，然后直接給其賦值即可，

1
list[index] = newValue
復制
刪除元素

通過索引刪除
和修改元素相似，定位要刪除的元素的索引，然后使用 del 關鍵字刪除即可，

1
del list[index]
復制
根據元素的值刪除
使用列表的 remove() 方法實現，

1
list.remove(elementValue)
復制
對列表進行統計與計算

獲取某個元素出現的次數
使用列表的 count() 方法可以獲取列表中某個元素的個數，

1
list.count(element)
復制
獲取某個元素首次出現的索引
通過列表的 index() 方法可以獲取指定元素在該列表中第一次出現的索引，

1
list.index(element)
復制
求純數字列表中元素的和
如果一個列表的元素全部是數字，則可以使用列表的 sum() 方法求其全部元素的和，

1
sum(list, addend)
復制
其中，addend 為可選參數，默認值 0，如果指定則在列表元素之和的基礎上再加上 addend ，如：

list = [1, 2, 3, 4, 5, 6, 7, 8, 9]

print(sum(list))
print(sum(list, 3))
復制
列表元素排序

sort() 方法
該方法用于將列表中的元素按指定方式排序，排序后元素的索引將會改變，

1
list.sort(key=None, reverse=False)
復制
key 用于指定從每個元素中提取一個用于比較的鍵；reverse 默認為 False，表示升序排列，如果為 True 則降序排列。

sort() 方法沒有返回值，所以只能對列表排序后，輸出該列表，

list = ["hello", "Python", "world", "Welcome", "list"]

list.sort()
print(list)
復制
對全部元素均為數字的列表排序很簡單，如果是對字符串元素進行排序，則先對大寫字母排序，然后再對小寫字母進行排序。如果想不區分大小寫排序，需要指定 key 參數的值，如 key=str.lower 。

而且，需要注意如果一個列表中的元素既有數字，又有字符串，則無法使用 sort() 方法進行排序。

sorted() 函數
在 Python 中，提供了一個內置的 sorted() 函數，用于對列表進行排序，該方法返回一個排序后的列表，而原列表保持不變，

1
new_list = sorted(old_list, key=None, reverse=False)
復制
其中，參數 key 和 reverse 的作用和 sort() 方法的參數一樣，例如：

old_list = ["hello", "Python", "world", "Welcome", "list"]

new_list = sorted(old_list, key=str.lower, reverse=True)
print(new_list)
復制
元組

元組與列表相似，也是有一系列按特定順序排列的元素（可以是 Python 中的任意數據類型）組成，但元組是不可變序列，即不能向元組中追加、刪除元素。在形式上，元組的所有元素被放入一對小括號中，兩個相鄰的元素使用逗號分隔，元素之間沒有任何關系。由于元組的不可變特性，所以元組一般用于保存程序中不可修改的內容。

創建元組

只需要給元組指定一個標識符，然后在其中填充元素即可，

1
tuple = ("hello", "python", 2019, 7, 31)
復制
我們也可以創建一個空元組，

1
tuple = ()
復制
在 Python 中，元組也不是一定就會使用小括號括起來，只要將一組元素使用逗號分隔開來，Python 就可以視其為元組，

1
tuple = "hello", "python", 2019, 7, 31
復制
當我們使用 print() 函數打印該元組時，這些元素將會被小括號括起來。

如果創建一個只有一個元素的元組，則需要在元素后面加一個逗號，否則該元組將會被視為一個字符串，或者其他數據類型。

刪除元組

因為元組已經創建就不可再改變，所有只能刪除元組，而不能刪除其中的元素，

1
del tuple
復制
訪問元組元素

元素也是一種序列，所以也可以使用索引、切片的方式訪問其中的元素。

元組與列表的區別

列表屬于可變序列，其元素可以被修改或刪除；而元組不能，只能整體替換
元組比列表的訪問和處理速度快
元組可以作為字典的鍵，而列表不可以
字典

在 Python 中，字典也是可變序列，但是字典沒有索引，而是以 鍵-值 對的形式存儲數據。字典具有一下特征;

通過 鍵 而不是索引來讀取
字典是任意對象的無需集合
字典是可變的，并且可以任意嵌套
字典的 鍵 必須是唯一的
字典的 鍵 必須不可變
創建字典

定義字典時，每個元素都包含兩個部分 鍵 和 值 ，它們之間使用冒號分隔，組成一個元素，元素和元素之間使用逗號分隔，

1
dictionary = {key_1:value_1, key_2:value_2, ..., key_n:value_n}
復制
元組中每個元素的 鍵 必須是唯一的、不可變的，可以是數字、字符串或者元組。元素的 值 可以是 Python 中的任何數據類型，且可以不是唯一的。

除了直接創建字典，也可以通過 dict() 和 zip() 函數將列表、元組組合成一個字典，

1
dictionary = dict(zip(tuple, list))
復制
如果 tuple 和 list 的長度不同，則以短的為基準創建相同長度的字典。

刪除字典

刪除字典同樣可以使用 del 關鍵字，

1
del dictionary
復制
如果不想刪除字典，而只是想刪除其中的全部元素，則可以使用 clear() 方法，

1
dictionary.clear()
復制
訪問字典元素

因為字典不像列表、元組一樣具有索引，所以不能通過索引、切片的方式訪問其元素。字典只能通過 鍵 訪問其對應的 值。

操作字典元素

添加元素

字典同列表一樣是可變序列，所以可以向其中添加元素，只需要指定元素的鍵和值即可，

1
dictionary[key] = value
復制
只要新加入的 key 在字典中已存在的鍵中不存在即可。

修改元素

修改字典的元素其實就是變相的添加元素，只需要 key 值在字典中已存在，就會將其對應的 value 替換成新的值。

刪除元素

刪除字典中的元素同樣可以使用 del 關鍵字，

1
del dictionary[key]
復制
將字典元素的 key 刪除，其對應的 value 也會被刪除，則這個元素在字典中就不存在了。

集合

Python 中的集合和數學中的集合相似，也是用于保存不重復元素的，有可變集合和不可變集合兩種。在形式上，集合中的元素之間用逗號分隔，所有元素被放在大括號中。集合最好的應用就是去除重復元素，因為集合中的每個元素都是唯一的。

創建集合

直接將所有元素放入括號中，然后給定一個標識符即可，

1
set = {element_1, element_2, ..., element_n}
復制
如果創建集合的時候，不小心輸入了若干個重復的元素，Python 會自動只保留一個。

我們也可以使用 set() 函數將列表、元組轉換成集合，

1
set = set(list/tuple)
復制
如果我們想創建一個空集合，也只能使用 set() 方法，而不使用空的大括號（因為空的大括號表示一個空字典）。

刪除集合

集合同樣可以使用 del 關鍵字刪除，

1
del set
復制
操作結合

添加元素

可以使用 add() 方法向集合中添加元素，

1
set.add(element)
復制
刪除元素

可以使用 pop() 或 remove() 方法刪除集合中的元素，或者使用 clear() 方法清空集合中的元素，

1
set.pop()
復制
pop() 方法會按順序刪除集合中的第一個元素。

1
set.remove(element)
復制
remove() 方法需要指定要刪除的元素，如果該元素不存在，則拋出異常。

1
set.clear()
復制
clear() 方法會刪除集合中的所有元素，使其變為一個空集合。

集合運算

交集

在 Python 中，求集合的交集使用 & 符號進行運算。

并集

在 Python 中，求集合的并集使用 | 符號進行運算。

差集

在 Python 中，求集合的差集使用 - 符號進行運算。

對稱差集

在 Python 中，求集合的對稱差集使用 ^ 符號進行運算。

例如，

1
2
3
4
5
6
7
set_1 = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19}
set_2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

print(set_1 & set_2)
print(set_1 | set_2)
print(set_1 - set_2)
print(set_1 ^ set_2)