这几天把pandas重温了一下，结合聚宽数据，感觉更好理解聚宽的用法。

import pandas as pd import numpy as npimport matplotlib.pyplot as plt

一直没有系统的学习过pandas，正好看到一篇文章，结合聚宽再捋一遍。

1.   Series¶

1.1   创建一个 Series 的基本语法如下:¶

my_series = pd.Series(data,index)¶

上面的 data 参数可以是任意数据对象，比如字典、列表甚至是 NumPy 数组，而index 参数则是对 data 的索引值，类似字典的 key。¶

1.1.1创建一个Series，data是数字，索引是字符串¶

guojia = ['usa','ru','cn','jp']qty = [100,300,500,200]

ser = pd.Series(qty,guojia)

ser

usa    100
ru     300
cn     500
jp     200
dtype: int64

ser2 = pd.Series(guojia,qty)

ser2

100    usa
300     ru
500     cn
200     jp
dtype: object

以上，括号前面的是Series的values，后面的是index¶

注意：请记住， index 参数是可省略的，你可以选择不输入这个参数。如果不带 index 参数，Pandas 会自动用默认 index 进行索引，类似数组，索引值是 [0, ..., len(data) - 1]¶

如果你从一个 Python 字典对象创建 Series，Pandas 会自动把字典的键值设置成 Series 的 index，并将对应的 values 放在和索引对应的 data 里。¶

和 NumPy 数组不同，Pandas 的 Series 能存放各种不同类型的对象。¶

1.1.2从 Series 里获取数据¶

访问 Series 里的数据的方式，和 Python 字典基本一样：¶

ser

usa    100
ru     300
cn     500
jp     200
dtype: int64

ser['ru']

300

ser['jp']

200

1.1.3 对 Series 进行算术运算操作¶

对 Series 的算术运算都是基于 index 进行的。我们可以用加减乘除（+ - * /）这样的运算符对两个 Series 进行运算，Pandas 将会根据索引 index，对响应的数据进行计算，结果将会以浮点数的形式存储，以避免丢失精度。¶

ser = pd.Series(qty,guojia)

guojia2 =['au','cn','jp','usa']qty2 =[200,300,400,598]

ser3 = pd.Series(qty2,guojia2)

ser3

au     200
cn     300
jp     400
usa    598
dtype: int64

ser - ser3

au       NaN
cn     200.0
jp    -200.0
ru       NaN
usa   -498.0
dtype: float64

ser + ser3

au       NaN
cn     800.0
jp     600.0
ru       NaN
usa    698.0
dtype: float64

Series基于索引进行运算，我们不必理会对齐的问题，系统自动将索引相同的值进行运算；如果一个series缺少某个索引，其运算结果为 NaN¶

2. DataFrames¶

Pandas 的 DataFrame（数据表）是一种 2 维数据结构，数据以表格的形式存储，分成若干行和列。通过 DataFrame，你能很方便地处理数据。常见的操作比如选取、替换行或列的数据，还能重组数据表、修改索引、多重筛选等。¶

2.1构建一个 DataFrame 对象的基本语法如下：¶

df = get_price('RB9999.XSGE',start_date='2018-12-1', end_date='2019-3-1',fields=None)

df.head()

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

df['open'].head()

2018-12-03    3250.0
2018-12-04    3306.0
2018-12-05    3389.0
2018-12-06    3470.0
2018-12-07    3360.0
Name: open, dtype: float64

df['volume'].tail()

2019-02-25    3659076.0
2019-02-26    3998202.0
2019-02-27    2948082.0
2019-02-28    3461158.0
2019-03-01    2986416.0
Name: volume, dtype: float64

看，上面表中的每一列基本上就是一个 Series ，它们都用了同一个 index。因此，我们基本上可以把 DataFrame 理解成一组采用同样索引的 Series 的集合。¶

2.2 获取 DataFrame 中的列 <  color = red  >¶

要获取一列的数据，还是用中括号 [] 的方式，跟 Series 类似。比如尝试获取上面这个表中的 open 列数据：¶

df['open'].head()

2018-12-03    3250.0
2018-12-04    3306.0
2018-12-05    3389.0
2018-12-06    3470.0
2018-12-07    3360.0
Name: open, dtype: float64

