pandas索引index

# from http://pandas.pydata.org/pandas-docs/stable/indexing.html
# pandas 0.22.0 

import pandas as pd
import numpy as np

"""
尽量利用pandas提供的专用索引方式，而不是python通用的切片方式。
三种主要的索引方式：indexers
.loc label based 基于标签， 可以是标签名，可以是布尔值，可以是一元函数
.iloc integer psition based 基于整数位置(from 0 to length-1 of the axis)，和python切片类似
[]

"""

"""
Object Type 		Selection 			Return Value Type
------------------------------------------------------------
Series 				series[label] 		scalar value
DataFrame 			frame[colname] 		Series corresponding to colname
Panel 				panel[itemname] 	DataFrame corresponding to the itemname
"""

# Here we construct a simple time series data set to use for illustrating the indexing functionality 
# 构造时间序列，举例说明索引的功能

dates = pd.date_range(‘1/1/2000‘, periods=8)
dates
df = pd.DataFrame(np.random.randn(8, 4), index=dates, columns=[‘A‘, ‘B‘, ‘C‘, ‘D‘])
df

panel = pd.Panel({‘one‘ : df, ‘two‘ : df - df.mean()})  # 多维表格
panel
panel[‘one‘]
panel[‘two‘]

# Thus, as per above, we have the most basic indexing using []:
# 最基本的索引方法，使用[]

s = df[‘A‘]
s
dates[5]  # 注意切片从0计数
s[dates[5]]

# 在[]中传入列名的列表，如[ ‘A‘, "B" ]
columns_l = [‘A‘, ‘B‘]
df[columns_l]  
df[[ ‘A‘, "B" ]]  # 相当于上面，注意两重[]
df

df[[‘A‘, ‘B‘]] = df[[‘B‘, ‘A‘]]  # 交换两列的值
df
df.loc[:,[‘B‘, ‘A‘]]

# 下式不能交换两列的值
# This will not modify df because the column alignment is before value assignment. ? 不理解？
# 列赋值在值赋值之前？
df.loc[:,[‘B‘, ‘A‘]] = df[[‘A‘, ‘B‘]]  
df

# df.loc[:,[‘B‘, ‘A‘]] = df[:, [‘A‘, ‘B‘]]   # 错误？
# df

# 正确的方式：
df.loc[:,[‘B‘, ‘A‘]] = df[[‘A‘, ‘B‘]].values  # 取列的值
df

# Attribute Access?
# 属性访问，属性存取
# You may access an index on a Series, column on a DataFrame, 
# and an item on a Panel directly as an attribute:

sa = pd.Series([1,2,3],index=list(‘abc‘))
sa

dfa = df.copy()
dfa

# 对item column等赋值
# 就像属性一样的存取，但需要注意：
# 1. 名称应符合python命名规则，由字母、数字和下划线组成
# 2. 不能和已有的方法名称重名，例如 min
# 3. 不能与pandas内部“关键字”重名，例如 index axis items labels
# 以上情况，可以使用 [ "" ] 引用

sa.a = 5
sa

dfa.index
dfa.A = list(range(len(dfa.index)))
dfa

x = pd.DataFrame({‘x‘: [1, 2, 3], ‘y‘: [3, 4, 5]})  # 字典key值为列名
x

dict(x=9, y=99)
x.iloc[1]
x.iloc[1] = dict(x=9, y=99)
x

df = pd.DataFrame({‘one‘: [1., 2., 3.]})
df
df.two = [4, 5, 6]  # 错误，不能增加一列，利用属性的方式不能对没有的列赋值
df.two  # 但是增加了一项属性，而且可以取得这项属性
df
df[‘two‘] = [4, 5, 6]  # 可以增加一列
df

# Slicing ranges
# 切片范围
# iloc 方法是最稳健和兼容的
# 下面介绍 方括号 [] 操作符 作为切片

# 对series操作
# 取值
s
s[:5]
s[::2]
s[::-1]

# 赋值
s2 = s.copy()
s2
s2[:5] = 0
s2

# 对DataFrame操作
# [] 操作 选择的是行
df
df[:3]
df[::-1]

# Selection By Label
# 通过标签选择

# 这种方式可能依靠上下文关系，有时候会调用链式赋值，这应该避免。参考：
# Returning a view versus a copy 返回视图 对比 拷贝

# When setting values in a pandas object, 
# care must be taken to avoid what is called chained indexing. 
# Here is an example.

