python中常用的經典數據結構有哪些

今天小編給大家分享一下python中常用的經典數據結構有哪些的相關知識點，內容詳細，邏輯清晰，相信大部分人都還太了解這方面的知識，所以分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后有所收獲，下面我們一起來了解一下吧。

NumPy包中的數據結構

NumPy中的數據結構，包括Ndarray、Matrix

數組（Ndarray）

創建Ndarray

• 引入NumPy包，將其命名為np。在引入NumPy包后方可使用數組數據結構

import numpy as np

創建數組對象，在NumPy包中：

1. array() 方法可以把序列型對象轉換成數組；

2. arange() 方法可以生成自定義終點的一堆數組；

3. ones 生成值全為1的數組；

4. empty() 方法會生成一個給定類型和維度且不進行數據初始化的數組；

5. random() 生成隨機數組；

6. linspace() 生成指定起止數值和步長的一維數組，例如生成一個從1到10的元素個數為5的數組

import numpy as np
array001 = np.array([1,2,3,4,5,6,7,8,9,10,11,12])
a2 = np.arange(5)
a3 = np.ones((2,2))
a4 = np.empty((2,2))
a5 = np.random.rand(4,2)
a6 = np.linspace(10,30,5)
print('\n序列型數據轉化得到數組:',array001,
      '\n顯示該數據結構類型:',type(array001),
      '\narange()函數創建的數組:',a2,
      '\nones()函數創建的全1數組:\n',a3,
      '\nempty()函數創建的未賦值的數組:\n',a4,
      '\nrandom()函數創建的隨機數組:\n',a5,
      '\nlinespace()函數創建的隨機數組:',a6)

序列型數據轉化得到數組: [ 1  2  3  4  5  6  7  8  9 10 11 12] 
顯示該數據結構類型: <class 'numpy.ndarray'> 
arange()函數創建的數組: [0 1 2 3 4] 
ones()函數創建的全1數組:
 [[1. 1.]
 [1. 1.]] 
empty()函數創建的未賦值的數組:
 [[0. 0.]
 [0. 0.]] 
random()函數創建的隨機數組:
 [[0.39902074 0.63298526]
 [0.09231821 0.23007193]
 [0.09899536 0.83000881]
 [0.27760961 0.65135898]] 
linespace()函數創建的隨機數組: [10. 15. 20. 25. 30.]

Ndarray查詢操作

數組可以通過 array[a:b] 從數組中提取子集，也可以在此基礎上進行批量賦值操作。

array002 = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
print('\n一維數組索引:',array001[4:],
      '\n二維數組索引:',array002[1:3,2:4]) #2-3行、3-4列

一維數組索引: [ 5  6  7  8  9 10 11 12] 
二維數組索引: [[ 7  8] [11 12]]

以下均為多維數組中的常用屬性，其中，shape 可以返回對象的數據結構，例如行數與列數，除了返回一個表示數組各維度的元組，也可以通過 reshape 改變數組的結構

array004 = array001.reshape(3,-1)
print('\n改變結構后的數組\n',array004,
      '\n數組各個維度：',array004.shape,
      '\n數組結構類型：',array004.dtype,
      '\n數組數據個數：',array004.size,
      '\n數組數據類型字節數：',array004.itemsize,
      '\n數組維度：',array004.ndim)

改變結構后的數組
 [[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]] 
數組各個維度： (3, 4) 
數組結構類型： int32 
數組數據個數： 12 
數組數據類型字節數： 4 
數組維度： 2

Ndarray增加操作

• append() 函數可以增加元素或者列表類型的數據，但必須注意維度需要保持一致。

array003 = np.append(array002,[[1],[2],[3]],axis = 1) # axis = 1 按列方向添加
print('\n增加一列后的數組\n',array003)

增加一列后的數組
 [[ 1  2  3  4  1]
 [ 5  6  7  8  2]
 [ 9 10 11 12  3]]

Ndarray 刪除操作

• 使用 delete(x,i,axis=) 方法可以刪除數組對象中行或者列，第三個參數 axis 決定了刪除的是行還是列，需要刪除的對象可以是一個數，也可以是一個元組。

