pandas学习

Pandas学习：

pandas 两大主要数据结构：Series,Dataframes

Series:一种类似于一维数组的对象,它由一组数据(各种Numpy数据类型)以及一
组与之相关的数据标签(即索引1)组成。仅由一组数据即可产生最简单的Series.

Series:创建

from pandas import Series,DataFrame
import pandas as pd
import numpy as np
obj = Series(["a", 22, False])
obj
# 输出：
0        a
1       22
2    False
dtype: object

自定义索引：

series1 = Series(["小明","小涨", "小红"],index = ["a","b","c"]) # 自定义索引
series1
series2 = Series(["小明","小涨", "小红"],index = ["a","a","a"]) # 自定义索引可以重复，但最好不要
series2
输出：
a    小明
b    小涨
c    小红
dtype: object
a    小明
a    小涨
a    小红
dtype: object

通过自定义索引访问：

# 通过自定义索引获取对应的值
series1["b"]
# series2["a"]
输出：
'小涨'

通过随机列表定义series数据

randomNum = Series(np.arange(5),index= ['a','b','c','d','d']) # 使用np创建series数据,
randomNum
输出：
a    0
b    1
c    2
d    3
d    4
dtype: int32

通过字典创建：

# 通过字典创建series
dicts = {"a":"小涨","b":"小明","c":"小王"}
series3 = Series(dicts)
series3
输出：
a    小涨
b    小明
c    小王
dtype: object

通过values访问值

series3.values
输出：
array(['小涨', '小明', '小王'], dtype=object)

通过index访问索引

series3.index
输出：
Index(['a', 'b', 'c'], dtype='object')

访问多个索引

series3[['a', 'b', 'c']] # 同时访问多个索引
a    小涨
b    小明
c    小王
dtype: object

DataFrames:是一个 表格型 的数据结构 ,它含有一组 有序的列 ,每列可以 是 不同的值类型 (数值、字符串布尔等 )

通过dict创建

# 构建DataFrame的第一种方法
dictq= {
    "省份":["上海","浙江","江苏"],
    "年份":[2015,2016,2017],
    "人口":[0.8,1.2,1.3]
}
df = DataFrame(dictq)
df 
# 输出
	人口	年份	省份
0	0.8	2015	上海
1	1.2	2016	浙江
2	1.3	2017	江苏

# 自定义DataFrame列索引，保证 每一列的前后顺序
df2 = DataFrame(dictq,columns=["省份","年份","人口"]) # 没有的index会显示为空

# 没有的index会显示为空，以NaN填充
df3 = DataFrame(dictq,columns=["省份","年","人"]) 
df3 
# 输出：
	省份	年	人
0	上海	NaN	NaN
1	浙江	NaN	NaN
2	江苏	NaN	NaN

# 获取DataFrame数据
# 通过列获取
df["省份"]
        
# 通过行获取        
df[0:1]
#获取多列
df[["省份","年份"]]

# 通过点获取单列数据
df.人口
# 使用loc获取指定索引的行
df.loc[0] 
df.iloc[0]

对DataFrame数据操作：

# 向DataFrame中添加一列数据
df["财政赤字"] = [1.5,2.0,1.1]

# 用series构建DataFrame
series1 = Series([1,2,3],index=["one",'two','three'])
series1
df["财政赤字"] = series1 # 这个是错误的，因为索引不匹配
df
series2 = Series([1,2,3])
df["财政赤字"] = series2 # 如果将series中数据添加或者替换掉DataFrame一列数据一定要索引一致
df
# 获取DataFrame行索引
df.index

# 修改行索引
df.index = ["one",'two','three'] 
df.index = [0,1,2] 

# 添加一行；做花式索引 df.省份 == "上海" 生成一个True和False的列，再赋值给df的magic列，如果没有magic列则进行添加
df["magic"] = df.省份 == "上海"  

# 删除一列
del df['magic']

#获得列的头信息key值
df.columns 

df.T # 转置 行列转换

