在 Python 中，列表（List）是一種有序的數(shù)據(jù)集合，可以存儲(chǔ)任意類型的數(shù)據(jù)，例如整數(shù)、浮點(diǎn)數(shù)、字符串、元組、列表等。因?yàn)榱斜硎怯行虻?，所以可以通過(guò)下標(biāo)（索引）來(lái)訪問(wèn)和修改列表中的元素。Python 中的列表是可變的，也就是說(shuō)可以動(dòng)態(tài)增加和刪除元素。

創(chuàng)建列表的方法有多種，其中最常見(jiàn)的是使用中括號(hào) [] ，并在其中用逗號(hào) , 分隔出各個(gè)元素。例如，以下是一個(gè)創(chuàng)建列表的例子：

a = [1, 2, 3, 4, 5]   # 創(chuàng)建一個(gè)包含五個(gè)整數(shù)的列表
b = ['apple', 'banana', 'orange']   # 創(chuàng)建一個(gè)包含三個(gè)字符串的列表
c = [1, 'apple', 3.14, [4, 5, 6]]  # 創(chuàng)建一個(gè)包含不同類型的元素的列表

可以通過(guò)下標(biāo)來(lái)訪問(wèn)和修改列表中的元素，下標(biāo)從0開(kāi)始計(jì)數(shù)。例如，可以使用以下方式訪問(wèn)和修改列表中的元素：

a = [1, 2, 3, 4, 5]
print(a[0])   # 訪問(wèn)第一個(gè)元素，輸出1
a[2] = 100   # 修改第三個(gè)元素為100
print(a)     # 輸出[1, 2, 100, 4, 5]

可以使用 len() 函數(shù)獲取列表的長(zhǎng)度，使用 + 運(yùn)算符連接兩個(gè)列表，使用 * 運(yùn)算符重復(fù)一個(gè)列表中的元素。例如，以下是一些常見(jiàn)的操作：

a = [1, 2, 3, 4, 5]
length = len(a)   # 獲取列表的長(zhǎng)度，結(jié)果為5
b = a + [6, 7, 8]   # 連接兩個(gè)列表
c = a * 2      # 重復(fù)a中的元素兩次
print(b)   # 輸出[1, 2, 3, 4, 5, 6, 7, 8]
print(c)   # 輸出[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

還可以使用列表的一些內(nèi)置函數(shù)來(lái)對(duì)列表進(jìn)行操作，例如 append() 方法可以向列表中添加一個(gè)元素， pop() 方法可以刪除列表中的一個(gè)元素等。例如，以下是一些常見(jiàn)的列表操作：

a = [1, 2, 3, 4, 5]
a.append(6)     # 向列表中添加一個(gè)元素6
a.pop(0)        # 刪除并返回列表中的第一個(gè)元素1
a.sort(reverse=True)  # 將列表中的元素從大到小排序
print(a)        # 輸出[6, 5, 4, 3, 2]

1. clear() 移除列表中的所有元素

Python中列表list的clear()方法用于從列表中刪除所有項(xiàng)目。它不返回任何值，只是修改了原始列表。

my_list = [1, 2, 3, 4, 5]
my_list.clear()
print(my_list)  # 輸出[]

2. copy() 返回列表的一個(gè)副本

在Python中，list類型的copy()方法用于創(chuàng)建一個(gè)原列表的副本，返回一個(gè)新的列表對(duì)象。副本是原列表的淺拷貝，即只復(fù)制了列表對(duì)象本身，而不是列表中的元素對(duì)象。如果列表中的元素是可變對(duì)象，修改副本中的元素也會(huì)影響原列表中的元素，因?yàn)楦北竞驮斜硪昧送慌貙?duì)象。 示例代碼：

my_list = [1, 2, 3]
new_list = my_list.copy()
print(new_list)  # [1, 2, 3]
new_list[0] = 4
print(new_list)  # [4, 2, 3]
print(my_list)   # [1, 2, 3]

在上面的示例中，我們首先使用copy()方法創(chuàng)建一個(gè)新的列表對(duì)象new_list，其內(nèi)容與原列表my_list相同。然后，我們通過(guò)修改new_list的第一個(gè)元素，演示了副本和原列表之間的區(qū)別。

我們可以看到，新列表中的第一個(gè)元素被修改為了4，而原列表中的第一個(gè)元素仍然是1。這是因?yàn)閚ew_list和my_list引用了不同的元素對(duì)象。

3.count() 統(tǒng)計(jì)某個(gè)元素在列表中出現(xiàn)的次數(shù)

在Python中，列表(list)類型提供了 count() 方法，用于統(tǒng)計(jì)某個(gè)元素在列表中出現(xiàn)的次數(shù)。 count() 方法接受一個(gè)參數(shù)，表示要統(tǒng)計(jì)的元素。該方法返回一個(gè)整數(shù)，表示元素在列表中出現(xiàn)的次數(shù)。 示例代碼：

my_list = [1, 2, 3, 1, 4, 1]
count_1 = my_list.count(1)
print(count_1)  # 輸出"3"，表示數(shù)字1在列表中出現(xiàn)了3次

以上示例中，我們創(chuàng)建了一個(gè)包含6個(gè)元素的列表 my_list ，其中數(shù)字 1 出現(xiàn)了3次。我們使用 count() 方法統(tǒng)計(jì)數(shù)字 1 在列表中出現(xiàn)的次數(shù)，并將結(jié)果保存到變量 count_1 中，輸出結(jié)果為 3 。

注意， count() 方法只能用于統(tǒng)計(jì)指定元素在列表中出現(xiàn)的次數(shù)。如果要統(tǒng)計(jì)列表中滿足某個(gè)條件的元素個(gè)數(shù)，可以使用列表推導(dǎo)式或循環(huán)等方式實(shí)現(xiàn)。