2.2.1 因为我们只获取一列，所以返回的就是一个 Series。可以用 type() 函数确认返回值的类型¶

type(df['open'])

pandas.core.series.Series

2.2.2 如果获取多个列，那返回的就是一个 DataFrame 类型：¶

df2 =df[['open','volume']].head()

df2

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

type(df2)

pandas.core.frame.DataFrame

2.3 向 DataFrame 里增加数据列¶

创建一个列的时候，你需要先定义这个列的数据和索引。¶

增加数据列有两种办法：可以从头开始定义一个 pd.Series，再把它放到表中，也可以利用现有的列来产生需要的新列。比如下面两种操作：¶

2.3.1  定义一个 Series ，并放入 'open-close' 列中： 新series的值是“NaN"¶

df['o-c'] =pd.Series()

df.head()

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

2.3.3 从现有的列创建新列¶

直接进行运算¶

df['o-c2'] = df['open'] - df['close']

df.head()

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

def cmp(df1,df2):cmp = df1.values - df2.values#     if cmp > 0:#         cmp1 = True#     else:#         cmp1 = Falsereturn cmp

df['cmp'] = cmp(df['open'],df['close'])

df.head()

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

2.4  从 DataFrame 里删除行/列¶

2.4.1 想要删除某一行或一列，可以用 .drop() 函数。在使用这个函数的时候，你需要先指定具体的删除方向，axis=0 对应的是行 row，而 axis=1 对应的是列 column 。¶

df.head()

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

要删除‘o-c’这一列，用axis=1，代表column¶

df.head().drop('o-c',axis=1)

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

请务必记住，除非用户明确指定，否则在调用 .drop() 的时候，Pandas 并不会真的永久性地删除这行/列。这主要是为了防止用户误操作丢失数据。

你可以通过调用 df 来确认数据的完整性。如果你确定要永久性删除某一行/列，你需要加上 inplace=True 参数，比如：

重新打印df

df.head()

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

永久删除 inplace =True  .....(报错了，以后再学)

df.head().drop('o-c',axis=1,inplace=True )

/opt/conda/lib/python3.6/site-packages/pandas/core/frame.py:3697: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame

See the c*eats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy
  errors=errors)

2.5  获取 DataFrame 中的一行或多行数据¶

要获取某一行，你需要用 .loc[] 来按索引（标签名）引用这一行，或者用 .iloc[]，按这行在表中的位置（行数）来引用。¶

df.head()

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

df.head().loc['2018-12-05']

open      3.389000e+03
close     3.463000e+03
high      3.466000e+03
low       3.362000e+03
volume    5.400890e+06
money     1.840964e+11
o-c                NaN
o-c2     -7.400000e+01
Name: 2018-12-05 00:00:00, dtype: float64

type(df.head().loc['2018-12-07'])

pandas.core.series.Series

输入：  df.head(10).iloc[[1,9]] 试一试¶

用 .loc[] 来按索引（标签名）引用这一行¶

df.head(10).iloc[[1,9]]

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

同时你可以用 .loc[] 来指定具体的行列范围，并生成一个子数据表，就像在 NumPy里做的一样。比如，提取 '12-08' 行中 'money’,'open'等1列或多 列的内容，可以如下操作¶

df.head().loc['2018-12-07',['money']]

money    1.729243e+11
Name: 2018-12-07 00:00:00, dtype: float64

df.head().loc['2018-12-07',['money','high','open']]

money    1.729243e+11
high     3.426000e+03
open     3.360000e+03
Name: 2018-12-07 00:00:00, dtype: float64

type(df.head().loc['2018-12-05',['open','high','volume']])

pandas.core.series.Series

iloc 直接写索引内容，报错¶

因为    ： 用 .iloc[]，按这行在表中的位置（行数）来引用。¶

df.head(10).iloc[['2018-12-04','2018-12-14']]

