California    False
Texas         False
New York       True
Florida        True
Illinois      False
Name: density, dtype: bool

# 3.5处理缺省值

## 3.5.1选择处理缺失值的方法

一般分为两种:一种方法是通过一个覆盖全局的掩码表示缺失值，另一种方法是用一个便签值(sentinel value)表示缺失值

## 3.5.2Pandas的缺失值

Pandas选择了标签方法表示缺失值，包括两种Python原有的缺失值:浮点数据类型的NaN值，以及Python的None对象

### 1.None:Python对象类型的缺失值

None在ndarray中属于object对象

import numpy as np
import pandas as pd

vals1 = np.array([1, None, 3, 4])
vals1

这里判断ndarray的dtype为object，，这种数据比NumPy的其他原生数据要消耗更多的资源

for dtype in ['object', 'int']:
    print('dtype =', dtype)
    %timeit np.arange(1E6)

由于元素为Python对象，所以一些方法如sum，min将无法使用

vals1.sum()

### 2.NaN:数值类型的缺失值

另一种缺失值的标签是NaN(全称Not a Number，不是一个数字)，是一种按照IEEE浮点数标准设计、在任何系统中都兼容的特殊浮点数。

vals2 = np.array([1, np.nan, 3, 4])
vals2.dtype

任何与NaN操作过数字都会变成NaN

1 + np.nan

0 / np.nan

0 > np.nan

0 <= np.nan

所以通过普通的求和，最大值，最小值会出现问题

vals2.sum(), vals2.min(), vals2.max()

np.nansum(vals2), np.nanmin(vals2), np.nanmax(vals2)

记住NaN是一种特殊的浮点数。

### 3.Pandas中NaN与None的差异

在Pandas里面NaN与None可以等价交换

pd.Series([1, np.nan, 2, None])

Pandas自动将没有便签的值转化为NaN

增加索引赋值为None的时候，也会自动转换NaN,且会更加对象的类型

x = pd.Series(range(2), dtype=int)
x

x[0] = None
x

pd.Series(['add'])

### 3.5.3处理缺失值

Pandas内置了一些来发现、剔除、替换数据结构种的缺失值

### 1.发现缺失值

isnull()和notnull()，每种方法都返回布尔类型的掩码数据

data = pd.Series([1, np.nan, 'hello', None])
data.isnull()

# 掩码取值
data[data.notnull()]

isnull与notnull同样适用与DataFrame

## 2.剔除缺失值 

dropna()剔除缺省值，fillna()填充缺省值

data

data.dropna()

df = pd.DataFrame([[1, np.nan,2],
                  [2, 3,5],
                  [None,4,6]])
df

df.dropna()

默认会删除行中有NaN数据的行

df.dropna(axis='columns')

df.dropna(axis=1)

但有时候并想只有一个NaN就删除整行或者整列，那就需要用到参数how或者thresh

df[3] = np.nan
df

# 删除只有全部是NaN的列，默认的how就是any
df.dropna(axis='columns', how='all')

通过thresh参数设定非缺失值的最小数量,注意是非缺失值的数量。

df.dropna(axis='rows', thresh=3)

df.iloc[0] = None
df

### 填充缺失值

通过fillna()方法，返回一个填充了缺失值后的数组副本

data = pd.Series([1, np.nan,2,None,3], index=list('abcde'))
data

# 填充一个固定的值
data.fillna(0)

# 从前往后填充 forward-fill
data.fillna(method='ffill')

# 从后往前填充 back-fill
data.fillna(method='bfill')

操作DataFrame相同，只不过需要指定axis

df

df.fillna(method='ffill', axis=1)

从前往后填充，第一个是NaN，无法填充

# 3.6层级索引

通过层级索引(hierarchical indexing, 也被称为多级索引,multi-indexing)配合多个有不同等级(level)的一级索引一起使用，这样就可以将高维度数组转换成类似一维Series和二维DataFrame对象的形式

import numpy as np
import pandas as pd

## 3.6.1多级索引Series

### 笨方法

# 通过索引给一个元祖，元祖里面有两个索引的元素
index = [('California', 2000), ('California', 2010),
         ('New York', 2000), ('New York', 2010),
         ('Texas', 2000), ('Texas', 2010)]
populations = [33871648, 37253956,
               18976457, 19378102,
               20851820, 25145561]