array003 = array002.T
print('刪除單行后的數組：\n',np.delete(array003,1,axis=0)) # axis=0刪除行
array003 = array002.T
print('批量刪除后的數組：\n',np.delete(array003,(1,3),0))
array003 = array002.T
print('刪除單列后的數組\n',np.delete(array003,1,1)) # axis=1刪除列

刪除單行后的數組：
 [[ 1  5  9]
 [ 3  7 11]
 [ 4  8 12]]
批量刪除后的數組：
 [[ 1  5  9]
 [ 3  7 11]]
刪除單列后的數組
 [[ 1  9]
 [ 2 10]
 [ 3 11]
 [ 4 12]]

Ndarray修改

• 可以使用索引的方式進行數組數據的批量修改。

array002[1:2]=0
print('數組批量賦值\n',array002)
array003 = array002.T
array003[1][1] = 100
print('修改數值后的數組\n',array003)

數組批量賦值
 [[ 1  2  3  4]
 [ 0  0  0  0]
 [ 9 10 11 12]]
修改數值后的數組
 [[  1   0   9]
 [  2 100  10]
 [  3   0  11]
 [  4   0  12]]

Ndarray其它操作

1.二維數組轉置。array.T 可以得到數組對象轉置后的結果

2.數組的堆疊。首先新進兩個數組，之后依次使用 vstack 進行縱向堆疊和使用 hstack 進行橫向堆疊

arr1 = np.array([1,2,3])
arr2 = np.array([4,5,6])
print('縱向堆疊后：\n',np.vstack((arr1,arr2)),
      '\n橫向堆疊后：\n',np.hstack((arr1,arr2)))

縱向堆疊后：
 [[1 2 3]
 [4 5 6]] 
橫向堆疊后：
 [1 2 3 4 5 6]

Ndarray轉化成其它數據結構

arr3 = np.array([[1,2,3],[4,5,6]])
print('轉換前的Ndarray是：\n',arr3)
import pandas as pd
dfFromNdarray = pd.DataFrame(arr3)
print('Ndarray轉化為DataFrame的結果是：\n',dfFromNdarray) #帶行號和列號

轉換前的Ndarray是：
 [[1 2 3]
 [4 5 6]]
Ndarray轉化為DataFrame的結果是：
    0  1  2
0  1  2  3
1  4  5  6

arrFromDataFrame = dfFromNdarray.values
print('DataFrame轉化為Ndarry的結果是：\n',arrFromDataFrame) #只提取value值

DataFrame轉化為Ndarry的結果是：
 [[1 2 3]
 [4 5 6]]

矩陣（Matrix）

創建Matrix

• 使用mat()方法可以把其他數據結構的對象轉換為矩陣類型。

array1 = [1,2,3]
array2 = [6,7,8]
array3 = [11,12,17]
matrix = np.mat([array1,array2,array3])
print('顯示該數據結構類型：',type(matrix))
print(matrix)

顯示該數據結構類型： <class 'numpy.matrix'>
[[ 1  2  3]
 [ 6  7  8]
 [11 12 17]]

創建隨機矩陣，在numpy中包含了許多創建特殊矩陣的方法，這里使用 empty() 方法創建一個新的數據隨機的矩陣

matrix1 = np.empty((3,3))
print(matrix1)

[[ 0.00000000e+000  0.00000000e+000  0.00000000e+000]
 [ 0.00000000e+000  0.00000000e+000  2.27270197e-321]
 [ 9.30350261e+199  1.10343781e-312 -3.38460783e+125]]

Matrix查詢操作

• 在矩陣中有一下常用屬性用于觀察矩陣

print('矩陣每維的大小：',matrix.shape)
print('矩陣所有數據的個數：',matrix.size)
print('矩陣每個數據的類型：',matrix.dtype)

矩陣每維的大小： (3, 3)
矩陣所有數據的個數： 9
矩陣每個數據的類型： int32

Matrix增加操作

