Python 內建的四種常用資料結構：列表（list）、元組（tuple）、字典（dict）以及集合（set）。

這四種資料結構一但都可用於儲存多個數據項，這對於程式設計而言是非常重要的，因為程式不僅需要使用單個變數來儲存資料，還需要使用多種資料結構來儲存大量資料，而列表、元組、字典和集合就可滿足儲存大量資料的需求。

列表（list）和元組（tuple）比較相似，它們都按順序儲存元素，每個元素都有自己的索引，因此列表和元組都可通過索引訪問元素。二者的區別在於元組是不可修改的，但列表是可修改的。

字典（dict）和集合（set）類似，它們儲存的資料都是無序的，其中字典是用 key-value 的形式儲存資料

python 序列詳解

所謂序列，指的是一塊可存放多個值的連續記憶體空間，這些值按一定順序排列，可通過每個值所在位置的編號（稱為索引）訪問它們。

無論是採用正索引值，還是負索引值，都可以訪問序列中的任何元素。

注意，在使用負值作為列序中各元素的索引值時，是從 -1 開始，而不是從 0 開始。

[root@kube list]# cat demo1.py 
str="Py序列化詳解"
print(str[0],"---",str[-6])
print(str[5],str[-1])
[root@kube list]# py demo1.py 
P --- y
詳 --- 解
[root@kube list]#

序列切片

切片操作是訪問序列中元素的另一種方法，它可以訪問一定範圍內的元素，通過切片操作，可以生成一個新的序列。

序列實現切片操作的語法格式如下：

sname[start : end : step]

其中，各個引數的含義分別是：

sname：表示序列的名稱；

start：表示切片的開始索引位置（包括該位置），此引數也可以不指定，會預設為 0，也就是從序列的開頭進行切片；

end：表示切片的結束索引位置（不包括該位置），如果不指定，則預設為序列的長度；

step：表示在切片過程中，隔幾個儲存位置（包含當前位置）取一次元素，也就是說，如果 step 的值大於 1，則在進行切片去序列元素時，會“跳躍式”的取元素。如果省略設定 step 的值，則最後一個冒號就可以省略。

[root@kube list]# cat demo2.py
str="py序列切片"
print(str[:0])        #end 為0 表示結束索引位置但是不包括該位置,因此為空 
print(str[:1])
print(str[:2])
print(str[1:2])
num="123456789"
print(num[1:5:2])       #在1-5 的區間中隔兩位取一個值
[root@kube list]# py demo2.py 

p
py
y
24
[root@kube list]#

序列相加

Python 中，支援兩種型別相同的序列使用“+”運算子做相加操作，它會將兩個序列進行連線，但不會去除重複的元素。

裡所說的“型別相同”，指的是“+”運算子的兩側序列要麼都是序列型別，要麼都是元組型別，要麼都是字串。

root@kube list]# cat demo3.py 
print("你好"+"我好"+"dajiahao")
[root@kube list]# py demo3.py 
你好我好dajiahao
[root@kube list]# 

序列相乘

Python 中，使用數字 n 乘以一個序列會生成新的序列，其內容為原來序列被重複 n 次的結果

[root@kube list]# cat demo3.py 
str="你好"+"我好"+"dajiahao"
print(str*3)
[root@kube list]# py demo3.py 
你好我好dajiahao你好我好dajiahao你好我好dajiahao
[root@kube list]# 

檢查元素是否包含在序列中

Python 中，可以使用 in 關鍵字檢查某元素是否為序列的成員，其語法格式為：

value in sequence

和 in 關鍵字用法相同，但功能恰好相反的，還有 not in 關鍵字，它用法檢查某個元素是否不包含在指定的序列中

value not in sequence

[root@kube list]# cat demo4.py 
#coding:utf-8

str="test.com.cn"
print('e' in str)
print('e' not in str)
[root@kube list]# py demo4.py 
True
False
[root@kube list]#

和序列相關的內建函式

Python提供了幾個內建函式（表 3 所示），可用於實現與序列相關的一些常用操作

表 3 序列相關的內建函式

[root@kube list]# cat demo5.py 
str="test.com.cn"
print(max(str))
print(min(str))
print(len(str))
print(list(str))
[root@kube list]# py demo5.py 
t
.
11
['t','e','s','t','.','c','o','m','n']
[root@kube list]#

python list 列表

Python 中沒有陣列，但是加入了更加強大的列表。如果把陣列看做是一個集裝箱，那麼 Python 的列表就是一個工廠的倉庫。

