suchen

Heim >Backend-Entwicklung >Python-Tutorial >Was sind die am häufigsten verwendeten klassischen Datenstrukturen in Python?

Was sind die am häufigsten verwendeten klassischen Datenstrukturen in Python?

王林
王林nach vorne
2023-05-12 14:58:261776Durchsuche

Datenstrukturen im NumPy-Paket

Datenstrukturen in NumPy, einschließlich Ndarray, Matrix

Array (Ndarray)#🎜 🎜 #

Erstellen Sie Ndarray

  • Führen Sie das NumPy-Paket ein und nennen Sie es np. Array-Datenstrukturen können nach der Einführung des NumPy-Pakets 

    • import numpy as np
zum Erstellen von Array-Objekten im NumPy-Paket verwendet werden:

    #🎜 🎜#array()-Methode kann Sequenzobjekte in Arrays konvertieren;

  1. arange()-Methode kann eine Reihe von Arrays mit benutzerdefinierten Endpunkten generieren; # 🎜🎜#
  2. ones generiert ein Array mit allen Werten 1;

  3. empty() Methode generiert ein Array mit ein gegebener Typ und eine bestimmte Dimension und kein Array für die Dateninitialisierung;

    4. random() generiert ein zufälliges Array; 🎜#linspace() generiert ein spezifiziertes eindimensionales Array aus Start- und Endwerten und Schrittgrößen, beispielsweise ein Array mit 5 Elementen von 1 bis 10

  4. 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)
  5. Sequentielle Datenkonvertierung Holen Sie sich das Array: [ 1 2 3 4 5 6 7 8 9 10 11 12]

    Zeigen Sie den Datenstrukturtyp an: 5da6683f0d0b83d4e145f3ca103c36c4 🎜🎜#Array erstellt durch die arange()-Funktion: [ 0 1 2 3 4]

    ones()-Funktion erstellt ein Array aller Einsen:
    6. [[1.]
  6. [ 1. 1.]]

    empty() Funktion Nicht zugewiesenes Array erstellt:

    [[0. 0.]
    7. [0. 0.]]
random() Funktion zufällig erstellt Array:
[[0,39902074 0,63298526 ]

[0,09231821 0,23007193]
[0,09899536 0,83000881]
[0,2776096 1 0,65135898]]
Zufällig erstellt durch die linespace()-Funktion Array: [10. 15. 20. 25. 30. ]


Ndarray-Abfragevorgang

Arrays können Teilmengen aus dem Array über Array[a:b] extrahieren, Auf dieser Basis können auch Batch-Zuordnungsvorgänge durchgeführt werden. 

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列


Eindimensionaler Array-Index: [ 5 6 7 8 9 10 11 12]
Zweidimensionaler Array-Index: [[ 7 8] [11 12]]# 🎜🎜 #

Die folgenden Attribute sind in mehrdimensionalen Arrays üblich: Neben der Rückgabe eines Tupels kann die Form auch die Datenstruktur des Objekts zurückgeben Es repräsentiert jede Dimension des Arrays und kann auch übergeben werden. Umformen ändert die Struktur des Arrays

array004 = array001.reshape(3,-1)
print('\n改变结构后的数组\n',array004,
      '\n数组各个维度：',array004.shape,
      '\n数组结构类型：',array004.dtype,
      '\n数组数据个数：',array004.size,
      '\n数组数据类型字节数：',array004.itemsize,
      '\n数组维度：',array004.ndim)

Das Array nach der Änderung der Struktur

[[ 1 2 3 4]# 🎜🎜# [ 5 6 7 8]

[ 9 10 11 12]]

Abmessungen des Arrays: (3, 4)
Array-Strukturtyp: int32

Anzahl der Array-Daten : 12
Anzahl der Bytes des Array-Datentyps: 4 # 🎜🎜#Array-Dimension: 2

Ndarray-Hinzufügen-Operation

Die Funktion
append() kann Elemente hinzufügen oder Typdaten auflisten, es muss jedoch beachtet werden, dass die Dimensionen konsistent sein müssen. 


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


