pandas详解

Series是一种类似于一维数组的对象，它由一组数据（各种NumPy数据类型）以及一组与之相关的数据标签（即索引）组成。
仅由一组数据即可产生最简单的
Series：

In [4]: obj = Series([4, 7, -5, 3])

In [5]: obj
Out[5]:
0    4
1    7
2   -5
3    3

 行：axis=0  列：axis=1      取值顺序 [列][行]
DataFrame是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔值等）。
DataFrame既有行索引也有列索引，它可以被看做由Series组成的字典（共用同一个索引）。
跟其他类似的数据结构相比（如R的data.frame），DataFrame中面向行和面向列的操作基本上是平衡的。
其实，DataFrame中的数据是以一个或多个二维块存放的（而不是列表、字典或别的一维数据结构）。
import pandas as pd
data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
        'year': [2000, 2001, 2002, 2001, 2002],
        'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}
frame = pd.DataFrame(data)
In [38]: frame
Out[38]:
   pop   state  year
0  1.5    Ohio  2000
1  1.7    Ohio  2001
2  3.6    Ohio  2002
3  2.4  Nevada  2001
4  2.9  Nevada  2002



3.查看DateFrame信息
（1）df.index # 查看行索引名
（2）df.columns # 查看列索引名
（3）df.shape # 查看DateFrame的shape 形状
（4）df.head(5) # 查看前五行的值默认为5
（5）df.tail(5) # 查看后五行的值默认为5
（6）df.dtypes # 查看每列的数据类型
（7）df.info() # 查看每列的数量（缺失值）， 类型、列名、占内存大小、数据类型的统计
（8）df.values # 查看数据


isin        计算一个指示各值是否都包含在参数集合中的布尔型数值
delete      删除索引出的元素，并得到新的index
drop        删除传入的值，并得到新的index
            data.drop(['Colorado', 'Ohio'])
            frame.drop(['year'], axis=1) 在列的方向下删除 暂时的
            frame.drop([0, 1], axis=0) 在行上删除0 行和 1行
            frame =  frame.drop(['year'], axis=1) 在原数据上真正删除
insert      将元素插入到索引处，并得到新的index
				frame.insert(1, 'year', [2012, 2013, 2015, 2017, 2014])在第2列位置插入新的一列（序列从0开始）
unique      计算index中唯一值的数组
rename	    修改列名,行名DataFrame.rename(mapper=None, index=None, columns=None, axis=None, copy=True, inplace=False, level=None)
			frame.rename(columns={'built':'bui'}, inplace=True) inplace 为True则改变的是真正的数据
			否则，就是表面修改，不需要 frame = frame.rename(columns={'built':'bui'}, inplace=True) 也能改变
			frame.rename(index={0:'bu'}, inplace=False)
			frame.rename(index={0:'bu'}, columns={'year': 'day'}, inplace=False)融合在一起

reindex    obj3.reindex(range(6), method='ffill')
method：
ffill  pad          前向填充值
bfill  backfill     向后填充
删除列：
del方法
In [5]:
del odata['date']
.pop方法可以将所选列从原数据块中弹出，原数据块不再保留该列

In [6]:
spring = odata.pop('spring')

.drop()方法
drop方法既可以保留原数据块中的所选列，也可以删除，这取决于参数inplace

In [8]:
withoutSummer = odata.drop(['summer'],axis=1)


列子：
In [112]: data = DataFrame(np.arange(16).reshape((4, 4)),
     ...:                  index=['Ohio', 'Colorado', 'Utah', 'New York'],
     ...:                  columns=['one', 'two', 'three', 'four'])

In [113]: data
Out[113]:
          one  two  three  four
Ohio        0    1      2     3
Colorado    4    5      6     7
Utah        8    9     10    11
New York   12   13     14    15

In [114]: data['two']       In [115]: data[['three', 'one']]
Out[114]:                   Out[115]:
Ohio         1                        three  one
Colorado     5              Ohio          2    0
Utah         9              Colorado      6    4
New York    13              Utah         10    8
Name: two                   New York     14   12
这种索引方式有几个特殊的情况。首先通过切片或布尔型数组选取行：

In [116]: data[:2]                   In [117]: data[data['three'] > 5]
Out[116]:                            Out[117]:
          one  two  three  four                 one  two  three  four
Ohio        0    1      2     3      Colorado    4    5      6     7
Colorado    4    5      6     7      Utah        8    9     10    11
                                     New York   12   13     14    15



DataFrame的索引选项

obj[val]             选取Dataframe的单个列或一组列。在一些特殊情况下会比较便利：布尔型数组、切片、    f.ix[:2, :5] 取前两行，前五列的数据
obj.ix[val]          选取Dataframe的单个行或一组行
obj.ix[:, val]       选取单个列或列子集                                                        f.ix[:, 3]
obj.ix[val1, val2]   同时选取行和列                                                            取到的是一个具体的值


In[62]:f['drink']           单取一列
Out[62]:
0    0
1    1
2    2
Name: drink, dtype: int64

现在大多数都用loc    iloc               取得是某一行的数据   形成一个column的竖列   一个该行的value
df.loc['one'].T
Out[67]:
（column）                （one）没有的
id                         1001
date        2013-01-02 00:00:00
city                   Beijing
age                          23
category                  100-A
price                      1200
name                          0
Name: one, dtype: object

df.ix[:3]取前三行的数据

排序
根据条件对数据集排序（sorting）也是一种重要的内置运算。
要对行或列索引进行排序（按字典顺序），可使用sort_index方法，它将返回一个已排序的新对象：


Series
In [169]: obj = Series(range(4), index=['d', 'a', 'b', 'c'])

