pandas简单解析

最新推荐文章于 2023-07-24 20:57:48 发布

置顶不再彷惶

最新推荐文章于 2023-07-24 20:57:48 发布

阅读量184

点赞数

分类专栏： python

本文链接：https://blog.csdn.net/qq_43604520/article/details/103217349

版权

python 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

此博客仅是我平时学习遇到的一些小代码

import pandas as pd

pandas有两种数据类型：Series(一维), DataFrame(多维)

Series类型

由一维数据及其相关的数据索引组成，说白了就是个带标签数组

1.列表创建Series
	s = pd.Series(range(5))
	输出结果：
		0    0
		1    1
		2    2
		3    3
		4    4
		dtype: int64
		
2.自定义索引
	s = pd.Series(range(5) , index=['a','b','c','d','e'])
	输出结果：
		a    0
		b    1
		c    2
		d    3
		e    4
		dtype: int64

3.标量值创建：
	w = pd.Series(25 , index=['a','b','c','d','e'])		index不能省略，因为代码要根据这个确定创建几个值
	输出结果：
		a    25
		b    25
		c    25
		d    25
		e    25
		dtype: int64

4.字典创建：
	e = pd.Series({'a':1,'b':2,'c':3,'d':4,'e':5})
	输出结果：
		a    1
		b    2
		c    3
		d    4
		e    5
		dtype: int64
		
	此时设置index就不是设置索引值了，而是改变位置
		e = pd.Series({'a':1,'b':2,'c':3,'d':4,'e':5},index=['d','a','b','c','e'])
	输出结果：
		d    4
		a    1
		b    2
		c    3
		e    5
		dtype: int64

5.使用numpy创建
	a = pd.Series(np.arange(0,5,1))
	结果：
		0    0
		1    1
		2    2
		3    3
		4    4
		dtype: int32

		index也可以使用numpy创建
		a = pd.Series(np.arange(0,5,1) , index=np.linspace(10,100,5))
		输出结果：
			10.0     0
			32.5     1
			55.0     2
			77.5     3
			100.0    4
			dtype: int32

二.基本操作：
	a = pd.Series(np.arange(0,5,1) , index=['a','b','c','d','e'])
	a.median()		获取中位数
	a.index			获得索引
		Index(['a', 'b', 'c', 'd', 'e'], dtype='object')
	a.values		获得数据
	[0 1 2 3 4]

	切片：同时可以进行值的修改
		使用自定义索引：
			a['a'] -> 0
			a[['a','c']] -> a    0
						    c    2
						    dtype: int32
		也可以使用默认索引：
			a[1] -> 1
			a[[1,3]] -> b    1
					    d    3
					    dtype: int32
			a[[1,3]] - >a    0
					    b    1
					    c    2
					    dtype: int32
		但是两种索引不能同时使用

	in操作符：判断字符是否存在于Series的索引内(只在自定义索引内寻找)
	'a' in a -> true
	'x' in a -> false
	
	a.get('f' , 100) -> 索引内有f的话，就返回对应的值，否则返回100

两个Series相加计算：具有相同索引的数据进行相加，某个索引只有一个Series具有，则该索引的值为nan，应为任何数和nan相加都为nan

DataFrame类型

就是一个表格，每列值的类型不同
index axis=0 纵向
column axis=1 横向

1.numpy创建
	a = pd.DataFrame(np.arange(10).reshape(2,5))
	输出结果：
		   0  1  2  3  4
		0  0  1  2  3  4
		1  5  6  7  8  9

2.字典创建
	
	a = pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']),
                      'two':pd.Series([9,8,7,6],index=['a','b','c','d'])})
    输出结果：
    	   one  two
		a  1.0    9
		b  2.0    8
		c  3.0    7
		d  NaN    6

	b = pd.DataFrame(a , index=['b','c','d'],columns=['two','three'])
	输出结果：
		   two  three
		b    8    NaN
		c    7    NaN
		d    6    NaN

	c = pd.DataFrame({'a':[1,2,3,4],'b':[5,6,7,8]})
	输出结果：
		   a  b
		0  1  5
		1  2  6
		2  3  7
		3  4  8

	d = {'城市':["北京",'上海','广州','深圳','沈阳'],
     '环比':[1,2,3,4,5],
     '同比':[6,7,8,9,10],
     '定级':[11,12,13,14,15],
     '哈哈':[16,17,18,19,10]}
	e = pd.DataFrame(d , index=['c1','c2','c3','c4','c5'])
	输出结果：
		    同比  哈哈  城市  定级  环比
		c1   6    16   北京   11   1
		c2   7    17   上海   12   2
		c3   8    18   广州   13   3
		c4   9    19   深圳   14   4
		c5  10    10   沈阳   15   5
	
基本操作：
	e.index,e.columns获取纵轴横轴的索引
	e.values 获取数据，格式为矩阵
	e['同比']  获取列元素
	e.ix['c2'] 获取行元素，也可以使用默认索引
	d['同比']['c2']  获取某个位置的元素