• 矩陣合并。c_() 方法進行連接，根據參數順序也將決定生產矩陣的結果；r_() 方法用于列連接。

mat1 = np.mat([[1,2],[3,4]])
mat2 = np.mat([4,5])
matrix_r = np.c_[mat1,mat2.T]
print('將mat2矩陣添加在原矩陣右側\n',matrix_r)
matrix_l = np.c_[mat2.T,mat1]
print('將mat2矩陣添加在原矩陣左側\n',matrix_l)
matrix_u = np.r_[np.mat([array1]),matrix]
print('在原矩陣上方連接矩陣\n',matrix_u)

將mat2矩陣添加在原矩陣右側
 [[1 2 4]
 [3 4 5]]
將mat2矩陣添加在原矩陣左側
 [[4 1 2]
 [5 3 4]]
在原矩陣上方連接矩陣
 [[ 1  2  3]
 [ 1  2  3]
 [ 6  7  8]
 [11 12 17]]

Matrix刪除操作

• delete() 方法可以刪除矩陣的指定行列，具體類似數組中的用法。

matrix2 = np.delete(matrix,1,axis = 1)
print('刪除第一行后的結果\n',matrix2)
matrix3 = np.delete(matrix,1,axis=0)
print('刪除第一列后的結果\n',matrix3)

刪除第一行后的結果
 [[ 1  3]
 [ 6  8]
 [11 17]]
刪除第一列后的結果
 [[ 1  2  3]
 [11 12 17]]

Matrix特殊操作

1.矩陣運算，在矩陣運算中，* 被重寫用于矩陣乘法，dot() 則用于計算矩陣點乘

2.如果需要對應位置相乘，則需使用其它函數。

mat3 = np.mat([[5,6],[7,8]])
matrix4 = mat1*mat3
print('矩陣乘法結果\n',matrix4)
matrix5 = mat1.dot(mat3)
print('矩陣點乘結果\n',matrix5)

矩陣乘法結果
 [[19 22]
 [43 50]]
矩陣點乘結果
 [[19 22]
 [43 50]]

矩陣常用函數。矩陣也可以使用 .T 進行轉置。linalg.inv() 可以用于求逆運算，若不存在逆矩陣則報錯。

matrix6 = matrix.T
matrix7 = np.linalg.inv(mat1)
print('\n矩陣轉置后：\n',matrix6,
      '\n矩陣求逆后：\n',matrix7)

矩陣轉置后：
 [[ 1  6 11]
 [ 2  7 12]
 [ 3  8 17]] 
矩陣求逆后：
 [[-2.   1. ]
 [ 1.5 -0.5]]

求矩陣特征值（使用numpy必須是方陣）

matrix8 = np.linalg.eig(matrix)
print(matrix8)

(array([24.88734753, -0.8418908 ,  0.95454327]), matrix([[-0.1481723 , -0.87920199,  0.10036602],
        [-0.4447565 ,  0.3814255 , -0.82855015],
        [-0.88331004,  0.28551435,  0.550846  ]]))

Matrix轉換為其它數據結構

由于結構相似，矩陣常常與列表和數組進行數據類型轉換。

print('矩陣列表轉換：\n',matrix.tolist(),
      '\n矩陣轉數組：\n',np.array(matrix))

矩陣列表轉換：
 [[1, 2, 3], [6, 7, 8], [11, 12, 17]] 
矩陣轉數組：
 [[ 1  2  3]
 [ 6  7  8]
 [11 12 17]]

Pandas中的數據結構，包括Series和DataFrame

序列（Series）

創建Series

• 引入Pandas包并取別名pd

import pandas as pd

• 首先建立一個字典，使用 Series() 方法將字典轉換成序列對象，字典的key會自動成為series的index；若轉換列表，則生產的序列對象會自動賦予index值。

sdata = {'Ohio':35000,'Texas':71000,'Oregon':16000,'Utah':5000}
s0 = pd.Series(sdata)
print('利用字典生成的序列對象\n',s0)
print('顯示該數據結構類型：',type(s0))
s1 = pd.Series([6,1,2,9])
print('利用列表生成的序列對象\n',s1)

