【Python】Python入門-列表初相識

公眾號：尤而小屋
作者：Peter
編輯：Peter

在之前的文章中，我們已經(jīng)介紹了Python中的兩種常見數(shù)據(jù)類型：字符串和數(shù)字。本文中介紹的是Python中極其重要的數(shù)據(jù)類型：列表。

在Python中，列表用一個方括號[]表示；括號里面可以是數(shù)字，字符串，布爾值（True或者False），甚至還可以嵌套列表等不同的數(shù)據(jù)類型。列表是有序的數(shù)據(jù)類型。

思維導(dǎo)圖

列表定義

列表的定義有多種方式：

空列表

a = []  # 定義一個空列表
a 

[]

type(a)  # 查看對象的類型

list

單層列表

b = [1,2,3]
b

[1, 2, 3]

type(b)

list

c = [1,2,"python"]
c

[1, 2, 'python']

type(c)

list

d = [True,True,False]
d

[True, True, False]

type(d)

list

嵌套列表

e = [1,2,[3,4],"python"]
e

[1, 2, [3, 4], 'python']

type(e)

list

通過布爾函數(shù)bool來判斷一個對象是真還是假：

bool(a)  # 空列表

False

bool(c)  # 非空列表

True

list函數(shù)生成

list("1234")

['1', '2', '3', '4']

小結(jié)：從上面的多個例子，我們可以看到python列表中的數(shù)據(jù)類型是多樣的，從數(shù)字、字符串到布爾類型，再到嵌套的列表，都是裝的下的

操作

列表是Python的重要數(shù)據(jù)類型，其操作也是多樣化的。

基本操作

# 1、求長度

b

[1, 2, 3]

len(b)

3

# 2、連接兩個列表

b + c

[1, 2, 3, 1, 2, 'python']

c + d

[1, 2, 'python', True, True, False]

相當(dāng)于是將兩個列表的內(nèi)容合并之后放在一個大列表中

# 3、成員判斷in

f = ["python","java","php","html"]
f

['python', 'java', 'php', 'html']

"python" in f  # python這個元素是否在列表f中，當(dāng)然是在

True

"html" in f

True

"go" in f  # go不在列表f

False

# 4、列表重復(fù)

c * 3 

[1, 2, 'python', 1, 2, 'python', 1, 2, 'python']

b * 2

[1, 2, 3, 1, 2, 3]

# 5、列表求最值：根據(jù)列表中元素的字典的長度來比較

max(f)  

'python'

f列表中元素的第一個字母p是最大的。當(dāng)?shù)谝粋€字母相同比較第二個字母，y大于h；比較的是兩個字母的ASCII碼大小。

f

['python', 'java', 'php', 'html']

max(b)

3

min(f)

'html'

修改列表元素

之前講過的數(shù)據(jù)類型，字符串和數(shù)值型是不能修改的，但是列表卻是可以進(jìn)行修改的，能夠?qū)崿F(xiàn)增刪改的操作

f

['python', 'java', 'php', 'html']

len(f)  # 長度為4

4

f[1] 

'java'

f[1] = "c++"  # 將索引為1的元素修改成c++
f

['python', 'c++', 'php', 'html']

列表追加元素

往列表中追加元素使用的是append方法；追加到原列表的末尾

f.append("javascript")  # 自動追加到末尾

f

['python', 'c++', 'php', 'html', 'javascript']

列表刪除元素

列表中還可以實現(xiàn)元素的刪除，使用的是del方法

del f[1]

f  # c++被刪除了

['python', 'php', 'html', 'javascript']

列表常用函數(shù)

列表中有幾個常用的函數(shù)，需要我們掌握：

• append：將整體追加到列表的末尾
• extend：列表中的每個元素進(jìn)行合并，組成一個大的列表
• index：查看元素的索引
• insert：指定位置插入元素
• pop：刪除頂部的元素（彈出棧頂元素）
• remove：刪除第一次出現(xiàn)的元素；元素不存在則會報錯
• reverse：將列表中元素的順序顛倒過來；類比reversed
• sort：列表元素的排序；類比sorted