[list(‘abcd‘),list(‘efgh‘),list(‘ijkl‘),list(‘mnop‘)]
[[‘one‘,‘two‘],[‘first‘,‘second‘]]

dfmi = pd.DataFrame([list(‘abcd‘),list(‘efgh‘),list(‘ijkl‘),list(‘mnop‘)],  # 定义四列数值
        columns=pd.MultiIndex.from_product(
         [[‘one‘,‘two‘],[‘first‘,‘second‘]])) # 定义多重索引，第一个list是第一层，以下类推

dfmi

#  Compare these two access methods:
dfmi[‘one‘][‘second‘]  # chained
dfmi.loc[:,(‘one‘,‘second‘)]

# 两种方式分析

# 第一种方式：链式 使用两个 []
dfmi[‘one‘]  # 第一个[] 先生成了一个DataFrame
dfmi[‘one‘][‘second‘]  # pandas 把两个[] 作为分开的事件，他们执行分开的两步调用 __getitem__

# 第二种方式：loc
# 通过嵌套的元组切片
df_s = (slice(None), (‘one‘, ‘second‘))
dfmi.loc[df_s]  # 只调用了一次 __getitem__

# Selection By Label
# 通过标签选择

# loc要注意索引的数据类型，必须与索引的数据类型一致才可以，
# 例如 datetimeIndex 中，使用loc[2:3] ，即整数型的slice 将会出现TypeError


dfl = pd.DataFrame(np.random.randn(5,4), columns=list(‘ABCD‘), 
                   index=pd.date_range(‘20130101‘,periods=5))

dfl
# dfl.loc[2:3]  # 错误的loc
dfl.loc[‘20130102‘:‘20130104‘]  # 使用可转换为datetime的字符串
dfl.loc[‘20130202‘:‘20130204‘]  # 不报错，返回为空DataFrame
# dfl.loc[‘20130202‘]  # 报错，错误信息是index无此值
dfl.loc[‘20130104‘:‘20130114‘]  # 只返回存在的数据

# loc可以使用整数，但此时的整数不代表位置，而是label
# loc是基本的取值方法
# 给loc的输入，即在[]中的值，可以是：
# 1. 单独的label  e.g. 5 or ‘a
# 2. labels的list   [‘a‘, ‘b‘, ‘c‘]
# 3. slice对象  ‘a‘:‘f‘  !! 注意：与python的切片不同，pandas的切片包括开始和结尾，而python不包括结尾
# 4. 布尔值
# 5. 调用函数  [lambda df: df.A > 0, :]

# Series
s1 = pd.Series(np.random.randn(6),index=list(‘abcdef‘))
s1
s1.loc[‘c‘:]
s1.loc[‘b‘]
s1.loc[‘c‘:] = 0
s1

# DataFrame
df1 = pd.DataFrame(np.random.randn(6,4),  # 6X4 阵列
                   index=list(‘abcdef‘),  # 索引
                   columns=list(‘ABCD‘))  # 行号
df1

df1.loc[[‘a‘, ‘b‘, ‘d‘], :]  # 先是行label选择，再是列label选择
df1.loc[‘d‘:, ‘A‘:‘C‘]

# 取得 a cross section 截面，用单个的label，返回Series
# 以下三式等同
df1.loc[‘a‘]
df1.loc[‘a‘,:]
df1.xs(‘a‘)
type(df1.loc[‘a‘])

# 通过布尔值数组取值
df1.loc[‘a‘] > 0
df1.loc[:, df1.loc[‘a‘] > 0]

# 获取一个值
# this is also equivalent to ``df1.at[‘a‘,‘A‘]``
df1.loc[‘a‘, ‘A‘]
df1.at[‘a‘,‘A‘]

# Slicing with labels?
# 用labels切片
s = pd.Series(list(‘abcde‘), index=[0,3,2,5,4])
s
s.loc[3:5]  # 包含 5， 注意不是 3 4 5 ，而是从 标签3 到 标签5

# s.loc[3:6]  # 2个错误，ValueError: index must be monotonic increasing or decreasing  KeyError: 6
# 如果排序的话，可以超出范围
s.sort_index()  # 不改变原值
s
s.sort_index().loc[1:6]  # 可以超出范围
s.sort_index().loc[6:8]  # 即使一个都没有
# s.sort_index().loc[8]  # 但不能是单值，必须是切片