利用字典生成的序列對象
 Ohio      35000
Texas     71000
Oregon    16000
Utah       5000
dtype: int64
顯示該數據結構類型： <class 'pandas.core.series.Series'>
利用列表生成的序列對象
 0    6
1    1
2    2
3    9
dtype: int64

• 添加索引，通過指定index為series增加索引

s1 = pd.Series([6,1,2,9],index=['a','b','c','d'])
print(s1)

a    6
b    1
c    2
d    9
dtype: int64

Series查詢操作

• values 顯示series中的值，index 顯示索引，此外還可以按照索引值顯示元素。

print('序列的值\n',s0.values)
print('序列的索引\n',s0.index)
print('按照下標查找序列',s0[2])
print('按照索引值查找元素',s0['Utah'])
print('按照下標批量查找序列\n',s0[:2])
print('按照索引值批量查找元素\n',s0[['Ohio','Oregon']])

序列的值
 [35000 71000 16000  5000]
序列的索引
 Index(['Ohio', 'Texas', 'Oregon', 'Utah'], dtype='object')
按照下標查找序列 16000
按照索引值查找元素 5000
按照下標批量查找序列
 Ohio     35000
Texas    71000
dtype: int64
按照索引值批量查找元素
 Ohio      35000
Oregon    16000
dtype: int64

Series增加操作

• append() 方法為series增加元素，index可以指定索引值。

s2 = s1.append(pd.Series([12],index=['e']))
print(s2)

a     6
b     1
c     2
d     9
e    12
dtype: int64

Series刪除操作

• 刪除Series中的元素（只能通過index來刪除元素）

s3 = s1.drop('a')
print(s3)

dtype: int64
b    1
c    2
d    9

dtype: int64

Series修改操作

• 序列中可以直接根據索引查找并更新元素。

s1['a'] = 4 #將s1中index為a的元素更改為4
print(s1)

a    4
b    1
c    2
d    9
dtype: int64

Series特殊操作

• 序列排序。sort_values()方法可以使用series的值按照升序排序。

print(s1.sort_values)

a    4

b    1
c    2
d    9
dtype: int64>

• 序列求中位數。median()方法可以直接得到序列的中位數，在此之上可以進行比較等操作。

print(s1)
print('中位數為：'+str(s1.median()))
print('大于序列中位數的數\n',s1[s1>s1.median()])

中位數為：3.0
大于序列中位數的數
 a    4
d    9
dtype: int64

• 序列的運算，兩個series之間的運算，可以加減乘除（必須保證index是一致的）。

s2 = pd.Series([4,3,5,8],index=['a','b','c','d'])
print(s2+s1)

a     8
b     4
c     7
d    17
dtype: int64

• 時間序列。pandas包中的data_range()方法可以生成時間序列，便于進行數據的處理。

s3 = pd.Series([100,150,200])
print('產生的序列是：\n',s3)
idx = pd.date_range(start='2019-9',freq='M',periods=3)
print('\n生成的時間序列是：\n',idx)
s3.index = idx
print('\n產生的時間序列是：\n',s3)

產生的序列是：
 0    100
1    150
2    200
dtype: int64

生成的時間序列是：
 DatetimeIndex(['2019-09-30', '2019-10-31', '2019-11-30'], dtype='datetime64[ns]', freq='M')

產生的時間序列是：
 2019-09-30    100
2019-10-31    150
2019-11-30    200
Freq: M, dtype: int64

Series轉換為其它數據結構

dfFromSeries = s2.to_frame()
print('Series轉DataFrame\n',dfFromSeries)
print('顯示數據結構類型：',type(dfFromSeries))

Series轉DataFrame
    0
a  4
b  3
c  5
d  8
顯示數據結構類型： <class 'pandas.core.frame.DataFrame'>

dictFromSeries = s2.to_dict()
print('Series轉Dict\n',dictFromSeries)
print('顯示數據結構類型：',type(dictFromSeries))

Series轉Dict
 {'a': 4, 'b': 3, 'c': 5, 'd': 8}