-ValueError                                Traceback (most recent call last)<ipython-input-73-74b1efb5eb04> in <module>> 1 df.head(10).iloc[['2018-12-04','2018-12-14']]/opt/conda/lib/python3.6/site-packages/pandas/core/indexing.py in __getitem__(self, key)   1476    1477             maybe_callable = com._apply_if_callable(key, self.obj)-> 1478             return self._getitem_axis(maybe_callable, axis=axis)   1479    1480     def _is_scalar_access(self, key):/opt/conda/lib/python3.6/site-packages/pandas/core/indexing.py in _getitem_axis(self, key, axis)   2089         # a list of integers   2090         elif is_list_like_indexer(key):-> 2091             return self._get_list_axis(key, axis=axis)   2092    2093         # a single integer/opt/conda/lib/python3.6/site-packages/pandas/core/indexing.py in _get_list_axis(self, key, axis)   2068             axis = self.axis or 0   2069         try:-> 2070             return self.obj._take(key, axis=axis)   2071         except IndexError:   2072             # re-raise with different error message/opt/conda/lib/python3.6/site-packages/pandas/core/generic.py in _take(self, indices, axis, is_copy)   2787         new_data = self._data.take(indices,   2788                                    axis=self._get_block_manager_axis(axis),-> 2789                                    verify=True)   2790         result = self._constructor(new_data).__finalize__(self)   2791 /opt/conda/lib/python3.6/site-packages/pandas/core/internals.py in take(self, indexer, axis, verify, convert)   4524                              dtype='int64')   4525                    if isinstance(indexer, slice)-> 4526                    else np.asanyarray(indexer, dtype='int64'))   4527    4528         n = self.shape[axis]/opt/conda/lib/python3.6/site-packages/numpy/core/numeric.py in asanyarray(a, dtype, order)    542     543     """> 544     return array(a, dtype, copy=False, order=order, subok=True)    545     546 ValueError: invalid literal for int() with base 10: '2018-12-04'

2.5  条件筛选¶

2.51 用中括号 [] 的方式，除了直接指定选中某些列外，还能接收一个条件语句，然后筛选出符合条件的行/列。比如，我们希望在下面这个表格中筛选出 'o-c2'>0 的行：¶

df.head()

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

df['o-c2']>0

2018-12-03    False
2018-12-04    False
2018-12-05    False
2018-12-06     True
2018-12-07    False
2018-12-10     True
2018-12-11    False
2018-12-12     True
2018-12-13    False
2018-12-14    False
2018-12-17     True
2018-12-18    False
2018-12-19     True
2018-12-20    False
2018-12-21    False
2018-12-24     True
2018-12-25     True
2018-12-26    False
2018-12-27     True
2018-12-28    False
2019-01-02     True
2019-01-03    False
2019-01-04    False
2019-01-07    False
2019-01-08     True
2019-01-09    False
2019-01-10    False
2019-01-11    False
2019-01-14    False
2019-01-15     True
2019-01-16    False
2019-01-17    False
2019-01-18    False
2019-01-21    False
2019-01-22     True
2019-01-23    False
2019-01-24    False
2019-01-25    False
2019-01-28     True
2019-01-29     True
2019-01-30     True
2019-01-31    False
2019-02-01    False
2019-02-11     True
2019-02-12     True
2019-02-13     True
2019-02-14     True
2019-02-15     True
2019-02-18    False
2019-02-19     True
2019-02-20     True
2019-02-21    False
2019-02-22    False
2019-02-25     True
2019-02-26    False
2019-02-27     True
2019-02-28    False
2019-03-01    False
Name: o-c2, dtype: bool

df[df['o-c2']>0][['open','close','money']]

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

你可以用逻辑运算符 &（与）和 |（或）来链接多个条件语句，以便一次应用多个筛选条件到当前的 DataFrame 上。举个栗子，你可以用下面的方法筛选出同时满足 'o-c2'>0 和'close'> 3400 的行：比如 ‘2018-12-06’这行

df.head(20)

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

df[ (df['o-c2']>0) & (df['close'] > 3400)  ]¶

df[  (  ) & ()   ]    () = df['column name']  > 0¶

验证一下（）的类型¶

df[ (df['o-c2']>0) & (df['close'] > 3400)  ]

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

xx = (df['o-c2']>0)

type(xx)

pandas.core.series.Series

yy = df['o-c2'] >0

type(yy)

pandas.core.series.Series

df[ (df['o-c2'] >0)  & (df['close'] > 3400)   ]

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

2.6    重置 DataFrame 的索引¶