append

往列表的末尾追加元素，返回沒有返回值；直接原地修改

f 

['python', 'php', 'html', 'javascript']

f.append("java")  # 追加到末尾

f

['python', 'php', 'html', 'javascript', 'java']

extend

列表中每個元素的個體追加；原地修改，沒有返回值

print(c)  
print(f)

[1, 2, 'python']
['python', 'php', 'html', 'javascript', 'java']

c.extend(f)

c  # 實現(xiàn)列表c的整體擴張

[1, 2, 'python', 'python', 'php', 'html', 'javascript', 'java']

c.extend("go")   

c

[1, 2, 'python', 'python', 'php', 'html', 'javascript', 'java', 'g', 'o']

如果上字符串元素，會自動的進(jìn)行拆解之后再進(jìn)行擴張追加

c.extend(["go"])  # 只追加列表的一個元素

c

[1, 2, 'python', 'python', 'php', 'html', 'javascript', 'java', 'g', 'o', 'go']

c.extend(3)  # 數(shù)值型數(shù)據(jù)不能進(jìn)行extend，因為它是不可迭代的（iterable）

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-45-35eb2b66cb19> in <module>
----> 1 c.extend(3)  # 數(shù)值型數(shù)據(jù)不能進(jìn)行extend，因為它是不可迭代的（iterable）


TypeError: 'int' object is not iterable

如何查看Python中的數(shù)據(jù)類型是否可迭代？使用hasattr()方法：

hasattr(c,"__iter__")  # 列表可迭代

True

hasattr("learn python","__iter__")  # 字符串可迭代

True

hasattr(3,"__iter__")  # 數(shù)值型數(shù)據(jù)不可迭代

False

如何查看幫助文檔？使用help方法

help(list.extend)

Help on method_descriptor:

extend(self, iterable, /)
    Extend list by appending elements from the iterable.

help(list.append)

Help on method_descriptor:

append(self, object, /)
    Append object to the end of the list.

在上面的例子中我們發(fā)現(xiàn)extend和append執(zhí)行之后，是沒有任何返回值的，它們是在原數(shù)據(jù)上直接添加的。

lst1 = ["python","java","go"]
lst2 = [1,2,3]

id(lst1)  # 查看內(nèi)存地址

4452149200

lst3 = lst1.extend(lst2)

print(lst3)  # 賦值的結(jié)果仍為None

None

lst1   # 其實lst1已經(jīng)變化了

['python', 'java', 'go', 1, 2, 3]

id(lst1)  # 內(nèi)存地址并沒改變

4452149200

像這種修改數(shù)據(jù)之后，內(nèi)存地址仍然沒有變化的操作，我們稱之為原地修改，不影響對象的內(nèi)存地址

二者區(qū)別

• append：整體的追加
• extend：個體化擴編

f

['python', 'php', 'html', 'javascript', 'java']

g = ["go","c++"]

f.append(g)  # 追加整體

f

['python', 'php', 'html', 'javascript', 'java', ['go', 'c++']]

f1 = ['python', 'php', 'html', 'javascript', 'java']  # 和之前f相同

f1.extend(g)  # 每個元素的追加

f1  

['python', 'php', 'html', 'javascript', 'java', 'go', 'c++']

count

統(tǒng)計列表中每個元素出現(xiàn)的次數(shù)

f1.count("python")

1

f1.count("go")

1

f2 = [1,2,3,3,2,3,2,2,1]
f2

[1, 2, 3, 3, 2, 3, 2, 2, 1]

f2.count(3)

3

f2.count(4)  # 元素不存在則為0，而不是報錯

0

Python中有個庫能夠直接統(tǒng)計列表中每個元素的個數(shù)：Count

from collections import Counter

count = Counter(f2)
count

Counter({1: 2, 2: 4, 3: 3})

index

元素第一次出現(xiàn)的索引位置

f2

[1, 2, 3, 3, 2, 3, 2, 2, 1]

f2.index(1)  # 1第一次出現(xiàn)的索引為0

0

f2.index(3)  # 3第一次出現(xiàn)的索引為2

