在 Python 中，列表（List）是一種有序的數(shù)據(jù)集合，可以存儲任意類型的數(shù)據(jù)，例如整數(shù)、浮點數(shù)、字符串、元組、列表等。因為列表是有序的，所以可以通過下標(biāo)（索引）來訪問和修改列表中的元素。Python 中的列表是可變的，也就是說可以動態(tài)增加和刪除元素。

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

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

可以通過下標(biāo)來訪問和修改列表中的元素，下標(biāo)從0開始計數(shù)。例如，可以使用以下方式訪問和修改列表中的元素：

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

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

a = [1, 2, 3, 4, 5]
length = len(a)   # 獲取列表的長度，結(jié)果為5
b = a + [6, 7, 8]   # 連接兩個列表
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ù)來對列表進行操作，例如 append() 方法可以向列表中添加一個元素， pop() 方法可以刪除列表中的一個元素等。例如，以下是一些常見的列表操作：

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

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

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

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

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

在Python中，list類型的copy()方法用于創(chuàng)建一個原列表的副本，返回一個新的列表對象。副本是原列表的淺拷貝，即只復(fù)制了列表對象本身，而不是列表中的元素對象。如果列表中的元素是可變對象，修改副本中的元素也會影響原列表中的元素，因為副本和原列表引用了同一批元素對象。 示例代碼：

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)建一個新的列表對象new_list，其內(nèi)容與原列表my_list相同。然后，我們通過修改new_list的第一個元素，演示了副本和原列表之間的區(qū)別。

我們可以看到，新列表中的第一個元素被修改為了4，而原列表中的第一個元素仍然是1。這是因為new_list和my_list引用了不同的元素對象。

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

在Python中，列表(list)類型提供了 count() 方法，用于統(tǒng)計某個元素在列表中出現(xiàn)的次數(shù)。 count() 方法接受一個參數(shù)，表示要統(tǒng)計的元素。該方法返回一個整數(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)建了一個包含6個元素的列表 my_list ，其中數(shù)字 1 出現(xiàn)了3次。我們使用 count() 方法統(tǒng)計數(shù)字 1 在列表中出現(xiàn)的次數(shù)，并將結(jié)果保存到變量 count_1 中，輸出結(jié)果為 3 。

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

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

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

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

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

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

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

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

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

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

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

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

如果要查找的元素在列表中出現(xiàn)了多次， index() 方法只會返回其第一次出現(xiàn)的索引位置。如果要查找所有出現(xiàn)位置的索引值，可以使用列表推導(dǎo)式實現(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)建了一個列表my_list，包含了數(shù)字1~6，同時數(shù)字2在列表中出現(xiàn)了三次。接著，我們使用列表推導(dǎo)式查找所有數(shù)字2在列表中出現(xiàn)的索引位置，并將結(jié)果保存到變量indices中，最后輸出indices，結(jié)果為 [1, 3, 6] 。

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

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

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

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

需要注意的是， insert() 方法會直接修改原列表，而不是創(chuàng)建一個新的列表。如果需要在原列表的基礎(chǔ)上創(chuàng)建一個新的列表，則需要使用列表的切片（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)建了一個列表my_list，包含了數(shù)字1~5。然后，我們使用切片操作將原列表分成兩部分，再在中間插入字符串"hello"，最后將兩部分合并成一個新的列表new_list，結(jié)果與 insert() 方法的示例代碼相同。

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

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

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

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

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

8. remove() 移除列表中某個值的第一個匹配項

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

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

在上述示例代碼中，我們首先創(chuàng)建了一個列表my_list，包含了數(shù)字1~5和一個額外的數(shù)字4。然后，我們使用 remove() 方法刪除第一個匹配的元素4，最后輸出my_list的值，結(jié)果為 [1, 2, 3, 5, 4] 。 需要注意的是， remove() 方法會直接修改原列表，而不是創(chuàng)建一個新的列表。如果需要在原列表的基礎(chǔ)上創(chuàng)建一個新的列表，則需要使用列表的切片（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)建了一個列表my_list，包含了數(shù)字1~5和一個額外的數(shù)字4。然后，我們使用列表推導(dǎo)式創(chuàng)建一個新列表new_list，該列表中包含了my_list中所有不等于4的元素。最后輸出new_list的值，結(jié)果與 remove() 方法的示例代碼相同。

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

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

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

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

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

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

10. sort() 對原列表進行排序

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

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

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

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