增删改查：

1.调节各行个列索引的位置：
d = {'城市':["北京",'上海','广州','深圳','沈阳'],
     '环比':[1,2,3,4,5],
     '同比':[6,7,8,9,10],
     '定级':[11,12,13,14,15],
     '哈哈':[16,17,18,19,10]}
e = pd.DataFrame(d , index=['c1','c2','c3','c4','c5'])

f = e.reindex(index=['c1','c5','c2','c3','c4'])
f = f.reindex(columns=['城市','同比','哈哈','环比','定级'])
输出结果：
	    城市  同比  哈哈  环比  定级
	c1  北京   6    16     1    11
	c5  沈阳  10    10     5    15
	c2  上海   7    17     2    12
	c3  广州   8    18     3    13
	c4  深圳   9    19     4    14
2 .reindex参数：
	index,columns 自定义索引
	fill_value 填充缺失位置的值
	method	填充方法：ffill向前填充，bfill向后填充
	limit 最大填充量
	
g = f.columns.insert(5,'新增')
h = f.reindex(columns=g,fill_value=200)
输出结果：
	    城市  同比  哈哈  环比  定级   新增
	c1  北京   6  	16    1  	11   200
	c5  沈阳  10  	10    5  	15   200
	c2  上海   7  	17    2  	12   200
	c3  广州   8 	18    3  	13   200
	c4  深圳   9 	19    4  	14   200
	
3. e.index,e.columns获取纵轴横轴的索引，返回值为Index对象
对这个对象能进行的操作：
	.append(idx)		连接另一个Index对象，生成一个新的index对象
	.diff(idx)			两者计算差集，产生新的对象
	.intersection(idx)	计算交集
	.union(idx)			计算并集
	.delete(loc)		删除loc位置的元素
	.insert(loc,e)		在loc位置插入元素
通过改变index的值，来操控数据
nc = e.columns.delete(2)
ni = e.index.insert(5,'c0')
g = e.reindex(index=ni , columns=nc , fill_value='补充')

4.删除指定的行或列
.drop 默认删除行，添加axis=1删除列
	e = e.drop(['c1','c2'])					删除c1和c2行
	e = e.drop(['同比','城市'] , axis=1)		删除同比和城市列

算数运行

同维度

具有相同行和列索引的元素相运算，其他元素用NaN补齐后再运算。
a = pd.DataFrame(np.arange(12).reshape(3,4))
b = pd.DataFrame(np.arange(20).reshape(4,5))
print(a)
	   0  1   2   3
	0  0  1   2   3
	1  4  5   6   7
	2  8  9  10  11
print(b)
	    0   1   2   3   4
	0   0   1   2   3   4
	1   5   6   7   8   9
	2  10  11  12  13  14
	3  15  16  17  18  19
使用算数符号
print(a+b)          加减乘除都能用
	      0     1     2     3   4
	0   0.0   2.0   4.0   6.0 NaN
	1   9.0  11.0  13.0  15.0 NaN
	2  18.0  20.0  22.0  24.0 NaN
	3   NaN   NaN   NaN   NaN NaN
使用函数：好处就是能添加缺省值
print(a.add(b , fill_value=100))
	       0      1      2      3      4
	0    0.0    2.0    4.0    6.0  104.0
	1    9.0   11.0   13.0   15.0  109.0
	2   18.0   20.0   22.0   24.0  114.0
	3  115.0  116.0  117.0  118.0  119.0
加add
减sub
乘mul
除div

不同维度

c = pd.Series(np.arange(4))
print(c)
	0    0
	1    1
	2    2
	3    3
print(c-10)		不同维度运算会进行广播，低维的数作用于高维的每一个
	0   -10
	1    -9
	2    -8
	3    -7

b = pd.DataFrame(np.arange(20).reshape(4,5))
print(b)
	    0   1   2   3   4
	0   0   1   2   3   4
	1   5   6   7   8   9
	2  10  11  12  13  14
	3  15  16  17  18  19
print(b-c)	默认在一轴运算，就是b的每一行都减去c，没有的补NaN
	      0     1     2     3   4
	0   0.0   0.0   0.0   0.0 NaN
	1   5.0   5.0   5.0   5.0 NaN
	2  10.0  10.0  10.0  10.0 NaN
	3  15.0  15.0  15.0  15.0 NaN
print(b.sub(c,axis=0))
	    0   1   2   3   4
	0   0   1   2   3   4
	1   4   5   6   7   8
	2   8   9  10  11  12
	3  12  13  14  15  16

比较运算

只比较相同索引的元素，不进行补齐，所以说相比较的两个同维元素尺寸要相同，不然报错

a = pd.DataFrame(np.arange(12).reshape(3,4))
b = pd.DataFrame(np.arange(13,25,1).reshape(3,4))
print(a>b)
	       0      1      2      3
	0  False  False  False  False
	1  False  False  False  False
	2  False  False  False  False
print(a!=b)
     	 0     1     2     3
	0  True  True  True  True
	1  True  True  True  True
	2  True  True  True  True
