Python에서 일반적으로 사용되는 고전적인 데이터 구조는 무엇입니까?
- 王林앞으로
- 2023-05-12 14:58:261790검색
NumPy 패키지의 데이터 구조
Ndarray, Matrix
Array(Ndarray)
Create Ndarray
NumPy 패키지를 소개하고 이름을 np로 지정하는 NumPy의 데이터 구조. NumPy 패키지가 도입된 후 배열 데이터 구조
import numpy as np
를 사용하여 배열 개체를 만들 수 있습니다. NumPy 패키지에서
array() 메서드는 시퀀스 개체를 배열로 변환할 수 있습니다. ) 메소드는 사용자 정의 끝점을 사용하여 여러 배열을 생성할 수 있습니다.
ones는 모든 값이 포함된 배열을 생성합니다.
empty() 메소드는 데이터 없이 지정된 유형과 차원으로 배열을 생성합니다. 초기화
무작위 배열을 생성합니다.
linspace()는 지정된 시작 및 끝 값과 단계 크기를 사용하여 1차원 배열을 생성합니다. 예를 들어 1에서 5개의 요소가 있는 배열을 생성합니다. to 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)순차 데이터 변환된 배열: [ 1 2 3 4 5 6 7 8 9 10 11 12] 데이터 구조 유형 표시: 5da6683f0d0b83d4e145f3ca103c36c4 arange() 함수: [0 1 2 3 4 [ 0. 0.]]
[[0.39902074 0.63298526][0.09231821 0.23007193]
[0.09899536 0.830008 81]
[0.277609 61 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列
1차원 배열 인덱스: [5 6 7 8 9 10 11 12]
2차원 배열 인덱스: [[ 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]]배열 데이터 유형의 바이트 수: 4배열 크기: (3, 4)
배열 개수 데이터: 12
배열 구조 유형: int32
Array 차원: 2
[[ 1 2 3 4 1]Ndarray 추가 연산
append() 함수는 요소를 추가하거나 목록 유형의 데이터를 추가할 수 있지만 차원이 필요하다는 점에 유의해야 합니다. 일관성을 유지하십시오.array003 = np.append(array002,[[1],[2],[3]],axis = 1) # axis = 1 按列方向添加 print('\n增加一列后的数组\n',array003)
열 하나를 추가한 후의 배열
[ 5 6 7 8 2]
[ 9 10 11 12 3]]Ndarray 삭제 작업
delete( x,i,axis=) 메소드는 배열 객체에서 행 또는 열을 삭제할 수 있습니다. 세 번째 매개변수 축은 행 또는 열이 삭제되는지 여부를 결정합니다. 삭제할 객체는 숫자 또는 튜플일 수 있습니다.[[ 1 5 9]
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删除列
단일 행을 삭제한 후의 배열:
[ 3 7 11]
[ 4 8 12]]- 일괄 삭제 후의 배열:
- [[ 1 5 9]
[ 3 7 11]]
단일 열을 삭제한 후의 배열 [[ 1 9]
[ 3 11][[ 1 2 3 4][ 4 12]]
Ndarray 수정
인덱싱을 사용하여 일괄 처리할 수 있습니다. 배열 데이터 수정.array002[1:2]=0 print('数组批量赋值\n',array002) array003 = array002.T array003[1][1] = 100 print('修改数值后的数组\n',array003)
배열 일괄 할당
[ 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으로 변환됩니다. 2 3
1 4 5 6arrFromDataFrame = dfFromNdarray.values print('DataFrame转化为Ndarry的结果是：\n',arrFromDataFrame) #只提取value值
DataFrame을 Ndarry로 변환한 결과는 다음과 같습니다.
[[1 2 3][4 5 6]]mat() 메서드를 사용하여 다른 데이터 구조의 객체를 행렬 유형으로 변환합니다.
Matrix(Matrix)
Create Matrix
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']
위 내용은 Python에서 일반적으로 사용되는 고전적인 데이터 구조는 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!