4. extend() 在列表的末尾一次性追加另一個(gè)序列中的多個(gè)值

在 Python 中，列表（list）類型提供了 extend() 方法，用于將一個(gè)列表中的所有元素添加到另一個(gè)列表中。 extend() 方法接受一個(gè)參數(shù)，表示要添加的列表。該方法將要添加的列表元素逐個(gè)添加到原列表末尾，返回值為 None 。 示例代碼：

list1 = [1, 2, 3]
list2 = [4, 5, 6]
list1.extend(list2)
print(list1) # 輸出[1, 2, 3, 4, 5, 6]

在上述示例代碼中，我們首先創(chuàng)建了兩個(gè)列表list1和list2，分別包含了數(shù)字1~6。接著，我們使用 extend() 方法將list2中的所有元素添加到list1末尾，最后輸出list1，結(jié)果為 [1, 2, 3, 4, 5, 6] 。

需要注意的是， extend() 方法會(huì)修改原列表，而不是創(chuàng)建一個(gè)新列表。如果需要?jiǎng)?chuàng)建一個(gè)新的列表，可以使用加法運(yùn)算符或列表推導(dǎo)式實(shí)現(xiàn)。例如：

list1 = [1, 2, 3]
list2 = [4, 5, 6]
new_list = list1 + list2
print(new_list) # 輸出[1, 2, 3, 4, 5, 6]

以上代碼中，我們使用加法運(yùn)算符將list1和list2連接起來(lái)，創(chuàng)建一個(gè)新的列表new_list，最后輸出new_list，結(jié)果同樣為 [1, 2, 3, 4, 5, 6] 。

5. index() 返回元素在列表中的索引

在 Python 中，列表（list）類型提供了 index() 方法，用于查找指定元素在列表中的索引位置。 index() 方法接受一個(gè)參數(shù)，表示要查找的元素。如果列表中包含該元素，則返回其在列表中的第一個(gè)出現(xiàn)位置的索引值，否則會(huì)拋出 ValueError 異常。 示例代碼：

my_list = [1, 2, 3, 4, 5, 6]
index = my_list.index(3)
print(index) # 輸出2

在上述示例代碼中，我們首先創(chuàng)建了一個(gè)列表my_list，包含了數(shù)字1~6。接著，我們使用 index() 方法查找數(shù)字3在列表中的索引位置，并將結(jié)果保存到變量index中，最后輸出index，結(jié)果為 2 。

如果要查找的元素在列表中出現(xiàn)了多次， index() 方法只會(huì)返回其第一次出現(xiàn)的索引位置。如果要查找所有出現(xiàn)位置的索引值，可以使用列表推導(dǎo)式實(shí)現(xiàn)。例如：

my_list = [1, 2, 3, 2, 4, 5, 2, 6]
indices = [i for i, x in enumerate(my_list) if x == 2]
print(indices) # 輸出[1, 3, 6]

以上代碼中，我們首先創(chuàng)建了一個(gè)列表my_list，包含了數(shù)字1~6，同時(shí)數(shù)字2在列表中出現(xiàn)了三次。接著，我們使用列表推導(dǎo)式查找所有數(shù)字2在列表中出現(xiàn)的索引位置，并將結(jié)果保存到變量indices中，最后輸出indices，結(jié)果為 [1, 3, 6] 。

6. insert() 將元素插入到列表中的指定位置

在 Python 中，列表（list）類型提供了 insert() 方法，用于在指定位置插入一個(gè)元素。 insert() 方法接受兩個(gè)參數(shù)，第一個(gè)參數(shù)表示要插入元素的位置，第二個(gè)參數(shù)表示要插入的元素。如果要插入的位置大于列表的長(zhǎng)度，則會(huì)將元素插入到列表的末尾。 示例代碼：

my_list = [1, 2, 3, 4, 5]
my_list.insert(2, "hello")
print(my_list) # 輸出[1, 2, 'hello', 3, 4, 5]

在上述示例代碼中，我們首先創(chuàng)建了一個(gè)列表my_list，包含了數(shù)字1~5。接著，我們使用 insert() 方法在索引為2的位置插入字符串"hello"，最后輸出列表my_list，結(jié)果為 [1, 2, 'hello', 3, 4, 5] 。

需要注意的是， insert() 方法會(huì)直接修改原列表，而不是創(chuàng)建一個(gè)新的列表。如果需要在原列表的基礎(chǔ)上創(chuàng)建一個(gè)新的列表，則需要使用列表的切片（slice）操作。例如：

my_list = [1, 2, 3, 4, 5]
new_list = my_list[:2] + ["hello"] + my_list[2:]
print(new_list) # 輸出[1, 2, 'hello', 3, 4, 5]

以上代碼中，我們首先創(chuàng)建了一個(gè)列表my_list，包含了數(shù)字1~5。然后，我們使用切片操作將原列表分成兩部分，再在中間插入字符串"hello"，最后將兩部分合并成一個(gè)新的列表new_list，結(jié)果與 insert() 方法的示例代碼相同。

7. pop() 移除列表中的一個(gè)元素，并返回該元素的值

在 Python 中，列表（list）類型提供了 pop() 方法，用于從列表中刪除一個(gè)元素，并返回該元素的值。默認(rèn)情況下， pop() 方法會(huì)刪除列表中的最后一個(gè)元素，即索引為-1的元素。也可以傳遞一個(gè)參數(shù)，表示要?jiǎng)h除的元素的索引，例如 pop(0) 表示刪除列表中的第一個(gè)元素。 示例代碼：

