[Pandas]一些笔记（利用Python进行数据分析）

最新推荐文章于 2023-06-28 15:00:00 发布

起风了xxx

最新推荐文章于 2023-06-28 15:00:00 发布

阅读量435

点赞数

文章标签： python pandas 数据分析

本文链接：https://blog.csdn.net/m0_73598509/article/details/127146234

版权

1.pandas数据结构介绍

1.1Series

series是一种一维的数组型对象，包含了一个值序列，并且包含了数据标签，称为索引（index）。

一般索引在左边，值在右边。若不为数据指定索引，默认生成的索引是从0到N-1。可以通过values属性和index属性分别获得Series对象的值和索引

需要时，我们可以创建一个索引序列，用标签标识每一个数据点。我们从数据中进行选择时，可以利用标签来进行索引

in:
obj = pd.Series([1,2,3,4,5,6],index = ['a','v','d','a','q','w'])
obj
out:
a    1
v    2
d    3
a    4
q    5
w    6
dtype: int64
in:
obj['a']
out:
a    1
a    4
dtype: int64

Series有一个自动对齐索引的特性

in:
#利用字典生成Series
sdata = {'ohio':35000,'texas':70000,'oregon':16000,'utah':6000}
obj1 = pd.Series(sdata)
obj1
out:
ohio      35000
texas     70000
oregon    16000
utah       6000
dtype: int64
in:
states = ['california','ohio','oregon','texas']
obj2 = pd.Series(sdata,index = states)
obj2
out:
california        NaN
ohio          35000.0
oregon        16000.0
texas         70000.0
dtype: float64
in:
obj2 + obj1
out:
california         NaN
ohio           70000.0
oregon         32000.0
texas         140000.0
utah               NaN
dtype: float64

Series对象自身和其索引都有name属性

in:
obj2.name = 'population'
obj2.index.name = 'state'
obj2

out:
state
california        NaN
ohio          35000.0
oregon        16000.0
texas         70000.0
Name: population, dtype: float64

Series的索引可以通过按位置赋值的方式进行改变

in:
obj
out:
a    1
v    2
d    3
a    4
q    5
w    6
dtype: int64

in:
obj.index = ['bob','jerry','steve','eve','jeff','ryan']
obj
out:
bob      1
jerry    2
steve    3
eve      4
jeff     5
ryan     6
dtype: int64

1.2DataFrame

DataFrame表示的是矩阵的数据表，它包含已排序的列集合，每一列可以是不同的值类型（数值、字符串、布尔值等）。DataFrame既有行索引又有列索引，它可以被视为一个共享相同索引的Series的字典。DateFrame中，数据被存储为一个以上的二维块，而不是列表、字典或其他一维数组的集合。

最常用的创建DataFrame的方式是利用包含等长度列表或Numpy数组的字典来形成DataFrame。

in:
data = {'state':['ohio','ohio','ohio','utah','utah','utah'],
       'year':[2000,2001,2002,2003,2004,2005],
       'pop':[1.5,1.6,2.4,4.6,3.7,4.8]}
df1 = pd.DataFrame(data)
df1

out:

state	year	pop
0	ohio	2000	1.5
1	ohio	2001	1.6
2	ohio	2002	2.4
3	utah	2003	4.6
4	utah	2004	3.7
5	utah	2005	4.8

可以指定列的顺序

in:
pd.DataFrame(data,columns = ['year','state','pop'])
out:

year	state	pop
0	2000	ohio	1.5
1	2001	ohio	1.6
2	2002	ohio	2.4
3	2003	utah	4.6
4	2004	utah	3.7
5	2005	utah	4.8

如果所穿的列不包含在字典中。将会在结果中出现缺失值NaN

DataFrame中的一列，可以按照字典型标记或属性那样检索为Series

del方法可以用于移除列

从DataFrame中选取的列是数据的视图，而不是拷贝，所以，对Series的修改会映射到DataFrame中，如果需要复制，应该显式地使用Series的copy方法。