2

f2.index(4)  # 元素不存在則會報錯

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-71-568e9ea7baf1> in <module>
----> 1 f2.index(4)  # 元素不存在則會報錯


ValueError: 4 is not in list

insert

在指定的位置插入數(shù)據(jù)。append和extend都是在末尾添加。list.insert(i,"待插入元素")，表示在索引i之前插入元素

lst1  # 查看lst1列表

['python', 'java', 'go', 1, 2, 3]

lst1.insert(1,"c++")  # 1號索引位置插入c++

同樣是沒有返回值，說明是原地修改，lst1已經(jīng)發(fā)生了變化，但是內(nèi)存地址不變。

lst1

['python', 'c++', 'java', 'go', 1, 2, 3]

len(lst1)  # 長度為7

7

lst1.insert(9, "html")

lst1

['python', 'c++', 'java', 'go', 1, 2, 3, 'html']

上面的例子我們觀察到，雖然lst1的長度為7，但是在9號索引之前仍是可以插入成功的

lst4 = ["go","python"]  # 長度為2

lst4.insert(10,"java")

lst4  # 仍然是可以插入成功

['go', 'python', 'java']

說明當(dāng)插入的索大于原列表的長度時候，會直接追加到末尾

小結(jié)：insert方法也是沒有返回值的，原地修改

pop

pop方法表示的是刪除頂部的元素；而且運行之后返回的就是該元素

lst1

['python', 'c++', 'java', 'go', 1, 2, 3, 'html']

lst1.pop()  

'html'

通過運行結(jié)果發(fā)現(xiàn)：

• 最后面的元素被刪除了
• 函數(shù)運行后返回的是刪除的元素

lst1   #  已經(jīng)沒有了html元素

['python', 'c++', 'java', 'go', 1, 2, 3]

remove

刪除列表中的第一次出現(xiàn)的某個元素，也就是說如果某個元素在列表中重復(fù)出現(xiàn)，只刪除第一個

• 原地刪除數(shù)據(jù)，沒有返回值
• 重復(fù)元素刪除第一個

lst5 = ["python","go","java","python","c++"]
lst5

['python', 'go', 'java', 'python', 'c++']

lst5.remove("python")  # 原地刪除，沒有返回值

lst5  # 第一個python已經(jīng)被刪除了

['go', 'java', 'python', 'c++']

lst5.remove("java")

lst5  # java被刪除了

['go', 'python', 'c++']

如果元素不存在呢？運行結(jié)果直接報錯：

lst5.remove("html")

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-88-957c479875d4> in <module>
----> 1 lst5.remove("html")


ValueError: list.remove(x): x not in list

reverse

將列表中的元素進(jìn)行翻轉(zhuǎn)，函數(shù)沒有返回值

lst5

['go', 'python', 'c++']

lst5.reverse()  # 沒有返回值

lst5  # 列表已經(jīng)翻轉(zhuǎn)

['c++', 'python', 'go']

對比下reversed(list_object)函數(shù)，該函數(shù)返回的是翻轉(zhuǎn)后的可迭代對象：

reversed(lst5)  # 翻轉(zhuǎn)的可迭代對象

<list_reverseiterator at 0x109689490>

實施翻轉(zhuǎn)之后是一個可迭代對象，我們需要使用list函數(shù)進(jìn)行展開：

list(reversed(lst5))  # lst5再次翻轉(zhuǎn)

['go', 'python', 'c++']

sort

對列表中的元素進(jìn)行排序，只接受對列表的排序，中文官網(wǎng)學(xué)習(xí)地址：https://docs.python.org/zh-cn/3/howto/sorting.html

list.sort(key=None, reverse=False)

• key : 主要是用來進(jìn)行比較的元素，只有一個參數(shù)，具體的函數(shù)的參數(shù)就是取自于可迭代對象中，指定可迭代對象中的一個元素來進(jìn)行排序。
• reverse : 排序規(guī)則，reverse = True 降序， reverse = False 升序（默認(rèn)）。

lst6 = ["python","javascript","go","java","html","c++"]
lst6