my_list = [1, 2, 3, 4, 5]
last_element = my_list.pop()
print(last_element) # 輸出5
print(my_list) # 輸出[1, 2, 3, 4]

在上述示例代碼中，我們首先創(chuàng)建了一個(gè)列表my_list，包含了數(shù)字1~5。接著，我們使用 pop() 方法刪除列表中的最后一個(gè)元素，將返回值保存到變量last_element中，并輸出last_element的值，結(jié)果為5。最后，我們輸出my_list的值，結(jié)果為 [1, 2, 3, 4] 。 需要注意的是， pop() 方法會(huì)直接修改原列表，而不是創(chuàng)建一個(gè)新的列表。如果需要在原列表的基礎(chǔ)上創(chuàng)建一個(gè)新的列表，則需要使用列表的切片（slice）操作。例如：

my_list = [1, 2, 3, 4, 5]
new_list = my_list[:-1]
print(new_list) # 輸出[1, 2, 3, 4]

以上代碼中，我們首先創(chuàng)建了一個(gè)列表my_list，包含了數(shù)字1~5。然后，我們使用切片操作將原列表的最后一個(gè)元素刪除，將剩余部分賦值給一個(gè)新的列表new_list，最后輸出new_list的值，結(jié)果與 pop() 方法的示例代碼相同。

8. remove() 移除列表中某個(gè)值的第一個(gè)匹配項(xiàng)

在 Python 中，列表（list）類型提供了 remove() 方法，用于從列表中刪除匹配特定元素的第一個(gè)元素。方法的參數(shù)是要?jiǎng)h除的元素的值，如果列表中不存在該元素，則會(huì)拋出ValueError異常。如果列表中存在多個(gè)匹配的元素，則只會(huì)刪除第一個(gè)匹配的元素。 示例代碼：

my_list = [1, 2, 3, 4, 5, 4]
my_list.remove(4)
print(my_list) # 輸出[1, 2, 3, 5, 4]

在上述示例代碼中，我們首先創(chuàng)建了一個(gè)列表my_list，包含了數(shù)字1~5和一個(gè)額外的數(shù)字4。然后，我們使用 remove() 方法刪除第一個(gè)匹配的元素4，最后輸出my_list的值，結(jié)果為 [1, 2, 3, 5, 4] 。 需要注意的是， remove() 方法會(huì)直接修改原列表，而不是創(chuàng)建一個(gè)新的列表。如果需要在原列表的基礎(chǔ)上創(chuàng)建一個(gè)新的列表，則需要使用列表的切片（slice）操作，或者使用列表推導(dǎo)式（list comprehension）。例如：

my_list = [1, 2, 3, 4, 5, 4]
new_list = [x for x in my_list if x != 4]
print(new_list) # 輸出[1, 2, 3, 5]

以上代碼中，我們首先創(chuàng)建了一個(gè)列表my_list，包含了數(shù)字1~5和一個(gè)額外的數(shù)字4。然后，我們使用列表推導(dǎo)式創(chuàng)建一個(gè)新列表new_list，該列表中包含了my_list中所有不等于4的元素。最后輸出new_list的值，結(jié)果與 remove() 方法的示例代碼相同。

9. reverse() 反轉(zhuǎn)列表中的元素

在 Python 中，list提供了reverse()方法，用于翻轉(zhuǎn)（反轉(zhuǎn)）列表中元素的順序，即將列表中第一個(gè)元素變?yōu)樽詈笠粋€(gè)，第二個(gè)變?yōu)榈箶?shù)第二個(gè)，以此類推。該方法不接受任何參數(shù)。示例如下：

my_list = [1, 2, 3, 4, 5]
my_list.reverse()
print(my_list) # 輸出 [5, 4, 3, 2, 1]

在上述代碼中，我們首先創(chuàng)建了一個(gè)包含數(shù)字1~5的列表my_list。然后，我們使用 reverse() 方法翻轉(zhuǎn)該列表中元素的順序，并輸出翻轉(zhuǎn)后的列表。結(jié)果為 [5, 4, 3, 2, 1] 。 需要注意的是， reverse() 方法會(huì)直接修改原列表，而不是創(chuàng)建一個(gè)新列表。如果需要在原列表的基礎(chǔ)上創(chuàng)建一個(gè)新的列表，則需要使用列表的切片（slice）操作。例如：

my_list = [1, 2, 3, 4, 5]
new_list = my_list[::-1]
print(new_list) # 輸出 [5, 4, 3, 2, 1]

以上代碼中，我們首先創(chuàng)建了一個(gè)包含數(shù)字1~5的列表my_list。然后，我們使用my_list[::-1]切片操作生成一個(gè)新的列表new_list，該列表包含了my_list中所有元素的倒序排列。最后輸出new_list的值，結(jié)果與 reverse() 方法的示例代碼相同。

10. sort() 對(duì)原列表進(jìn)行排序

在 Python 中，list提供了 sort() 方法，用于對(duì)列表中的元素進(jìn)行排序。該方法可以接受多個(gè)參數(shù)，但最重要的是 key 和 reverse 參數(shù)。 key 參數(shù)是一個(gè)函數(shù)，用于指定排序規(guī)則。例如，可以將列表中的元素按照它們的長(zhǎng)度進(jìn)行排序，示例如下：

my_list = ["apple", "banana", "cherry", "pear"]
my_list.sort(key=len)
print(my_list) # 輸出 ["pear", "apple", "banana", "cherry"]

在上述代碼中，我們首先創(chuàng)建了一個(gè)包含四個(gè)字符串的列表my_list。然后，我們使用 sort() 方法對(duì)該列表進(jìn)行排序，并使用 len 函數(shù)作為 key 參數(shù)，指定按字符串長(zhǎng)度進(jìn)行排序。輸出結(jié)果為 ["pear", "apple", "banana", "cherry"] ，即按字符串長(zhǎng)度從小到大排序的結(jié)果。 reverse 參數(shù)是一個(gè)布爾值，用于指定是否按照降序進(jìn)行排序。例如，可以將列表中的元素按照它們的值進(jìn)行降序排序，示例如下：