# 为行和列添加说明注释
df1.columns.name = "省份"
df1.index.name="年份"
df1
# 获取DataFrame所有值
df1.values
# 在DataFrame当中获取得到的一列数据就是一个series；
# 可以把series看成DataFrame的组成单位

pandas索引的操作：

# Series创建时指定行索引
obj = Series(np.arange(3),index=['a','b','c'])
# 修改行索引
obj.index = ['c','b','a']

# 通过index获取Series的行索引
index = obj.index
index[1]
# 通过切片获取series的多个数据
index[0:1]

# index类型数据不支持修改series的行索引
index[1] =7 # 这个是会报错；错误的写法

索引的过滤和选取：

series1 = Series(np.arange(4),index=['a','b','c','d'])
#根据索引序号查数据
series1[2]
#根据索引名称查数据
series1["d"]
#多个索引查数据
series1[['a','b','c']]
# series1 < 2  花式索引 找到小于2的数
series1[series1<2] 
# 使用索引切片
series1['b':'c'] 

删除操作：

# 删除DataFrame中的多列数据
df = DataFrame(np.arange(16).reshape(4,4),index=['安徽','湖南','北京','山东'],columns=['one','two','three','four'])

# 删除指定行
df.drop("北京")
# 删除两行
df.drop(['安徽','山东'])

# 删除指定列,需要指定参数axis=1 这样是删除指定列
df.drop(['one','two'],axis=1)

数据运算：

s1 = Series([4.7,1.5,2.3,6.3],index=['a',"c","d","e"])
s2 = Series([1,2,3,4,5],index=["a","c","e","f","g"])
# 根据index匹配，index相同列相加，如果不同则返回NaN值
s1+s2

# 通过split()函数将创建index使用的数组
s3 = DataFrame(np.arange(16).reshape(4,4),
    index="s,s1,s2,s4".split(","),columns="s,s1,s2,s4".split(","))

# 如何处理dataframe的NAN值
df1 = DataFrame(np.arange(12).reshape((3,4)),columns="a,b,c,d".split(","))
df2 = DataFrame(np.arange(20).reshape((4,5)),columns="a,b,c,d,e".split(","))
# 也可以写成如下
# df1 = DataFrame(np.arange(12).reshape((3,4)),columns=list("abcd"))
# df2 = DataFrame(np.arange(20).reshape((4,5)),columns=list("abcde"))

# 对应相加，无对应取NaN值
df1+df2  
df1.add(df2) # df1 +df2效果一致 

# 缺省列填充完成后，再相加
df1.add(df2,fill_value=0) # 和df2.add(df1,fill_value=0)数据是一致的，谁少列或者行填充谁 ；

# 这个只是把相加结果为NaN的值去为零
df1.add(df2).fillna(0)
df2.add(df1).fillna(0) # 相加后有空的值填充为0

# DataFrame和Series进行相加或相减操作
df1 = DataFrame(np.arange(12).reshape(4,3),columns=list("bde"),index="北京 上海 天津 重庆".split(" "))
# 获取DataFrame中的一行数据
series1 = df1.loc["北京"]
df1-series1 # DataFrame 与Series 相减是 Series 依次向下广播相减
# df1+series1
# 输出：
	  b   d	  e
北京	0	0	0
上海	3	3	3
天津	6	6	6
重庆	9	9	9

简单统计使用：

# 定义数据
df = DataFrame([
    [1.4,NA],
    [7.1,-4.5],
    [NA,NA],
    [0.75,-1.3]
],index=list('abcd'),columns="one,two".split(','))

# 求和，默认省略none值
df.sum()
df.sum(axis=1) # 按照行求和

# 求平均 默认排除nan值，不参与运算
df.mean()
df.mean(skipna=False) # 这样NaN值也参与运算

# 累积求和，默认按照列方向进行
df.cumsum()

# 统计数据的简单描述
df.describe()

# 查看DataFrame数据信息
df.info()

# 查看series中的describe
series = Series(['a','a','b','c']*4)

