python自带及pandas、numpy数据结构(一)

Posted 2023-03-23

参考技术A

1.python自带数据结构：序列（如list）、映射（如字典）、集合（set）。
以下只介绍序列中的list：
创建list：
list1 = []
list1 = [1,2,3,4,5,6,7,8,9] #逗号隔开
list2 = [[1,2],[3,4],[5,6],[7,8]] #list2长度(len(list2))为2,list2[0] = [1,2]
liststring = list(“thisisalist”) #只用于创建字符串列表
索引list：
e = list1[0] #下标从零开始，用中括号
分片list：
es = list1[0:3]
es = list1[0:9:2] #步长在第二个冒号后
list拼接（list1.append(obj)、加运算及乘运算）：

list长度：

list每个元素乘一个数值：
list2 = numpy.dot(list2,2)
list类似矩阵相乘（每个元素对应相乘取和）：
list3 = numpy.dot(list1,list1)
#要求相乘的两个list长度相同
list3 = numpy.dot(list2,list22)
#要求numpy.shape(list2)和numpy.shape(list22)满足“左行等于右列”的矩阵相乘条件，相乘结果numpy.shape(list3)满足“左列右行”

2.numpy数据结构：

Array：
产生array：
data=np.array([[1, 9, 6], [2, 8, 5], [3, 7, 4]])
data=np.array(list1)
data1 = np.zeros(5) #data1.shape = (5,),5列
data1 = np.eye(5)
索引array:
datacut = data[0,2] #取第零行第二列，此处是6
切片array：
datacut = data[0:2,2] # array([6, 5])
array长度：
data.shape
data.size
np.shape(data)
np.size(data)
len(data)
array拼接：
#括号内也有一个括号（中括号或者小括号）！
d = np.concatenate((data,data))
d = np.concatenate((data,data),axis = 1) #对应行拼接
array加法：逐个相加
array乘法：
d = data data #逐个相乘
d = np.dot(data,data) #矩阵相乘
d = data 3 #每个元素乘3
d = np.dot(data,3) #每个元素乘3
array矩阵运算：
取逆 : np.linalg.inv(data)
转置：data.T
所有元素求和 : np.sum(data)
生成随机数：np.random.normal(loc=0, scale=10, size=None)
生成标准正态分布随机数组：np.random.normal(size=(4,4))
生成二维随机数组：
np.random.multivariate_normal([0,0],np.eye(2))
生成范围在0到1之间的随机矩阵(M,N)：
np.random.randint(0,2,(M,N))

Matrix:
创建matrix：
mat1 = np.mat([[1, 2, 3], [4, 5, 6]])
mat1 = np.mat(list)
mat1 = np.mat(data)
matrix是二维的，所有+，-，*都是矩阵操作。
matrix索引和分列：
mat1[0:2，1]
matrix转置：
np.transpose(mat1)
mat1.transpose()
matrix拼接：
np.concatenate([mat1,mat1])
np.concatenate([mat1,mat1],axis = 1)

numpy数据结构总结：对于numpy中的数据结构的操作方法基本相同：
创建：np.mat(list),np.array(list)
矩阵乘：np.dot(x,y)
转置：x.T or np.transpose(x)
拼接：np.concatenate([x,y],axis = 1)
索引：mat[0:1,4],ary[0:1,4]

3.pandas数据结构:
Series:
创建series：
s = pd.Series([[1,2,3],[4,5,6]],index = [‘a’,‘b’])
索引series：
s1 = s[‘b’]
拼接series：
pd.concat([s1,s1],axis = 1) #也可使用s.append(s)