my_list = [3, 6, 1, 8, 2, 9]
my_list.sort(reverse=True)
print(my_list) # 輸出 [9, 8, 6, 3, 2, 1]

在上述代碼中，我們首先創(chuàng)建了一個(gè)包含六個(gè)數(shù)字的列表my_list。然后，我們使用 sort() 方法對(duì)該列表進(jìn)行排序，并指定 reverse=True ，即按降序進(jìn)行排序。輸出結(jié)果為 [9, 8, 6, 3, 2, 1] ，即按數(shù)字大小從大到小排序的結(jié)果。 需要注意的是， sort() 方法會(huì)直接修改原列表，而不是創(chuàng)建一個(gè)新列表。如果需要在原列表的基礎(chǔ)上創(chuàng)建一個(gè)新的列表，則需要使用列表的切片（slice）操作。例如：

my_list = [3, 6, 1, 8, 2, 9]
new_list = sorted(my_list, reverse=True)
print(new_list) # 輸出 [9, 8, 6, 3, 2, 1]

在上述代碼中，我們使用了內(nèi)置函數(shù) sorted() 對(duì) my_list 進(jìn)行排序，并將結(jié)果保存到新列表 new_list 中。由于 sorted() 方法不會(huì)修改原列表，因此該方法返回的結(jié)果是一個(gè)新的列表。最后輸出new_list的值，結(jié)果與 sort() 方法的示例代碼相同。

11. fromkeys() 創(chuàng)建一個(gè)新字典，以序列中元素做此字典所有鍵的鍵，值全部為同一個(gè)value

在 Python 中， fromkeys() 是字典類型的一個(gè)方法，用于創(chuàng)建一個(gè)新字典并指定字典中的所有鍵的默認(rèn)值。不過(guò)，我們同樣可以使用列表類型的 fromkeys() 方法，用于創(chuàng)建一個(gè)新列表并指定列表中所有元素的默認(rèn)值。 fromkeys() 方法的語(yǔ)法如下：

new_list = list.fromkeys(seq, value)

其中， seq 是一個(gè)序列，用于指定新列表中的所有元素； value 是一個(gè)可選參數(shù)，用于指定新列表中所有元素的默認(rèn)值，默認(rèn)值為 None 。 fromkeys() 方法會(huì)返回一個(gè)新的列表對(duì)象。 下面是使用 fromkeys() 方法創(chuàng)建新列表的示例代碼：

my_list = list.fromkeys(['apple', 'banana', 'cherry'], 0)
print(my_list) # 輸出 [0, 0, 0]

在上述代碼中，我們使用 fromkeys() 方法創(chuàng)建了一個(gè)包含三個(gè)字符串的列表，新列表中所有元素的默認(rèn)值都為 0 。輸出結(jié)果為 [0, 0, 0] 。 需要注意的是， fromkeys() 方法會(huì)將所有元素的默認(rèn)值設(shè)置為同一個(gè)對(duì)象，因此如果 value 參數(shù)是可變類型的對(duì)象（如列表、字典等），則新列表中所有元素都會(huì)指向同一個(gè)對(duì)象。如果需要避免這種情況，可以將 value 參數(shù)設(shè)置為不可變類型的對(duì)象（如數(shù)字、字符串等）或使用列表生成式生成新列表。

12.get() 返回指定鍵的值，如果值不在字典中返回默認(rèn)值

在 Python 中，列表類型有一個(gè)名為 get() 的方法，該方法用于獲取指定索引位置上的元素，如果該索引不存在則返回默認(rèn)值。 get() 方法的語(yǔ)法如下：

list.get(index, default=None)

其中， index 表示要獲取元素的索引位置， default 是可選參數(shù)，表示如果指定索引位置上不存在元素，則返回的默認(rèn)值，默認(rèn)為 None 。 下面是使用 get() 方法獲取列表元素的示例代碼：

my_list = ['apple', 'banana', 'cherry']
print(my_list.get(1)) # 輸出 'banana'
print(my_list.get(3, 'orange')) # 輸出 'orange'

在上述代碼中，我們首先創(chuàng)建了一個(gè)包含三個(gè)字符串的列表 my_list 。然后使用 get() 方法獲取了第二個(gè)元素，即索引位置為 1 的元素，輸出結(jié)果為 'banana' 。接下來(lái)使用 get() 方法獲取了列表中不存在的第四個(gè)元素，同時(shí)通過(guò) default 參數(shù)設(shè)定了默認(rèn)值為 'orange' ，輸出結(jié)果為 'orange' 。

需要注意的是，如果使用索引操作獲取列表元素時(shí)，如果指定的索引位置不存在元素，Python 解釋器會(huì)拋出 IndexError 異常，而 get() 方法則會(huì)返回默認(rèn)值。因此，在使用 get() 方法時(shí)需要確認(rèn)是否需要返回默認(rèn)值，并根據(jù)需要選擇是否使用 get() 方法。

13. items() 返回一個(gè)包含所有字典項(xiàng)的列表

在 Python 中，列表類型有一個(gè)名為 items() 的方法，該方法用于返回列表中所有元素的鍵值對(duì)。 items() 方法的語(yǔ)法如下：

list.items()

下面是使用 items() 方法遍歷列表中的所有元素的示例代碼：

my_list = ['apple', 'banana', 'cherry']
for key, value in enumerate(my_list):
    print(key, value)

