当前位置：
  1. 首页
  2. python
  3. 正文
本文介绍: 详细解析pandas扩展包功能，助力数据分析！欢迎大家阅读。
数组只能存储一种类型的数据， 同时，
数组提供了许多方便统计计算的功能
（如平均值
mean
、标准差
std
等）

pandas与numpy的区别

pandas
是基于
numpy
数组构的， 但
二者最大的不同是
pandas
是专门为处
理表格和混杂数据设计的，比较契合统
计分析中的表结构，而
numpy
更适合处
理统一的数值数组数据。
举个例子进行对比 
chengji=[['', '期末', '期末'], ['张三',50, 80], ['李四', 60, 90], ['王老五', 70, 89]]
np.array(chengji)

#array([['', '期末', '期末'],
#['张三', '50', '80'],
#['李四', '60', '90'],
#['王老五', '70', '89']], dtype='<U3')

上图是使用numpy得出的结果

dic={ ' 期 中 ':[50,60,70], ' 期 末':[80,90,89]}
pd.DataFrame(dic,index=['张三','李四','王老五'])

上图是使用pandas得出的结果

Pandas库简介

pandas官网

 pandas扩展包的安装

  1. win+R打开命令行
  2. 输入pip install pandas

pandas扩展包的调用

import pandas as pd

pandas数据结构

 pandas库的理解

Numpy Pandas
基础数据类型
维度：数据间的关系
数据与索引间的关系

相同操作，输出形式对比：

np.arange(4)

#array([0,1,2,3])

pd.Series(np.arange(4))
#0 0
#1 1
#2 2
#3 3
#dtype: int32

可以看出使用pandas库可视化程度更高，能以比较清晰直观的形式展现处理后的数据

series对象类型

Series
是一种类似于一维数组的对象，它由一组数据以及一组与之相关的索引组成，仅由一组数据即可产生最简单的Series


 series对象的创建

 dp.Serise(obj=None, index=None, dtype=None)

•
标量或
Python
列表
•
Python
字典
•
Ndarray
•
其他函数
•
人为指定
并存，但不能混用

 创建时注意事项

标量值，
index
表达
Series
类型的尺寸
Python
字典，键值对中的“键”是索引，
index
从字典中进行选择操作
ndarray
，索引和数据都可以通过
ndarray
类型创建
其他函数，
range()
函数等 