DataFrame:
创建DaraFrame:
df = pd.DataFrame([[1,2,3],[1,2,3]],index = [\'a\',\'b\'],columns = [\'x\',\'y\',\'z\'])
df取某一列：
dfc1 =df.x
dfc1 = df[‘x’]
dfc2 = df.iloc[:,0] #用.iloc方括号里是数字而不是column名！
dfc2 = df.iloc[:,0:3]
df取某一行：
dfr1 = df.iloc[0]
df1 = df.iloc[0:2]
df1 = df[0:2] #这种方法只能用于取一个区间
df取某个值：
dfc2 = df.iloc[0,0]
dfc2 = df.iloc[0:2,0:3]

python(pandas模块)？

1.什么是pandas? numpy模块和pandas模块都是用于处理数据的模块。 numpy主要用于针对数组进行统计计算,处理数字数据比较方便。 pandas除了可以处理数字数据,还可... 参考技术A 一、模块的安装
1. 安装pandas
pip instal pandas
2. 安装openpyxl
pip instal openpyxl
二、数据结构
pandas模块更擅长处理二维数据，主要有series和dataframe两种数据结构。
series创建一维数组，不仅包含数值，还包含一组索引。
dataframe通过列表、字典或二维数组创建，包含行索引和列索引。
在此主要记录DataFrame的使用，包括：
- 创建
- 修改索引
- DataFrame数据信息的查看
- DataFrame数据的整理
1. DataFrame的创建
- 通过二维列表创建
- 通过字典创建
- 通过NumPy模块创建的二维数组创建DataFrame
（1） 通过列表创建
a=pd.DataFrame([[1,2], [3,4]]) # 用二维列表创建2行2列的二维数组
还可以在创建时自定义行索引和列索引。
a=pd.DataFrame([[1,2], [3,4]]，columns=['data','score'],index=['a','b']) # columns指定列索引，index指定行索引。
（2）通过字典创建
a=pd.DataFrame('a': [1,3,5],'b': [2,4,6], index=['x', 'y', 'z']) # 创建a,b列，xyz行的二维数组
如果想以字典的键名作为行索引，可以用from_dict()函数将字典转换成DataFrame，同时设置参数orient的值为‘index’
c=pd.DataFrame.from_dict('a': [1,3,5],'b': [2,4,6], orient='index')
（3）通过NumPy模块创建的二维数组创建DataFrame
a = np.arange(12).reshape(3, 4)
b = pd.DataFrame(a, index=[1,2,3], columns=['a', 'b', 'c', 'd'])
2. DataFrame索引的修改
（1）a.index.name="Com"
（2）重命名索引rename()
rename()函数会用新索引创建一个新的DataFrame，不会改变原值。通过设置参数inplace为True来修改原值
a.rename(index='a':'万科', 'b':'阿里', 'c':'百度', inplace=True) #更改行索引名称
a.rename(columns='1':'分数', '2':'排名', inplace=True) #更改列索引名称
（3）行索引转换为常规列
a=a.reset_index() # 设置参数inplace=True，可以一步到位的修改
（4）设置索引列
a=a.set_index['id',inplace=True] #将id列设为索引列
3. DataFrame数据信息查看
（1）df.shape #维度查看
（2）df.info() #数据表基本信息（维度、列名称、数据格式、所占空间等）
（3）df.dtypes #每一列数据的格式
df['A1'].dtype #某一列数据的格式
（4）df.isnull() #查看所有列是否为空值
df['A1'].isnull() #查看某一列是否为空值
（5）df['A1'].unique #查看某一列的唯一值
（6）df.values #查看数据表的值
注：带.values输出的是np数组。不带.values则输出的是DataFrame类型**
（7）df.columns #查看列名称
df.columns.values #查看列名称，并输出值（输出的是一个np数组）。
（8）df.index #查看行索引名称
df.index.values #查看列名称，并输出值（输出的是一个np数组）。当进行循环遍历时，两者一样。
（9）df.head() #默认输出前5行
df.tail() #默认输出后5行
（10）print(data.describe()) #描述性统计
三、文件的读取和写入
1. 读取
data=pd.read_excel('data.xlsx') # 需要安装openpyxl模块
df = pd.read_excel(r"/Users/andy/Downloads/books.xlsx", skiprows=3, usecols="C:F", index_col=None, sheet_name = 0, dtype = "ID":str, "InStore":str)
#文件的路径使用"r", 主要是为了避免路径出错
#skiprows表示忽略前面XX行. 例如上面的例子, 读取的时候直接忽略了前面3行
#usecols 表示读取哪几列, 可以使用列表的方式表示要导入哪几列, 例如usecols = [0,2]
#sheet_name 用于指定读取哪个工作表
#index_col表示使用哪一列作为索引
#header=0, 可以使用header表示使用哪一行作为列索引
#dtype使用字典, 更改对应的Series的数据类型. 一般转化成str, 便于后期的运算或修改

df = pd.read_excel("/Users/andy/Downloads/books.xlsx", skiprows=3, usecols="C:F", index_col=None, sheet_name = 0, dtype = "ID":str, "InStore":str)
for i in df.index:
df["ID"].at[i] = 1 + i
df["InStore"].at[i] = "YES" if i % 2 == 0 else "NO"
df["ID"] = df["ID"].astype("str").str.zfill(3)
#在上面的例子中, ID这一列我使用了zfill()这个方法, 它会自动的让字符前面自动添加0. 这里要注意的是, 只能为字符串添加zfill(), 所以我这里进行了数据类型的转化.
#读取文件的时候, 使用了dtype参数, 主要是为了将对应的列转化为字符串, 便于我们进行填充排序
#skiprows表示忽略哪几行, usecols表示要导入哪些列, 可以使用列表的方式导入指定的列, 例如usecols = [0,3], 也可以按上面的方法

data=pd.read_csv('data.csv', delimiter=',', encoding='utf-8')
#delimiter指定csv文件的数据分隔符；encoding指定文件的编码方式；index_col用于设置索引
#注意：读取excle时不能指定编码encoding，读取csv文件时可以指定
2. 写入
data.to_excel('data.xlsx', sheet_name=0, columns=['A列'], index=False)
sheet_name指定工作表的名成； index指定是否写入行索引信息；columns指定要写入的列；encoding指定编码方式。
四、 数据的选取和处理
1. 数据的选取
**使用切片操作时，遵循左闭右开规则。先行后列，中间用逗号(,)分隔。**
（1）按行选取
data.iloc[1:3]
data.loc[['r2', 'r3']] # 根据行的名称来选取。列表中嵌套一个行列表。
data.head() # 用head函数选取前几行
（2）按区块选取
a=data.iloc[0:2][['r1','r3' ]]
a=data.iloc[0:2, [0,2]] # 读取0-1行，0和2列。loc方法使用字符串作为索引，iloc方法使用数字作为索引；
a=data.iloc[0:44, 0:5] # 读取0-44行，0-5列。第0行0列为索引行和索引列
a=data.iloc[0:5, 11:12] # 读取第0-5行，第12列（索引号为11）。
a=data.iloc[[0,2],[0,2]] #按位置单独提取数据
读取指定不连续的多行多列，需要在列表中嵌套列表
（3）使用ix按索引标签和位置混合提取数据
df_inner.ix[:'2018-01-03',:4] # 将日期设为行索引，提取2018/1/3以前，前4列的数据
2. 数据的处理
（1）数据的筛选提取
a = data[data['c1']>1] # c1列大于1的行。多个筛选条件，用”&“（表示’且‘）或”|“（表示’或‘）连接。
data[data['c1'].str[-1].values=='年']|data['c1'].str[-1]=='月'] #按照c1列字符串最后一个字是年或月筛选
df.loc[(df['age']>20)&(df_inner['city']=='beijing'),['id','gender']] #行筛选，提取id、gender列
（2）数据的排序
-按值排序
a=data.sort_values(by='c2', ascending=False) # by指定按哪一列排序；ascending（“上升”的意思）默认为True，升序；False表示降序
-按索引排序
a=a.sort_index() # 按索引列排序
data.sort_index(axis=0,ascending=False) #降序排列行索引
data.sort_index(axis=1,ascending=False) #降序排列列索引
（3）数据的运算
通过数据运算可以基于已有的列生成新的一列
data['c4']=data['c3']-data['c1']
df.loc[(df_inner['city']=='beijing')].city.count() #对筛选后的数据按city列进行计数
df[(df['city']=='beijing')].price.sum() #对筛选后的结果按price进行求和
（4）数据的判断
df['city'].isin(['beijing']) #判断city列是否为beijing
df_inner.loc[df_inner['city'].isin(['beijing','shanghai'])] #判断city列里是否包含beijing和shanghai，然后将符合条件的数据提取出来
（5）转置
df.T
（6）数据的修改、替换和填加
-数据的修改
scores["ID"][1] ="1006" #数据的修改
df.ix[['ID']=='shanghai', 'Scores']='90' #数据的修改。先选取，后赋值。
-数据的替换
df['city'].replace('shagnhai','sh') #数据替换
-数据的添加
scores["df1"]= scores["Scores"]//10 #添加一列df1，数据为Scores列除以10的商整数
scores["df2"]= scores["Scores"]>85 #添加一列df2，数据为True或False
df['group']=np.where(df_inner['price']>3000,'high','low') #添加一列，根据‘price’列的值来填
注：增加行列还可以使用数据的拼接函数
（7）数据的删除
pop()和drop()函数可以删除DataFrame中的指定数据。
data.pop('b3')
drop([],axis=0,inplace) #axis=0指定删除行，axis=1指定删除列；index指定要删除的行；columns指定要删除的列；inplace默认为False，表示删除操作不改变原DataFrame。
df.drop([0,1,3,6]) #删除指定行，第1，2，4，7行的数据
df.drop(['A1','D1'], axis=1) #删除指定列。
不论是删除行还是删除列，都可以通过drop方法实现，只需要设定好删除的轴即可，即调整drop方法中的axis参数。默认该参数为0，表示删除行观测，如果需要删除列变量，则需设置为1。
del df #删除整个df数据
（8）数据缺失值的处理
对于缺失值的存在可能会影响到后期的数据分析或挖掘工作，那么我们该如何处理这些缺失值呢？常用的有三大类方法，即删除法、填补法和插值法。
删除法：当数据中的某个变量大部分值都是缺失值，可以考虑删除改变量；当缺失值是随机分布的，且缺失的数量并不是很多是，也可以删除这些缺失的观测。
替补法：对于连续型变量，如果变量的分布近似或就是正态分布的话，可以用均值替代那些缺失值；如果变量是有偏的，可以使用中位数来代替那些缺失值；对于离散型变量，我们一般用众数去替换那些存在缺失的观测。
插补法：插补法是基于蒙特卡洛模拟法，结合线性模型、广义线性模型、决策树等方法计算出来的预测值替换缺失值。

-删除法
df.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False) #删除缺失值
how : 'any', 'all'
any : if any NA values are present, drop that label
all : if all values are NA, drop that label
df['A1'].drop_duplicates() #删除后出现的重复值
df['A1'].drop_duplicates(keep='last') #删除先出现的重复值，保留后出现的
通过del命令实现，该命令可以删除Python的所有对象。
-替补法
df.fillna() #填充空值
df.fillna(values=0) #用数字0填充空值
df['A'].fillna(df['A1'].mean()) #用A1列的均值填充空值
采用前项填充或后项填充
df.fillna(method='ffill') #采用前项填
df.fillna(method='bfill') #采用后项填充
（9）df['A1'].map(str.strip) #对某一列数据中的字符串进行strip处理
（10）df['A1'].str.lower() #对某一列数据中的字符串进行大小写转换
（11）df['A1'].astype('float') #对某一列数据中的数据进行数据类型转换
（12）df.loc[(df['city']=='beijing')&(df['price']>100),'sign']=1 #对复合多个条件的数据进行分组标记
（13）split=pd.DataFrame((x.split('-') for x in df_inner['category']),index=df_inner.index,columns=['category','size']) #对category字段的值依次进行**分列**，并创建新的DataFrame数据表，索引值为df_inner的索引列，列名称为category和size
（14）pd.DataFrame(category.str[:3]) #提取前三个字符，并生成数据表
（15）对DataFrame使用函数
def multiply(x):
return x * 2
df["height"].**apply**(multiply)
3. 数据的拼接（增加行、列）
-merge()函数
-concat()函数
-append()函数
（1）merge()函数
根据一个或多个同名的列将不同数据表中的行连接起来。
df3 = pd.merge(df1,df2, on='公司', how='outer')
on指定按照哪一同名列进行合并；how=outer指取并集连接。how=left指保留左表全部内容，而对右表不太在意；how=right指保留右表全部内容，而对左表不太在意；
df3 = pd.merge(df1,df2,left_index=True, right_index=True) # 按照行索引进行合并
（2）concat()函数
使用全连接方式完成拼接，不需要对齐，而是直接进行合并。用参数axis指定连接的轴向，默认为0，即按行方向连接（纵向拼接）
df3 = pd.concat([df1, df2], axis=0, ignore_index=True) #忽略原有索引，生成新的数字序列作为索引。
（3）append()函数
实现的是纵向拼接。
df3 = df1.append(df2)
另一个用途是新增元素。新增元素时，一定要设置参数ignore_index=True来忽略原索引，否则会报错。
df3 = df1.append('公司':'腾飞', '分数': '90', ignore_index=True)
4.数据的统计分析
pandas模块为我们提供了非常多的描述性统计分析的指标函数，如总和、均值、最小值、最大值等，我们来具体看看这些函数：
首先随机生成三组数据
np.random.seed(1234)
d1 = pd.Series(2*np.random.normal(size = 100)+3)
d2 = np.random.f(2,4,size = 100)
d3 = np.random.randint(1,100,size = 100)
d1.count() #非空元素计算
d1.min() #最小值
d1.max() #最大值
d1.idxmin() #最小值的位置，类似于R中的which.min函数
d1.idxmax() #最大值的位置，类似于R中的which.max函数
d1.quantile(0.1) #10%分位数
d1.sum() #求和
d1.mean() #均值
d1.median() #中位数
d1.mode() #众数
d1.var() #方差
d1.std() #标准差
d1.mad() #平均绝对偏差
d1.skew() #偏度
d1.kurt() #峰度
d1.describe() #一次性输出多个描述性统计指标
必须注意的是，descirbe方法只能针对序列或数据框，一维数组是没有这个方法的

