pandas学习笔记

pandas学习笔记

一、数据的导入导出

1.导入pandas库

import pandas as pd
1

2.文件的导入导出

# 导入csv
data=pd.read_csv("1.csv",encoding='gbk',low_memory=False)
# 导出csv
data.to_csv('1.csv',index=False)
1
2
3
4

3.创建dataframe

# 利用字典创建
d = {'one' : [1, 2, 3,4],
   'two' : [5, 6, 7, 8]}
df = pd.DataFrame(d)

# 利用numpy
df = pd.DataFrame(np.random.randn(2,3))
1
2
3
4
5
6
7

二、查看数据

df.head(n) # 查看DataFrame对象的前n⾏
df.tail(n) # 查看DataFrame对象的最后n⾏
df.shape() # 查看⾏数和列数
df.info() # 查看索引、数据类型和内存信息
df.columns() # 查看字段（⾸⾏）名称
df['xxx'].value_counts()	#某一列每个相同值的数量
df.apply(pd.Series.value_counts) # 查看DataFrame对象中每⼀列的唯⼀值和计数
df.isnull().any() # 查看是否有缺失值 
df[df[column_name].duplicated()] # 查看column_name字段数据重复的数据信息
df[df[column_name].duplicated()].count() # 查看column_name字段数据重复的个数
#查看重复数据总和
df.duplicated().sum()
1
2
3
4
5
6
7
8
9
10
11
12

三、数据提取

df[col] # 根据列名，并以Series的形式返回列
df[[col1,col2]] # 以DataFrame形式返回多列

df.iloc[0] # 返回第一行
df.iloc[0,:] # 返回第⼀⾏
df.iloc[0,0] # 返回第⼀列的第⼀个元素
df.iloc[x:x,x:x]	#选择相应的行与列

s.loc['index_one'] # 按索引选取数据
df.loc[0,:] # 返回第⼀⾏（索引为默认的数字时，⽤法同df.iloc），但需要注意的是loc是按索引,iloc参数只接受数字参数
print(df.loc[df['xxx']=='xxxx','xxxxx'])	#提取特定行的特定列
1
2
3
4
5
6
7
8
9
10
11

四、数据清洗

1.删除数据

#清除不必要的列
data.drop(['xx','xx'],axis=1,inplace=True)
#删除空格
data['xxx']=data['xxx'].map(str.strip)
#删除包含某种字符的行
data = df['a'].str.contains('-').fillna(False)
df.drop(df[data].index,inplace=True)
#查看重复数据总和
data.duplicated().sum()
#判断重复数据记录
isDplicated=df.duplicated()   
#删除重复数据
data=data.drop_duplicates(subset='xxx',inplace=True)
1
2
3
4
5
6
7
8
9
10
11
12
13

2.缺失值处理

#检查每列的缺失值占比
print(data.apply(lambda x : sum(x.isnull())/len(x), axis=0))
#检查data每列的缺失值总和
print(data.isnull().sum())
#或者
print(data.info())
#查看有缺失值的行
a=data.isnull()
b=data[a.any(axis=1)]
#删除缺失值,默认为 ‘any’；any表示只要该行（列）出现空值就删除整行（列），all表示整行（列）都出现空值才会删除整行（列）
data=data.dropna(subset=['缺失列'],how='any')
print('删除缺失值后':data.shape)
#再次检查data每列缺失值总和
print(data.isnull().sum())
#统计data数据
print(data.describe())

#把缺失值填充为0
data.fillna(value=0,inplace=True)
#使用平均数填补缺失值
data['xx']=data['xx'].fillna(data['xx'].mean(),inplace=True)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

3.时间格式的处理

#时间格式的转换,把不合法的转为null
data.loc[:,'xx时间']=pd.to_datetime(data.loc[:,'xx时间'].astype(str),format='%Y-%m-%d',errors='coerce')
#提取月份和日期和星期(一定要先转化为pd.to_datetime格式)
data['year']=data['xxxx'].dt.year
data['month']=data['xxxx'].dt.month
data['day']=data['xxxx'].dt.day
data['week']=data['xxxx'].dt.dayofweek+1
#获取a月到b月的数据
data[data['xxxx'].dt.month.isin(np.arange(a,b+1))]
#获取a-b-c到b-c-d的数据
open_day='a-b-c'
close_day='d_e_f+1'
con1=data['xxxx']>=open_day
con2=data['xxxx']<close_day
data[con1&con2]
#增加一个日期索引
df.index = pd.date_range('2017/1/1', periods=df.shape[0])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4.修改与替换

