列表：
- 可以容納任意數目不同類型的元素（支持我們學過的任意數據類型）
- 元素之間有先后順序
- 用中括號包裹，每個元素用逗號隔開
例如：
students = ['林黛玉','薛寶釵','賈元春','賈探春','史湘云','妙玉','賈迎春','賈惜春','王熙鳳','賈巧姐','李紈','秦可卿'
]列表可容納任意個元素，當然也包括 0 個元素。這樣的列表我們稱為?空列表，只用一對中括號?[]?表示即可，中間不加逗號。
反向索引的數字和我們日常生活中的倒數數字是一樣的，用?-1?表示倒數第一個，用?-2?表示倒數第二個。
正向索引?和?反向索引?（比如：students[-1]）都是通過位置，查找對應值的方法
快速獲取列表索引值的方法：使用?
列表.index(元素內容)?的形式
列表元素的修改：
通過?列表[索引] = 新值?的格式
# 第二個名字，索引為 1
students[1] = '賈寶玉'列表元素的添加：
在列表末尾添加一個元素：append()?方法會在列表末尾新增一個元素，同時列表長度加一
students.append('賈寶玉')在列表中間某個位置插入一個元素：insert()?方法
students.insert(9, '賈璉')列表元素的刪除：
用列表的?pop()?方法，pop()?的功能是：返回列表指定位置的元素，并刪除這個元素。?pop()?可以傳入一個參數，表示要刪除的元素的索引，如果不傳入，就默認為最后一個元素的索引。
students.pop()可以使用更加便捷的?del?語句來操作列表，格式為：del 列表[索引]。
del students[0]通過?列表.remove(值)?的方式，我們可以在列表中找到?第一個?指定的值，然后將它刪除。
students.remove('王熙鳳')列表的分片：
列表分片用一對以冒號分隔的索引位置表示，格式為?列表[起始索引:結束索引]。比如要獲取?students?中第三到第五個元素，也就是索引為?2，3，4?的元素，就要寫成?students[2:5]。
on_duty = ['賈璉', '王熙鳳', '林黛玉', '賈寶玉', '李紈', '薛寶釵', '妙玉']# 打印周一周二值日的人
print(on_duty[:2])# 打印周三到周五值日的人
print(on_duty[2:5])# 打印周末值日的人
print(on_duty[-2:])截取前三個元素，就寫成?
list[:3]；而截取最后四個元素，就寫成?list[-4:]；截取中間部分?list[a:b]，分片長度就是 b - a。
列表常用方法：
統計元素出現的次數：count()?方法可以統計元素在列表中出現的次數
students = ['林黛玉', '賈寶玉', '薛寶釵', '賈寶玉']
print(students.count('賈寶玉'))
# 輸出：2排序：sort()?是一個很強大的方法，可以對列表內的元素進行排序。
str_list = ["lin", "jia", "xue"]
str_list.sort()
print(str_list)
# 輸出：['jia', 'lin', 'xue']num_list = [4, 2, 1, 9]
num_list.sort()
print(num_list)
# 輸出：[1, 2, 4, 9]
- 字符串列表的排序按照每個元素首字母的順序來排序，比如 j 在 l 前面，l 在 x 前面，可以簡單地按照 26 個字母順序表即可；
- 數值列表的排序是按照數值大小從小到大進行排序，比如 1 比 2 小，所以 1 在 2 前面。
反轉、復制和清空：reverse()、copy()、clear()?方法
# reverse() 方法：將列表順序反轉
students = ["林黛玉", "賈寶玉", "薛寶釵"]
students.reverse()
print(students)
# 輸出：['薛寶釵', '賈寶玉', '林黛玉']# copy() 方法：復制一個同樣的列表
students1 = ["林黛玉", "賈寶玉", "薛寶釵"]
students2 = students1.copy()
print(students2)
# 輸出：['林黛玉', '賈寶玉', '薛寶釵']# clear() 方法：清空列表
students = ["林黛玉", "賈寶玉", "薛寶釵"]
students.clear()
print(students)
# 輸出：[]列表的基本運算：
成員運算符 in：用來判斷一個元素是否在一個列表中，格式為?元素 in 列表。這是一個布爾表達式，如果元素在列表中，結果為布爾值?True，反之為?False。
students = ['林黛玉','薛寶釵','賈元春','妙玉','賈惜春','王熙鳳','秦可卿','賈寶玉'
]
miaoyu_in = '妙玉' in students
print(miaoyu_in)
# 輸出：Truexiangyun_in = '史湘云' in students
print(xiangyun_in)
# 輸出：False加法和乘法：
# 列表的加法
students = ['林黛玉', '薛寶釵', '賈元春', '賈探春', '史湘云', '妙玉', '賈迎春', '賈惜春', '王熙鳳', '賈璉', '賈巧姐', '李紈', '秦可卿', '賈寶玉']parents = ['賈敬', '賈政', '王夫人', '賈赦', '邢夫人']meeting = students + parents# 打印 meeting 的結果，以及最終人數
print(meeting)
print('與會人數為', len(meeting), '人')
# 輸出：
# ['林黛玉', '薛寶釵', '賈元春', '賈探春', '史湘云', '妙玉', '賈迎春', '賈惜春', '王熙鳳', '賈璉', '賈巧姐', '李紈', '秦可卿', '賈寶玉', '賈敬', '賈政', '王夫人', '賈赦', '邢夫人']
# 與會人數為 19 人#列表的乘法
lag_behind = ['賈探春', '秦可卿', '賈惜春', '賈璉']
# 用乘法快速生成輪班表
recite_list = lag_behind * 5print(recite_list)
# 輸出：['賈探春', '秦可卿', '賈惜春', '賈璉', '賈探春', '秦可卿', '賈惜春', '賈璉', '賈探春', '秦可卿', '賈惜春', '賈璉', '賈探春', '秦可卿', '賈惜春', '賈璉', '賈探春', '秦可卿', '賈惜春', '賈璉']列表的擴展操作：
zip() 函數：它的作用是將兩個長度相同的列表合并起來，相同位置的元素會被一一組對，變成一個元組。結果返回一個組合好的打包對象，需要我們再用?list()?函數轉換回列表。
midterm_rank = ['妙玉','薛寶釵','賈元春','王熙鳳','林黛玉','賈巧姐','史湘云','賈迎春','賈寶玉','李紈','賈探春','秦可卿','賈惜春','賈璉'
]scores = [100, 92, 77, 85, 81, 90, 100, 86, 79, 93, 91, 96, 75, 84]# 將 scores 元素從低到高排列
scores.sort()# 倒轉 scores 中的排列順序
scores.reverse()print(scores)
# 輸出：[100, 100, 96, 93, 92, 91, 90, 86, 85, 84, 81, 79, 77, 75]# 用 zip() 將兩個列表合并
zipped = zip(midterm_rank, scores)# 將結果轉換回列表后，賦值給 zipped_rank
zipped_rank = list(zipped)# 來看看結果
print(zipped_rank)
# 輸出：[('妙玉', 100), ('薛寶釵', 100), ('賈元春', 96), ('王熙鳳', 93), ('林黛玉', 92), ('賈巧姐', 91), ('史湘云', 90), ('賈迎春', 86), ('賈寶玉', 85), ('李紈', 84), ('賈探春', 81), ('秦可卿', 79), ('賈惜春', 77), ('賈璉', 75)]enumerate() 函數：“enumerate”單詞本身意思是“枚舉、數數”。所以對應的函數功能，就是一個一個地將列表中的元素數出來。它返回的是一個枚舉對象，也需要我們用?list()?函數轉換回列表。
# 枚舉原排名表后，再轉回列表的形式
rank_with_id = list(enumerate(midterm_rank))print(rank_with_id)
# 輸出：[(0, '妙玉'), (1, '薛寶釵'), (2, '賈元春'), (3, '王熙鳳'), (4, '林黛玉'), (5, '賈巧姐'), (6, '史湘云'), (7, '賈迎春'), (8, '賈寶玉'), (9, '李紈'), (10, '賈探春'), (11, '秦可卿'), (12, '賈惜春'), (13, '賈璉')]# enumerate()中這次有兩個參數，一個為排名列表，一個為起始數字。
rank_with_ID = list(enumerate(midterm_rank, 1))print(rank_with_ID)
# 輸出：[(1, '妙玉'), (2, '薛寶釵'), (3, '賈元春'), (4, '王熙鳳'), (5, '林黛玉'), (6, '賈巧姐'), (7, '史湘云'), (8, '賈迎春'), (9, '賈寶玉'), (10, '李紈'), (11, '賈探春'), (12, '秦可卿'), (13, '賈惜春'), (14, '賈璉')]元組：
元組和列表非常相似。不同之處在于，外觀上：列表是被方括號包裹起來的，而元組是被?圓括號?包裹起來的。本質上：列表里的元素可修改，元組里的元素是?不可以“增刪改”?的。
還有一個微妙的地方要注意，就是只有一個元素的元組，在格式上與列表是不同的。僅一個元素 x 的列表寫成?[x], 但僅一個元素的元組要在括號內多寫個逗號：(x,)。
對于僅一個元素的元組，我們要特意加個逗號來聲明：這是個元組。
single = (1,)
print(type(single))
# 輸出：<class 'tuple'>元組不能用于增加、修改或刪除語句。
由于查詢與分片操作并不會改變數據，所以我們說的兩種列表元素的查詢方式以及分片操作，在元組中是可用的。列表運算符，元組也都支持，用?
in?查詢元素是否在元組內；用?+?將兩個元組疊加生成新元組；用?*?生成元素重復循環多次的新元組。
如果真的有特殊需求，需要修改元組中的元素：可以先用?list()?函數把元組轉換成列表，相當于給數據“解鎖”，將元素修改完畢后，再用?tuple()?函數轉換回元組，相當于“重新上鎖”。
students = ('林黛玉', '賈寶玉', '薛寶釵')# 用 list() 函數給數據“解鎖”，生成一個相同元素的新列表
students_list = list(students)# 在新列表中修改元素
students_list[0] = '妙玉'# 兩次給數據“上鎖”
students = tuple(students_list)print(students)
# 輸出：('妙玉', '賈寶玉', '薛寶釵')字符串：
Python 中的字符串是使用一對英文單引號（'）或英文雙引號（"）包裹的任意文本。無論是用單引號還是用雙引號，它倆的效果都是一樣的，但需要保持前后引號的統一。
使用一對三引號（'''?或?"""）來包裹多行字符串，三引號包裹的字符串和普通的字符串使用上沒有區別，只是三引號支持多行字符串而已。
字符串拼接：
可以使用+或者*
str1 = '煩死了'
str2 = str1 + str1 + str1
print(str2)
# 輸出：煩死了煩死了煩死了str11 = '煩死了'
str22 = str11 * 3 # 相當于 str11 + str11 + str11
print(str22)
# 輸出：煩死了煩死了煩死了字符串格式化輸出：
用+?來拼接字符串：
def print_intro(name, age, city):intro = '我叫' + name + '，今年 ' + str(age) + ' 歲，來自' + city + '。'print(intro)print_intro('貝殼', 18, '世界各地')
# 輸出：我叫貝殼，今年 18 歲，來自世界各地。提示：字符串類型和數字類型不能直接相加，需要用?str()?函數進行類型轉換。
用字符串的格式化輸出實現同樣的功能：
def print_intro(name, age, city):intro = '我叫%s，今年 %d 歲，來自%s。' % (name, age, city)print(intro)print_intro('貝殼', 18, '世界各地')
# 輸出：我叫貝殼，今年 18 歲，來自世界各地。提示：如果不太確定應該用什么占位符，%s?是萬能的，它會把任何數據類型轉換為字符串。
字符串索引：
str = 'Hello World'
print(str[6]) # 輸出：W
print(str[-5]) # 輸出：W字符串分片：
str = 'Hello World'
# 下面兩個效果一樣
print(str[6:]) # 輸出：World
print(str[-5:]) # 輸出：World
- 分片是半閉半開區間，即包含前面索引位置的元素，不包含后面索引位置的元素。比如：string[m:n]?獲取的是字符串 string 中索引為 m 到 n-1 之間的元素（包括 m 和 n-1）；
- 分片中前后索引的值是可以省略的，前索引省略默認為 0，后索引省略默認為序列長度。
字符串不可變性：
但字符串一旦創建后是不可改變的，這個屬性和元組類似，通過索引來改變字符串中元素就會報錯：
name = '張藝興'
name[0] = '賈'
print(name)
# 報錯：TypeError: 'str' does not support item assignment on line 2字符串的相關方法：
upper()：用于將字符串中的小寫字母轉為大寫字母。
'abcd'.upper() # 'ABCD'lower()：用于將字符串中的大寫字母轉為小寫字母。
'ABCD'.lower() # 'abcd'capitalize()：用于將字符串的第一個字母變成大寫，其他字母變小寫。首字符如果是非字母則不變，其他字母變小寫。
'ABCD'.capitalize() # 'Abcd'
'aBcD'.capitalize() # 'Abcd'
'1abcd'.capitalize() # '1abcd'
'1aBcD'.capitalize() # '1abcd'title()：用于返回“標題化”的字符串——即所有單詞的首字母轉為大寫，其余字母均為小寫。注意：非字母后的第一個字母將轉為大寫字母。
'this is an example string'.title() # This Is An Example String
'5g is coming'.title() # 5G Is Comingswapcase()：用于對字符串的大小寫字母進行互相轉換。
'abcd'.swapcase() # 'ABCD'
'aBcD'.swapcase() # 'AbCd'分割、組合與移除方法：
split()：
用于通過指定分隔符對字符串進行分割。split()?方法有兩個可選參數，第一個參數為分隔符，默認為所有的空字符，包括空格、換行（\n）、制表符（\t）等。第二個參數為最大分割次數，默認為?-1，即不限次數。
'好 運 連 連'.split() # ['好', '運', '連', '連']
'好 運 連 連'.split(' ') # ['好', '運', '連', '連']
'好-運-連-連'.split('-') # ['好', '運', '連', '連']
'好運連連'.split('運連') # ['好', '連']
'好 運 連 連'.split(' ', 1) # ['好', '運 連 連']join()：
用于將序列中的元素以指定的字符連接生成一個新的字符串。join()?方法接收一個序列（列表、元組、字符串等）作為參數，前面的字符串用于連接符。
# 列表
''.join(['好', '運', '連', '連']) # 好運連連
'-'.join(['好', '運', '連', '連']) # 好-運-連-連# 元組
'-'.join(('好', '運', '連', '連')) # 好-運-連-連# 字符串
'-'.join('好運連連') # 好-運-連-連strip()：
用于移除字符串開頭和結尾指定的字符（默認為空字符）或字符序列。當傳入一個字符串時，會將傳入字符串中每個字符依次移除。
'好運連連 '.strip() #'好運連連'
'~~好運連連~~'.strip('~') #'好運連連'
'~~好運~~連連~~'.strip('~') #'好運~~連連'
'_~_好運連連_~~'.strip('~_') #'好運連連'定位與替換方法:
count():
用于統計字符串中某個字符串出現的次數。第一個參數為要統計次數的字符串，后兩個可選參數為在字符串搜索的開始與結束索引。
'aabbcccd'.count('a') # 2
'aabbcccd'.count('ab') # 1
'aabbcccd'.count('e') # 0'aabbcccd'.count('a', 2, 6) # 0
# 等同于 'bbcc'.count('a')'aabbcccd'.count('c', 2, 6) # 2
# 等同于 'bbcc'.count('c')find():
用于檢測字符串中是否包含子字符串，如果包含子字符串返回第一次出現的索引值，否則返回 -1。第一個參數為要查找的子字符串，后兩個可選參數為在字符串搜索的開始與結束索引。
'abc'.find('b') # 1
'abcabc'.find('b') # 1
'abcabc'.find('d') # -1
'abcbcdabc'.find('bcd') # 3
'abcabc'.find('b', 1, 2) # 1
'abcabc'.find('b', 2, 3) # -1replace():
用于將字符串中的指定字符串替換成別的字符串。第一個參數為被替換字符串，第二個參數為替換字符串，第三個可選參數為替換的最多次數，默認為無限次。
'abcd'.replace('b', 'e') # 'aecd'
'abbbcbd'.replace('b', 'e') # 'aeeeced'
'abbbcbd'.replace('bb', 'e') # 'aebcbd'
'abbbcbd'.replace('b', 'e', 2) # 'aeebcbd'格式化輸出方法:
可以使用字符串的?format()?方法:
'我叫{}，今年 {} 歲，來自{}'.format('貝殼', 18, '世界各地')
# 我叫貝殼，今年 18 歲，來自世界各地集合：
集合（set）是一個無序的不重復元素序列。
集合中的元素不會重復，并且可以進行交集、并集、差集等常見的集合操作。
可以使用大括號?{ }?創建集合，元素之間用逗號?,?分隔， 或者也可以使用?set()?函數創建集合。
set1 = {1, 2, 3, 4} # 直接使用大括號創建集合
set2 = set() # 使用 set() 函數創建集合創建一個空集合必須用?set()?而不是?{ }，因為?{ }?是用來創建一個空字典。
添加元素：
s.add( x )：將元素 x 添加到集合 s 中，如果元素已存在，則不進行任何操作。
s.update( x )：x 可以有多個，用逗號分開。
set1={1,2,3,4}
set1.add(5)
print(set1) #{1, 2, 3, 4, 5}
set1.update({6,7})
print(set1) #{1, 2, 3, 4, 5, 6, 7}移除元素：
s.remove( x )：將元素 x 從集合 s 中移除，如果元素不存在，則會發生錯誤。
s.discard( x )：也是移除集合中的元素，且如果元素不存在，不會發生錯誤。
s.pop() ：隨機刪除集合中的一個元素
set1={1,2,3,4}
set1.remove(3)
print(set1) #{1, 2, 4}
set1.discard(4)
print(set1) #{1, 2}
set1.pop()
print(set1) #{2}計算集合元素個數：
len(s)：計算集合 s 元素個數。
set1={1,2,3,4}
print(len(set1)) #4清空集合：
s.clear()：清空集合 s。
set1={1,2,3,4}
print(set1.clear()) #None字典：
字典?是由一對大括號（{}）包裹著的。和列表不同的是，字典的每個元素是?鍵值對
字典中的?鍵?需要是?唯一的，如果字典中有兩個相同的?鍵，Python 只會保留后面那個。而?值?則沒有限制，可以是任意類型的，也可以有相同的值。
scores = {'林黛玉': 95,'薛寶釵': 93,'賈寶玉': 78,'林黛玉': 78
}
print(scores)
# 輸出：{'林黛玉': 78, '薛寶釵': 93, '賈寶玉': 78}字典的取值：
和列表類似，訪問字典中的元素也使用方括號?[]。不同的是，列表中括號內的是?索引，字典中括號內的是?鍵。
scores = {'林黛玉': 95,'薛寶釵': 93,'賈寶玉': 78
}
print(scores['林黛玉'])
# 輸出：95字典元素的修改/添加/刪除：
修改和添加都使用?字典名[鍵] = 值?的方式，如果?鍵?存在于字典中，就是修改，不存在就是添加。字典元素的刪除和列表元素的刪除一樣也是使用?del?關鍵字進行刪除。
scores = {'林黛玉': 95,'薛寶釵': 93,'賈寶玉': 78
}# 修改
scores['林黛玉'] = 90
print(scores)
# 輸出：{'林黛玉': 90, '薛寶釵': 93, '賈寶玉': 78}# 添加
scores['襲人'] = 85
print(scores)
# 輸出：{'林黛玉': 90, '薛寶釵': 93, '賈寶玉': 78, '襲人': 85}# 刪除
del scores['林黛玉']
print(scores)
# 輸出：{'薛寶釵': 93, '賈寶玉': 78, '襲人': 85}字典常用方法：
get()：
將字典的鍵作為參數傳入?get()?方法中，它就會幫我們查詢字典中有沒有這個鍵。如果存在的話，返回鍵對應的值；不存在的話，默認返回?None。
students = {'林黛玉': 95,'薛寶釵': 93,'賈寶玉': 78,'襲人': 85
}
print(students.get('林黛玉'))
# 輸出：95
print(students.get('張藝興'))
# 輸出：Nonekeys()：
keys()?方法則可以獲取字典中所有的?鍵。
students = {'林黛玉': 95,'薛寶釵': 93,'賈寶玉': 78,'襲人': 85
}
names = students.keys()
print(names)
# 輸出：dict_keys(['林黛玉', '薛寶釵', '賈寶玉', '襲人'])
print(type(names))
# 輸出：<class 'dict_keys'>values()：
與?keys()?方法相對應，我們可以通過?values()?方法獲取字典中所有的?值。
students = {'林黛玉': 95,'薛寶釵': 93,'賈寶玉': 78,'襲人': 85
}
scores = students.values()
print(scores)
# 輸出：dict_values([95, 93, 78, 85])
print(type(scores))
# 輸出：<class 'dict_values'>
for score in scores:print(score)
# 輸出：95 93 78 85items()：
除了獲取所有的鍵、值，我們也可以通過?items()?方法，一次性獲取字典中所有的?鍵值對?，其中每個鍵值對都是一個形如?(鍵, 值)?的元組。items()?方法返回的也是一個特殊類型，不可索引，可遍歷。
students = {'林黛玉': 95,'薛寶釵': 93,'賈寶玉': 78,'襲人': 85
}
student = students.items()
print(student)
# 輸出：dict_items([('林黛玉', 95), ('薛寶釵', 93), ('賈寶玉', 78), ('襲人', 85)])
print(type(items))
# 輸出：<class 'dict_items'># 以 name, score 遍歷 students 中鍵值對
for name, score in students.items():print('{}的分數是：{}'.format(name, score))# 輸出：
# 林黛玉的分數是：95
# 薛寶釵的分數是：93
# 賈寶玉的分數是：78
# 襲人的分數是：85字典的嵌套：
列表中嵌套字典：
scores = [{'林黛玉': 95, '賈寶玉': 78},{'薛寶釵': 93, '襲人': 85}
]print(scores[0])
# 輸出：{'林黛玉': 95, '賈寶玉': 78}print(scores[0]['林黛玉'])
# 輸出：95字典中嵌套列表：
students = {'第一': ['林黛玉', '賈寶玉'],'第二': ['薛寶釵', '襲人']
}print(students['第一'])
# 輸出：['林黛玉', '賈寶玉']
print(students['第一'][0])
# 輸出：林黛玉字典中嵌套字典：
dictionary = {'apple': {'釋義': '蘋果', '詞性': '名詞'},'grape': {'釋義': '葡萄', '詞性': '名詞'}
}print(dictionary['apple'])
# 輸出：{'釋義': '蘋果', '詞性': '名詞'}
print(dictionary['apple']['釋義'])
# 輸出：蘋果
