Rumah > Artikel > pembangunan bahagian belakang > Apakah struktur data klasik yang biasa digunakan dalam python?
Apakah struktur data klasik yang biasa digunakan dalam python?
- 王林ke hadapan
- 2023-05-12 14:58:261705semak imbas
Struktur data dalam pakej NumPy
Struktur data dalam NumPy, termasuk Ndarray, Matrix
Array (Ndarray)
Buat Ndarray
Perkenalkan pakej NumPy dan namakannya np. Selepas memperkenalkan pakej NumPy, anda boleh menggunakan struktur data tatasusunan
import numpy as np
untuk mencipta objek tatasusunan dalam pakej NumPy:
tatasusunan. () kaedah boleh Objek bersiri ditukarkan kepada tatasusunan; ones menjana semua nilai Array 1;
-
kaedah kosong() akan menjana tatasusunan jenis dan dimensi yang diberikan tanpa permulaan data;
random( ) Hasilkan tatasusunan rawak; - linspace() menjana tatasusunan satu dimensi dengan nilai mula dan akhir serta saiz langkah yang ditentukan, contohnya, menjana tatasusunan dengan 5 elemen daripada 1 hingga 10
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)Data jujukan ditukar kepada tatasusunan: [ 1 2 3 4 5 6 7 8 9 10 11 12] - Paparan jenis struktur data: d4549aa8de390443dd6a6184aefd5201
Array dicipta oleh arange() fungsi: [0 1 2 3 4]
Semua tatasusunan yang dicipta oleh one() fungsi: [[ 1. 1.] - [1. 1.]]
Tatasusunan yang tidak ditetapkan dibuat oleh fungsi kosong():
[[0.] [0.]]
[[0.39902074 0.63298526]Berikut ialah atribut biasa dalam tatasusunan berbilang dimensi Antaranya, bentuk boleh mengembalikan struktur data objek, seperti bilangan baris dan lajur, selain mengembalikan tuple yang mewakili setiap dimensi tatasusunan. struktur tatasusunan juga boleh diubah melalui bentuk semula[0.09231821 0.23007193]
[0.09899536 0.83298526]
[0.09231821 0.23007193]
[0.09899536 0.83298526] 898]]
Tatasusunan rawak yang dicipta oleh fungsi linespace(). : [10. 15. 20. 25 .]
Operasi pertanyaan Ndarray
Array boleh mengekstrak subset daripada tatasusunan melalui tatasusunan[a:b], dan operasi penugasan kelompok juga boleh dilakukan atas dasar ini.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列
Indeks tatasusunan satu dimensi: [ 5 6 7 8 9 10 11 12]
Indeks tatasusunan dua dimensi: [[ 7 8] [11 12]]
array004 = array001.reshape(3,-1)
print('\n改变结构后的数组\n',array004,
'\n数组各个维度：',array004.shape,
'\n数组结构类型：',array004.dtype,
'\n数组数据个数：',array004.size,
'\n数组数据类型字节数：',array004.itemsize,
'\n数组维度：',array004.ndim)
Tatasusunan selepas menukar struktur
[[ 1 2 3 4][ 5 6 7 8]Bilangan data tatasusunan: 12[ 9 10 11 12]]
Jenis struktur tatasusunan: int32
Dimensi tatasusunan: ( 3, 4)
Bilangan bait jenis data tatasusunan: 4
Dimensi tatasusunan: 2Array selepas menambah satu lajur
Ndarray meningkat Operasi
fungsi append() boleh menambah elemen atau data jenis senarai, tetapi perlu diperhatikan bahawa dimensi perlu konsisten.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]]
- Operasi pemadaman Ndarray
Array selepas memadamkan satu baris:Gunakan kaedah delete(x,i,axis=) untuk memadam baris atau lajur dalam objek tatasusunan, paksi parameter ketiga menentukan sama ada baris atau lajur dipadamkan Objek yang akan dipadamkan boleh menjadi nombor atau tuple.
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]]
- Tatasusunan selepas pemadaman kelompok:
[[ 1 5 9]
[ 3 7 11]] Tatasusunan selepas pemadaman lajur tunggal
[ 2 10]Tugasan kelompok tatasusunan[ 3 11]
[ 4 12]]
Pengubahsuaian Ndarray
Anda boleh menggunakan pengindeksan untuk membatch mengubah suai data tatasusunan.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]]
- Tatasusunan dengan nilai yang diubah suai
[[ 1 0 9]
[ 2 100 10] [ 3 0 11]
[4 5 6 ] ]
Ndarray Other operasi
1. Transpose tatasusunan dua dimensi. tatasusunan.T boleh mendapatkan hasil objek tatasusunan terpindah
2. Susunan tatasusunan. Mula-mula, masukkan dua tatasusunan baharu, dan kemudian gunakan vstack untuk tindanan menegak dan hstack untuk tindanan mendatararr1 = np.array([1,2,3]) arr2 = np.array([4,5,6]) print('纵向堆叠后：\n',np.vstack((arr1,arr2)), '\n横向堆叠后：\n',np.hstack((arr1,arr2)))
Selepas tindanan menegak: [[1 2 3]
Selepas tindanan mendatar:
[1 2 3 4 5 6]Ndarray ditukar kepada struktur data lain
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) #带行号和列号
1 4 5 6Ndarray sebelum penukaran ialah :
0 1 2 3
[[1 2 3]
[4 5 6]] Hasil penukaran
Ndarray kepada DataFrame ialah:
0 1 2
arrFromDataFrame = dfFromNdarray.values print('DataFrame转化为Ndarry的结果是：\n',arrFromDataFrame) #只提取value值
Hasil penukaran DataFrame kepada Ndarry ialah:
Buat Matriks
[[1 2 3]
[4 5 6]]
Matriks ( Matriks)
Gunakan kaedah mat() untuk menukar objek struktur data lain kepada jenis matriks.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
矩阵每个数据的类型： int32Matrix增加操作
矩阵合并。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: int64Series查询操作
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: int64Series增加操作
append() 方法为series增加元素，index可以指定索引值。
s2 = s1.append(pd.Series([12],index=['e'])) print(s2)a 6
b 1
c 2
d 9
e 12
dtype: int64Series删除操作
删除Series中的元素（只能通过index来删除元素）
s3 = s1.drop('a') print(s3)dtype: int64
b 1
c 2
d 9dtype: int64
Series修改操作
序列中可以直接根据索引查找并更新元素。
s1['a'] = 4 #将s1中index为a的元素更改为4 print(s1)a 4
b 1
c 2
d 9
dtype: int64Series特殊操作
序列排序。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: int64Series转换为其它数据结构
dfFromSeries = s2.to_frame() print('Series转DataFrame\n',dfFromSeries) print('显示数据结构类型：',type(dfFromSeries))Series转DataFrame
0
a 4
b 3
c 5
d 8
显示数据结构类型： d4cd70a66338930570b9d281337f8601dictFromSeries = 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 mDataFrame 查询操作
通过 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: objectDataFrame增加操作
使用 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 5DataFrame删除操作
使用 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 mDataFrame修改操作
数据框按列合并（效果和增加列相同）
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 mDataFrame 特殊操作
数据框的时间序列。通过 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 LilyDataFrame转换为其它数据结构
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: objectpython原生数据结构
元组(Tuple)
使用（）、tuple（）创建元组，元组可以为空且元素类型可以不同；
若元组中仅包含一个数字，则应该添加逗号以区别运算符号：tup=(1,)；
元组一旦创建就无法对其元素进行增加、删除、修改。
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其它操作
len() 返回元组元素个数；
max()/min() 返回元组元素中的最大、最小元素。
Tulpe转换为其它数据结构（举例）
元组可以转换为字符串、列表……不过单个元组无法直接转换成字典
print("\n元组转列表：\n",list(tup1), "\n元组转字符串：\n",tup1.__str__())列表（List）
创建列表
一维列表的创建。使用[]可以创建一个列表对象，列表是一种有序的集合，可以随时添加和删除其中的元素；
多维列表的创建。尽管list默认是一维的，但可以使用[]嵌套创建多维列表。
List查询操作
list[a:b] 返回列表中第a个至第b-1个元素的列表对象；
list[::a] 返回一个从列表第一个元素开始，步长为a的列表对象；
list[i] 返回列表中下标为i的元素，若i为负数，则从列表尾部从后至前访问第i个元素。
List增加操作
append() 可以在列表末尾增加新的项目，可以增加一个元素，也可以增加一个list对象成为多维列表。
List删除操作
remove() 函数可以删除指定值的元素，list.remove(i)会删除list对象中值为i的元素，若不存在则报错；
pop() 函数可以删除指定下标的元素，默认为列表对象的最后一个元素，list.pop(i)将删除下标为i的元素。
List修改操作
list[i]=x 可以直接替换列表中指定下标的元素
List其它操作
reverse() 函数可以使列表倒置；
len() 函数可以返回列表的元素个数；
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 mysetSet 增加操作
add() 函数可以在集合对象中加入新元素，若元素已存在，则无效果；
使用update表示添加（并非修改）是一个一个添加，并且按照顺序添加进集合。
myset.add('ghk') myset.update('tyu') #一个一个元素添加 print(myset){'t', 'b', 'a', 'ghk', 'c', 'y', 'u'}
Set删除操作
remove() 函数可以将集合中的元素删除，元素不存在会报错；
discard() 函数可以删除集合中指定的元素，且元素不存在不报错；
pop() 函数可以随机删除集合中的一个元素（在交互模式下删除最后一个元素）；
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
根据键查询: 001Dict增加操作
添加一名学生的信息（增加行，其实是增加列表中一个元素），之后再添加一个学生信息科目（增加列，其实就是增加字典中一个键值对）
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']
Atas ialah kandungan terperinci Apakah struktur data klasik yang biasa digunakan dalam python?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!