浅谈python中常用的8种经典数据结构

Python
200
0
0
2023-09-10
目录
  • NumPy包中的数据结构
  • 数组(Ndarray)
  • 创建Ndarray
  • Ndarray查询操作
  • Ndarray增加操作
  • Ndarray 删除操作
  • Ndarray修改
  • Ndarray其它操作
  • Ndarray转化成其它数据结构
  • 矩阵(Matrix)
  • 创建Matrix
  • Matrix查询操作
  • Matrix增加操作
  • Matrix删除操作
  • Matrix特殊操作
  • Matrix转换为其它数据结构
  • 序列(Series)
  • 创建Series
  • Series查询操作
  • Series增加操作
  • Series删除操作
  • Series修改操作
  • Series特殊操作
  • Series转换为其它数据结构
  • 数据框(DataFrame)
  • 创建DataFrame
  • DataFrame 查询操作
  • DataFrame增加操作
  • DataFrame删除操作
  • DataFrame修改操作
  • DataFrame 特殊操作
  • DataFrame转换为其它数据结构
  • python原生数据结构
  • 元组(Tuple)
  • Tuple查询操作
  • Tuple整体删除操作
  • Tuple连接和复制
  • Tuple其它操作
  • Tulpe转换为其它数据结构(举例)
  • 列表(List)
  • 创建列表
  • List查询操作
  • List增加操作
  • List删除操作
  • List修改操作
  • List其它操作
  • List转换为其它数据结构
  • 集合(Set)
  • 创建Set
  • Set 查询操作
  • Set 增加操作
  • Set删除操作
  • Set其它操作
  • 字典(Dictionary)
  • 创建Dict
  • Dict查询操作
  • Dict增加操作
  • Dict删除操作
  • Dict修改操作
  • Dict转换为其它数据结构
  • python原生数据结构:元组Tuple(),列表List[],集合Set{},字典Dictionary{A:B};
  • NumPy包中的数据结构:数组Ndarray(带多种操作),矩阵Matrix(多种线性代数计算);
  • Pandas包中的数据结构:序列Series(索引+1列数据),数据框DataFrame(索引+多列数据表)。

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
array = np.array([1,2,3,4,5,6,7,8,9,10,11,12])
a = np.arange(5)
a = np.ones((2,2))
a = np.empty((2,2))
a = np.random.rand(4,2)
a = np.linspace(10,30,5)
print('\n序列型数据转化得到数组:',array,
      '\n显示该数据结构类型:',type(array),
      '\narange()函数创建的数组:',a,
      '\nones()函数创建的全数组:\n',a3,
      '\nempty()函数创建的未赋值的数组:\n',a,
      '\nrandom()函数创建的随机数组:\n',a,
      '\nlinespace()函数创建的随机数组:',a)
序列型数据转化得到数组: [ 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] 从数组中提取子集,也可以在此基础上进行批量赋值操作。

array = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
print('\n一维数组索引:',array[4:],
      '\n二维数组索引:',array[1:3,2:4]) #2-3行、3-4
一维数组索引: [ 5 6 7 8 9 10 11 12] 
二维数组索引: [[ 7 8] [11 12]]

以下均为多维数组中的常用属性,其中,shape 可以返回对象的数据结构,例如行数与列数,除了返回一个表示数组各维度的元组,也可以通过 reshape 改变数组的结构

array = array001.reshape(3,-1)
print('\n改变结构后的数组\n',array,
      '\n数组各个维度:',array.shape,
      '\n数组结构类型:',array.dtype,
      '\n数组数据个数:',array.size,
      '\n数组数据类型字节数:',array.itemsize,
      '\n数组维度:',array.ndim)
改变结构后的数组
 [[ 1 2 3 4]
 [ 5 6 7 8]
 [ 9 10 11 12]] 
数组各个维度: (3, 4) 
数组结构类型: int32 
数组数据个数: 12 
数组数据类型字节数: 4 
数组维度: 2

Ndarray增加操作

  • append() 函数可以增加元素或者列表类型的数据,但必须注意维度需要保持一致。
