Pandas是一个Python包，提供快速、灵活和富有表现力的数据结构，使关联或标记数据的使用既简单又直观。html
它旨在成为Python中进行实际，真实世界数据分析的基础高级构建块。这次外还有更普遍的目标，即称为任何语言中最强大，最灵活的开源数据分析/操做工具。数组
适合许多不一样类型的数据数据结构
- 具备异构类型列的表格数据，如SQL表或Excel表
- 有序和无序的时间序列数据
- 具备行和列标签的任意矩阵数据
- 任何其余形式的观察/统计数据集。实际上不须要将数据标记为放置在pandas数据结构中
主要数据结构是Series（一维）和DataFrame（二维）处理金融，统计，社会科学和许多工程领域中的绝大多数典型用例。Pandas创建在NumPy之上，与许多其余第三方库完美集成。dom
数据结构
数据对齐是固有的函数
- import numpy as np
- import pandas as pd
- import matplotlib.pyplot as plt
Series是一维标记的数组，可以保存任何数据类型。轴标签统称为索引，建立系列的基本方法是调用工具
- s = pd.Series(data,index=index)
data能够有不少不一样的东西，好比spa
- 一个Python字典
- 一个ndarray
- 标量
传递的索引是轴标签列表。所以根据数据的不一样，能够分为几种状况code
来自ndarrayhtm
若是data是ndarray，则索引的长度必须与数据的长度相同。若是没有传递索引，将建立一个具备值的索引对象
pd.Series(np.random.rand(5))
来自dict
能够从dicts实例化
pd.Series({'b':1})
来自标量值
若是data是标量值，则必须提供索引。将重复该值以匹配索引的长度
pd.Series(5.,index=['a','b'])
index是行索引，columns是列索引
能够对Series进行计算和切片等操做
系列也能够有一个name属性
s = pd.Series(np.random.randn(5),name='something')
DataFrame是一个二维标记数据结构，具备可能不一样类型的列。能够将其视为电子表格或SQL表，或Series对象的字段。一般是最经常使用的pandas对象。接受不一样类型的输入
- 1D ndarray，list,dicts或Series的Dict
- 二维numpy.ndarray
- 结构化或记录ndarray
- 一个Series
- 另外一个DataFrame
除了数据，还能够传递索引（行标签）和列（列标签）参数。若是传递索引和/或列，则能够保证生成的DataFrame的索引和/或列。
来自dict或Series的dicts
获得的指数将是各类系列的指标。若是有任何嵌套的dicts，将首先转换为Series。
In [34]: d = {'one' : pd.Series([1., 2., 3.], index=['a', 'b', 'c']), ....: 'two' : pd.Series([1., 2., 3., 4.], index=['a', 'b', 'c', 'd'])} ....: In [35]: df = pd.DataFrame(d) In [36]: df Out[36]: one two a 1.0 1.0 b 2.0 2.0 c 3.0 3.0 d NaN 4.0 In [37]: pd.DataFrame(d, index=['d', 'b', 'a']) Out[37]: one two d NaN 4.0 b 2.0 2.0 a 1.0 1.0 In [38]: pd.DataFrame(d, index=['d', 'b', 'a'], columns=['two', 'three']) Out[38]: two three d 4.0 NaN b 2.0 NaN a 1.0 NaN
经过访问索引和列数据，能够分别访问行和列标签
In [39]: df.index Out[39]: Index(['a', 'b', 'c', 'd'], dtype='object') In [40]: df.columns Out[40]: Index(['one', 'two'], dtype='object')
来自ndarrays 、lists的字典
ndarrays必须都是相同的长度。若是传递索引，则它必须明显与数组的长度相同。若是没有传递索引，结果将是range(n)
In [41]: d = {'one' : [1., 2., 3., 4.], ....: 'two' : [4., 3., 2., 1.]} ....: In [42]: pd.DataFrame(d) Out[42]: one two 0 1.0 4.0 1 2.0 3.0 2 3.0 2.0 3 4.0 1.0 In [43]: pd.DataFrame(d, index=['a', 'b', 'c', 'd']) Out[43]: one two a 1.0 4.0 b 2.0 3.0 c 3.0 2.0 d 4.0 1.0
来自structrued或record array
处理方式与数组的字段相同
In [44]: data = np.zeros((2,), dtype=[('A', 'i4'),('B', 'f4'),('C', 'a10')]) In [45]: data[:] = [(1,2.,'Hello'), (2,3.,"World")] In [46]: pd.DataFrame(data) Out[46]: A B C 0 1 2.0 b'Hello' 1 2 3.0 b'World' In [47]: pd.DataFrame(data, index=['first', 'second']) Out[47]: A B C first 1 2.0 b'Hello' second 2 3.0 b'World' In [48]: pd.DataFrame(data, columns=['C', 'A', 'B']) Out[48]: C A B 0 b'Hello' 1 2.0 1 b'World' 2 3.0
来自dicts列表
In [49]: data2 = [{'a': 1, 'b': 2}, {'a': 5, 'b': 10, 'c': 20}] In [50]: pd.DataFrame(data2) Out[50]: a b c 0 1 2 NaN 1 5 10 20.0 In [51]: pd.DataFrame(data2, index=['first', 'second']) Out[51]: a b c first 1 2 NaN second 5 10 20.0 In [52]: pd.DataFrame(data2, columns=['a', 'b']) Out[52]: a b 0 1 2 1 5 10
来自元组
In [53]: pd.DataFrame({('a', 'b'): {('A', 'B'): 1, ('A', 'C'): 2}, ....: ('a', 'a'): {('A', 'C'): 3, ('A', 'B'): 4}, ....: ('a', 'c'): {('A', 'B'): 5, ('A', 'C'): 6}, ....: ('b', 'a'): {('A', 'C'): 7, ('A', 'B'): 8}, ....: ('b', 'b'): {('A', 'D'): 9, ('A', 'B'): 10}}) ....: Out[53]: a b b a c a b A B 1.0 4.0 5.0 8.0 10.0 C 2.0 3.0 6.0 7.0 NaN D NaN NaN NaN NaN 9.0
构造函数
DataFrame.from_dict采用dicts的dict或相似数组序列的dict并返回DataFrame。DataFrame除了默认状况下的orient参数外，它的操做相似于构造函数columns，但能够将其设置index为使用dict键做为行标签
In [54]: pd.DataFrame.from_dict(dict([('A', [1, 2, 3]), ('B', [4, 5, 6])])) Out[54]: A B 0 1 4 1 2 5 2 3 6
若是设置orient='index'，则键将是行标签。还能够传递所需的列名称
In [55]: pd.DataFrame.from_dict(dict([('A', [1, 2, 3]), ('B', [4, 5, 6])]), ....: orient='index', columns=['one', 'two', 'three']) ....: Out[55]: one two three A 1 2 3 B 4 5 6
DataFrame.from_record获取元组列表或带有结构化dtype的ndarray。相似于普通DataFrame构造函数，但生产的DataFrame索引多是结构化dtype的特定字段
In [57]: pd.DataFrame.from_records(data, index='C') Out[57]: A B C b'Hello' 1 2.0 b'World' 2 3.0
列选择、添加、删除
能够将DataFrame视为相似索引的Series对象的dict。获取，设置和删除的工做方式与dict操做相同
In [58]: df['one'] Out[58]: a 1.0 b 2.0 c 3.0 d NaN Name: one, dtype: float64 In [59]: df['three'] = df['one'] * df['two'] In [60]: df['flag'] = df['one'] > 2 In [61]: df Out[61]: one two three flag a 1.0 1.0 1.0 False b 2.0 2.0 4.0 False c 3.0 3.0 9.0 True d NaN 4.0 NaN False
删除
In [62]: del df['two'] In [63]: three = df.pop('three') In [64]: df Out[64]: one flag a 1.0 False b 2.0 False c 3.0 True d NaN False
插入
In [65]: df['foo'] = 'bar' In [66]: df Out[66]: one flag foo a 1.0 False bar b 2.0 False bar c 3.0 True bar d NaN False bar
若是插入与DataFrame不具备相同索引的Series时，将符合DataFrame的索引
In [67]: df['one_trunc'] = df['one'][:2] In [68]: df Out[68]: one flag foo one_trunc a 1.0 False bar 1.0 b 2.0 False bar 2.0 c 3.0 True bar NaN d NaN False bar NaN
能够插入原始的ndarrays，但他们的长度必须与DataFrame索引的长度相匹配
默认状况下，列会在末尾插入。该insert函数能够用于插入列的特定位置
In [69]: df.insert(1, 'bar', df['one']) In [70]: df Out[70]: one bar flag foo one_trunc a 1.0 1.0 False bar 1.0 b 2.0 2.0 False bar 2.0 c 3.0 3.0 True bar NaN d NaN NaN False bar NaN
在方法链中分配新列
DataFrame有一种assign()方法能够建立从现有列派生的新列
In [71]: iris = pd.read_csv('data/iris.data') In [72]: iris.head() Out[72]: SepalLength SepalWidth PetalLength PetalWidth Name 0 5.1 3.5 1.4 0.2 Iris-setosa 1 4.9 3.0 1.4 0.2 Iris-setosa 2 4.7 3.2 1.3 0.2 Iris-setosa 3 4.6 3.1 1.5 0.2 Iris-setosa 4 5.0 3.6 1.4 0.2 Iris-setosa In [73]: (iris.assign(sepal_ratio = iris['SepalWidth'] / iris['SepalLength']) ....: .head()) ....: Out[73]: SepalLength SepalWidth PetalLength PetalWidth Name sepal_ratio 0 5.1 3.5 1.4 0.2 Iris-setosa 0.6863 1 4.9 3.0 1.4 0.2 Iris-setosa 0.6122 2 4.7 3.2 1.3 0.2 Iris-setosa 0.6809 3 4.6 3.1 1.5 0.2 Iris-setosa 0.6739 4 5.0 3.6 1.4 0.2 Iris-setosa 0.7200
咱们插入了一个预先计算的值，还能够传入一个参数的函数，以便在分配给DataFrame上进行求值
In [74]: iris.assign(sepal_ratio = lambda x: (x['SepalWidth'] / ....: x['SepalLength'])).head() ....: Out[74]: SepalLength SepalWidth PetalLength PetalWidth Name sepal_ratio 0 5.1 3.5 1.4 0.2 Iris-setosa 0.6863 1 4.9 3.0 1.4 0.2 Iris-setosa 0.6122 2 4.7 3.2 1.3 0.2 Iris-setosa 0.6809 3 4.6 3.1 1.5 0.2 Iris-setosa 0.6739 4 5.0 3.6 1.4 0.2 Iris-setosa 0.7200
assign始终返回数据的副本，保持原始DataFrame不变
当没有引用DataFrame时，传递可调用的，而不是要插入的实际值。这assign在操做链中使用时很常见
In [75]: (iris.query('SepalLength > 5') ....: .assign(SepalRatio = lambda x: x.SepalWidth / x.SepalLength, ....: PetalRatio = lambda x: x.PetalWidth / x.PetalLength) ....: .plot(kind='scatter', x='SepalRatio', y='PetalRatio'))
索引选择
选择列：df[col]：系列
按标签选择行：df.loc[label]：系列
按整数位置选择行：df.iloc[loc]：系列
切片行：df[5:10]：数据帧
按布尔向量选择行：df[bool_vec]：数据帧
数据对齐和算术
DataFrame对象之间的数据对其自动在列和索引（行标签）上对齐。一样生成的对象具备列和行标签的并集
In [82]: df = pd.DataFrame(np.random.randn(10, 4), columns=['A', 'B', 'C', 'D']) In [83]: df2 = pd.DataFrame(np.random.randn(7, 3), columns=['A', 'B', 'C']) In [84]: df + df2 Out[84]: A B C D 0 0.0457 -0.0141 1.3809 NaN 1 -0.9554 -1.5010 0.0372 NaN 2 -0.6627 1.5348 -0.8597 NaN 3 -2.4529 1.2373 -0.1337 NaN
DataFrame和Series之间执行操做时，默认行为是在DataFrame列上对齐Series索引，从而按行进行广播
df - df.iloc[0]
在使用时间序列数据的特殊状况下，DataFrame索引还包含日期，广播将按列进行
index = pd.date_range('1/1/2000', periods=8)
df = pd.DataFrame(np.random.randn(8, 3), index=index, columns=list('ABC'))
df*5+2
1/df
df ** 4
df1 & df2
df1 | df2
df1 ^ df2
-df1
转置
要进行转置，须要访问T属性，相似于ndarray
df[:5].T
DataFrame与NumPy函数的互操做性
能够在DataFrame上使用其余的Numpy函数
np.exp(df)
np.asarray(df)
df.T.dot(df)
DataFrame列属性访问
若是DataFrame列标签是有效的Python变量名称，则能够像属性同样访问
df.A
基本功能
要查看Series或DataFrame对象的小样本，请使用head()和tail()方法。显示的默认元素数为5，但您能够传递自定义数字。
long_series = pd.Series(np.random.randn(100))
long_series.head() //查看头
long_series.tail(3) //查看末尾
属性和原始ndarray(s)
df.columns = [x.lower() for x in df.columns] //列名小写
df.values 访问实际数据
加速操做
pandas支持使用numexpr库和bottleneck库加速某些类型的二进制数值和布尔运算
pd.set_option('compute.use_bottleneck', False) pd.set_option('compute.use_numexpr', False)
匹配和广播
数据框所拥有的方法add()，sub()，mul()，div()和相关的功能radd()，rsub()用于执行二进制运算。
对于广播行为，系列输入是主要关注点。能够经过axis关键字匹配索引或列。
填充值数据的操做
算术函数能够选择输入fill_value，即当缺乏某个位置时须要替换的值。
df.add(df2,fill_value=0)
布尔缩减
能够使用empty,any(),all,bool()提供一种方法来归纳一个布尔结果
- (df>0).all()
- (df>0).any()
- df.empty
比较对象是否相等
df+df != df*2 这个表达式是错误的
(df+df).equals(df*2) 应该使用这个表达式
比较相似数组的对象
pandas数据结构与标量值进行比较时，能够用下面方式执行元素比较
In [64]: pd.Series(['foo', 'bar', 'baz']) == 'foo' Out[64]: 0 True 1 False 2 False dtype: bool In [65]: pd.Index(['foo', 'bar', 'baz']) == 'foo' Out[65]: array([ True, False, False], dtype=bool)
pandas还处理相同长度的不一样数组对象之间的元素比较
In [66]: pd.Series(['foo', 'bar', 'baz']) == pd.Index(['foo', 'bar', 'qux']) Out[66]: 0 True 1 True 2 False dtype: bool In [67]: pd.Series(['foo', 'bar', 'baz']) == np.array(['foo', 'bar', 'qux']) Out[67]: 0 True 1 True 2 False dtype: bool
尝试比较Index或Series不一样长度的对象将引起ValueError
注意：这个和NumPy的广播不同
组合重叠数据集
两个类似数据集的组合，其中一个比较好。咱们但愿组合两个DataFrame对象，其中一个DataFrame中的缺失值有条件地填充来自其余DataFrame的相似标记的值。实现操做的函数是combine_first()，如同位置两边都存在则使用第一个。
In [70]: df1 = pd.DataFrame({'A' : [1., np.nan, 3., 5., np.nan], ....: 'B' : [np.nan, 2., 3., np.nan, 6.]}) ....: In [71]: df2 = pd.DataFrame({'A' : [5., 2., 4., np.nan, 3., 7.], ....: 'B' : [np.nan, np.nan, 3., 4., 6., 8.]}) ....: In [72]: df1 Out[72]: A B 0 1.0 NaN 1 NaN 2.0 2 3.0 3.0 3 5.0 NaN 4 NaN 6.0 In [73]: df2 Out[73]: A B 0 5.0 NaN 1 2.0 NaN 2 4.0 3.0 3 NaN 4.0 4 3.0 6.0 5 7.0 8.0 In [74]: df1.combine_first(df2) Out[74]: A B 0 1.0 NaN 1 2.0 2.0 2 3.0 3.0 3 5.0 4.0 4 3.0 6.0 5 7.0 8.0
通用DataFrame组合
另外一个DataFrame和组合器函数，对齐输入DataFrame，而后传递Series的组合器函数对（名称相同的列）
In [75]: combiner = lambda x, y: np.where(pd.isna(x), y, x) In [76]: df1.combine(df2, combiner)
描述性统计
http://pandas.pydata.org/pandas-docs/stable/basics.html