# Selection By Position
# 通过位置选择，仅通过基于索引的整数，与python和numpy类似，从0开始，且不包括最后一个
# iloc的输入：
# 1. 整数
# 2. 整数的list
# 3. 整数的切片
# 4. 布尔值数组
# 5. 调用函数

# Series
s1 = pd.Series(np.random.randn(5), index=list(range(0,10,2)))
s1
s1.iloc[:3]
s1.iloc[3]
s1.iloc[:3] = 0
s1

# DataFrame
df1 = pd.DataFrame(np.random.randn(6,4),
                  index=list(range(0,12,2)),
                  columns=list(range(0,8,2)))
df1

df1.iloc[:3]
df1.iloc[1:5, 2:4]
df1.iloc[[1, 3, 5], [1, 3]]
df1.iloc[1:3, :]
df1.iloc[:, 1:3]

# this is also equivalent to ``df1.iat[1,1]``
# 取单个的值
df1.iloc[1, 1]
df1.iat[1, 1]

# For getting a cross section using an integer position (equiv to df.xs(1))
# 取截面，得到Series
df1.iloc[1]
df1.iloc[:,1]

# Out of range slice indexes are handled gracefully just as in Python/Numpy.
# 超过索引的切片处理，与python和numpy一样
# 注意：不能是单独索引，或列表中，有超过界限的值，只可以是slice，即带冒号的切片才不会提示错误

x = list(‘abcdef‘)
x[4:10]
x[8:10]
s = pd.Series(x)
s.iloc[4:10]
s.iloc[8:10]  # 超过界限bound返回空

dfl = pd.DataFrame(np.random.randn(5,2), columns=list(‘AB‘))
dfl
dfl.iloc[:, 2:3]
dfl.iloc[:, 1:3]
dfl.iloc[4:6]

# Selection By Callable
# 通过调用函数进行选择

df1 = pd.DataFrame(np.random.randn(6,4),
                  index=list("abcdef"),
                  columns=list("ABCD"))
df1
df1.A

df1.loc[lambda df: df.A > 0, :]
df1.loc[:, lambda df: [‘A‘, ‘B‘]]
df1.iloc[:, lambda df: [0, 1]]
df1[lambda df: df.columns[0]]

df1.A
df1.A.loc[lambda s: s > 0]
df1.A.loc[df1.A > 0]

# 使用这些方法或索引，可以使用链式的选择方法，而不用中间的临时变量。链式方法，不是链式[]
bb = pd.read_csv(‘data/baseball.csv‘, index_col=‘id‘)
bb.groupby([‘year‘, ‘team‘]).sum().loc[lambda df: df.r > 100]

# IX Indexer is Deprecated
# 不推荐使用ix
# in favor of the more strict .iloc and .loc indexers.
# 使用.iloc和.loc代替.ix

dfd = pd.DataFrame({‘A‘: [1, 2, 3],‘B‘: [4, 5, 6]},index=list(‘abc‘))
dfd

dfd.ix[[0, 2], ‘A‘]

dfd.index[[0, 2]]  # 取得索引的名称
dfd.loc[dfd.index[[0, 2]], ‘A‘]
dfd.columns.get_loc(‘A‘)  # 取得列的索引值
dfd.iloc[[0, 2], dfd.columns.get_loc(‘A‘)]

# Indexing with list with missing labels is Deprecated
# 不推荐用有缺失标签的list进行索引
# using .loc or [] with a list with one or more missing labels, is deprecated, in favor of .reindex.
# 推荐使用.reindex

s = pd.Series([1, 2, 3])
s

s.loc[[1, 2]]  # list中的keys都存在，则没有变化

s.loc[[1, 2, 3]]  # 当有缺失时，赋值为NaN 

# Reindexing

s.reindex([1, 2, 3])

# 如果仅选择有效的keys
labels = [1, 2, 3]
s.index.intersection(labels)  # index和labes的交集
s.loc[s.index.intersection(labels)]

# reindex 索引中不能有重复的项
s = pd.Series(np.arange(4), index=[‘a‘, ‘a‘, ‘b‘, ‘c‘])
s
labels = [‘c‘, ‘d‘]
# s.reindex(labels)  # 不能reindex

# 可以先把交集切出来，再进行reindex
# 但是交集不能有重复的index
s.index.intersection(labels)
s.loc[s.index.intersection(labels)]
s.loc[s.index.intersection(labels)].reindex(labels)

# Selecting Random Samples
# 随机取样选择
# 默认行取样

s = pd.Series([0,1,2,3,4,5])
s