#浮点型数值转化为整形
data['xx']=data['xx'].astype(int)
#字符类型统一
df['aaaa'] = df['aaaa'].str.capitalize()
#分成a,b两类(条件满足时为a类,条件不满足时为b类)
data['xxxx']=np.where(data['xxx']==n,'a','b')
#替换(把a换成b,c换成d)
data['xxxx'] = data['xxxx'].astype(str).replace(({'a': 'b', 'c': 'd'}))
#利用正则表达式提取信息
data['city'] = data['省市区'].apply((lambda x: re.findall('.{2}市',x)[0]))
#利用正则表达式替换
data['xxxx'] = data2['xxxx'].apply(lambda x: re.sub('a', 'b', x))
#更改列的名称
data.rename(columns={'a','b'})
#在某条件下用某一列的数据替换另一列
data['a']=data['a'].mask(条件,data['b'])
#转换单位
for i,lbs_row in df[rows_with_lbs].iterrows():
    weight = int(float(lbs_row['weight'][:-3])/2.2)
    df.at[i,'weight'] = '{}kgs'.format(weight) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

五、合并数据

1.concat

pd.concat(objs, axis=0, join=‘outer’, ignore_index=False)

objs：一个列表，内容可以是DataFrame或者Series，可以混合
axis：默认是0代表按行合并，如果等于1代表按列合并
join：合并的时候索引的对齐方式，默认是outer join，也可以是inner join
ignore_index：是否忽略掉原来的数据索引

result = pd.concat([df1,df2,df3], keys=['x', 'y', 'z'])
result = pd.concat([df1, df4], axis=1, join_axes=[df1.index])
result = pd.concat([df1,df2], ignore_index=True)
1
2
3

2.append

res = df1.append([df2,df3,df4])
s2 = pd.Series(['X0', 'X1', 'X2', 'X3'], index=['A', 'B', 'C', 'D'])
result = df1.append(s2, ignore_index=True)
1
2
3

3.merge

left 参与合并的左侧DataFrame
right 参与合并的右侧DataFrame
how 连接方式：‘inner’（默认）；还有，‘outer’、‘left’、‘right’
on 用于连接的列名，必须同时存在于左右两个DataFrame对象中，如果位指定，则以left和right列名的交集作为连接键
left_on 左侧DataFarme中用作连接键的列
right_on 右侧DataFarme中用作连接键的列
left_index 将左侧的行索引用作其连接键
right_index 将右侧的行索引用作其连接键
sort 根据连接键对合并后的数据进行排序，默认为True。有时在处理大数据集时，禁用该选项可获得更好的性能

data=pd.merge(df1,df2,left_on='key',right_index=True,how='left',sort=True)
1

六、数据统计

1.统计函数

2.计算相关系数

#相关系数矩阵，任意两物的相关系数
data.corr()
#xx与其他的相关系数
data.corr()['xx']
#xx与xxx的相关系数
data['xx'].corr(data['xxx'])
1
2
3
4
5
6

3.拉格朗日插值法

from scipy.interpolate import lagrange
x=[1,2,3,4,7]
y=[5,7,10,3,9]
a=lagrange(x,y)
print('插值函数\n',a)
print('插值函数的阶数',a.order)
print('x=1对应函数y值{}，\nx=2对应函数y值{}，\nx=3对应函数y值{}'.format(a(1),a(2),a(3)))
print('常数项系数{}，\n二阶项系数{}，\n三阶项系数{}'.format(a[0],a[2],a[3]))
1
2
3
4
5
6
7
8

4.排序

df = df.sort_values(by="Count_AnimalName",ascending=False)  # by指定按哪列排序。ascending表示是否升序
df.sort_index(axis=1,ascending=False,inplace=True)
df.sort_index(axis=0,ascending=False,inplace=True)
1
2
3