顯示數據結構類型： <class 'dict'>

數據框（DataFrame）

創建DataFrame

引入pandas包，創建DataFrame對象。首先創建字典，之后使用 DataFrame() 方法創建數據框對象。通過index.name給其索引命名。最后使用 to_csv 和 to_excel 方法將其保存為csv和excel文件；也可以用列表進行創建：pd.DataFrame(data,columns,index)。

dic1 = {'name':['Tom','Lily','Cindy','Petter'],'no':['001','002','003','004'],'age':[16,16,15,16],'gender':['m','f','f','m']}
df1 = pd.DataFrame(dic1)
print('顯示該數據結構類型',type(df1))
df1.index.name = 'id'
#df1.to_csv('students.csv')
#df1.to_excel('students.xls')     ！！！會報錯
print(df1)

顯示該數據結構類型 <class 'pandas.core.frame.DataFrame'>
      name   no  age gender
id                         
0     Tom     001   16      m
1     Lily      002   16      f
2     Cindy  003   15      f
3     Petter  004   16      m

DataFrame 查詢操作

• 通過 DataFrame.name 可以返回索引值為name的整列數據，而 DataFrame.loc[i] 可以返回指定行數的全部數據。除此之外也可以使用根據時間序列查找內容。

• ！！！loc[ ]  按列名稱   iloc[ ] 按列號 操作

• 獲取列索引：df.cloums 

• 獲取行索引：df.index

• 獲取值：df.value

column = df1.no
row = df1.loc[3]
print('\n列數據索引\n',column,'\n行數據索引\n',row)

列數據索引
 id
0    001
1    002
2    003
3    004
Name: no, dtype: object 
行數據索引
name        Petter
no             004
age           16
gender      m
Name: 3, dtype: object

DataFrame增加操作

• 使用 append() 方法增加一名同學的信息，這里根據行索引分別添加值。update() 方法可以給數據框增加列。

print('修改前：\n',df1)
df2 = df1.append([{'name':'Stark','no':'005','age':15,'gender':'m'}],ignore_index=True) #接著索引號為4，不寫的話就是0
print('增加行：\n',df2)
df2['new_Col'] = [1,2,3,4,5]
print('增加列：\n',df2)

修改前：
       name   no  age gender
id                         
0     Tom  001   16      m
1     Lily    002   16       f
2    Cindy  003   15      f
3   Petter  004   16      m
增加行：
      name   no  age gender
0   Tom    001   16      m
1   Lily     002   16      f
2   Cindy  003   15      f
3  Petter  004   16      m
4   Stark  005   15      m
增加列：
      name   no  age gender  new_Col
0   Tom  001     16      m        1
1    Lily  002     16      f        2
2   Cindy  003   15      f        3
3  Petter  004   16      m        4
4   Stark  005   15      m        5

DataFrame刪除操作

• 使用 drop 方法刪除'address'列，還可以通過修改參數刪除行。除此之外通過 del 指令可以刪除指定索引值的整列數據（操作一旦進行即不可回復）。

df3 = df1.copy()
print('處理前的數據\n',df1)
df3b = df3.drop(['name'],axis=1)
print('刪除列后的數據框\n',df3b)
df3c = df3.drop([2])
print('刪除行后的數據框\n',df3c)

處理前的數據
       name   no  age gender
id                         
0      Tom  001   16      m
1     Lily  002   16      f
2    Cindy  003   15      f
3   Petter  004   16      m
刪除列后的數據框
      no  age gender
id                 
0   001   16      m
1   002   16      f
2   003   15      f
3   004   16      m
刪除行后的數據框
       name   no  age gender
id                         
0      Tom  001   16      m
1     Lily  002   16      f
3   Petter  004   16      m

DataFrame修改操作

• 數據框按列合并（效果和增加列相同）

df4 = pd.DataFrame({'address':['school','home','school','school','home']})
df5 = pd.concat([df2,df4],axis=1)
print('合并前的df2\n',df2)
print('合并前的df4\n',df4)
print('合并后的df5\n',df5)