['python', 'javascript', 'go', 'java', 'html', 'c++']

1、默認(rèn)使用情況如下例子：

# 默認(rèn)

lst6.sort()  

lst6

['c++', 'go', 'html', 'java', 'javascript', 'python']

從第一個字母的ASCII碼開始比較，如果相同就比較下一個字母；默認(rèn)是升序

ord("c")   # 查看c的ASCII碼值

99

chr(99)

'c'

chr(1000)   # 每個數(shù)值都有對應(yīng)的元素

'?'

chr(400)

'?'

2、參數(shù)reverse的使用：

lst6

['c++', 'go', 'html', 'java', 'javascript', 'python']

lst6.sort(reverse=True)

lst6  # 改成了降序

['python', 'javascript', 'java', 'html', 'go', 'c++']

3、參數(shù)key的使用

student = ["xiaoming","xiaozhang","Peter","Mike","Tom","Jimmy"]  # 定義新列表
student

['xiaoming', 'xiaozhang', 'Peter', 'Mike', 'Tom', 'Jimmy']

student.sort(key=len)

student

['Tom', 'Mike', 'Peter', 'Jimmy', 'xiaoming', 'xiaozhang']

根據(jù)傳入?yún)?shù)key的len函數(shù)，求解student列表中每個原始的長度，升序排列

student.sort(key=str.lower)    # 列表中的元素全部變成小寫開頭，再進(jìn)行比較

student   

['Jimmy', 'Mike', 'Peter', 'Tom', 'xiaoming', 'xiaozhang']

根據(jù)首字母的順序進(jìn)行比較，升序排列

ord("j")  # str.lower函數(shù)已經(jīng)全部轉(zhuǎn)成了小寫

106

ord("m")

109

ord("p")  # 其余類推

112

關(guān)于另一個排序sorted函數(shù)，最大的不同點是：它對任何可迭代對象都可以進(jìn)行排序，不僅僅是列表；同時，函數(shù)有返回值

• 針對任何可迭代對象
• 有返回值

student

['Jimmy', 'Mike', 'Peter', 'Tom', 'xiaoming', 'xiaozhang']

sorted(student)   # 默認(rèn)按照字母的ASCII碼大小來排序

['Jimmy', 'Mike', 'Peter', 'Tom', 'xiaoming', 'xiaozhang']

sorted(student,key=len)

['Tom', 'Mike', 'Jimmy', 'Peter', 'xiaoming', 'xiaozhang']

sorted(student,key=str.lower)  # 字母變成小寫之后再排序

['Jimmy', 'Mike', 'Peter', 'Tom', 'xiaoming', 'xiaozhang']

針對其他可迭代對象的排序，比如字符串：

strings = "I am learning python"  # 定義一個字符串strings

sorted(strings.split(),key=len)

['I', 'am', 'python', 'learning']

上面代碼的含義是先對字符串使用切割函數(shù)split（默認(rèn)根據(jù)空格切割），對切割之后的每個字符串求長度len，升序排列得到結(jié)果

student   #  原列表是一直不變化的

['Jimmy', 'Mike', 'Peter', 'Tom', 'xiaoming', 'xiaozhang']

對嵌套列表的排序過程：

lst9 = [[5,"python"],[2,"java"],[3,"c++"],[1,"javascript"]]

sorted(lst9)

[[1, 'javascript'], [2, 'java'], [3, 'c++'], [5, 'python']]

sorted(lst9,key=lambda x:len(x[1]))

[[3, 'c++'], [2, 'java'], [5, 'python'], [1, 'javascript']]

解釋下上面的代碼：

• lambda是python的匿名函數(shù)（后面會詳細(xì)介紹）x為函數(shù)的參數(shù)
• 匿名函數(shù)的功能是取出列表中索引為1的元素，求出長度len
• 根據(jù)長度升序排列，長度最短為3（c++），最長為10（javascript）

lst9   # 沒有變化

[[5, 'python'], [2, 'java'], [3, 'c++'], [1, 'javascript']]

因為sorted函數(shù)有返回值，所以對原對象是不會有影響的。