pop = pd.Series(populations, index=index)
pop

# 通过切片取值
pop[('California', 2010):('Texas', 2000)]

# 需要取特定的元素，比如2010年的就比较麻烦，且效率低
pop[[i for i in pop.index if i[1] == 2010]]

### 好方法:Pandas多级索引

# 这个显式跟书中的已经不一样，个人感觉还是这样的不错
index = pd.MultiIndex.from_tuples(index)
index

# 更换索引
pop = pop.reindex(index)
pop

# 索引直接可以通过切片获取
pop[:, 2010]

### 3.高维数据的多级索引

多级索引可以转换成一个带行列索引的简单DataFrame。unstack()方法可以快速将一个多级索引的Series转换为普通的DataFrame

pop

pop_df=pop.unstack()
pop_df

# 当然也可以通过stack的方法转换为Series
pop_df.stack()

我们可以用含多级索引的一维Series数据表示二维数据，那么我们就可以用Series或DataFrame表示三维甚至更高维度的数据。
多级索引每增加一级，就表示数据增加一维，利用这一特点就可以表示任意长度的数据了。

# 增加一列数据，变成DataFrame
pop_df = pd.DataFrame({'total':pop,
                      'under18': [9267089, 9284094,
                                   4687374, 4318033,
                                   5906301, 6879014]})
pop_df

增加一些我自己的理解，上面的DataFrame其实在ndarray里面可以理解为三维，因为进来的Series是多重索引的，可以理解为二维，增加了一个colums维度

f_u18 = pop_df['under18'] / pop_df['total']
f_u18

# 转换为DataFrame
f_u18.unstack()

### 3.6.2多级索引的创建方法

为Series或DataFrame创建多级索引最直接的办法是将index参数设置为至少二维的索引数组

df = pd.DataFrame(np.random.rand(4, 2),
                  index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]], # 二维的数组
                  columns=['data1', 'data2'])
df

如果把元祖作为键的字典传给Pandas，它默认也会把index处理为MutilIndex

data = {('California', 2000): 33871648,
        ('California', 2010): 37253956,
        ('Texas', 2000): 20851820,
        ('Texas', 2010): 25145561,
        ('New York', 2000): 18976457,
        ('New York', 2010): 19378102}
pd.Series(data)

### 1.显式地创建多级索引

# 有点zip打包出来的效果
pd.MultiIndex.from_arrays([['a', 'a', 'b', 'b'], [1, 2, 1, 2]])

# 直接把DataFrame的数据拿来当多重索引
pd.MultiIndex.from_frame(df)

# 这个比较直接
pd.MultiIndex.from_tuples([('a', 1), ('a', 2), ('b', 1), ('b', 2)])

# 用笛卡尔积
pd.MultiIndex.from_product([['a', 'b'], [1, 2]])

### 多级索引的等级名称

给多级索引加上一些名称，看起来更加便利

pop.index

pop.index.names = ['stats', 'year']
pop

# 在unstacks的时候还在
pop.unstack()

### 3 多级列索引

既然有多级行索引，那必然存在多级列索引

# 多级的行索引，应该是4行
index = pd.MultiIndex.from_product([[2013, 2014], [1, 2]],
                                   names=['year', 'visit'])
# 多级的列索引，应该有6列
columns = pd.MultiIndex.from_product([['Bob', 'Guido', 'Sue'], ['HR', 'Temp']],
                                     names=['subject', 'type'])
# 创建一个4行5列的数据
data = np.round(np.random.randn(4, 6), 1)
data[:, ::2] *= 10
data += 37

# 创建DataFrame对象
health_data = pd.DataFrame(data=data, columns=columns, index=index)
health_data

从上面可以看出，多行多列的创建是多么的难。上面就创建了4维数据，4个维度分别包括姓名，检查的项目，检查的年份，检查的次数
取数据也很简单，跟着我：

# 简单的检索信息
health_data['Guido']

## 3.6.3 多级索引的取值与切片

对MulitIndex的取值和切片很直观，可以把索引看成额外增加的维度

### 1.Series多级索引

pop

# 取单个元素
pop['California',2000]

# 局部取值(partial indexing) 返回一个新的Series
pop['California']

# 局部切片，但要求MultiIndex是按序列排序的
pop.loc['California':'New York']