s.sample()  # 默认取1行
s.sample(n=3)  # 取3行
s.sample(frac=0.5)  # 小数，行数百分数
s.sample(frac=0.8)  # 小数
s

s.sample(n=6, replace=False)  # 默认
s.sample(n=6, replace=True)  # replace，不改变本身
s

# 默认每行都有同样的概率被抽样到，也可以指定每行的概率比重
example_weights = [0, 0, 0.2, 0.2, 0.2, 0.4]
s.sample(n=3, weights=example_weights)

example_weights2 = [0.5, 0, 0, 0, 0, 0]  # 权重将会自动的归一化
s.sample(n=1, weights=example_weights2)

# 可以指定DataFrame的某列作为权重
df2 = pd.DataFrame({‘col1‘:[9,8,7,6], ‘weight_column‘:[0.5, 0.4, 0.1, 0]})
df2.sample(n = 3, weights = ‘weight_column‘)

# 对列进行抽样
df3 = pd.DataFrame({‘col1‘:[1,2,3], ‘col2‘:[2,3,4], ‘col3‘:[3,4,5]})
df3
df3.sample(n=2, axis=1)  # 指定axis=1，对列抽样，抽取的是列的组合
df3.sample(n=2, axis=0)

# 可以指定random seed 或者 numpy 的 randomState 对象，作为sample 随机数生成器的种子
# 一旦seed确定，随机数不变
df3.sample(n=2, random_state=2)
df3.sample(n=2, random_state=2)
df3.sample(n=2, random_state=200)
df3.sample(n=2, random_state=200)

# Setting With Enlargement
# loc或[] 操作 可以通过赋值不存在的键扩大Series或Dataframe

# Series
se = pd.Series([1,2,3])
se
se[5] = 5  # append
se

# DataFrame

dfi = pd.DataFrame(np.arange(6).reshape(3,2),columns=[‘A‘,‘B‘])
dfi

dfi.loc[:,‘C‘] = dfi.loc[:,‘A‘]  # enlarge 增加列
dfi

dfi.loc[3] = 5  # append 增加行
dfi

# Fast scalar value getting and setting
# 快速取得或设置标量的值
# [] 可以进行很多操作，所以它为了知道你要进行那种操作，会有一点计算开销
# 最快的标量访问方式是使用 at 和 iat 方法，他们可以在所有的数据结构上使用
# at 类似于 loc 基于 label
# iat 类似于 iloc 基于 整数index
s = pd.Series([0,1,2,3,4,5])
s
df = pd.DataFrame(np.random.randn(8, 4), index=dates, columns=[‘A‘, ‘B‘, ‘C‘, ‘D‘])
df

# get value
s.iat[5]
df.at[dates[5], ‘A‘]
df.iat[3, 0]

# set value
df.at[dates[5], ‘E‘] = 7  # 没有列就增加一列，没有值的默认赋值为nan
df

df.iat[3, 0] = 7
df

df.at[dates[-1]+1, 0] = 7  # 行和列都扩展了
df

# Boolean indexing
# 使用布尔向量过滤数据
# 操作符包括：| for or, & for and, and ~ for not ，必须用括号进行分组

s = pd.Series(range(-3, 4))  # 不用把range先list，直接可以series
s

s[s >= 0]  # 直接用series，不用取其值
s[~(s < 0)]
s[(s < -1) | (s > 0.5)]

df[df[‘A‘] > 0]

# List comprehensions and map method of Series can also be used to produce more complex criteria:
# 列表生成式和map方法 也可以用来生成 更复杂的条件判断

df2 = pd.DataFrame({‘a‘ : [‘one‘, ‘one‘, ‘two‘, ‘three‘, ‘two‘, ‘one‘, ‘six‘],
                     ‘b‘ : [‘x‘, ‘y‘, ‘y‘, ‘x‘, ‘y‘, ‘x‘, ‘x‘],
                     ‘c‘ : np.random.randn(7)})
df2

# 判别式
criterion = df2[‘a‘].map(lambda x: x.startswith(‘t‘))  # 选择 two 和 three
criterion

df2[criterion]  # 根据 a 列的判别式 选择数据表的一部分，包含其他列

# 等价的方式，但是速度慢一些 
df2[[x.startswith(‘t‘) for x in df2[‘a‘]]]  # 不适用map，而是用列表生成式

# 复合判断
df2[criterion & (df2[‘b‘] == ‘x‘)]  # a 列 和 b 列 均符合某类要求