5.聚合一类数据

#根据其中一列分组
df_expenditure_mean = df.groupby(['Gender']).mean()

#根据其中两列分组
df_expenditure_mean = df.groupby(['Gender', 'name']).mean()

#只对其中一列求均值
df_expenditure_mean = df.groupby(['Gender', 'name'])['income'].mean()
1
2
3
4
5
6
7
8

# 解决groupby.sum() 后层级索引levels上移的问题
#不以组标签为索引，通过 as_index 来实现
df_expenditure_mean = df.groupby(['Gender', 'name'], as_index=False).mean()
1
2
3

# 加一句df_apply_index = df_apply.reset_index()
df_apply = df.groupby(['Gender', 'name'], as_index=False).apply(lambda x: sum(x['income']-x['expenditure'])/sum(x['income']))
df_apply = pd.DataFrame(df_apply,columns=['存钱占比'])#转化成dataframe格式
df_apply_index = df_apply.reset_index()
1
2
3
4

6.区间划分

pd.cut(x, bins, labels=None)
用于将数据值按照值本身进行分段并排序到 bins 中。
参数包含：x, bins, right, include_lowest, labels, retbins, precision
x ：被划分的数组
bins ：被划分的区间/区间数-
① 当 bins 为整数时，表示数组 x 被划分为多少个等间距的区间；
② 当 bins 为序列时，表示数组 x 将被划分在该指定序列中，若不在则输出 NaN；

ages = [19,22,25,27,21,23,37,31,61,90]
cats1=pd.cut(ages,bins=[18,25,35,60,90])
# [(18, 25], (18, 25], (18, 25], (25, 35], (18, 25], (18, 25], (35, 60], (25, 35], (60, 90], (60, 90]]
1
2
3

pandas.qcut(x, q, labels=None)
将指定序列 x，划分为q 个区间，使落在每个区间的记录数一致

输入

ll = [1,2,3,5,3,4,1,2]
print('- - - pd.cut()示例1 - - -')
print(pd.cut(ll, 4, precision=2).value_counts())
print('- - - pd.cut()示例2 - - -')
print(pd.cut(ll, [1,2,4], precision=2).value_counts())
print('- - - pd.qcut()示例 - - -')
print(pd.qcut(ll, 4, precision=2).value_counts())
1
2
3
4
5
6
7

输出:

- - - pd.cut()示例1 - - -
(1.0, 2.0]    4
(2.0, 3.0]    2
(3.0, 4.0]    1
(4.0, 5.0]    1
dtype: int64
- - - pd.cut()示例2 - - -
(1, 2]    2
(2, 4]    3
dtype: int64
- - - pd.qcut()示例 - - -
(0.99, 1.75]    2
(1.75, 2.5]     2
(2.5, 3.25]     2
(3.25, 5.0]     2
dtype: int64
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

七、各种数据类型的转换

dataframe结构类似于一个二维矩阵格式，每一列和每一个行都有个index
Series只有row index，有点类似于一个一维向量。
array是由不同维度的list转换来的,更方便矩阵操作
tensor是在深度学习框架中的一个数据结构，把数据喂进模型中需要把数据转换为tensor结构,，等我们再取出来做框架以外的操作，比如保存成文件，用plot画图，都需要重新转换为array或list结构。

1.Dataframe到Series

Series = Dataframe['column']
1

2.Series到list

list = Series.to_list()
1

3.list 转 array

array = np.array(list)
1

4.array 转 torch.Tensor

tensor = torch.from_numpy(array)
1

5.torch.Tensor 转 array

array = tensor.numpy()
# gpu情况下需要如下的操作
array = tensor.cpu().numpy()
1
2
3

6.torch.Tensor 转 list

# 先转numpy，后转list
list = tensor.numpy().tolist()
1
2

7.array 转 list

list = array.tolist()
1

8.list 转 torch.Tensor

tensor=torch.Tensor(list)
1

9.array或者list转Series

series = pd.Series({'a': array})
series2 = pd.Series({'a': list})
1
2