这里自定义一个函数，将这些统计描述指标全部汇总到一起:
def stats(x):
return pd.Series([x.count(),x.min(),x.idxmin(),
x.quantile(.25),x.median(),
x.quantile(.75),x.mean(),
x.max(),x.idxmax(),
x.mad(),x.var(),
x.std(),x.skew(),x.kurt()],
index = ['Count','Min','Whicn_Min','Q1',
'Median','Q3','Mean',
'Max','Which_Max','Mad',
'Var','Std','Skew','Kurt'])
stats(d1)
在实际的工作中，我们可能需要处理的是一系列的数值型数据框，如何将这个函数应用到数据框中的每一列呢？可以使用apply函数。
将之前创建的d1,d2,d3数据构建数据框:
df = pd.DataFrame(np.array([d1,d2,d3]).T,columns=['x1','x2','x3'])
df.apply(stats)
非常完美，就这样很简单的创建了数值型数据的统计性描述。如果是离散型数据呢？就不能用这个统计口径了，我们需要统计离散变量的观测数、唯一值个数、众数水平及个数。你只需要使用describe方法就可以实现这样的统计了。
student['Sex'].describe()
除以上的简单描述性统计之外，还提供了连续变量的相关系数（corr）和协方差矩阵（cov）的求解，这个跟R语言是一致的用法。
df.corr()
关于相关系数的计算可以调用pearson方法或kendell方法或spearman方法，默认使用pearson方法。
df.corr('spearman')
如果只想关注某一个变量与其余变量的相关系数的话，可以使用corrwith,如下方只关心x1与其余变量的相关系数:
df.corrwith(df['x1'])
数值型变量间的协方差矩阵
df.cov()
5. 数据的汇总
主要函数是groupby和pivote_table。
-**数据聚合：groupby()函数**
聚合：pandas模块中可以通过groupby()函数实现数据的聚合操作
（1）对所有的列进行计数汇总
df_inner.groupby('city').count() #根据city分组，对其它列进行统计
student.groupby('Sex').mean() #根据性别分组，对其它列求平均值
（2）按城市对id字段进行计数
df_inner.groupby('city')['id'].count()
（3）groupby还可以使用多个分组变量，例如对两个字段进行汇总计数
df_inner.groupby(['city','size'])['id'].count()
student.groupby(['Age','Sex']).mean() #根据年龄、性别分组，对其它列求平均值
（4）对city字段进行汇总，并分别计算price的合计和均值
df_inner.groupby('city')['price'].agg([len,np.sum,np.mean])
-**数据透视表 pivote_table函数**
pandas为我们提供了非常强大的函数pivot_table()，该函数就是实现数据透视表功能的。我们先看看这个函数的语法和参数：
pivot_table(data,values=None,index=None,columns=None,aggfunc='mean',fill_value=None,margins=False,dropna=True,margins_name='All')
data：需要进行数据透视表操作的数据框
values：指定需要聚合的字段
index：指定某些原始变量作为行索引
columns：指定哪些离散的分组变量
aggfunc：指定相应的聚合函数
fill_value：使用一个常数替代缺失值，默认不替换
margins：是否进行行或列的汇总，默认不汇总
dropna：默认所有观测为缺失的列
margins_name：默认行汇总或列汇总的名称为'All'
例1：对一个分组变量（Sex），一个数值变量（Height）作统计汇总
pd.pivot_table(student, values=['Height'], columns=['Sex'])
例2：对一个分组变量（Sex），两个数值变量（Height,Weight）作统计汇总
pd.pivot_table(student, values=['Height','Weight'], columns=['Sex'])
例3：对两个分组变量（Sex，Age)，两个数值变量（Height,Weight）作统计汇总
pd.pivot_table(student, values=['Height','Weight'], columns=['Sex','Age'])
这样的结果并不像Excel中预期的那样，该如何变成列联表的形式的？很简单，只需将结果进行非堆叠操作（unstack）即可： pd.pivot_table(student, values=['Height','Weight'], columns=['Sex','Age']).unstack()

参考文章：
[](https://www.cnblogs.com/wobujiaonaoxin/articles/11386046.html)
[](https://mp.weixin.qq.com/s/GPaSz4viebOik_XeGMmq4A)
[](https://blog.csdn.net/weixin_30763455/article/details/96917719)
————————————————
版权声明：本文为CSDN博主「python-小卒」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_64336020/article/details/121540951 参考技术B Python由荷兰数学和计算机科学研究学会的Guido van Rossum于1990 年代初设计，作为一门叫做ABC语言的替代品。[1]Python提供了高效的高级数据结构，还能简单有效地面向对象编程。Python语法和动态类型，以及解释型语言的本质，使它成为多数平台上写脚本和快速开发应用的编程语言，[2]随着版本的不断更新和语言新功能的添加，逐渐被用于独立的、大型项目的开发。[3]
Python解释器易于扩展，可以使用C或C++（或者其他可以通过C调用的语言）扩展新的功能和数据类型。 [4] Python 也可用于可定制化软件中的扩展程序语言。Python丰富的标准库，提供了适用于各个主要系统平台的源码或机器码。 [4]
2021年10月，语言流行指数的编译器Tiobe将Python加冕为最受欢迎的编程语言，20年来首次将其置于Java、C和JavaScript之上。