合并前的df2
      name   no  age gender  new_Col
0     Tom  001   16      m        1
1    Lily  002   16      f        2
2   Cindy  003   15      f        3
3  Petter  004   16      m        4
4   Stark  005   15      m        5
合并前的df4
   address
0  school
1    home
2  school
3  school
4    home
合并后的df5
      name   no  age gender  new_Col address
0     Tom  001   16      m        1  school
1    Lily  002   16      f        2    home
2   Cindy  003   15      f        3  school
3  Petter  004   16      m        4  school
4   Stark  005   15      m        5    home

• 數據框按行合并（效果和增加學生信息相同）

df6 = pd.DataFrame({'name':['Tony'],'no':['005'],'age':[16],'gender':['m']})
df7 = pd.concat([df1,df6],axis=0)
print('合并前的df1\n',df1)
print('合并前的df6\n',df6)
print('合并后的df7\n',df7)

合并前的df1
       name   no  age gender
id                         
0      Tom  001   16      m
1     Lily  002   16      f
2    Cindy  003   15      f
3   Petter  004   16      m
合并前的df6
    name   no  age gender
0  Tony  005   16      m
合并后的df7
      name   no  age gender
0     Tom  001   16      m
1    Lily  002   16      f
2   Cindy  003   15      f
3  Petter  004   16      m
0    Tony  005   16      m

DataFrame 特殊操作

• 數據框的時間序列。通過  date_range  函數生成序列并加入數據中，列如創建從2019年9月21日開始的連續4天的時間序列。使用pandas包中的 read_csv() 方法讀取之前保存的學生數據，更新數據后可以看到生成的時間序列已經加入到了數據框中

i1 = pd.date_range('2019/9/21',periods=4,freq='7D')
df10 = pd.read_csv('students.csv')
df10.index = i1
print(df10)

            id    name  no  age gender
2019-09-21   0     Tom   1   16      m
2019-09-28   1    Lily   2   16      f
2019-10-05   2   Cindy   3   15      f
2019-10-12   3  Petter   4   16      m

時間序列查詢

print('\n根據時間序列索引得到的值\n',df10.loc['2019-09-21':'2019-09-30',['gender','age','name']])

根據時間序列索引得到的值
            gender  age  name
2019-09-21      m   16   Tom
2019-09-28      f   16  Lily

DataFrame轉換為其它數據結構

print('DataFrame轉ndarray\n',df10.values,
      '\nDataFrame轉series\n',df10['gender'])

DataFrame轉ndarray
 [[0 'Tom' 1 16 'm']
 [1 'Lily' 2 16 'f']
 [2 'Cindy' 3 15 'f']
 [3 'Petter' 4 16 'm']] 
DataFrame轉series
 2019-09-21    m
2019-09-28    f
2019-10-05    f
2019-10-12    m
Freq: 7D, Name: gender, dtype: object

python原生數據結構

元組(Tuple)

1. 使用（）、tuple（）創建元組，元組可以為空且元素類型可以不同；

2. 若元組中僅包含一個數字，則應該添加逗號以區別運算符號：tup=(1,)；

3. 元組一旦創建就無法對其元素進行增加、刪除、修改。

Tuple查詢操作

• 元組可以使用下標索引來訪問元組中的值。

tup1=('Google','Runoob',1997,2000)
tup2=(1,) #創建單個數字元組
print("tup1[0]:",tup1[0]) #訪問元組中第一各元素
print("tup2[1:5]:",tup2[1:5])

tup1[0]: Google
tup2[1:5]: ()

Tuple整體刪除操作

• 使用del方法可以刪除指定的元組對象，但無法刪除指定下標的元組元素。

Tuple連接和復制

• 雖然元組中的元素不允許修改，但可以對元組進行連接組合創建出一個新的元組。

tup3=tup1+tup2
tup4=tup2*3 #復制三份

Tuple其它操作

1. len() 返回元組元素個數；

2. max()/min() 返回元組元素中的最大、最小元素。

Tulpe轉換為其它數據結構（舉例）