在上述代碼中，我們首先創(chuàng)建了一個包含六個數(shù)字的列表my_list。然后，我們使用 sort() 方法對該列表進行排序，并指定 reverse=True ，即按降序進行排序。輸出結(jié)果為 [9, 8, 6, 3, 2, 1] ，即按數(shù)字大小從大到小排序的結(jié)果。 需要注意的是， sort() 方法會直接修改原列表，而不是創(chuàng)建一個新列表。如果需要在原列表的基礎(chǔ)上創(chuàng)建一個新的列表，則需要使用列表的切片（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() 對 my_list 進行排序，并將結(jié)果保存到新列表 new_list 中。由于 sorted() 方法不會修改原列表，因此該方法返回的結(jié)果是一個新的列表。最后輸出new_list的值，結(jié)果與 sort() 方法的示例代碼相同。

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

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

new_list = list.fromkeys(seq, value)

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

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

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

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

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

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)建了一個包含三個字符串的列表 my_list 。然后使用 get() 方法獲取了第二個元素，即索引位置為 1 的元素，輸出結(jié)果為 'banana' 。接下來使用 get() 方法獲取了列表中不存在的第四個元素，同時通過 default 參數(shù)設(shè)定了默認(rèn)值為 'orange' ，輸出結(jié)果為 'orange' 。

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

13. items() 返回一個包含所有字典項的列表

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

list.items()

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

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

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

0 apple
1 banana
2 cherry

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

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

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

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

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

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

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

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

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

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

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

需要注意的是，在調(diào)用 setdefault() 方法時，第一個參數(shù)是要獲取或設(shè)置的鍵，第二個參數(shù)是默認(rèn)值，可以省略。如果省略第二個參數(shù)，則默認(rèn)值為 None 。如果需要在列表類型中實現(xiàn)類似 setdefault() 方法的功能，可以在獲取元素時使用 try-except 語句，如果索引超出了范圍，則返回默認(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  # 該行代碼不會執(zhí)行

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

列表也就是list類型有一個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

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

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

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

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

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

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

輸出結(jié)果為：

0 apple
1 banana
2 orange

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

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

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

該方法用于根據(jù)函數(shù)返回值的真假來過濾一個列表，返回一個新的列表。該函數(shù)接受兩個參數(shù)，第一個參數(shù)是一個函數(shù)，該函數(shù)接受一個參數(shù)并返回真或假；第二個參數(shù)是要被過濾的列表。 下面是一個使用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] 在上面的代碼中，我們首先定義了一個列表my_list，然后使用filter()方法過濾出其中的偶數(shù)元素，并將結(jié)果存儲到一個新的列表new_list中，最后打印出來。

需要注意的是，filter()方法返回的是一個filter對象，如果需要將它轉(zhuǎn)換成一個列表，需要使用list()方法。同時也可以使用列表解析(list comprehension)的方式來實現(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]

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

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

該方法用于將一個列表中的每一個元素都執(zhí)行一個指定的函數(shù)，返回一個新的列表，新列表中的元素就是每個元素執(zhí)行函數(shù)的結(jié)果。 下面是一個使用 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] 在上面的代碼中，我們定義了一個列表 my_list，然后使用 map() 方法將列表中的每個元素都乘以 2，最后將得到的結(jié)果存儲到一個新的列表 new_list 中，并打印出來。

需要注意的是，map() 方法返回的是一個 map 對象，如果需要將它轉(zhuǎn)換成一個列表，需要使用 list() 方法。同時也可以使用列表解析(list comprehension)的方式來實現(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]

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

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

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

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

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() 方法來對列表中的所有元素求和。函數(shù) lambda x, y: x + y 用于將兩個元素相加，而 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)置的序列類型，它用于存儲一組有序的元素。 list 列表提供了一系列方法用于對序列進行操作，其中包括 reverse() 方法。 reverse() 方法用于對列表中的元素進行反轉(zhuǎn)。該方法沒有參數(shù)，只是將列表中的元素順序進行翻轉(zhuǎn)，直接修改原列表，不返回任何值。

下面是一個使用 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]

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

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

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

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

此外，還可以通過切片（slice）操作，從一個列表中獲取子列表。切片操作可以選擇列表的一部分來返回一個新的列表對象。

切片操作使用冒號（:）表示，它在兩個索引之間進行，中間用冒號分隔。下面是一些常用的切片操作：

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

其中， start 表示起始索引（包含在切片中）， end 表示結(jié)束索引（不包含在切片中）， step 表示步長，默認(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 中非常強大和常用的操作之一，它可以方便地從一個序列中獲取需要的子序列。除了列表之外，其他序列類型（如字符串、元組等）也都支持切片操作。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

需要注意的是， zip() 函數(shù)返回的是一個迭代器對象，如果需要將其轉(zhuǎn)換成列表或其他類型的序列，則可以通過 list() 等函數(shù)進行轉(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的資料請關(guān)注腳本之家其它相關(guān)文章！

最新評論