從形式上看，列表會將所有元素都放在一對中括號 [] 中，相鄰元素之間用逗號分隔，格式中，element1~elementn 表示列表中的元素，個數沒有限制，只要是 Python 支援的資料型別就可以。如下所示

[element1,element2,element3,...,elementn]

[root@kube list]# cat demo6.py
lt=['c.test.com',1,[2,3],2.34,'aa']
print(lt)
print(type(lt))
[root@kube list]# py demo6.py 
['c.test.com','aa']
<class 'list'>
[root@kube list]#

建立列表

[root@kube list]# cat demo7.py
lt=[1,'x.test.com',3]]       # = 號賦值使用 []  括起來
str="1234test"
print(type(lt))
print(type(str))
lt2=list(str)             #使用 list() 函式轉換
print(lt2)
print(type(lt2))
[root@kube list]# py demo7.py 
<class 'list'>
<class 'str'>
['1','2','3','4','t']
<class 'list'>
[root@kube list]#

python 訪問和刪除列表

[root@kube list]# cat demo8.py
vol=[1,'test.com',[3,4,5],44,'fff','ee']
print(vol[:1])
print(vol[:2])
print(vol[2:4])
del vol
print(vol)
[root@kube list]# py demo8.py 
[1]
[1,'test.com']
[[3,44]
Traceback (most recent call last):
 File "demo8.py",line 6,in <module>
  print(vol)
NameError: name 'vol' is not defined
[root@kube list]#

python list 列表新增元素的三種方法

append() 方法用於在列表的末尾追加元素，該方法的語法格式如下：

listname.append(obj)

當然，如果希望不將被追加的列表或元組當成一個整體，而是隻追加列表中的元素，則可使用列表提供的 extend() 方法。extend()方法的語法格式如下：

listname.extend(obj)

如果希望在列表中間增加元素，則可使用列表的 insert() 方法，此方法的語法格式為：

listname.insert(index,obj)

其中，index 引數指的是將元素插入到列表中指定位置處的索引值。

使用 insert() 方法向列表中插入元素，和 append() 方法一樣，無論插入的物件是列表還是元組，都只會將其整體視為一個元素。

[root@kube list]# cat demo9.py
a_list=['test.com.cn',2,'a']]
a_list.append('b')
print(a_list)
a_list.extend([9,8,7])
print(a_list)
a_list.insert(4,'MM')
print(a_list)
[root@kube list]# py demo9.py 
['test.com.cn','a'],'b']
['test.com.cn','b',9,7]
['test.com.cn','MM',7]
[root@kube list]#

python list 列表刪除元素的三種方法

在列表中刪除元素，主要分為以下 3 種應用場景：

1 根據目標元素所在位置的索引值進行刪除，可使用 del 語句；

2 根據元素的值進行刪除，可使用列表（list型別）提供的 remove() 方法；

3 將列表中所有元素全部刪除，可使用列表（list型別）提供的 clear() 方法。

python list 修改元素

列表的元素相當於變數，因此程式可以對列表的元素賦值，這樣即可修改列表的元素

slice 分片同樣可以使用

[root@kube list]# cat demo11.py 
a_list=list(range(0,10))    #list() 函式轉換為列表
print(a_list)
a_list[2]='a'         #替換序列為2 的值
print(a_list)
a_list[-1]='ffff'       #替換序列為-1 的值
print(a_list)
a_list[3:4]=['s','d']     #替換分片3-4 的值
print(a_list)
a_list[4:6]=[]         #把 4-6 的值替換為空
print(a_list)
a_list[1:3]='test'       #對列表使用 slice 語法賦值時，不能使用單個值；如果使用字串賦值，Python會自動把字串當成序列處理，其中每個字元都是一個元素。
print(a_list)
a_list[2:6:2]=['MM','NN']    #在使用 slice 語法賦值時，也可指定 step 引數。但如果指定了 step 引數，則要求所賦值的列表元素個數與所替換的列表元素個數相等
print(a_list)
[root@kube list]# py demo11.py 
[0,3,5,6,7,9]
[0,'a','ffff']
[0,'d','NN','ffff']
[root@kube list]#

python list 常用方法

除前面的增加元素、刪除元素、修改元素方法之外，列表還包含了一些常用的方法。

count() 方法,此方法用於統計列表中某個元素出現的次數

listname.count(obj)

index() 方法用於定位某個元素在列表中出現的位置（也就是索引），如果該元素沒有出現，則會引發 ValueError 錯誤。此方法的基本語法格式為

listname.index(obj,start,end)

同 count() 方法不同，index() 方法還可傳入 start、end 引數，用於在列表的指定範圍內搜尋元素。