Array nach dem Hinzufügen einer Spalte
[[ 1 2 3 4 1]
[ 5 6 7 8 2]# 🎜🎜# [ 9 10 11 12 3]]

Ndarray-Löschvorgang

  • Verwenden Sie delete(x,i,axis =)-Methode kann Zeilen oder Spalten im Array-Objekt löschen. Die dritte Parameterachse bestimmt, ob die Zeile oder Spalte gelöscht wird. Das zu löschende Objekt kann eine Zahl oder ein Tupel sein. 

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删除列

Das Array nach dem Löschen einer einzelnen Zeile:
[[ 1 5 9]
[ 3 7 11]#🎜 🎜# [ 4 8 12]]
Array nach Stapellöschung:

[[ 1 5 9]
[ 3 7 11]]

Array nach dem Löschen einer einzelnen Spalte#🎜🎜 # [ [ 1 9]

[ 2 10]
    [ 3 11]
  • [ 4 12]]

    • Ndarray geändert
# 🎜🎜 #

Sie können die Indizierung verwenden, um Array-Daten stapelweise zu ändern. 


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


Array-Stapelzuweisung
[[ 1 2 3 4]
[ 0 0 0 0]
[ 9 10 11 12]]
Array nach geändertem Wert
[[ 1 0 9]
[ 2 100 10]

[ 3 0 11]
[ 4 0 12 ]]

    Andere Operationen von Ndarray

  • 1. Transponieren eines zweidimensionalen Arrays. array.T kann das Ergebnis des transponierten Array-Objekts erhalten

    • 2. Geben Sie zuerst zwei neue Arrays ein und verwenden Sie dann vstack für vertikales Stapeln und hstack für horizontales Stapeln 
arr1 = np.array([1,2,3])
arr2 = np.array([4,5,6])
print('纵向堆叠后：\n',np.vstack((arr1,arr2)),
      '\n横向堆叠后：\n',np.hstack((arr1,arr2)))

Nach dem vertikalen Stapeln:
[[1 2 3]#🎜🎜 # [4 5 6]]
Nach dem horizontalen Stapeln:
[1 2 3 4 5 6]


Ndarray wird in andere Datenstrukturen konvertiert

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) #带行号和列号

Das Ndarray vor der Konvertierung ist:
[[1 2 3]

[4 5 6]]

Das Ergebnis der Konvertierung von Ndarray in DataFrame ist: #🎜🎜 # 0 1 2

0 1 2 3

1 4 5 6

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

Das Ergebnis der Konvertierung von DataFrame in Ndarry ist:
[[ 1 2 3]
[4 5 6]]

Matrix(Matrix)

CreateMatrix

# 🎜 🎜#

Verwenden Sie die Methode mat(), um Objekte anderer Datenstrukturen in Matrixtypen umzuwandeln. 

array1 = [1,2,3]
array2 = [6,7,8]
array3 = [11,12,17]
matrix = np.mat([array1,array2,array3])
print('显示该数据结构类型：',type(matrix))
print(matrix)

显示该数据结构类型： 63a7ca5578ccfca91b3416aced5e49cd
[[ 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
显示该数据结构类型： 6640c34909e7f9df31bff1c5b149a8be
利用列表生成的序列对象
 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
显示数据结构类型： d4cd70a66338930570b9d281337f8601

dictFromSeries = s2.to_dict()
print('Series转Dict\n',dictFromSeries)
print('显示数据结构类型：',type(dictFromSeries))

Series转Dict
 {'a': 4, 'b': 3, 'c': 5, 'd': 8}
显示数据结构类型： 2606d06b87509932d2e41a8a0974a706

数据框（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)

显示该数据结构类型 d4cd70a66338930570b9d281337f8601
      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转换为其它数据结构（举例）

  • 元组可以转换为字符串、列表……不过单个元组无法直接转换成字典

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'}

  • 集合的运算。首先建立两个集合用于运算，在集合运算中，‘-’表示求差，‘&’表示求和，‘|’表示求并集，'^'表示两个集合的并集减去交集

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)

显示该数据结构类型 2606d06b87509932d2e41a8a0974a706
{'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']

Das obige ist der detaillierte Inhalt vonWas sind die am häufigsten verwendeten klassischen Datenstrukturen in Python?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Python numpy pandas 数据类型 Array Object 运算符 多维数组 sort 字符串 数据结构 堆 class len append copy delete 类型转换 对象 default excel
Stellungnahme：
Dieser Artikel ist reproduziert unter:yisu.com. Bei Verstößen wenden Sie sich bitte an admin@php.cn löschen
Vorheriger Artikel：So schreiben Sie einen einfachen JSONParser mit PythonNächster Artikel：So schreiben Sie einen einfachen JSONParser mit Python

In Verbindung stehende Artikel

Mehr sehen