在上述代碼中，我們首先創(chuàng)建一個(gè)包含三個(gè)字符串的列表 my_list ，然后使用 items() 方法獲取列表中所有元素的鍵值對(duì)，接著使用 enumerate() 函數(shù)遍歷所有元素，并打印每一個(gè)元素的鍵和值。 運(yùn)行上述代碼，輸出結(jié)果如下：

0 apple
1 banana
2 cherry

需要注意的是，列表類型并沒(méi)有 items() 方法，上述代碼中的 items() 方法其實(shí)是使用了 enumerate() 函數(shù)生成的枚舉對(duì)象的方法。 enumerate() 函數(shù)用于將一個(gè)可遍歷的數(shù)據(jù)對(duì)象組合為一個(gè)索引序列，同時(shí)列出數(shù)據(jù)和數(shù)據(jù)下標(biāo)，返回一個(gè)枚舉對(duì)象，該對(duì)象可以用于遍歷列表的所有元素。

14. keys() 返回字典中所有鍵的列表

在 Python 中，列表類型沒(méi)有 keys() 方法。 keys() 方法只適用于字典類型。 如果想要獲取列表中每個(gè)元素的索引作為鍵，可以使用 enumerate() 函數(shù)生成一個(gè)包含索引和元素值的元組的枚舉對(duì)象，然后將其轉(zhuǎn)換為字典類型，其中索引作為鍵，元素值作為值。示例代碼如下：

my_list = ['apple', 'banana', 'cherry']
my_dict = dict(enumerate(my_list))
print(my_dict)

在上述代碼中，我們首先創(chuàng)建一個(gè)包含三個(gè)字符串的列表 my_list ，然后使用 enumerate() 函數(shù)生成一個(gè)枚舉對(duì)象，該對(duì)象包含列表中所有元素的索引和元素值的元組，接著使用 dict() 函數(shù)將其轉(zhuǎn)換為字典類型，其中索引作為鍵，元素值作為值，最后打印字典類型的結(jié)果。 運(yùn)行上述代碼，輸出結(jié)果如下：

{0: 'apple', 1: 'banana', 2: 'cherry'}

需要注意的是，由于字典是無(wú)序的，因此輸出結(jié)果的順序可能與輸入列表的順序不一致。

15. setdefault() 和get()方法類似, 但如果鍵不存在于字典中，將會(huì)添加鍵并將值設(shè)為默認(rèn)值

在 Python 中，列表類型沒(méi)有 setdefault() 方法。 setdefault() 方法只適用于字典類型。 字典類型的 setdefault() 方法用于獲取指定鍵的值，如果該鍵不存在，則返回默認(rèn)值并將其添加到字典中。如果該鍵已經(jīng)存在，則直接返回其對(duì)應(yīng)的值。具體用法如下：

d = {'a': 1, 'b': 2}
value1 = d.setdefault('c', 3)  # 返回 3，將 {'c': 3} 添加到 d 中
value2 = d.setdefault('b', 4)  # 返回 2，d 中 'b' 對(duì)應(yīng)的值已經(jīng)是 2

在上述代碼中，首先創(chuàng)建了一個(gè)字典 d ，然后調(diào)用了兩次 setdefault() 方法。第一次調(diào)用傳入的鍵 'c' 在字典中不存在，因此該方法返回默認(rèn)值 3 ，并將鍵值對(duì) {'c': 3} 添加到字典 d 中；第二次調(diào)用傳入的鍵 'b' 在字典中已經(jīng)存在，因此該方法返回該鍵對(duì)應(yīng)的值 2 ，并不會(huì)修改字典 d 。

需要注意的是，在調(diào)用 setdefault() 方法時(shí)，第一個(gè)參數(shù)是要獲取或設(shè)置的鍵，第二個(gè)參數(shù)是默認(rèn)值，可以省略。如果省略第二個(gè)參數(shù)，則默認(rèn)值為 None 。如果需要在列表類型中實(shí)現(xiàn)類似 setdefault() 方法的功能，可以在獲取元素時(shí)使用 try-except 語(yǔ)句，如果索引超出了范圍，則返回默認(rèn)值并將其添加到列表末尾，否則直接返回該元素。具體用法如下：

my_list = ['apple', 'banana']
try:
    value1 = my_list[2]  # 索引超出范圍，拋出 IndexError 異常
except IndexError:
    value1 = 'cherry'   # 返回默認(rèn)值 'cherry'
    my_list.append(value1)  # 將默認(rèn)值添加到列表末尾

try:
    value2 = my_list[1]  # 索引未超出范圍，直接返回元素值 'banana'
except IndexError:
    value2 = None  # 該行代碼不會(huì)執(zhí)行

在上述代碼中，首先創(chuàng)建了一個(gè)包含兩個(gè)字符串的列表 my_list ，然后使用 try-except 語(yǔ)句獲取了列表中第三個(gè)元素（超出了索引范圍），由于捕獲到了 IndexError 異常，因此返回默認(rèn)值 cherry 并將其添加到列表末尾。接著又使用 try-except 語(yǔ)句獲取了列表中第二個(gè)元素（未超出索引范圍），由于沒(méi)有異常，因此直接返回該元素的值 banana 。

16.max() 返回列表中的最大值

在 Python 中，可以使用內(nèi)置函數(shù) max() 來(lái)獲取列表中的最大值。 max() 函數(shù)接受一個(gè)可迭代對(duì)象作為參數(shù)，并返回其中最大的元素。 例子：

numbers = [3, 5, 1, 9, 7, 2]
max_number = max(numbers)
print(max_number)   # 輸出 9