不同维度与上面基本差不多，不再写了

W = pd.read_csv(' ')    		''里面输入路径,文件名尽量不要包含中文。

W.head()  			显示W内前五行数据，括号内可以加参数，设置显示几行数据
W.tail()  		显示末尾几行，默认5行。
W.shape				查看形状
W.columns			返回列名
W.index				返回行名
W.name.value_counts()   	显示文件内各类别的数目，（name）可以换成其他的列名。
W.values   			将数据转化为矩阵
-----------------------------------------------------------------------------
pd.DataFrame(np.random.randn(6,4) , index=['1','2','3','4','5','6'] , columns=['a','b','c','d'])
自己指定数据的行名和列名，也可以不指定，默认0~无穷


pd.get_dummies()		onehot编码，将文字特征变为0或1

W.cumsum()			计算前n项和

W.groupby('name').min()		#以name为分界区间，对词文件内其他所有的列取最小值。
#同理还有sum，max，mean等操作。取得各个位置的元素都为最小值，他们在文件内并不一定属于同一行。

数据处理

索引排序，默认0轴，升序

a = pd.DataFrame(np.arange(20).reshape(4,5),index=['c','a','d','b'])
print(a)
    0   1   2   3   4
c   0   1   2   3   4
a   5   6   7   8   9
d  10  11  12  13  14
b  15  16  17  18  19
a = a.sort_index()
print(a)
    0   1   2   3   4
a   5   6   7   8   9
b  15  16  17  18  19
c   0   1   2   3   4
d  10  11  12  13  14
print(a.sort_index(axis=1,,ascending=False))
    4   3   2   1   0
a   9   8   7   6   5
b  19  18  17  16  15
c   4   3   2   1   0
d  14  13  12  11  10

数据排序，默认0轴，升序
Datareame还会多一个根据哪一个索引进行排序

Series只有一列，所以说根据这一列的数据进行升序或者降序排，不再多说

Datareame：
a = pd.DataFrame(np.random.randint(-10,10,(4,5)),index=['c','a','d','b'])
print(a)
	    0  1  2   3  4
	c   6 -4 -6 -10 -7
	a -10  5 -5   9  4
	d  -9 -3  3   8  2
	b  -6  6 -3   4  8
a = a.sort_values(by=2,axis=0,ascending=True)
	    0  1  2   3  4
	c   6 -4 -6 -10 -7
	a -10  5 -5   9  4
	b  -6  6 -3   4  8
	d  -9 -3  3   8  2

基本统计分析
两种类型共用的方法：
在这里插入图片描述
适用于Series的方法

.describe() 针对0轴的统计数据汇总
a = pd.DataFrame(np.arange(20).reshape(4,5),index=['c','a','d','b'])
print(a)
    	0   1   2   3   4
	c   0   1   2   3   4
	a   5   6   7   8   9
	d  10  11  12  13  14
	b  15  16  17  18  19
print(a.describe())			返回的是DataFrame数据类型
               	0          1          2          3          4
	count   4.000000   4.000000   4.000000   4.000000   4.000000		
	mean    7.500000   8.500000   9.500000  10.500000  11.500000		
	std     6.454972   6.454972   6.454972   6.454972   6.454972		
	min     0.000000   1.000000   2.000000   3.000000   4.000000		
	25%     3.750000   4.750000   5.750000   6.750000   7.750000		
	50%     7.500000   8.500000   9.500000  10.500000  11.500000		
	75%    11.250000  12.250000  13.250000  14.250000  15.250000		
	max    15.000000  16.000000  17.000000  18.000000  19.000000

累计统计分析
在这里插入图片描述

a = pd.DataFrame(np.arange(20).reshape(4,5),index=['c','a','d','b'])
print(a)
    0   1   2   3   4
c   0   1   2   3   4
a   5   6   7   8   9
d  10  11  12  13  14
b  15  16  17  18  19
print(a.cumsum())
    0   1   2   3   4
c   0   1   2   3   4
a   5   7   9  11  13
d  15  18  21  24  27
b  30  34  38  42  46
print(a.rolling(2).sum())
      0     1     2     3     4
c   NaN   NaN   NaN   NaN   NaN			窗口长度为2，这一列前面没有元素了，所以说全为NaN
a   5.0   7.0   9.0  11.0  13.0
d  15.0  17.0  19.0  21.0  23.0
b  25.0  27.0  29.0  31.0  33.0

数据集处理

ont_hot编码：pd.get_dummies(data) 返回一个编码后的DataFrame

不再彷惶

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
pandas简单解析

此博客仅是我平时学习遇到的一些小代码import pandas as pd1.pandas就是读取数据用的，对于处理大型数据集很方便。2.pandas的切片索引左右都是闭，不相python一样，左闭右开。1.pd.DataFrame(a) #此时a为一个字典2.W = pd.read_csv(' ') #''里面输入路径3.W.head() #显示W内前五行数据，括...
复制链接

扫一扫