array = np.append(array002,[[1],[2],[3]],axis = 1) # axis = 1 按列方向添加
print('\n增加一列后的数组\n',array)
增加一列后的数组
 [[ 1 2 3 4 1]
 [ 5 6 7 8 2]
 [ 9 10 11 12 3]]

Ndarray 删除操作

  • 使用 delete(x,i,axis=) 方法可以删除数组对象中行或者列,第三个参数 axis 决定了删除的是行还是列,需要删除的对象可以是一个数,也可以是一个元组。
array = array002.T
print('删除单行后的数组:\n',np.delete(array,1,axis=0)) # axis=0删除行
array = array002.T
print('批量删除后的数组:\n',np.delete(array,(1,3),0))
array = array002.T
print('删除单列后的数组\n',np.delete(array,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修改

  • 可以使用索引的方式进行数组数据的批量修改。
array[1:2]=0
print('数组批量赋值\n',array)
array = array002.T
array[1][1] = 100
print('修改数值后的数组\n',array)
数组批量赋值
 [[ 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 进行横向堆叠

arr = np.array([1,2,3])
arr = np.array([4,5,6])
print('纵向堆叠后:\n',np.vstack((arr,arr2)),
      '\n横向堆叠后:\n',np.hstack((arr,arr2)))
纵向堆叠后:
 [[1 2 3]
 [4 5 6]] 
横向堆叠后:
 [1 2 3 4 5 6]

Ndarray转化成其它数据结构

arr = np.array([[1,2,3],[4,5,6]])
print('转换前的Ndarray是:\n',arr)
import pandas as pd
dfFromNdarray = pd.DataFrame(arr)
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()方法可以把其他数据结构的对象转换为矩阵类型。
array = [1,2,3]
array = [6,7,8]
array = [11,12,17]
matrix = np.mat([array,array2,array3])
print('显示该数据结构类型:',type(matrix))
print(matrix)
显示该数据结构类型: <class 'numpy.matrix'>
[[ 1 2 3]
 [ 6 7 8]
 [11 12 17]]

创建随机矩阵,在numpy中包含了许多创建特殊矩阵的方法,这里使用 empty() 方法创建一个新的数据随机的矩阵

matrix = np.empty((3,3))
print(matrix)
[[ 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_() 方法用于列连接。
mat = np.mat([[1,2],[3,4]])
mat = np.mat([4,5])
matrix_r = np.c_[mat,mat2.T]
print('将mat矩阵添加在原矩阵右侧\n',matrix_r)
matrix_l = np.c_[mat.T,mat1]
print('将mat矩阵添加在原矩阵左侧\n',matrix_l)
matrix_u = np.r_[np.mat([array]),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() 方法可以删除矩阵的指定行列,具体类似数组中的用法。
matrix = np.delete(matrix,1,axis = 1)
print('删除第一行后的结果\n',matrix)
matrix = np.delete(matrix,1,axis=0)
print('删除第一列后的结果\n',matrix)
删除第一行后的结果
 [[ 1 3]
 [ 6 8]
 [11 17]]
删除第一列后的结果
 [[ 1 2 3]
 [11 12 17]]

Matrix特殊操作

1.矩阵运算,在矩阵运算中,* 被重写用于矩阵乘法,dot() 则用于计算矩阵点乘

2.如果需要对应位置相乘,则需使用其它函数。

mat = np.mat([[5,6],[7,8]])
matrix = mat1*mat3
print('矩阵乘法结果\n',matrix)
matrix = mat1.dot(mat3)
print('矩阵点乘结果\n',matrix)
矩阵乘法结果
 [[19 22]
 [43 50]]
矩阵点乘结果
 [[19 22]
 [43 50]]

矩阵常用函数。矩阵也可以使用 .T 进行转置。linalg.inv() 可以用于求逆运算,若不存在逆矩阵则报错。

matrix = matrix.T
matrix = np.linalg.inv(mat1)
print('\n矩阵转置后:\n',matrix,
      '\n矩阵求逆后:\n',matrix)
矩阵转置后:
 [[ 1 6 11]
 [ 2 7 12]
 [ 3 8 17]] 
矩阵求逆后:
 [[-2. 1. ]
 [ 1.5 -0.5]]

求矩阵特征值(使用numpy必须是方阵)

matrix = np.linalg.eig(matrix)
print(matrix)
(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':,'Texas':71000,'Oregon':16000,'Utah':5000}
s = pd.Series(sdata)
print('利用字典生成的序列对象\n',s)
print('显示该数据结构类型:',type(s))
s = pd.Series([6,1,2,9])
print('利用列表生成的序列对象\n',s)
利用字典生成的序列对象
 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增加索引
s = pd.Series([6,1,2,9],index=['a','b','c','d'])
print(s)
a  6
b  1
c  2
d  9
dtype: int64

Series查询操作

  • values 显示series中的值,index 显示索引,此外还可以按照索引值显示元素。
print('序列的值\n',s.values)
print('序列的索引\n',s.index)
print('按照下标查找序列',s[2])
print('按照索引值查找元素',s['Utah'])
print('按照下标批量查找序列\n',s[:2])
print('按照索引值批量查找元素\n',s[['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可以指定索引值。
s = s1.append(pd.Series([12],index=['e']))
print(s)
a  6
b  1
c  2
d  9
e  12
dtype: int64

Series删除操作

  • 删除Series中的元素(只能通过index来删除元素)
s = s1.drop('a')
print(s)
dtype: int64
b  1
c  2
d  9
dtype: int64

Series修改操作

  • 序列中可以直接根据索引查找并更新元素。
s['a'] = 4 #将s1中index为a的元素更改为4
print(s)
a  4
b  1
c  2
d  9
dtype: int64

Series特殊操作

  • 序列排序。sort_values()方法可以使用series的值按照升序排序。
print(s.sort_values)
a  4
b  1
c  2
d  9
dtype: int64>
  • 序列求中位数。median()方法可以直接得到序列的中位数,在此之上可以进行比较等操作。
print(s)
print('中位数为:'+str(s.median()))
print('大于序列中位数的数\n',s[s1>s1.median()])
中位数为:3.0
大于序列中位数的数
 a  4
d  9
dtype: int64
  • 序列的运算,两个series之间的运算,可以加减乘除(必须保证index是一致的)。
s = pd.Series([4,3,5,8],index=['a','b','c','d'])
print(s+s1)
a  8
b  4
c  7
d  17
dtype: int64
  • 时间序列。pandas包中的data_range()方法可以生成时间序列,便于进行数据的处理。
s = pd.Series([100,150,200])
print('产生的序列是:\n',s)
idx = pd.date_range(start='-9',freq='M',periods=3)
print('\n生成的时间序列是:\n',idx)
s.index = idx
print('\n产生的时间序列是:\n',s)
产生的序列是:
 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 = s.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 = s.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)。

dic = {'name':['Tom','Lily','Cindy','Petter'],'no':['001','002','003','004'],'age':[16,16,15,16],'gender':['m','f','f','m']}
df = pd.DataFrame(dic1)
print('显示该数据结构类型',type(df))
df.index.name = 'id'
#df.to_csv('students.csv')
#df.to_excel('students.xls')     !!!会报错
print(df)
显示该数据结构类型 <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 = df.no
row = df.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',df)
df = df1.append([{'name':'Stark','no':'005','age':15,'gender':'m'}],ignore_index=True) #接着索引号为4,不写的话就是0
print('增加行:\n',df)
df['new_Col'] = [1,2,3,4,5]
print('增加列:\n',df)
修改前:
    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 指令可以删除指定索引值的整列数据(操作一旦进行即不可回复)。
df = df1.copy()
print('处理前的数据\n',df)
dfb = df3.drop(['name'],axis=1)
print('删除列后的数据框\n',dfb)
dfc = df3.drop([2])
print('删除行后的数据框\n',dfc)
处理前的数据
    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修改操作

  • 数据框按列合并(效果和增加列相同)
df = pd.DataFrame({'address':['school','home','school','school','home']})
df = pd.concat([df2,df4],axis=1)
print('合并前的df\n',df2)
print('合并前的df\n',df4)
print('合并后的df\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
  • 数据框按行合并(效果和增加学生信息相同)
df = pd.DataFrame({'name':['Tony'],'no':['005'],'age':[16],'gender':['m']})
df = pd.concat([df1,df6],axis=0)
print('合并前的df\n',df1)
print('合并前的df\n',df6)
print('合并后的df\n',df7)
合并前的df
       name   no  age gender
id                               Tom  001   16      m
     Lily  002   16      f
    Cindy  003   15      f
   Petter  004   16      m
合并前的df
    name   no  age gender  Tony  005   16      m
合并后的df
      name   no  age gender     Tom  001   16      m
    Lily  002   16      f
   Cindy  003   15      f
  Petter  004   16      m
    Tony  005   16      m

DataFrame 特殊操作

  • 数据框的时间序列。通过 date_range 函数生成序列并加入数据中,列如创建从2019年9月21日开始的连续4天的时间序列。使用pandas包中的 read_csv() 方法读取之前保存的学生数据,更新数据后可以看到生成的时间序列已经加入到了数据框中
i = pd.date_range('2019/9/21',periods=4,freq='7D')
df = pd.read_csv('students.csv')
df.index = i1
print(df)
      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',df.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',df.values,
      '\nDataFrame转series\n',df['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查询操作

  • 元组可以使用下标索引来访问元组中的值。
tup=('Google','Runoob',1997,2000)
tup=(1,) #创建单个数字元组
print("tup[0]:",tup1[0]) #访问元组中第一各元素
print("tup[1:5]:",tup2[1:5])
tup1[0]: Google
tup2[1:5]: ()

Tuple整体删除操作

  • 使用del方法可以删除指定的元组对象,但无法删除指定下标的元组元素。

Tuple连接和复制

  • 虽然元组中的元素不允许修改,但可以对元组进行连接组合创建出一个新的元组。
tup=tup1+tup2
tup=tup2*3 #复制三份

Tuple其它操作

  1. len() 返回元组元素个数;
  2. max()/min() 返回元组元素中的最大、最小元素。

Tulpe转换为其它数据结构(举例)

  • 元组可以转换为字符串、列表……不过单个元组无法直接转换成字典
print("\n元组转列表:\n",list(tup),
      "\n元组转字符串:\n",tup.__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)
myset = set(('hello','world'))
print(myset)
{'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中的元素是字典)
dict={"ID":"L100","Name":"COCO"}
students = [{'name':'n','id':'001'},{'name':'n2','id':'002'},{'name':'n3','id':'003'}]
print("显示该数据结构类型",type(dict))
print(dict)
显示该数据结构类型 <class 'dict'>
{'ID': 'L100', 'Name': 'COCO'}
  • 使用zip方法创建字典。zip() 方法可以返回元组组成的列表,可以用于快速构建字典。
demo_dict = dict(zip('abc',''))
print(demo_dict)
{'a': '1', 'b': '2', 'c': '3'}

Dict查询操作

  • 查找第一个学生的学号(显示出第一个字典元素id键的值);此外还可以使用get(key,default=None)方法获取指定键的值。
print('常规查询:',students[]['id'])
print('根据键查询:',students[].get('id'))
常规查询: 001
根据键查询: 001

Dict增加操作

  • 添加一名学生的信息(增加行,其实是增加列表中一个元素),之后再添加一个学生信息科目(增加列,其实就是增加字典中一个键值对)
students.append({'name':'n','id':'004'})
print('添加一个字典对象后:',students)
students[]['school']='school1'
students[]['school']='school2'
students[]['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[] #删除第4行(下标为3)
print('删除列表中的一个字典对象后:\n',students)
students[].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(,len(students)):
    students[i].pop('school')
print(students)
[{'name': 'n1'}, {'name': 'n2', 'id': '002'}, {'name': 'n3', 'id': '003'}]

Dict修改操作

  • 添加(更改)第一个学生的学号(在列表的第一个字典元素中增加/更改键值对)
students[].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']