在上面的例子中，我們創(chuàng)建了一個(gè)包含一些整數(shù)的列表 numbers ，并使用 max() 函數(shù)獲取其中的最大值，并將其保存為變量 max_number 。最后，我們打印輸出該變量的值，即列表中的最大值 9 。 需要注意的是，如果列表中存在不同類型的元素，那么 max() 函數(shù)將會(huì)拋出一個(gè) TypeError 異常。因此，在使用 max() 函數(shù)之前，需要確保列表中的元素類型是相同的。

min方法同理，返回列表中最小的值

17.len() 返回列表中元素的個(gè)數(shù)

在 Python 中，可以使用內(nèi)置函數(shù) len() 來(lái)獲取列表中元素的數(shù)量。 len() 函數(shù)接受一個(gè)可迭代對(duì)象作為參數(shù)，并返回其中元素的數(shù)量或長(zhǎng)度。 例子：

numbers = [3, 5, 1, 9, 7, 2]
length = len(numbers)
print(length)   # 輸出 6

在上面的例子中，我們創(chuàng)建了一個(gè)包含一些整數(shù)的列表 numbers ，并使用 len() 函數(shù)獲取其中元素的數(shù)量，并將其保存為變量 length 。最后，我們打印輸出該變量的值，即列表的長(zhǎng)度 6 。

需要注意的是，如果列表中包含一個(gè)元素，這個(gè)元素也是列表，則 len() 函數(shù)將會(huì)返回該元素列表包含的元素?cái)?shù)量，而不是元素列表本身的數(shù)量。如果需要對(duì)嵌套的列表進(jìn)行遞歸計(jì)數(shù)，則需要編寫遞歸函數(shù)或者使用第三方庫(kù)，如 iteration_utilities 。

18.any() 如果列表中的任一元素為True，則返回True

在 Python 中， any() 函數(shù)用于檢查給定可迭代對(duì)象中是否存在任何一個(gè)元素為 True。如果存在，則返回 True，否則返回 False?？傻鷮?duì)象可以是列表、元組、集合、字典等。 下面是一個(gè)例子：

numbers = [0, 1, 2, 3, 4]
result = any(numbers)
print(result)  # 輸出 True

在上面的例子中，我們定義了一個(gè)包含一些數(shù)字的列表 numbers 。我們將該列表作為參數(shù)傳遞給 any() 函數(shù)。由于列表中存在數(shù)字 1 ，該函數(shù)將返回 True。 需要注意的是，當(dāng)可迭代對(duì)象中的所有元素都是 False 或?yàn)榭諘r(shí)， any() 函數(shù)將返回 False。因此，在使用該函數(shù)時(shí)需要注意檢查空值情況。

19. all() 如果列表中的所有元素都為True，則返回True 3

列表也就是list類型有一個(gè)all()方法，該方法用于判斷列表中的所有元素是否為真（非0，非空，非None等）。如果列表為空，all()方法也返回True。

下面是使用all()方法的示例代碼：

my_list = [1, 2, 3, 4]
print(all(my_list))  # 輸出 True

my_list = [1, 0, 3, 4]
print(all(my_list))  # 輸出 False

my_list = []
print(all(my_list))  # 輸出 True

在第一個(gè)示例中，列表my_list中的所有元素都是真，所以all()方法返回True。

在第二個(gè)示例中，列表my_list中的第二個(gè)元素為假（即0），所以all()方法返回False。

在第三個(gè)示例中，列表my_list為空，all()方法返回True。

20. enumerate() 將可遍歷的對(duì)象組合為一個(gè)索引序列，同時(shí)列出數(shù)據(jù)和數(shù)據(jù)下標(biāo)

在Python中，列表也就是list類型有一個(gè)enumerate()方法，該方法用于將一個(gè)列表中的每個(gè)元素和它的下標(biāo)組成一個(gè)元組返回。這樣就不必手動(dòng)創(chuàng)建一個(gè)計(jì)數(shù)器來(lái)處理列表的每個(gè)元素了。 下面是使用enumerate()方法的示例代碼：

my_list = ['apple', 'banana', 'orange']
for idx, val in enumerate(my_list):
    print(idx, val)

輸出結(jié)果為：

0 apple
1 banana
2 orange

在上面的代碼中，我們使用enumerate()方法對(duì)列表my_list進(jìn)行迭代循環(huán)，每次循環(huán)將當(dāng)前元素的下標(biāo)和值組成一個(gè)元組返回，然后打印出來(lái)。 需要注意的是，enumerate()方法默認(rèn)從0開(kāi)始計(jì)數(shù)，但是我們也可以指定起始計(jì)數(shù)值，例如：

my_list = ['apple', 'banana', 'orange']
for idx, val in enumerate(my_list, start=1):
    print(idx, val)

輸出結(jié)果為：

1 apple
2 banana
3 orange

在這個(gè)示例中，我們使用了start參數(shù)來(lái)指定enumerate()方法的起始計(jì)數(shù)值為1，并且打印出了帶有計(jì)數(shù)值的結(jié)果。

21. filter() 用于過(guò)濾序列，過(guò)濾掉不符合條件的元素

該方法用于根據(jù)函數(shù)返回值的真假來(lái)過(guò)濾一個(gè)列表，返回一個(gè)新的列表。該函數(shù)接受兩個(gè)參數(shù)，第一個(gè)參數(shù)是一個(gè)函數(shù)，該函數(shù)接受一個(gè)參數(shù)并返回真或假；第二個(gè)參數(shù)是要被過(guò)濾的列表。 下面是一個(gè)使用filter()方法的示例代碼：

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
new_list = list(filter(lambda x: x % 2 == 0, my_list))
print(new_list)

輸出結(jié)果為：[2, 4, 6, 8] 在上面的代碼中，我們首先定義了一個(gè)列表my_list，然后使用filter()方法過(guò)濾出其中的偶數(shù)元素，并將結(jié)果存儲(chǔ)到一個(gè)新的列表new_list中，最后打印出來(lái)。