另一种常用的数据形式是包含字典的嵌套字典

如果嵌套字典被赋值给DataFrame，pandas会将字典的键作为列，将内部字典的键作为行索引

in:
pop = {'nevade':{2001:2.4,2002:2.9},
    'ohio':{2000:1.5,2001:1.7,2002:3.6}}
pop

out:
{'nevade': {2001: 2.4, 2002: 2.9}, 'ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}

in:
dt = pd.DataFrame(pop,index = [2000,2001,2002])
dt
out:

nevade	ohio
2000	NaN	1.5
2001	2.4	1.7
2002	2.9	3.6

#转置操作
in:
de.T

out:

2000	2001	2002
nevade	NaN	2.4	2.9
ohio	1.5	1.7	3.6

如果DataFrame的索引和列拥有name属性，则这些name属性也会被显示

in:
dt.index.name = 'year'
dt.columns.name = 'columns'
dt

out:

columns	nevade	ohio
year		
2000	NaN	1.5
2001	2.4	1.7
2002	2.9	3.6

2.基本功能

2.1重建索引

reindex可以创建一个符合新索引的新对象.如果某个索引值之前并不存在，则会引入缺失值

in:
obj = pd.Series([4,7,-5,6],index = ['a','q','f','g'])
obj
out:
a    4
q    7
f   -5
g    6
dtype: int64
in:
obj2 = obj.reindex(['a','b','c','d'])
obj2
out:
a    4.0
b    NaN
c    NaN
d    NaN
dtype: float64

注意，这里新索引的新对象关键在“新”，并不是在原来的数据上进行改动。作为对比：

in:
obj.reindex(['a','b','c','d'])
obj
out:
a    4
q    7
f   -5
g    6
dtype: int64

对于顺序数据，比如时间序列，在重建索引时可能会需要进行插值或填值。method方法可选参数允许我们使用诸如ffill等方法在重建索引时插值，ffill方法会将值向前填充

in:
obj3 = pd.Series(['blue','yellow','red'],index = [0,2,4])
obj3
out:
0      blue
2    yellow
4       red
dtype: object
in:
obj4.reindex(range(6),method = 'ffill')
obj4
out:
0      blue
1      blue
2    yellow
3    yellow
4       red
5       red
dtype: object

在DataFrame中，reindex可以改变行索引，列索引，也可以同时改变二者。当仅传入一个序列时，结果中的行会重建索引,列可以使用columns关键字重建索引

想要从轴向上删除某个条目时，可以用drop方法。语法如下：

new_obj = obj.drop('想要删除的行索引')，也可以传入axis = 1或axis = columns来从列中删除值

drop会修改Series和DataFrame的尺寸或形状，会直接操作原对象而不返回新对象

2.2索引、选择和过滤

Series的索引与Numpy数组索引的功能类似，只不过Series的索引值可以不仅仅是整数。同时，普通的Python切片是不包含尾部的，Series的切片与之不同，是包含尾部的。

对于DataFrame，可以使用单个值或序列来索引出一个或多个列，可以使用df[:2]这样类似的方法进行行选择，也可以利用布尔值进行索引，比如：

in:
data = pd.DataFrame(np.arange(16).reshape((4,4)),
                   index = ['a','b','c','d'],
                   columns = ['q','w','e','r'])
data

out:
q	w	e	r
a	0	1	2	3
b	4	5	6	7
c	8	9	10	11
d	12	13	14	15

in:
data>6

out:
	q	w	e	r
a	False	False	False	False
b	False	False	False	True
c	True	True	True	True
d	True	True	True	True

in:
data[data>6]

out:
	q	w	e	r
a	NaN	NaN	NaN	NaN
b	NaN	NaN	NaN	7.0
c	8.0	9.0	10.0	11.0
d	12.0	13.0	14.0	15.0

in:
data[data<6] = 0
data

out:
	q	w	e	r
a	0	0	0	0
b	0	0	6	7
c	8	9	10	11
d	12	13	14	15

使用loc和iloc选择数据

特殊的索引符号loc和ilo可以帮助我们用轴标签（loc）或整数标签（iloc）以Numpy风格的语法从DataFrame中选出数组的行和列的子集

in:
data
out:
	q	w	e	r
a	0	0	0	0
b	0	0	6	7
c	8	9	10	11
d	12	13	14	15
in:
data.loc['a','q']
out:
0
in:
data.loc['c','e']
out:
10
in:
data.loc['d']
out:
q    12
w    13
e    14
r    15
Name: d, dtype: int32
in:
data.loc[:,'e']
out:
a     0
b     6
c    10
d    14
Name: e, dtype: int32

使用整数标签iloc进行类似的数据选择

in:
data.iloc[2]
out:
q     8
w     9
e    10
r    11
Name: c, dtype: int32

loc和iloc运算符分别用于严格处理基于标签和基于整数的索引

2.3算术和数据对齐

不同索引的对象之间，进行相加时，如果存在某个索引对不相同，则返回结果的索引将是索引对的并集。没有交叠的标签位置上，内部数据对齐会产生缺失值。在某些方法，比如使用add方法将两个DataFrame进行相加时，若存在缺失值，可以将fill_value作为参数传入，比如：

in:
df1 = pd.DataFrame(np.arange(20).reshape(4,5),
                  index = ['a','b','c','d'],
                  columns = ['zxc','vbn','asd','fgh','qwe'])
df1
out:
	zxc	vbn	asd	fgh	qwe
a	0	1	2	3	4
b	5	6	7	8	9
c	10	11	12	13	14
d	15	16	17	18	19

in:
df2 = pd.DataFrame(np.arange(36).reshape(6,6),
                  index = ['a','d','f','q','y','u'],
                  columns = ['zxc','qwe','fsa','wqe','dfd','fdf'])
df2
out:

zxc	qwe	fsa	wqe	dfd	fdf
a	0	1	2	3	4	5
d	6	7	8	9	10	11
f	12	13	14	15	16	17
q	18	19	20	21	22	23
y	24	25	26	27	28	29
u	30	31	32	33	34	35

in:
df1+df2
out:

asd	dfd	fdf	fgh	fsa	qwe	vbn	wqe	zxc
a	NaN	NaN	NaN	NaN	NaN	5.0	NaN	NaN	0.0
b	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
c	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
d	NaN	NaN	NaN	NaN	NaN	26.0	NaN	NaN	21.0
f	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
q	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
u	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN
y	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN

in；
df1.add(df2,fill_value = 0)
out:

asd	dfd	fdf	fgh	fsa	qwe	vbn	wqe	zxc
a	2.0	4.0	5.0	3.0	2.0	5.0	1.0	3.0	0.0
b	7.0	NaN	NaN	8.0	NaN	9.0	6.0	NaN	5.0
c	12.0	NaN	NaN	13.0	NaN	14.0	11.0	NaN	10.0
d	17.0	10.0	11.0	18.0	8.0	26.0	16.0	9.0	21.0
f	NaN	16.0	17.0	NaN	14.0	13.0	NaN	15.0	12.0
q	NaN	22.0	23.0	NaN	20.0	19.0	NaN	21.0	18.0
u	NaN	34.0	35.0	NaN	32.0	31.0	NaN	33.0	30.0
y	NaN	28.0	29.0	NaN	26.0	25.0	NaN	27.0	24.0

Series和DataFrame的一些算术方法

2.4排序和排名

如果需要按行或列索引进行字典型排序，需要使用sort_index方法。该方法返回一个新的、排序好的对象：

in:
obj = pd.Series(range(4),index = ['a','c','d','b'])
obj
out:
a    0
c    1
d    2
b    3
dtype: int64

in:
obj.sort_index()
out:
a    0
b    3
c    1
d    2
dtype: int64

在各个轴上按索引排序：

in:
df = pd.DataFrame(np.arange(8).reshape((2,4)),
                 index = ['three','one'],
                 columns = ['a','v','d','e'])
df
out:
a	v	d	e
three	0	1	2	3
one	4	5	6	7

in；
df.sort_index()
out:
a	v	d	e
one	4	5	6	7
three	0	1	2	3

in；
df.sort_index(axis = 1)
out:
a	d	e	v
three	0	2	3	1
one	4	6	7	5

数据会默认按照升序排序，也可以按照降序排序，需要传递参数ascending = False

如果要根据Series的值进行排序，使用sort_values方法。默认情况下，所有的缺失值会被排序在Series的尾部

当对DataFrame排序时，可以使用一列或多列作为排序键，传递给一个或多个列名给sort_values的可选参数by:

in:
frame = pd.DataFrame({'b':[4,7,-3,2],'a':[0,1,0,1]})
frame
out:
b	a
0	4	0
1	7	1
2	-3	0
3	2	1

in:
frame.sort_values(by = 'b')
out:
b	a
2	-3	0
3	2	1
0	4	0
1	7	1

in:
frame.sort_values(by = ['a','b'])
out:
b	a
2	-3	0
0	4	0
3	2	1
1	7	1

排名是指对数组从1到有效数据点总数分配名次的操作。Series和DataFrame是通过rank方法来实现排名。默认情况下，rank通过将排名平均化分派到每个组来打破平级关系，比如下列数据中的4.5，6.5就是这样的操作

in:
obj = pd.Series([7,-5,7,4,2,0,4])
obj.rank()
out:
0    6.5
1    1.0
2    6.5
3    4.5
4    3.0
5    2.0
6    4.5
dtype: float64

排名也可以根据他们在数据中的观察顺序来进行分配

in:
obj.rank(method='first')
out:
0    6.0
1    1.0
2    7.0
3    4.0
4    3.0
5    2.0
6    5.0
dtype: float64

也可以按照降序排名

in:
obj.rank(ascending = False,method = 'max')
out:
0    2.0
1    7.0
2    2.0
3    4.0
4    5.0
5    6.0
6    4.0
dtype: float64

排名中的平级关系打破方法

DataFrame可以对行或列计算排名：需要在 .rank(）中引入axis = '索引名' 参数

3.描述性统计的概述与计算

Pandas对象装配了一个常用数学、统计学方法的集合，其中大部分属于归约或汇总统计的类别，这些方法从DataFrame的行或列中抽取一个Series或一系列值的单个值（如总和或平均值）。在使用这些方法时，除非整个切片上都是NA，否则NA值是被自动排除的，可以通过禁用skipna来实现不排除NA值。

规约方法可选参数：

一些方法，比如idxmin和idxmax，返回的是间接统计信息，比如最小值或最大值的索引值

除了归约方法外，有的方法是积累型方法，比如cumsum

除了归约方法和积累型方法，还有一类，比如describe。语法如下:df.describe()。df是数据名。describe输出count、mean、std、min、max等描述性结果

对于非数值型数据，describe也会产生另一种汇总统计

下表是汇总统计及其相关方法的完整列表：

唯一值、计数和集合成员属性方法

最后附上pandas的文档供查阅相关内容：User Guide — pandas 1.5.0 documentation

起风了xxx

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
[Pandas]一些笔记（利用Python进行数据分析）

Pandas对象装配了一个常用数学、统计学方法的集合，其中大部分属于归约或汇总统计的类别，这些方法从DataFrame的行或列中抽取一个Series或一系列值的单个值（如总和或平均值）。在使用这些方法时，除非整个切片上都是NA，否则NA值是被自动排除的，可以通过禁用skipna来实现不排除NA值。规约方法可选参数：一些方法，比如idxmin和idxmax，返回的是间接统计信息，比如最小值或最大值的索引值除了归约方法外，有的方法是积累型方法，比如cumsum。
复制链接

扫一扫