如果你觉得当前 DataFrame 的索引有问题，你可以用 .reset_index() 简单地把整个表的索引都重置掉。这个方法将把目标 DataFrame 的索引保存在一个叫 index 的列中，而把表格的索引变成默认的从零开始的数字，也就是 [0, ..., len(data) - 1] 。比如下面这样：¶

df.head()

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

df.reset_index().head()

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

和删除操作差不多，.reset_index() 并不会永久改变你表格的索引，除非你调用的时候明确传入了 inplace 参数，比如：.reset_index(inplace=True)¶

df.head()

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

df.reset_index(inplace=True)

df.head()

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

2.7   设置 DataFrame 的索引值¶

类似地，我们还可以用 .set_index() 方法，将 DataFrame 里的某一列作为索引来用。比如，我们在这个表里新建一个名为 "ID" 的列¶

：

df.head()

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

df['code'] ='rb9999'

df.head()

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

df.set_index('code').head()

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

df.head()

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

注意，不像 .reset_index() 会保留一个备份，然后才用默认的索引值代替原索引，.set_index() 将会完全覆盖原来的索引值。

2.8   多级索引（MultiIndex）以及命名索引的不同等级¶

多级索引其实就是一个由元组（Tuple）组成的数组，每一个元组都是独一无二的。你可以从一个包含许多数组的列表中创建多级索引（调用 MultiIndex.from_arrays ），也可以用一个包含许多元组的数组（调用 MultiIndex.from_tuples ）或者是用一对可迭代对象的集合（比如两个列表，互相两两配对）来构建（调用MultiIndex.from_product ）。¶

下面这个例子，我们从元组中创建多级索引：¶

应该暂时用不到多级索引，以后学习。

df.head()

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

我们可以用 .index.names 给它们加上名字？？？？

2.9    清洗数据¶

删除或填充空值¶

在许多情况下，如果你用 Pandas 来读取大量数据，往往会发现原始数据中会存在不完整的地方。在 DataFrame 中缺少数据的位置， Pandas 会自动填入一个空值，比如 NaN或 Null 。因此，我们可以选择用 .dropna() 来丢弃这些自动填充的值，或是用.fillna() 来自动给这些空值填充数据。¶

比如这个例子：¶

df.head()

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

df.dropna()

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

请注意，如果你没有指定 axis 参数，默认是删除行。¶

axis =1 , 删除含有NaN，Null  的列¶

df.dropna(axis =  1).head()

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

df

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

类似的，如果你使用 .fillna() 方法，Pandas 将对这个 DataFrame 里所有的空值位置填上你指定的默认值。比如，将表中所有 NaN 替换成 20 ：

同理，.dropna() 和 .fillna() 并不会永久性改变你的数据，除非你传入了inplace=True 参数。

df['cross']= nan

df

.dataframe tbody tr th:only-of-type {        vertical-align: middle;    }    .dataframe tbody tr th {        vertical-align: top;    }    .dataframe thead th {        text-align: right;    }

def cross(cmp):if cmp > 0:crs = Trueelse:crs = Falsereturn crs

cross(df['cmp'])

-ValueError                                Traceback (most recent call last)<ipython-input-26-7833c6976bc2> in <module>> 1 cross(df['cmp'])<ipython-input-25-70d306d78f78> in cross(cmp)      1 def cross(cmp):> 2     if cmp > 0:      3         crs = True      4     else:      5         crs = False/opt/conda/lib/python3.6/site-packages/pandas/core/generic.py in __nonzero__(self)   1574         raise ValueError("The truth value of a {0} is ambiguous. "   1575                          "Use a.empty, a.bool(), a.item(), a.any() or a.all()."-> 1576                          .format(self.__class__.__name__))   1577    1578     __bool__ = __nonzero__ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().

ts =pd.Series(np.random.randn(1000), index=pd.date_range("2001-1-1",periods = 1000))

df4 = pd.DataFrame(np.random.randn(1000,4),index=ts.index,columns = ['a','b','c','d'])

df5 =df4.cumsum()

df5.plot()

<matplotlib.axes._subplots.AxesSubplot at 0x7f774e988400>

df5.dtypes

a    float64
b    float64
c    float64
d    float64
dtype: object

df.dtypes

index     datetime64[ns]
open             float64
close            float64
high             float64
low              float64
volume           float64
money            float64
o-c              float64
o-c2             float64
code              object
dtype: object