# 可以第一层索引空切片
pop[:, 2000]

# 布尔掩码取值
pop[pop>22000000]

# 花哨取值
pop[['California','Texas']]

### 2.DataFrame多级索引

health_data

DataFrame的基本索引是列索引，因此Series中多级索引的用法到了DataFrame就应用在列上了。

health_data['Guido', 'HR']

h = health_data['Guido']
print(type(h))
h

loc与iloc的索引辅助方法也可以使用

# 前两行 两列的数据
health_data.iloc[:2,:2]

# 花哨取值
health_data.loc[:, ['Bob', 'Sue']]

# 特定列取值
health_data.loc[:, ('Bob', 'Temp')]

这种索引元祖的用法不是很方便，如果在元祖中使用切片还会导致语法错误:

health_data.loc[(:,1), (:, 'HR')]

# 通过pd.IndexSlice来对多索引的行与列选定专门的定位
idx = pd.IndexSlice
health_data.loc[idx[:, 1], idx[:, 'HR']]

## 3.6.4多级索引行列转换

尝试多级索引，索引无序的情况下切片会如何

# 创建一个多重索引无序的Series
index = pd.MultiIndex.from_product([['a','c','b'], [1,2]])
data = pd.Series(np.random.rand(6),index=index)
data.index.names = ['char', 'int']
data

try:
    print(data.loc['a':'b'])
except KeyError as e:
    print(type(e))
    print(e)

# 对索引排序，重新返回
data = data.sort_index()
data

data.loc['a':'b']

### 2.索引stack与unstack

stack与unstack可以设置索引的层级

pop

# 设置level参数，我的理解就是联合索引的第几列数据变成DataFrame的colums数据，当然从0开始
pop.unstack()

# 跟默认的输出一样，默认参数为-1
pop.unstack(level=1)

pop.unstack(level=0)

### 3.索引的设置与重置

前面书中使用了方法reindex()可以替换掉原索引，这里将介绍层级转换的另一种方法rest_index
如果在上面的人口数据Series中使用该方法，则会生成一个列便签种包含之前行索引标签stats与year的DataFrame

pop

pop.reset_index()

# 通过name属性为列设置名
pop_flat = pop.reset_index(name='population')
pop_flat

上面这样的DataFrame要是能够直接转换成多重索引的DataFrame也可以直接通过set_inex实现

pop_flat.set_index(['stats', 'year'])

## 3.6.5多级索引的数据累计方法

health_data

# 通过设置level的参数来选定需要参与计算的数据
data_mean = health_data.mean(level='year')
data_mean

# 多从索引可以填写多重索引的名称，也就是为多重索引的索引编号
health_data.mean(level=0)

# 通过设置axis来选择坐标轴，也就是axis=0，折叠水平坐标，纵坐标不变，横坐标压缩，当选择axis为1时，那就是纵坐标折叠，横坐标不变了。
health_data.mean(axis=1, level=1)

health_data.mean(axis=1, level='type')

# 合并数据集:Concat与Append操作

# 导入Pandas与NumPy
import pandas as pd
import numpy as np

# 定义一个创建DataFrame的函数
def make_df(cols, ind):
    data = {c: [str(c) + str(i) for i in ind]
        for c in cols
    }
    return pd.DataFrame(data, ind)
make_df('ABC', range(3))

## 3.7.1 知识回顾:NumPy数组的合并

合并Series与DateFrame与合并NumPy数组基本相同，后者通过np.concatenate函数完成。

x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
ll = np.concatenate([x, y, z])
ll

concatenate通过axis参数选择合并的方向

x = [[1, 2],
     [3, 4]]
# x=1 在纵坐标连接
np.concatenate([x, x], axis=1)

## 3.7.2通过pd.cancat实现简易合并

Pandas有pd.cancat()函数与np.concatenate语法类似，但参数多很多

```python
# Signature in Pandas v0.18
pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
          keys=None, levels=None, names=None, verify_integrity=False,
          copy=True)
```

简单合并一维的Series或DataFrame对象

ser1 = pd.Series(['A','B','C'],index=[1,2,3])
ser2 = pd.Series(['D', 'E', 'F'], index=[4, 5, 6])
# 合并在一起，默认axis=0
pd.concat([ser1,ser2], axis='rows')

