pandas基本介绍
基于numpy的扩展库
两个数据类型：Series（一维），DataFrame（二维）
基于上述的数据类型的各类操作：
基本操作、运算操作。特征类操作、关联类操作
对比:
| Numpy | pandas |
|---|---|
| 基础数据类型 | 扩展数据类型 |
| 关注数据的结构表达 | 关注数据的应用表达 |
| 维度：数据间的关系 | 维度：数据与索引间关系 |
pandas的Series类型
Series是一维带“标签”数组
index_0 --> data_a
Series基本操作类似于ndarray和字典，根据索引对齐
import pandas as pd
import numpy as np
# 自动索引
b = pd.Series([1,3,6,np.nan,44,1])
#索引 数据
# 0 1.0
# 1 3.0
# 2 6.0
# 3 NaN 无穷
# 4 44.0
# 5 1.0
# 自定义索引
b = pd.Series([1,3,6,np.nan,44,1], index=['a','b','c','d','e','f'])
/***创建series类型***/
# 1.标量值
s = pd.Series(25, index=['a','b','c'])
# 索引 数据
# a 25
# b 25
# c 25
# 2.字典
s = pd.Series({'a':9,'b':8,'c':7})
# 索引 数据
# a 9
# b 8
# c 7
# 利用index指定顺序
s = pd.Series({'a':9,'b':8,'c':7}, index=['c','a','b','d'])
# 索引 数据
# c 7
# a 9
# b 8
# d NaN
# 3.ndarry
s = pd.Series(np.arange(5))
# 索引 数据
# 0 0
# 1 1
# 2 2
# 3 3
# 4 4
s = pd.Series(np.arnge(5), index=np.arange(9,4,-1))
# 索引 数据
# 9 0
# 8 1
# 7 2
# 6 3
# 5 4
# 4.列表
b = pd.Series([1,3,6,np.nan,44,1], index=['a','b','c','d','e','f'])
# 5.range函数
/***series的基本操作***/
# 1.索引
b = pd.Series([1,3,6,np.nan,44,1], index=['a','b','c','d','e','f'])
b
b.index # 获取索引
b.values # 获取数据
b['b']
b[1]
b[['c','d','e']]
b[:3]
b[b > b.median]
'c' in b # 判断索引'c'是否在b中
0 in b # 判断值0是否在b中
b.get('f', 100) # 在b中查找f标签，如果不存在，就输出100，如果存在就输出f标签的值
# 2.对齐操作
a = pd.Series([1,2,3],['c','d','e'])
b = pd.Series([9,8,7,6],['a','b','c','d'])
a + b
# 索引 值
# a NaN # 9 + NaN = NaN
# b NaN
# c 8.0
# d 8.0
# e NaN
# 3.name属性（Series对象和索引可以有一个名字）
b = pd.Series([9,8,7,6],['a','b','c','d'])
b.name = 'Series对象'
b.index.name = '索引列'
b
# 索引列
# a 9
# b 8
# c 7
# d 6
# Name: series对象, dtype：int64
# 4.修改
b = pd.Series([9,8,7,6],['a','b','c','d'])
b['a'] = 15
b['b','c'] = 20
b.name = "Series"
pandas的DataFrame类型
二维带“标签”数组
由共用相同索引的多列数据组成，即“表格”
纵向，axis = 0
横向，axis = 1
可由以下类型创建：
1.二维ndarray对象
2.一维ndarray、列表、字典、元组或Series构成的字典
3.Series类型
4.其他的DataFrame类型
DataFrame基本操作类似于Series，依据行列索引
import pandas as pd
import numpy as np
/***创建***/
# 1.二维ndarray
d = pd.DataFrame(np.arange(10).reshape(2,5))
# 2.字典
dt = {'one':pd.Series([1,2,3], index=['a','b','c']),
'two':pd.Series([9,8,7,6],index=['a','b','c','d'])}
d = pd.DataFrame(dt) # 默认键是列索引，即行索引为abcd，列索引为one、two
# one two
# a 1 9
# b 2 8
# c 3 7
# d NaN 6
d = pd.DataFrame(dt,index = ['b','c','d'], cloumns=['two','three']) # 自定义索引，对应dt
# two three
# b 8 NaN
# c 7 NaN
# d 6 NaN
dl = {'one': [1,2,3,4], 'two': [9,8,7,6]}
d = pd.DataFrame(dl, index = ['a','b','c','d'])
# one two
# a 1 9
# b 2 8
# c 3 7
# d 4 6
/***索引***/
d.index
d.columns
d.values
d['one'] # 获取某一列数据
d.ix['a'] # 获取某一行数据
d['one']['a'] # 获取某一位置的数据
pandas的数据类型操作
改变结构
- 增加重排：重新索引，.reindex()
.reindex(index=None,columns=None,…)的参数
| 参数 | 说明 |
|---|---|
| index,columns | 新的行列自定义索引 |
| fill_value | 重新索引中，用于填充缺失位置的值 |
| method | 填充方法，ffill当前值向前填充（当前的值由前面填充），bfill向后填充 |
| limit | 最大填充量 |
| copy | 默认True，生成新的对象，False时，新旧相等不复制 |
索引类型的常用方法
| 方法 | 说明 |
|---|---|
| .append(idx) | 连接另一个index对象，产生新的index对象 |
| .diff(idx) | 计算差集，产生新的index对象 |
| .intersection(idx) | 计算交集 |
| .union(idx) | 计算并集 |
| .delete(loc) | 删除loc位置的元素 |
| .insert(loc,e) | 在loc位置增加一个元素e |
- 删除：.drop()
import pandas as pd
import numpy as np
dl = {'城市': ['北京','上海','广州','深圳','沈阳'],
'环比': [101.3,101.2,101.3,102.0,100.1],
'同比': [120.7,127.3,119.4,140.9,101.4],
'定基': [121.4,127.8,120.0,145.5,101.6]}
d = pd.DataFrame(dl. index = ['c1','c2','c3','c4','c5'])
/***修改***/
d = d.reindex(index=['c5','c4','c3','c2','c1']) # 更改每行的顺序，第一行是c5
d = d.reindex(columns=['城市','同比','环比','定基']) # 更改列的顺序，第一列改成‘城市’
newd = d.columns.insert(4,'新增') # 在第四个位置插入“新增”这一列
newd = d.reindex(columns=newc,fill_value=200) # 新生成一个DataFrame对象，列名为newc，填充值为200
print(newd)
nc = d.columns.delete(2) # 删除d.columns中的第2个元素
ni = d.index.insert(5, 'c0') # 在d.index中的第5个位置新增'c0'
nd = d.reindex(index=ni,columns=nc,method='ffill') # 'c0'行拷贝'c1'行
/***删除***/
a = pd.Series([9,8,7,6],index=['a','b','c','d'])
a.drop(['b','c'])
d.drop('c5') # 删除c5行，默认axis=0
d.drop('同比',axis=1) # 删除"同比"这一列
pandas的数据类型运算
算术运算法则
算术运算根据行列索引，补齐后运算，运算默认产生浮点数
补齐时缺项填充NaN(空值)
2维和1维、1维和0维间为广播运算
采用±*/符合进行的二元运算产生新的对象
方法形式的运算
| 方法 | 说明 |
|---|---|
| .add(d,**argws) | 类型间加法运算，可选参数 |
| .sub(d,**argws) | 类型间减法运算，可选参数 |
| .mul(d,**argws) | 类型间乘法运算，可选参数 |
| .div(d,**argws) | 类型间除法运算，可选参数 |
比较运算法则
比较运算只能比较相同索引的元素，不进行补齐
2维和1维，1维和0维间为广播运算
采用> < >= <= == !=等符合进行的二元运算产生布尔对象
import pandas as pd
import numpy as np
a = pd.DataFrame(np.arange(12).reshape(3,4))
b = pd.DataFrame(np.arange(20).reshape(4,5))
c = pd.Series(np.arange(4))
a + b
a * b
b.add(a, fill_value=100) # b+a，如果未运算前存在NaN，就把NaN改成100，再运算
a.mul(b, fill_value=0) # a*b
# 1轴运算
c - 10 # 每一个c中的元素都减10
b - c # b中每一行第i个元素减去c中对应的元素
b.sub(c,axis=0) # 0轴运算，即b中每一列第i个元素减去c中对应的元素
a > c # a中每一行第i个元素和c中对应的元素进行比较
c > 0 # c中每一个元素和0比较
数据的排序
对一组数据的理解
一组数据表达一个或多个含义，对该数据进行摘要，可得：
- 基本统计（含排序）
- 分布/累计统计
- 数据特征、相关性、周期性等
- 数据挖掘（形成知识）
pandas排序
.sort_index() 在指定轴上根据 索引 进行排序，默认升序
即.sort_index(axis=0,ascending=True)
.sort_values() 在指定轴上根据 数值 进行排序，默认升序
即
Series.sort_values(axis=0,ascending=True)
DataFrame.sort_values(by, axis=0,ascending=True)
by: axis轴上的某个索引或某个索引列表
NaN会放到排序的末尾
import pandas as pd
import numpy as np
b = pd.DataFrame(np.arange(20).reshape(4,5), index=['c','a','d','b'])
b.sort_index() # 升序排序，原来行标签是cabd，排序后行标签是abcd
b.sort_index(axis=1,ascending=False) # 降序排序，原来列标签是01234，排序后为43210
c = b.sort_values(2, ascending=False) # 对第二列的数据进行降序排序，其他和该列数据对应的数据也跟着改变（eg：第二列最后一行的数据移到第一行，其他列最后一行的数据也移到第一行）
# 排序前： ？
# 0 1 2 3 4
# c 0 1 2 3 4
# a 5 6 7 8 9
# b 10 11 12 13 14
# d 15 16 17 18 19
# 排序后： ？
# 0 1 2 3 4
# d 15 16 17 18 19
# b 10 11 12 13 14
# a 5 6 7 8 9
# c 0 1 2 3 4
c = c.sort_values('a',axis=1,ascending=False) # 对行标签为‘a’的行进行降序排序
数据的基本统计分析
适用于Series和DataFrame类型
| 方法 | 说明 |
|---|---|
| .sum() | 总和，默认按0轴计算 |
| .count() | 非NaN的数量 |
| .mean() | 算术平均值 |
| .median() | 算术中位数 |
| .var() | 方差 |
| .std() | 标准差 |
| .min() | 最小值 |
| .man() | 最大值 |
| .argmin() | 计算数据最小值所在位置的索引（自动索引） |
| .argmax() | 计算数据最大值所在位置的索引（自动索引） |
| .idxmin() | 计算数据最小值所在位置的索引（自定义索引） |
| .idxmax() | 计算数据最大值所在位置的索引（自定义索引） |
| .describe() | 针对0轴（各列）的统计汇总 |
import pandas as pd
import numpy as np
a = pd.Series([9,8,7,6], index=['a','b','c','d'])
a.describe() # a.describe()是一个Series类型
# count 4.000000 a.describe()['count']
# means 7.500000
# std 1.290994
# min 6.000000
# 25% 6.750000
# 50% 7.500000
# 75% 8.250000
# max 9.000000
b = pd.DataFrame(np.arange(20).reshape(4,5), index=['c','a','d','b'])
b.describe() # 对每一列进行统计分析，生成一个DataFrame类型
# 0 1 2 3
# count 4.000000 ......
# means 7.500000 ......
# std 6.454972 ......
# min 0.000000 ......
# 25% 3.750000 ......
# 50% 7.500000 ......
# 75% 11.250000 ......
# max 15.000000 ......
b.describe().ix('max')
b.describe()[2]
数据的累计统计分析
累计统计函数
| 方法 | 说明 |
|---|---|
| .cumsum() | 依次给出前1、2、3…n个数的和 |
| .cumprod() | 依次给出前1、2、3…n个数的积 |
| .cummax() | 依次给出前1、2、3…n个数的最大值 |
| .cummin() | 依次给出前1、2、3…n个数的最小值 |
滚动计算（窗口计算）函数
| 方法 | 说明 |
|---|---|
| .rolling(w).sum() | 依次计算相邻w个元素的和 |
| .rolling(w).mean() | 依次计算相邻w个元素的算术平均值 |
| .rolling(w).var() | 依次计算相邻w个元素的方差 |
| .rolling(w).std() | 依次计算相邻w个元素的标准差 |
| .rolling(w).max() | 依次计算相邻w个元素的最大值 |
| .rolling(w).min() | 依次计算相邻w个元素的最小值 |
import pandas as pd
import numpy as np
b = pd.DataFrame(np.arange(20).reshape(3,4), index=['c','a','d','b'])
b.cumsum() # 对每一列运算，依次求出前1、2、3、4个数的和
b.sumprod()
b.cummax()
b.cummin()
b.rolling(2).sum() # 在纵向上，对该元素和前一个元素求和
b.rolling(3).sum() # 两
数据的相关分析
相关性
- 正相关
- 负相关
- 不相关
判断两个变量X、Y的相关性
- 协方差
- Pearson相关系数
相关分析函数
| 方法 | 说明 |
|---|---|
| .cov() | 计算协方差矩阵 |
| .corr() | 计算相关系数矩阵，Pearson、Spearman、Kendall等系数 |
import pandas as pd
hprice = pd.Series([3.04, 22.93, 12.75, 22.6, 12.33], index=['2008','2009','2010','2011','2012'])
m2 = pd.Series([8.18, 18.38, 9.13, 7.82, 6.69], index=['2008','2009','2010','2011','2012'])
hprice.corr(m2) # 0.52394
扫一扫
1015
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