需要注意的是，filter()方法返回的是一個(gè)filter對(duì)象，如果需要將它轉(zhuǎn)換成一個(gè)列表，需要使用list()方法。同時(shí)也可以使用列表解析(list comprehension)的方式來(lái)實(shí)現(xiàn)同樣的功能，例如：

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
new_list = [x for x in my_list if x % 2 == 0]
print(new_list)

輸出結(jié)果為：

[2, 4, 6, 8]

在這個(gè)示例中，我們使用了列表解析的方式來(lái)實(shí)現(xiàn)同樣的功能，代碼更加簡(jiǎn)潔。

22. map() 對(duì)列表中所有元素進(jìn)行指定操作，并返回新列表

該方法用于將一個(gè)列表中的每一個(gè)元素都執(zhí)行一個(gè)指定的函數(shù)，返回一個(gè)新的列表，新列表中的元素就是每個(gè)元素執(zhí)行函數(shù)的結(jié)果。 下面是一個(gè)使用 map() 方法的示例代碼：

my_list = [1, 2, 3, 4, 5]
new_list = list(map(lambda x: x * 2, my_list))
print(new_list)

輸出結(jié)果為：[2, 4, 6, 8, 10] 在上面的代碼中，我們定義了一個(gè)列表 my_list，然后使用 map() 方法將列表中的每個(gè)元素都乘以 2，最后將得到的結(jié)果存儲(chǔ)到一個(gè)新的列表 new_list 中，并打印出來(lái)。

需要注意的是，map() 方法返回的是一個(gè) map 對(duì)象，如果需要將它轉(zhuǎn)換成一個(gè)列表，需要使用 list() 方法。同時(shí)也可以使用列表解析(list comprehension)的方式來(lái)實(shí)現(xiàn)同樣的功能，例如：

my_list = [1, 2, 3, 4, 5]
new_list = [x * 2 for x in my_list]
print(new_list)

輸出結(jié)果為：

[2, 4, 6, 8, 10]

在這個(gè)示例中，我們使用了列表解析的方式來(lái)實(shí)現(xiàn)同樣的功能，代碼更加簡(jiǎn)潔。

23. reduce() 對(duì)列表中的所有元素進(jìn)行累積操作，返回計(jì)算結(jié)果

在 Python 中， reduce 是 functools 模塊提供的一個(gè)函數(shù)。 reduce 函數(shù)的作用是對(duì)一個(gè)序列做連續(xù)的操作，并返回最終結(jié)果。該函數(shù)需要兩個(gè)參數(shù)：一個(gè)是函數(shù)，一個(gè)是序列。

該函數(shù)將對(duì)序列中相鄰的兩個(gè)元素運(yùn)用函數(shù)，并將結(jié)果與下一個(gè)元素繼續(xù)執(zhí)行函數(shù)，直到序列中只剩下一個(gè)元素，最終返回這個(gè)元素。 下面是一個(gè)使用 reduce() 方法對(duì)列表求和的示例代碼：

from functools import reduce

my_list = [1, 2, 3, 4, 5]
result = reduce(lambda x, y: x + y, my_list)
print(result)

輸出結(jié)果為: 15 在上面的代碼中，我們使用 reduce() 方法來(lái)對(duì)列表中的所有元素求和。函數(shù) lambda x, y: x + y 用于將兩個(gè)元素相加，而 reduce() 方法將該函數(shù)應(yīng)用到列表中的所有元素，最終返回求和的結(jié)果。

需要注意的是， reduce 函數(shù)在 Python 3.x 中已經(jīng)被移到了 functools 模塊中，并且在 Python 3.x 中必須使用 from functools import reduce 的方式導(dǎo)入該函數(shù)。

24. reverse() 將列表中的元素反轉(zhuǎn)

在 Python 中， list 是一種內(nèi)置的序列類型，它用于存儲(chǔ)一組有序的元素。 list 列表提供了一系列方法用于對(duì)序列進(jìn)行操作，其中包括 reverse() 方法。 reverse() 方法用于對(duì)列表中的元素進(jìn)行反轉(zhuǎn)。該方法沒(méi)有參數(shù)，只是將列表中的元素順序進(jìn)行翻轉(zhuǎn)，直接修改原列表，不返回任何值。

下面是一個(gè)使用 reverse() 方法將列表元素反轉(zhuǎn)的示例代碼：

my_list = [1, 2, 3, 4, 5]
print("Original List:", my_list)

my_list.reverse()
print("Reversed List:", my_list)

輸出結(jié)果為：

Original List: [1, 2, 3, 4, 5]
Reversed List: [5, 4, 3, 2, 1]

在上面的代碼中，我們首先定義了一個(gè)列表 my_list ，然后使用 reverse() 方法將列表中的元素進(jìn)行反轉(zhuǎn)，最終輸出了反轉(zhuǎn)后的列表。

需要注意的是， reverse() 方法對(duì)原列表進(jìn)行操作，所以在輸出反轉(zhuǎn)后的列表時(shí)要使用原列表名。

25. slice() 創(chuàng)建一個(gè)切片對(duì)象，用于切片操作

在 Python 中，列表（ list ）是一種序列類型，可以通過(guò)索引操作訪問(wèn)其中的元素。

此外，還可以通過(guò)切片（slice）操作，從一個(gè)列表中獲取子列表。切片操作可以選擇列表的一部分來(lái)返回一個(gè)新的列表對(duì)象。

切片操作使用冒號(hào)（:）表示，它在兩個(gè)索引之間進(jìn)行，中間用冒號(hào)分隔。下面是一些常用的切片操作：