# 查看series中的describe
series1 = Series([1,2,3,4]*4)
series1.describe()

# 根据数据类型不同describe统计数据会有差异

#统计出现了哪些数据，重复的取一次
series1.unique()

#统计每个数据出现的频率次数
pd.value_counts(series1.values,sort=False,ascending=False)

mask = series1.isin([1,2]) # 通过这个可以进行数据的筛选
series1[mask]

pandas索引排序：

series1 = Series(np.arange(4),index=list('dabc'))
# 对series的索引进行排序 ;对应值也相应排序
series1.sort_index() 


# 对DataFrame中的缩影进行排序：行索引，列索引
df1 = DataFrame(np.arange(8).reshape(2,4),index='three,one'.split(','),columns=list("dabc"))
# 对行索引进行排序
df1.sort_index()

# 对列索引进行排序axis,默认升序
df1.sort_index(axis=1)

# 对列索引进行排序axis=1,ascending 控制升降序
df1.sort_index(axis=1,ascending=False)
# 对数据进行排序 by表示通过那一列进行排序，ascending表示是否升序
df1.sort_values(by='b',ascending=False)
df1.sort_values(by=['b','c'],ascending=False)

# 判断索引是否唯一
s1 = Series(range(5),index=list('aabbc'))
s1.index.is_unique # false代表有重复值

# pandas求个，可以按照列求和，也可以按照行求和
df1.sum()
df1.sum(axis=1)

缺失值处理：

data = Series([1,NA,3.5,NA,7])
# dropna()删除缺失值 ，删除整行数据，包括索引号也会删除
data.dropna()
data[data.notna()]

# 去除DataFrame中的缺失值
df = DataFrame([
    [1,6.5,3.],
    [1,NA,NA],
    [NA,NA,NA],
    [NA,6.5,3.]
])

df.dropna() # 删除所有包含NA的行
df.dropna(how="all")# 只删除一行数据中全为Na的行

df1 = DataFrame([
    [NA,6.5,3.],
    [NA,NA,NA],
    [NA,NA,NA],
    [NA,6.5,3.]
])
df1.dropna(axis=1,how="all")

#构造数据
df2 = DataFrame(np.random.randn(7,3))
series1 = Series([1,2,3,NA,5,NA,7])
series2 = Series([NA,2,NA,4,5,6,NA])
df2[0] = series1
df2[2] = series2

# 把第0列NA值替换为999;第2列NA值替换为888；不存在的第3列没有理睬
# 调用fillna()方法，传入一个字典，实现不同列的NA值替换不同的值
df2.fillna({0:999,2:888,3:-1})

df.fillna(0,inplace=True) # inplace修改自己本身

函数应用和映射

df = DataFrame(np.random.randn(4,3),columns=list("abc"),index="one,two,three,four".split(','))
#取绝对值
np.abs(df)
# 求每一列的最大值和最小值之差# 按照列的方向使用函数
f = lambda x : x.max() - x.min()
df.apply(f) 
# 按照行的方向使用函数
df.apply(f,axis=1)

f1 = lambda x : "%.2f"%x
# def f1(x):
#    return "%.2f"%x
# 
#对DataFrame中的每一个元素使用函数进行映射
df.applymap(f1)

# DataFrame中 apply() 方法和applymap()区别
# apply()对整行元素或整列元素进行操作
# applymap() 对DataFrame中的每一个数据进行操作

# 对Series数据进行map操作也是可以的
df.c.map(f1)

复合函数的使用：

data = DataFrame({
    "Qu1":[1,3,4,3,4],
    "Qu2":[2,3,1,2,3],
    "Qu3":[1,5,2,9,4]
})

#统计每一列数据中，每个数据出现的次数
result = data.apply(pd.value_counts).fillna(0)

mask = data.apply(pd.value_counts).isnull()
result[~mask] # 使用~进行取反
# 生成的是一个花式索引列表
data.apply(pd.value_counts).notnull()