# 布尔向量选择 可以与索引选择一并使用
df2.loc[criterion & (df2[‘b‘] == ‘x‘),‘b‘:‘c‘]  # 只选择 b 和 c 两列，不选择c列

# Indexing with isin
# 用isin索引

# series
# 对列数据进行判断
s = pd.Series(np.arange(5), index=np.arange(5)[::-1], dtype=‘int64‘)
s

s.isin([2, 4, 6])  # 列数据中是否存在列表中的值，返回布尔值
s[s.isin([2, 4, 6])]  # 可以利用返回的布尔值进行选择

# 也可以对index obj 进行筛选
s[s.index.isin([2, 4, 6])]
s.reindex([2, 4, 6])  # reindex不同，列表中没有的值返回了nan，且原来的int64返回了float64数据类型

# 对应多重索引，可以单独选择索引级别
s_mi = pd.Series(np.arange(6),index=pd.MultiIndex.from_product([[0, 1], [‘a‘, ‘b‘, ‘c‘]]))
s_mi

s_mi.iloc[s_mi.index.isin([(1, ‘a‘), (2, ‘b‘), (0, ‘c‘)])]
s_mi.iloc[s_mi.index.isin([‘a‘, ‘c‘, ‘e‘], level=1)]  # 指定索引级别，在第二级索引中选择

# DataFrame
df = pd.DataFrame({‘vals‘: [1, 2, 3, 4], ‘ids‘: [‘a‘, ‘b‘, ‘f‘, ‘n‘],‘ids2‘: [‘a‘, ‘n‘, ‘c‘, ‘n‘]})
df

values = [‘a‘, ‘b‘, 1, 3]
df.isin(values)  # 匹配所有的值

values = {‘ids‘: [‘a‘, ‘b‘], ‘ids2‘: [‘a‘, ‘c‘], ‘vals‘: [1, 3]}
row_mask = df.isin(values)  # 对不用的列，分别匹配某些值
row_mask
# ?row_mask.all  # Return whether all elements are True over requested axis
row_mask = row_mask.all(1)
row_mask
df[row_mask]  # 选择全是True的行

# The where() Method and Masking
# To guarantee that selection output has the same shape as the original data
# 保证选集输出与原数据有同样的shape形态

# series
s
s[s > 0]  # 只返回满足的项
s.where(s > 0)  # 全部返回，不满足的项，赋值nan

# DataFrame 使用布尔值选择时，返回值保留原数据结构
df = pd.DataFrame(np.random.randn(8, 4), index=dates, columns=[‘A‘, ‘B‘, ‘C‘, ‘D‘])
df

df[df < 0]
df.where(df < 0)  # 等价于上式
df.where(df < 0, -df)  # where 可以传入另一个参数，用于替换条件为 False 的项，返回copy数据拷贝，不修改原值
df

# You may wish to set values based on some boolean criteria. This can be done intuitively like so:
# 设置基于布尔值的项值

s2 = s.copy()
s2
s2[s2 < 3] = 0
s2
df2 = df.copy()
df2
df2[df2 < 0] = 0
df2

# where 默认返回修改后的数据拷贝，原值不变；可以设置inplace参数，直接修改原值，而不是创建拷贝

df_orig = df.copy()
df_orig.where(df > 0, -df, inplace=True)
df_orig

# 注意 ：pandas 和 numpy 的where方法不一样
# 一般的，df1.where(m, df2)  相当于 np.where(m, df1, df2)

df.where(df < 0, -df) == np.where(df < 0, df, -df)

# alignment 定位，对齐
# where 可以选择局部（部分区域）的布尔条件  
# This is analogous to partial setting via .loc (but on the contents rather than the axis labels)

df2 = df.copy()
df2
df2[1:4]   # 行选择
df2.where(df2[1:4] > 0, 3)  # 对不符合项的值进行赋值！
df2[ df2[1:4] > 0 ] = 3  # 只定位部分区域，对符合项的值进行赋值
df2

# Where can also accept axis and level parameters to align the input when performing the where.
# where 可以接受 轴参数axis 和 级别参数level 
df2 = df.copy()
df2
df2.where(df2>0,df2[‘A‘],axis=‘index‘)  # 小于等于0的值，赋值为A列的值
df2
df2.apply(lambda x, y: x.where(x>0,y), y=df[‘A‘])  # 相当于上式，但此式较慢，同样不改变原值，而是生成一个拷贝copy
df2