a[start:end]  # 從索引 start 開(kāi)始，到索引 end（不包括 end）結(jié)束
a[start:]     # 從索引 start 開(kāi)始，中間所有的元素
a[:end]       # 從開(kāi)始到索引 end（不包括 end）之間的元素
a[:]          # 所有元素，相當(dāng)于 a.copy()
a[start:end:step]  # 從 start 開(kāi)始，到 end（不包括 end）結(jié)束，步長(zhǎng)為 step

其中， start 表示起始索引（包含在切片中）， end 表示結(jié)束索引（不包含在切片中）， step 表示步長(zhǎng)，默認(rèn)值為 1。

下面是一些示例代碼，演示如何使用切片從列表中獲取子列表：

a = [1, 2, 3, 4, 5, 6]

# 獲取索引為 2 到索引為 4（不包括）之間的元素，即 [3, 4]
print(a[2:4])

# 獲取索引為 0 到索引為 3（不包括）之間的元素，即 [1, 2, 3]
print(a[:3])

# 獲取索引為 3 到列表末尾之間的元素，即 [4, 5, 6]
print(a[3:])

# 獲取列表中的所有元素，即 [1, 2, 3, 4, 5, 6]
print(a[:])

# 獲取列表中的所有偶數(shù)元素，即 [2, 4, 6]
print(a[1::2])

切片操作是 Python 中非常強(qiáng)大和常用的操作之一，它可以方便地從一個(gè)序列中獲取需要的子序列。除了列表之外，其他序列類型（如字符串、元組等）也都支持切片操作。

26. sum() 返回列表中所有元素的和

在 Python 中， sum() 函數(shù)用于計(jì)算序列（如列表、元組等）中所有元素的總和。它接受一個(gè)序列作為參數(shù)，并返回該序列中所有元素的總和。下面是一個(gè)簡(jiǎn)單的示例代碼，演示如何使用 sum() 函數(shù)計(jì)算列表中所有元素的總和：

a = [1, 2, 3, 4, 5]
total = sum(a)
print(total)  # 輸出：15

在上面的代碼中，我們定義了一個(gè)列表 a ，然后使用 sum() 函數(shù)計(jì)算列表中所有元素的總和，并將結(jié)果保存在變量 total 中，最后輸出 total 的值為 15。

需要注意的是， sum() 函數(shù)只能用于序列中元素類型為數(shù)值的情況，例如整數(shù)、浮點(diǎn)數(shù)等。如果序列中包含其他類型的元素，例如字符串或其他非數(shù)值類型的對(duì)象，則會(huì)拋出 TypeError 類型錯(cuò)誤。

在實(shí)際開(kāi)發(fā)中， sum() 函數(shù)可以用于計(jì)算列表中數(shù)值型元素的平均數(shù)，例如：

a = [1, 2, 3, 4, 5]
avg = sum(a) / len(a)
print(avg)  # 輸出：3.0

在上面的代碼中，我們首先使用 sum() 函數(shù)計(jì)算列表 a 中所有元素的總和，然后計(jì)算該列表的平均數(shù)，并將結(jié)果保存在變量 avg 中，最后輸出 avg 的值為 3.0。

27. zip() 將兩個(gè)列表壓縮成一個(gè)元組對(duì)列表，返回一個(gè)zip對(duì)象

在 Python 中， zip() 函數(shù)用于將多個(gè)列表中的元素進(jìn)行逐個(gè)配對(duì)，形成一個(gè)元組，從而得到一個(gè)新的序列。它接受一個(gè)或多個(gè)可迭代對(duì)象作為參數(shù)，并返回一個(gè)由元組組成的迭代器。下面是一個(gè)簡(jiǎn)單的示例代碼，演示如何使用 zip() 函數(shù)將兩個(gè)列表進(jìn)行配對(duì)：

a = [1, 2, 3]
b = ['a', 'b', 'c']
result = zip(a, b)
for item in result:
    print(item)

在上面的代碼中，我們定義了兩個(gè)列表 a 和 b ，分別包含數(shù)值和字符串類型的元素。然后使用 zip() 函數(shù)將這兩個(gè)列表進(jìn)行逐個(gè)配對(duì)，并得到一個(gè)新的迭代器對(duì)象 result 。最后使用 for 循環(huán)遍歷該迭代器，并輸出每個(gè)配對(duì)的元素。運(yùn)行上述代碼，輸出如下：

(1, 'a')
(2, 'b')
(3, 'c')

此外，如果兩個(gè)列表的長(zhǎng)度不同，則 zip() 函數(shù)會(huì)以較短列表的長(zhǎng)度為準(zhǔn)，忽略較長(zhǎng)列表中多余的元素。例如：

a = [1, 2, 3]
b = ['a', 'b']
result = zip(a, b)
for item in result:
    print(item)

在上面的代碼中，列表 b 的長(zhǎng)度為 2，小于列表 a 的長(zhǎng)度 3。因此，在使用 zip() 函數(shù)時(shí)， b 列表中多余的元素會(huì)被忽略。運(yùn)行上述代碼，輸出如下：

(1, 'a')
(2, 'b')

需要注意的是， zip() 函數(shù)返回的是一個(gè)迭代器對(duì)象，如果需要將其轉(zhuǎn)換成列表或其他類型的序列，則可以通過(guò) list() 等函數(shù)進(jìn)行轉(zhuǎn)換。例如：

a = [1, 2, 3]
b = ['a', 'b', 'c']
result = list(zip(a, b))
print(result)  # 輸出：[(1, 'a'), (2, 'b'), (3, 'c')]

以上就是Python中列表list常用方法總結(jié)的詳細(xì)內(nèi)容，更多關(guān)于Python列表list的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！