• 元組可以轉換為字符串、列表&hellip;&hellip;不過單個元組無法直接轉換成字典

print("\n元組轉列表：\n",list(tup1),
      "\n元組轉字符串：\n",tup1.__str__())

列表（List）

創建列表

1. 一維列表的創建。使用[]可以創建一個列表對象，列表是一種有序的集合，可以隨時添加和刪除其中的元素；

2. 多維列表的創建。盡管list默認是一維的，但可以使用[]嵌套創建多維列表。

List查詢操作

1. list[a:b] 返回列表中第a個至第b-1個元素的列表對象；

2. list[::a] 返回一個從列表第一個元素開始，步長為a的列表對象；

3. list[i] 返回列表中下標為i的元素，若i為負數，則從列表尾部從后至前訪問第i個元素。

List增加操作

• append() 可以在列表末尾增加新的項目，可以增加一個元素，也可以增加一個list對象成為多維列表。

List刪除操作

1. remove() 函數可以刪除指定值的元素，list.remove(i)會刪除list對象中值為i的元素，若不存在則報錯；

2. pop() 函數可以刪除指定下標的元素，默認為列表對象的最后一個元素，list.pop(i)將刪除下標為i的元素。

List修改操作

• list[i]=x 可以直接替換列表中指定下標的元素

List其它操作

1. reverse() 函數可以使列表倒置；

2. len() 函數可以返回列表的元素個數；

3. sort() 函數可以使列表元素升序排列。

List轉換為其它數據結構

• 列表可以便利的轉換為各種數據類型；注意，單個列表無法轉換為字典。

集合（Set）

創建Set

• 集合不會出現重復值，所有元素按照一定的順序排列，若元素為數字則按數字大小排列，使用set()函數創建集合會自動的拆分多個字母組成的字符串

myset = set('aabc') #使用set()函數創建集合會自動的拆分多個字母組成的字符串
print(myset)
myset1 = set(('hello','world'))
print(myset1)

{'a', 'c', 'b'}
{'hello', 'world'}

Set 查詢操作

• 使用in可以判斷a是否在集合中，存在為真，反之為假。

'a' in myset

Set 增加操作

1. add() 函數可以在集合對象中加入新元素，若元素已存在，則無效果；

2. 使用update表示添加（并非修改）是一個一個添加，并且按照順序添加進集合。

myset.add('ghk')
myset.update('tyu')  #一個一個元素添加
print(myset)

{'t', 'b', 'a', 'ghk', 'c', 'y', 'u'}

Set刪除操作

1. remove() 函數可以將集合中的元素刪除，元素不存在會報錯；

2. discard() 函數可以刪除集合中指定的元素，且元素不存在不報錯；

3. pop() 函數可以隨機刪除集合中的一個元素（在交互模式下刪除最后一個元素）；

4. clear() 函數可以清空集合。

Set其它操作

• len() 函數可以查詢集合的長度；

• copy() 可以復制集合中的元素并生成一個新的集合

copy_myset=myset.copy()
print('\nlen()返回集合的長度:',len(myset),
      '\ncopy()生成的集合:',copy_myset)

len()返回集合的長度: 7 
copy()生成的集合: {'a', 'c', 'u', 't', 'ghk', 'b', 'y'}

• 集合的運算。首先建立兩個集合用于運算，在集合運算中，&lsquo;-&rsquo;表示求差，&lsquo;&&rsquo;表示求和，&lsquo;|&rsquo;表示求并集，'^'表示兩個集合的并集減去交集

a = set('apple')
b = set('banana')
print ('\n求差集:',a-b,
       '\n求并集:',a|b,
       '\n求交集:',a&b,
       '\n求各自獨特的:',a^b)

求差集: {'e', 'p', 'l'} 
求并集: {'p', 'n', 'l', 'a', 'b', 'e'} 
求交集: {'a'} 
求各自獨特的: {'n', 'p', 'l', 'b', 'e'}

字典（Dictionary）

創建Dict