pop() 方法會移除列表中指定索引處的元素，如果不指定，預設會移除列表中最後一個元素。該方法的基本語法格式為：

listname.pop(index)

reverse() 方法會將列表中所有元素反向存放。該方法的基本語法格式為：

listname.reverse()

sort() 方法用於對列表元素進行排序，排序後原列表中的元素順序會方發生改變。sort() 方法的語法格式如下：

listname.sort(key=None,reserse=False)

可以看到，和其他方法不同，此方法中多了 2 個引數，它們的作用分別是：

key 引數用於指定從每個元素中提取一個用於比較的鍵。例如，使用此方法時設定 key=str.lower 表示在排序時不區分字母大小寫。

reverse 引數用於設定是否需要反轉排序，預設 False 表示從小到大排序；如果將該引數設為 True，將會改為從大到小排序。

下面程式碼示範了使用列表作為“棧”的示例：

stack = []
# 向棧中“入棧”3個元素
stack.append("fkit")
stack.append("crazyit")
stack.append("Charlie")
print(stack) # ['fkit','crazyit','Charlie']
# 第一次出棧：最後入棧的元素被移出棧
print(stack.pop())
print(stack) # ['fkit','crazyit']
# 再次出棧
print(stack.pop())
print(stack) # ['fkit']

python range 快速初始化數字列表

ython range() 函式能夠輕鬆地生成一系列的數字。例如，可以像如下這樣使用 range() 來列印一系列數字：

[root@kube list]# cat demo14.py 
#coding:utf-8
seq=[]
for i in range(1,4):  #求1-3 的乘積
  vol=i**2
  seq.append(vol)
print(seq)

print('----------------------------')
print(type([1,4]))   #range 的type 型別的轉化
print(type(range(1,5)))
[root@kube list]# py demo14.py 
[1,9]
----------------------------
<class 'list'>
<class 'range'>
[root@kube list]#

python list 列表實現棧和佇列

佇列和棧是兩種資料結構，其內部都是按照固定順序來存放變數的，二者的區別在於對資料的存取順序：

佇列是，先存入的資料最先取出，即“先進先出”。

棧是，最後存入的資料最先取出，即“後進先出”。

考慮到 list 型別資料本身的存放就是有順序的，而且內部元素又可以是各不相同的型別，非常適合用於佇列和棧的實現。本節將演示如何使用 list 型別變數來實現佇列和棧。

python list 列表實現

使用 list 列表模擬佇列功能的實現方法是，定義一個 list 變數，存入資料時使用 insert() 方法，設定其第一個引數為 0，即表示每次都從最前面插入資料；讀取資料時，使用 pop() 方法，即將佇列的最後一個元素彈出。

[root@kube list]# cat demo15.py 
#coding:utf-8

#定義一個空列表，當做佇列
queue = []
#向列表中插入元素
queue.insert(0,"one")
queue.insert(0,"two")
queue.insert(0,"three")
print(queue)
print('取第一個元素:',queue.pop())    #pop() 預設取佇列最後一位
print('取第二個元素:',queue.pop())
print('取第三個元素:',queue.pop())

[root@kube list]# py demo15.py 
['three','two','one']
取第一個元素: one
取第二個元素: two
取第三個元素: three
[root@kube list]#

python 實現棧

使用 list 列表模擬棧功能的實現方法是，使用 append() 方法存入資料；使用 pop() 方法讀取資料。append() 方法向 list 中存入資料時，每次都在最後面新增資料，這和前面程式中的 insert() 方法正好相反。

[root@kube list]# cat demo16.py 
#coding:utf-8

#定義一個list 當棧
stack = []
stack.append('one')
stack.append('two')
stack.append('three')
print(stack)
print('取第一個元素:',stack.pop())
print('取第二個元素:',stack.pop())
print('取第三個元素:',stack.pop())
[root@kube list]# py demo16.py 
['one','three']
取第一個元素: three
取第二個元素: two
取第三個元素: one
[root@kube list]#

collections模組實現棧和佇列

queueAndStack = deque()
queueAndStack.append(1)
queueAndStack.append(2)
queueAndStack.append("hello")
print(list(queueAndStack))
#實現佇列功能，從佇列中取一個元素，根據先進先出原則，這裡應輸出 1
print(queueAndStack.popleft())
#實現棧功能，從棧裡取一個元素，根據後進先出原則，這裡應輸出 hello
print(queueAndStack.pop())
#再次列印列表
print(list(queueAndStack))

以上就是深入瞭解python列表（LIST）的詳細內容，更多關於Python（list）的資料請關注我們其它相關文章！