# 合并DataFrame
df1 = make_df('AB', [1, 2])
df2 = make_df('AB', [3, 4])
display(df1, df2, pd.concat([df1, df2]))

# 通过axis的设置合并列，行数据要相等
df3 = make_df('AB', [0, 1])
df4 = make_df('CD', [0, 1])
display(df3, df4, pd.concat([df3, df4], axis='columns'))

# 也可以通过数字设置，效果一样
df3 = make_df('AB', [0, 1])
df4 = make_df('CD', [0, 1])
display(df3, df4, pd.concat([df3, df4], axis=1))

### 1.索引重复

pd.concatenate与pd.cancat最主要的差异之一就是合并会保留索引，即使索引是重复的

x = make_df('AB', [0, 1])
y = make_df('AB', [2, 3])
# y的索引复制x的
y.index = x.index  # make duplicate indices!
display(x, y, pd.concat([x, y]))

### 捕捉索引重复的数据

# 通过设置verify_integrity的值为True，当索引有重复时，上浮错误
try:
    pd.concat([x, y], verify_integrity=True)
except ValueError as e:
    print(f'ValueError {e}')

# 忽略索引，ignore_index参数,有时候索引用处不大的情况下，自动更改索引
print(x), print(y); print(pd.concat((x,y), ignore_index=True))

# 增加多级索引,通过key参数，设置多级索引
print(x);print(y);print(pd.concat((x,y), keys=['x','y']))

### 2.类似join的合并

简单看了书中的介绍，感觉跟数据的内联与外联差不多，默认是外联的

df5 = make_df('ABC', [1, 2])
df6 = make_df('BCD', [3, 4])
# 默认外联，没有数据的地方为NaN
display(df5, df6, pd.concat([df5, df6]))

# 通过设置join参数设置为'inner'，数据合并columns为并集,在sql里面为内联
print(df5);print(df6);print(pd.concat((df5,df6),join='inner'))

# 可以指定需要显式的columns的DataFrame源，也就像sql里面的左联，右联
# 我使用版本1.0.5已经没有这个join_axes参数了
print(pd.__version__)
print(df5);print(df6);print(pd.concat((df5,df6),join_axes=[df5.columns]))

### 3.append()方法

Series与Pandas对象带有append方法，也可以实现合并的效果。df1.append(df2)与pd.concat([df1, df2])效果一样

print(df1);print(df2);print(df1.append(df2))

Python列表中append()和extend()方法不同，Pandas的append()不直接更新原有对象的值，而是为合并后的数据创建一个新对象。因此，它不能称之为一个非常高效的解决方案，因此每次合并都需要重新创建索引和数据缓存。总之，如果你需要进行多个append操作，还是建议显创建一个DataFrame列表，然后用concat()函数一次性解决所有合并任务

	area	pop	e
California	423967	38332521	1.25
Texas	695662	26448193	1.25
New York	141297	19651127	1.25
Florida	170312	19552860	1.25
Illinois	149995	12882135	1.25

	area	pop	e
California	423967	38332521	1.25
Texas	695662	26448193	1.25
New York	141297	19651127	1.25
Florida	170312	19552860	1.25
Illinois	149995	12882135	1.25

	area	pop
California	423967	38332521
Texas	695662	26448193
New York	141297	19651127
Florida	170312	19552860
Illinois	149995	12882135

	area	pop	density
California	423967	38332521	90.413926
Texas	695662	26448193	38.018740
New York	141297	19651127	139.076746
Florida	170312	19552860	114.806121
Illinois	149995	12882135	85.883763

	area	pop	density
California	423967	38332521	90.413926
Texas	695662	26448193	38.018740
New York	141297	19651127	139.076746
Florida	170312	19552860	114.806121
Illinois	149995	12882135	85.883763

《Python数据科学手册》抄书笔记，第三章: Pandas数据处理

3.3数据取值与选择

3.3.1Series数据选择的方法

3.3.2DataFrame数据选择方法

将DataFrame看作字典

2.将DateFrame看作二维数组

	California	Texas	New York	Florida	Illinois
area	4.239670e+05	6.956620e+05	1.412970e+05	1.703120e+05	1.499950e+05
pop	3.833252e+07	2.644819e+07	1.965113e+07	1.955286e+07	1.288214e+07
density	9.041393e+01	3.801874e+01	1.390767e+02	1.148061e+02	8.588376e+01