• 生成一個字典和一個包含三個字典對象的字典列表。（列表中嵌套字典，students實際上是一個列表，students中的元素是字典）

dict1={"ID":"L100","Name":"COCO"}
students = [{'name':'n1','id':'001'},{'name':'n2','id':'002'},{'name':'n3','id':'003'}]
print("顯示該數據結構類型",type(dict1))
print(dict1)

顯示該數據結構類型 <class 'dict'>
{'ID': 'L100', 'Name': 'COCO'}

• 使用zip方法創建字典。zip() 方法可以返回元組組成的列表，可以用于快速構建字典。

demo_dict = dict(zip('abc','123'))
print(demo_dict)

{'a': '1', 'b': '2', 'c': '3'}

Dict查詢操作

• 查找第一個學生的學號（顯示出第一個字典元素id鍵的值）；此外還可以使用get(key,default=None)方法獲取指定鍵的值。

print('常規查詢:',students[0]['id'])
print('根據鍵查詢:',students[0].get('id'))

常規查詢: 001
根據鍵查詢: 001

Dict增加操作

• 添加一名學生的信息（增加行，其實是增加列表中一個元素），之后再添加一個學生信息科目（增加列，其實就是增加字典中一個鍵值對）

students.append({'name':'n4','id':'004'})
print('添加一個字典對象后:',students)
students[0]['school']='school1'
students[1]['school']='school2'
students[2]['school']='school2'
print('增加鍵值對后的字典:',students)

添加一個字典對象后: [{'name': 'n1', 'id': '001'}, {'name': 'n2', 'id': '002'}, {'name': 'n3', 'id': '003'}, {'name': 'n4', 'id': '004'}]
增加鍵值對后的字典: [{'name': 'n1', 'id': '001', 'school': 'school1'}, {'name': 'n2', 'id': '002', 'school': 'school2'}, {'name': 'n3', 'id': '003', 'school': 'school2'}, {'name': 'n4', 'id': '004'}]

Dict刪除操作

• 使用del刪除一名學生的信息（刪除行，其實就是刪除列表中的一個元素）。再使用pop刪除第一個學生的學號（刪除某一行中的列，其實是刪除字典中的一個鍵值對）

del students[3] #刪除第4行(下標為3)
print('刪除列表中的一個字典對象后:\n',students)
students[0].pop('id')
print('刪除一個鍵值對后:\n',students)

刪除列表中的一個字典對象后
 [{'name': 'n1', 'id': '001', 'school': 'school1'}, {'name': 'n2', 'id': '002', 'school': 'school2'}, {'name': 'n3', 'id': '003', 'school': 'school2'}]
刪除一個鍵值對后
 [{'name': 'n1', 'school': 'school1'}, {'name': 'n2', 'id': '002', 'school': 'school2'}, {'name': 'n3', 'id': '003', 'school': 'school2'}]

• 刪除所有學生的學號（刪除某一列，其實就是刪除所有字典中的一個鍵值對）

for i in range(0,len(students)):
    students[i].pop('school')
print(students)

[{'name': 'n1'}, {'name': 'n2', 'id': '002'}, {'name': 'n3', 'id': '003'}]

Dict修改操作

• 添加（更改）第一個學生的學號（在列表的第一個字典元素中增加/更改鍵值對）

students[0].update({'id':'001'})
print('\n更新后的字典\n',students)

更新后的字典
 [{'name': 'n1', 'id': '001'}, {'name': 'n2', 'id': '002'}, {'name': 'n3', 'id': '003'}]

Dict轉換為其它數據結構

• 字典的鍵和值可以被單獨各自轉換為list

print("字典值轉List：",list(demo_dict.values()))
print("字典鍵轉List：",list(demo_dict.keys()))

字典值轉List： ['1', '2', '3']
字典鍵轉List： ['a', 'b', 'c']

以上就是“python中常用的經典數據結構有哪些”這篇文章的所有內容，感謝各位的閱讀！相信大家閱讀完這篇文章都有很大的收獲，小編每天都會為大家更新不同的知識，如果還想學習更多的知識，請關注億速云行業資訊頻道。