In [170]: obj.sort_index()
Out[170]:
a   1
b   2
c   3
d   0

若要按值对Series进行排序，可使用其order方法：

In [175]: obj = Series([4, 7, -3, 2])

In [176]: obj.order()
Out[176]:
2   -3
3    2
0    4
1    7



而对于DataFrame，则可以根据任意一个轴上的索引进行排序：

In [171]: frame = DataFrame(np.arange(8).reshape((2, 4)), index=['three', 'one'],
     ...:                   columns=['d', 'a', 'b', 'c'])

In [172]: frame.sort_index()         In [173]: frame.sort_index(axis=1)
Out[172]:                            Out[173]:
       d  a  b  c                           a  b  c  d
one    4  5  6  7                    three  1  2  3  0
three  0  1  2  3                    one    5  6  7  4




表5-8列出了所有用于破坏平级关系的method选项。DataFrame可以在行或列上计算排名：

In [187]: frame = DataFrame({'b': [4.3, 7, -3, 2], 'a': [0, 1, 0, 1],
     ...:                    'c': [-2, 5, 8, -2.5]})

In [188]: frame              In [189]: frame.rank(axis=1, method='average')
Out[188]:                    Out[189]:
   a    b    c                   a  b  c
0  0  4.3 -2.0                0  2  3  1
1  1  7.0  5.0                1  1  3  2
2  0 -3.0  8.0                2  2  1  3
3  1  2.0 -2.5                3  2  3  1


average                 默认：在相等分组中，为各个值分配平均排名
min                     使用整个分组的最小排名
max                     使用整个分组的最大排名
first                   按值在原始数据中的出现数据顺序分配排名


axis            Dataframe的行用0，列用1



描述和汇总统计
count                       非NA值得数量
describe                    针对series或各Dataframe；列计算汇总统计
min,max                     计算最小值和最大值
argmin,argmax               计算能够获取到最小值和最大值的索引位置
idxmin,idxmax                计算能够获取到最小值和最大值的索引置
quantile                    计算样本的分位数（0到1）
sum                         值得总和
mean                        值得平均数
median                      值的算数中位数（50%分位数）
mad                         根据平均值计算平均绝对离差
var                         样本值的方差
std                         样本值的标准差
diff                        计算一阶差分
cumsum                      样本值的累计和
cummin cummax               样本值的累计最大值和累计最小值
cumprod                     样本值的累积值


df.describe()
Out[45]:
                id       age        price      name
count     6.000000   6.00000     4.000000  6.000000
mean   1003.500000  36.50000  3299.500000  2.500000
std       1.870829  10.87658  1966.638503  1.870829
min    1001.000000  23.00000  1200.000000  0.000000
25%    1002.250000  32.00000  1899.750000  1.250000
50%    1003.500000  33.00000  3282.500000  2.500000
75%    1004.750000  41.50000  4682.250000  3.750000
max    1006.000000  54.00000  5433.000000  5.000000



唯一值
isin                    计算一个表示series各值是否包含于传入的值序列中的布尔型数组
unique                  计算Series中唯一值数组，按发现的顺序返回
value_counts            返回一个Series，其索引为唯一值，其值为频率，按计数值降序排列

In [220]: obj.value_counts()
Out[220]:
c    3
a    3
b    2
d    1


缺失值的处理方法

dropna                  根据各标签的值中是否存在缺失值数据对轴标签进行过滤，可通过阙值调节对缺失值的容忍度
fillna                  用指定值或插值方法（如ffill bfill）填充缺失数据
isnull                  返回一个含有布尔值的对象，这些布尔值表示那些值是缺失值，该对象的类型与源类型一样
notnull                 isnull的否定式
In [235]: data = Series([1, NA, 3.5, NA, 7])

In [236]: data.dropna()
Out[236]:
0    1.0
2    3.5
4    7.0




读写文件
read_csv                    从文件、URL、文件型对象中加载带分隔符的数据。默认分隔符为逗号
read_table                  从文件、URL、文件型对象中加载带分隔符的数据。默认分隔符为'\t'
read_fwf                    读取定宽列格式数据（也就是说，没有分隔符）
read_clipboard              读取剪切板中的数据，可以看做read_table的剪贴板。在网页转换为表格时很有用


参数
path                        表示文件系统位置、URL、文件型对象的字符串
Sep / delimiter             用于对行中各字段进行拆分的字符串序列或正则表达式
header                      用作列名的行号。默认为0（第一行），如果没有header行就应该设置为None
skiprows                    需要忽略的行数（从文件开始算起）， 或需要跳过的行号列表（从0开始）
index_col                   用作行索引的列编号或列名。可以是单个名称/数字或由多个名称/数字组成的列表
names                       用于结果的列名列表，结合header=None
na_values                   一组用于替NA的值
comment                     用于将注释信息从行尾拆分出去的字符（一个或多个）
dayfirst                    当解析有歧义的日期时，将其看做国际格式
nrows                       需要读取的行数（从文件开始算起）
skip_footer                 需要忽略的行数（从文件末尾处算起
encoding                    用于Unicode的文本编码格式，例如，utf-8 表示用utf-8 编码的文本
chunksize                   文件块的大小（用于迭代）

chunker = pd.read_csv('ch06/ex6.csv', chunksize=1000)
tot = Series([])
for piece in chunker:
tot = tot.add(piece['key'].value_counts(), fill_value=0)
tot = tot.order(ascending=False)
于是我们就有了：
In [877]: tot[:10]
Out[877]:
E 368
X 364
L 346
O 343
Q 340
M 338
J 337
F 335
K 334
H 330