b=pd.Series([9,8,7],['a','b','c'])
#b
#a 9
#b 8
#c 7
#dtype: int64
>>> b.values
array([9, 8, 7], dtype=int64)
>>>b.index #索引
Index(['a', 'b', 'c'], dtype='object’)
>>> b.index.name='索引' #定义索引的名字
>>> b.name='Series对象' #对象名
>>> b
索引
a 9
b 8
c 7
Name: Series对象, dtype: int64
Series
类型的索引操作类似
ndarray
类型：
•
索引方法相同，采用
[]
•
NumPy
中运算和操作可用于
Series
类型
•
可通过自动索引进行切片，如果存在自定义索引，则一同被切片 

>>> b=pd.Series([9,8,7],['a','b','c'])
>>> b
a 9
b 8
c 7
dtype: int64

>>> b[b>=b.median()]
a 9
b 8
dtype: int64

>>> np.exp(b)
a 8103.083928
b 2980.957987
c 1096.633158
d 403.428793
dtype: float64
Series
类型的操作类似
Python
字典类型：
•
通过自定义索引访问
•
保留字
in
操作：判定给定的索引值是否在索引序列中
•
使用
.get()
方法：类似于字典中的
get
方法 
>>> b=pd.Series([9,8,7],['a','b','c'])
>>> b
a 9
b 8
c 7
dtype: int64

>>> b['a']
9
>>> 'c' in b
True

>>> b.get('a')
9

series常用函数 

DataFrame对象类型

  1. DataFrame类型由共用相同索引的一组列组成。
  2. DataFrame是一个表格型的数据类型，每列值类型可以不同
  3. DataFrame既有行索引(index)、也有列索引(columns)
  4. DataFrame常用于表达二维数据，但可以表达多维数据。

 DataFrame创建

pd.DataFrame(data=None, index=None, columns=None, dtype=None)
主要待创建
obj
类型：
•
二维
ndarray
对象
•
由一维
ndarray
、列表、字典、元组或
Series
构成的字典
•
Series
类型
•
其他的
DataFrame
类型
columns，index
分别为指定行和列的索引值，列表类型。 

df=pd.DataFrame(np.random.randint(60,100,size=(2,3)),index=['期中','期末'],columns=['张三','李四','王老五'])

>>> df.values
array([[70, 92, 72],
[60, 60, 88]])
>>> df.shape
(2,3)

>>> df.index
Index(['期中', '期末'], dtype='object')
>>> df.columns
Index(['张三', '李四', '王老五'], dtype='object')

>>> df.describe()
张三 李四 王老五
count 2.000000 2.000000 2.000000
mean 65.000000 76.000000 80.000000
std 7.071068 22.627417 11.313708
min 60.000000 60.000000 72.000000
25% 62.500000 68.000000 76.000000
50% 65.000000 76.000000 80.000000
75% 67.500000 84.000000 84.000000
max 70.000000 92.000000 88.000000

 根据行列参数索引。

>>> df.['x']
a 0
b 3
c 6
Name: x, dtype: int32

根据整数位置参数索引

>>> df.iloc[1,:]
x 3
y 4
z 5
Name:b, dtype: int32

某个轴上拥有多个索引级别

>>> df.['x','z']
a 0 2
b 3 5
c 6 8

列索引

通过类似字典的方式：
某一列
: obj[
列索引值
] 
>>> df['qizhong']
张三 50
李四 60
王老五 70
Name: qizhong, dtype: int64
多列
: obj[
列索引值列表
] 
>>> df[['qizhong', 'qimo']]
qizhong qimo
张三 50 80
李四 60 90
王老五 70 89

行索引

使用
.loc[]
加
index
来进行行索引
某一行
: obj.loc[
行索引值
] 
>>> df.loc['张三']
qizhong 50
qimo 80
Name: 张三, dtype: int64
多行
: obj[
行索引值列表
] 
>>> df.loc[['李四', '张三']]
qizhong qimo
李四 60 90
张三 50 80

效果图

位置索引

iloc
函数索引的数据是
int
整型，
Python
默认的前闭后开。索引方式与数组类似

 

连续索引与不连续索引 
df=pd.DataFrame(np.arange(16).reshape((4,4)),index=["a","b","c","d"],columns=["w","x","y","z"])
连续索引：索引值为切片 
>>> df.loc['a':'c']
>>> df.iloc[:3, :]
w x y z
a 0 1 2 3
b 4 5 6 7
c 8 9 10 11
不连续索引：索引值为列表 
>>> df[['w', 'y']]
>>> df.iloc[:, [0,2]]
w y
a 0 2
b 4 6
c 8 10
d 12 14

重新索引

.reindex()
能够改变或重排
Series
和
DataFrame
索引

删除指定索引

.drop()
能够删除
Series
和
DataFrame
指定行或列索引 
pd.drop(labels, axis=0)
>>> d
城市 环比 同比 定基
0 北京 101.5 120.7 121.4
1 上海 101.2 127.3 127.8
2 广州 101.3 119.4 120.0
3 深圳 102.0 145.5 125.3
4 沈阳 101.1 101.4 101.6
>>> d.drop(3)
城市 环比 同比 定基
0 北京 101.5 120.7 121.4
1 上海 101.2 127.3 127.8
2 广州 101.3 119.4 120.0
4 沈阳 101.1 101.4 101.6
>>> d.drop('同比', axis =1)
城市 环比 定基
0 北京 101.5 121.4
1 上海 101.2 127.8
2 广州 101.3 120.0
4 沈阳 101.1 101.6

Pandas库常用操作

算数运算法则
•
算术运算根据行列索引，补齐后运算，运算默认产生浮点数；
•
补齐时缺项填充
NaN (
空值
)
；
•
采用
+
‐
* /
符号进行的二元运算产生新的对象；
•
二维和一维、一维和零维间为广播运算；

实例

a=pd.DataFrame(np.arange(12).reshape((3,4))) 
b=pd.DataFrame(np.arange(20).reshape((4,5)))
运算结果为浮点型；
hape大小不一致，缺失部分元素以NaN补全 
>>> a
0 1 2 3
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11

>>> 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

 方法形式的运算

 实例

>>> a
0 1 2 3
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11

>>> 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

#加法
>>> b.add(a, 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

#乘法
>>> b.mul(b, fill_value=0)
0 1 2 3 4
0 0.0 1.0 4.0 9.0 0.0
1 20.0 30.0 42.0 56.0 0.0
2 80.0 99.0 120.0 143.0 0.0
3 0.0 0.0 0.0 0.0 0.0

Series与Dataframe之间的计算

使用
Python
操作符：
•
以行为单位操作（参数必须是行），对所有行都有效。（类似于
numpy
中二维 数组与一维数
组的运算，但可能出现
NaN
）
使用
pandas
操作函数：
•
axis=0
：以列为单位操作（参数必须是列），对所有列都有效。
•
axis=1
：以行为单位操作（参数必须是行），对所有行都有效。

传播运算（标量运算）

不同维度数据类型之间的运算。
标量与
Seriers
或
DataFrame
之间的运算（各元素均与标量运算） 
>>> c=pd.Series(np.arange(3))
0 0
1 1
2 2
dtype: int32
>>> c+1
0 1
1 2
2 3
dtype: int32

>>> a=pd.DataFrame(np.arange(12).reshape((3,4)))
0 1 2 3
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
>>> a+1
0 1 2 3
0 1 2 3 4
1 5 6 7 8
2 9 10 11 12
使用
Python
操作符：
•
以行为单位操作（参数必须是行），对所有行都有效。（类似于
numpy
中二维数组与一维数
组的运算，但可能出现
NaN
）
使用
pandas
操作函数：
•
axis=0
：以列为单位操作（参数必须是列），对所有列都有效。
•
axis=1
：以行为单位操作（参数必须是行），对所有行都有效。
传播运算（标量运算）
不同维度数据类型之间的运算。
标量与
Seriers
或
DataFrame
之间的运算（各元素均与标量运算） 
>>> c=pd.Series(np.arange(3))
0 0
1 1
2 2
dtype: int32
>>> c+1
0 1
1 2
2 3
dtype: int32

>>> a=pd.DataFrame(np.arange(12).reshape((3,4)))
0 1 2 3
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
>>> a+1
0 1 2 3
0 1 2 3 4
1 5 6 7 8
2 9 10 11 12

算数运算（传播机制）

默认
Seriers
参与
DataFrame
的行运算
将
Series
的索引匹配到
DataFrame的行，然后行一直向下传播。缺失元素
Nan
补全。 
>>> c=pd.Series(np.arange(4))
>>> a=pd.DataFrame(np.arange(12).reshape((3,4)))

比较运算规则

二维和一维、一维和零维间为广播运算
采用
> < >= <= == !=
等符号进行的二元运算产生布尔对象

不同维度，广播运算，默认在
1
轴
(
行
) 
>>> c=pd.Series(np.arange(4))
>>> a=pd.DataFrame(np.arange(12).reshape((3,4)))

 

 

 索引的排序

•
.sort_index()
方法在指定轴上根据索引进行排序，默认在
0
轴升序。

 .sort_index(axis=0, ascending=True) 

>>> b
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

>>> c=b.sort_index()
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

>>> c.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
.sort_values()
方法在指定轴上根据数值进行排序，默认升序

DataFrame.sort_values(by=‘##’,axis=0,ascending=True, inplace=False) 

 

a = [[9,3,1],[1,2,8],[1,0,5]]
data = pd.DataFrame(a, index=["0", "2", "1"], columns=["c", "a", "b"])

idx = pd.MultiIndex.from_tuples([('a', 1), ('a', 2), ('a', 2), ('b', 2), ('b', 1), ('b', 1)]) 
idx.names = ['first', 'second']
df_multi = pd.DataFrame({'A': np.arange(6, 0, -1)}, index=idx)

 

 汇总和计算描述统计

 汇总和计算描述统计：累计统计分析函数

适用于
Series
和
DataFrame
类型，滚动计算（窗口计算） 

obj = pd.Series(['c','a','d','a','a','b','b','c','c'])

 serieris.unique()：是以数组形式返回列的所有唯一值（特征的所有唯一值）

>>> uniques = obj.unique()
array(['c', 'a', 'd', 'b'], dtype=object)
Series.nunique():
返回的是唯一值的个数 
>>> uniques = obj.nunique()
4
serieris.value_counts()
：按
value
的出现次数多少
降序排序 
>>> obj.value_counts()
a 3
c 3
b 2
d 1
dtype: int64
pd.isin(values)
：来查看参数
values
是否在
Series/Data Frame
内，有返回按
DataFrame
分布布尔值
True
，否则
False
。
values
：
iterable, Series, DataFrame or dictt

函数映射

map
函数
•
作用在
Series
的每个元素
applymap
函数
•
作用
DataFrame
所有元素
apply
函数
•
作用在
DataFrame
行或列
df[‘col2’] = df[‘col1’].map(lambda x: x**2)
对行列用函数处理
apply
函数是
pandas
里面所有函数中自由度最高的函数
DataFrame.apply(func, axis=0, broadcast=False, raw=False, reduce=None, args=(), **kwds
•
func
： 函数，应用于每个列或行的函数；
•
axis
：
=0
或
1
将函数应用于每一列或行；
•
raw
：默认将每个行或列作为系列传递给函数
,
否则传递的函数将改为接收
ndarray
对象；
•
result_type
：
{‘expand’
，‘
reduce’
，‘
broadcast’
，
None}
，默认为
None
。仅在
axis=1
情况下起作用，‘
expand’
：类似列表的结果将变成列，
‘reduce‘
：如果可 能，
返回一个
Series
。
‘ broadcast ‘
：结果将广播到
DataFrame
的原始形状 
>>> name=["张三","李四 ","王五"]
>>> idx=["指标1","指标2","指标3","指标4"]
>>>df=pd.DataFrame(np.random.randint(67,80,12).reshape((3,4)),index=name,colum
ns=idx)
>>> df.apply(lambda x:((x-min(x))/(max(x)-min(x)),axis=1)
指标1 指标2 指标3 指标4
张三 70 70 72 77
李四 79 67 73 74
王五 67 74 69 724

    |
    V
指标1 指标2 指标3 指标4
张三 0.0 0.0 0.285714 1.000000
李四 1.0 0.0 0.500000 0.583333
王五 0.0 1.0 0.285714 0.714286

apply函数(对行列用函数处理)

 传送门：Python全套学习笔记

原文地址:https://blog.csdn.net/weixin_60535956/article/details/127982314

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。

如若转载，请注明出处：http://www.7code.cn/show_20130.html

如若内容造成侵权/违法违规/事实不符，请联系代码007邮箱：suwngjj01@126.com进行投诉反馈，一经查实，立即删除！

上一篇 python数学建模之Numpy、Pandas学习与应用介绍
下一篇 创建pandas容器和添加数据

相关文章

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

插入图片
浏览器会保存昵称、邮箱和网站cookies信息，下次评论时使用。