文章目录

  • 索引
  • 1、单级索引
  • 2、多级索引
  • 3、索引设定
  • 4、常用索引函数
  • 5、重复值
  • 6、抽样
  • 7、具体案例分析


索引

1、单级索引

更新pg索引 索引的更新_python


总结：

（1）iloc表示位置索引，loc表示标签索引，[]也具有很大的便利性，各有特点。

（2）所有在loc中使用的切片全部包含右端点、iloc方法切片右端点不包含。

（3）本质上说，loc中能传入的只有布尔列表和索引子集构成的列表。

（4）iloc中接收的参数只能为整数或整数列表，不能使用布尔索引。[]操作符常用于列选择或布尔选择，尽量避免行的选择。

（5） []操作符。如果不想陷入困境，请不要在行索引为浮点时使用[]操作符，因为在Series中的浮点[]并不是进行位置比较，而是值比较，非常特殊。

import numpy as np
import pandas as pd
#数据加载
df = pd.read_csv('C:/Users/Kingfish/Desktop/joyful-pandas/joyful-pandas/data/table.csv',index_col='ID')
df.head()
#一、单级索引
#1. loc方法、iloc方法、[]操作符
#（a）loc方法
#① 单行索引：
df.loc[1103]
#② 多行索引：
df.loc[[1102,2304]]
df.loc[1304:]
df.loc[2402::]
df.loc[2402::-1]
#[::-1] 顺序相反操作 ,[-1] 读取倒数第一个元素,[2402::-1] 从下标为3（从0开始）的元素开始翻转读取
#③ 单列索引：
df.loc[:,'Height'].head()
#④ 多列索引：
df.loc[:,['Height','Math']].head()
#⑤ 联合索引
df.loc[:,'Height':'Math'].head()
#⑥ 函数式索引：
df.loc[lambda x:x['Gender']=='M'].head()
#loc中使用的函数，传入参数就是前面的df
#lambda函数也叫匿名函数,即函数没有具体的名称。
#def f(x):
#return x**2
#print f(4)
#Python中使用lambda的话，写成这样
#g = lambda x : x**2
#print g(4)
def f(x):
    return [1101,1103]
df.loc[f]
#⑦ 布尔索引
df.loc[df['Address'].isin(['street_7','street_4'])].head()#筛选出Address是street_7或street_4的观测值,isin
df.loc[[True if i[-1]=='4' or i[-1]=='7' else False for i in df['Address'].values]].head()
#判断Address最后一个数是4或7
#（b）iloc方法（注意与loc不同，切片右端点不包含）
#① 单行索引：
df.iloc[0]
df.iloc[3]#位置在第4行的观测值信息
#② 多行索引：
df.iloc[3:5]#不包含切片右端，所以只显示第4行和第5行
#③ 单列索引：
df.iloc[:,3].head()#不考虑索引列的第4列
#④ 多列索引：
df.iloc[:,7::-2]#从第8列开始，，每次往前跳过一列
#⑤ 混合索引：
df.iloc[3::4,7::-2].head()#从第4行开始到最后，中间跳过3行，显示第四行
#⑥ 函数式索引：
df.iloc[lambda x:[3]].head()
#c） []操作符
#（c.1）Series的[]操作
#① 单元素索引：
s = pd.Series(df['Math'],index=df.index)   #s是df中的Math序列，索引也是df的索引ID
#s[1101] #34.0
#使用的是索引标签
#② 多行索引：
s[0:4]
#使用的是绝对位置的整数切片，位置，不包括右端，从1到4行，不包括4对应的第五行
#③ 函数式索引：
s[lambda x: x.index[16::-6]]  #从第17行开始往前，间隔5个
#注意使用lambda函数时，直接切片(如：s[lambda x: 16::-6])就报错，此时使用的不是绝对位置切片，而是元素切片，非常易错
#④ 布尔索引：
s[s.values>80]
（c.2）DataFrame的[]操作
#① 单行索引：
df[1:2]
#这里非常容易写成df['label']，会报错
#同Series使用了绝对位置切片
#如果想要获得某一个元素，可用如下get_loc方法，把元素转化为位置，然后[]来位置索引：
row = df.index.get_loc(1102)
df[row:row+1]
#② 多行索引：
#用切片，如果是选取指定的某几行，推荐使用loc，否则很可能报错
df[3:5]#不包含右端
#③ 单列索引：
df['School'].head()
#④ 多列索引：
df[['School','Math']].head()
#⑤函数式索引：
df[lambda x:['Math','Physics']].head()
#⑥ 布尔索引：
df[df['Gender']=='F'].head()
#2. 布尔索引
#（a）布尔符号：'&','|','~'：分别代表和and，或or，取反not
df[(df['Gender']=='F')&(df['Address']=='street_2')].head()
df[(df['Math']>85)|(df['Address']=='street_7')].head()
df[~((df['Math']>75)|(df['Address']=='street_1'))].head()
#loc和[]中相应位置都能使用布尔列表选择：
df.loc[df['Math']>60,(df[:8]['Address']=='street_6').values].head()
#如果不加values就会索引对齐发生错误，Pandas中的索引对齐是一个重要特征，很多时候非常使用
#但是若不加以留意，就会埋下隐患
（b） isin方法
df[df['Address'].isin(['street_1','street_4'])&df['Physics'].isin(['A','A+'])]
#上面也可以用字典方式写：
df[df[['Address','Physics']].isin({'Address':['street_1','street_4'],'Physics':['A','A+']}).all(1)]
#all与&的思路是类似的，其中的1代表按照跨列方向判断是否全为True
#3. 快速标量索引
display(df.at[1101,'School'])
display(df.loc[1101,'School'])
display(df.iat[0,0])
display(df.iloc[0,0])
#可尝试去掉注释对比时间
%timeit df.at[1101,'School']
%timeit df.loc[1101,'School']
%timeit df.iat[0,0]
%timeit df.iloc[0,0]
#4. 区间索引
#（a）利用interval_range方法
pd.interval_range(start=0,end=5)
#closed参数可选'left''right''both''neither'，默认左开右闭
pd.interval_range(start=0,periods=8,freq=5)
#periods参数控制区间个数，freq控制步长
#（b）利用cut将数值列转为区间为元素的分类变量，例如统计数学成绩的区间情况：
math_interval = pd.cut(df['Math'],bins=[0,40,60,80,100])
#注意，如果没有类型转换，此时并不是区间类型，而是category类型
math_interval.head()
#（c）区间索引的选取
df_i = df.join(math_interval,rsuffix='_interval')[['Math','Math_interval']]\.reset_index().set_index('Math_interval')
df_i.head()
df_i.loc[65].head()
#包含该值就会被选中
df_i.loc[[65,90]].head()
#如果想要选取某个区间，先要把分类变量转为区间变量，再使用overlap方法：
#df_i.loc[pd.Interval(70,75)].head() 报错
df_i[df_i.index.astype('interval').overlaps(pd.Interval(70, 85))].head()

2、多级索引

更新pg索引 索引的更新_更新pg索引_02

#1. 创建多级索引
#（a）通过from_tuple或from_arrays
#① 直接创建元组
tuples = [('A','a'),('A','b'),('B','a'),('B','b')]
mul_index = pd.MultiIndex.from_tuples(tuples, names=('Upper', 'Lower'))#通过from_tuples创建多级索引
mul_index
pd.DataFrame({'Score':['perfect','good','fair','bad']},index=mul_index)
#② 利用zip创建元组
L1 = list('AABB')
L2 = list('abab')
tuples = list(zip(L1,L2))
mul_index = pd.MultiIndex.from_tuples(tuples, names=('Upper', 'Lower'))
pd.DataFrame({'Score':['perfect','good','fair','bad']},index=mul_index)
#③ 通过Array创建
arrays = [['A','a'],['A','b'],['B','a'],['B','b']]
mul_index = pd.MultiIndex.from_tuples(arrays, names=('Upper', 'Lower'))
pd.DataFrame({'Score':['perfect','good','fair','bad']},index=mul_index)
mul_index
#由此看出内部自动转成元组
#（b）通过from_product
L1 = ['A','B']
L2 = ['a','b']
pd.MultiIndex.from_product([L1,L2],names=('Upper', 'Lower'))
#两两相乘
#（c）指定df中的列创建（set_index方法）
df_using_mul = df.set_index(['Class','Address'])
df_using_mul.head()
#2、多层索引切片
df_using_mul.head()
（a）一般切片
#df_using_mul.loc['C_2','street_5']
#当索引不排序时，单个索引会报出性能警告
#df_using_mul.index.is_lexsorted()
#该函数检查是否排序
df_using_mul.sort_index().loc['C_2','street_5']
#df_using_mul.sort_index().index.is_lexsorted()
#df_using_mul.loc[('C_2','street_5'):] 报错
#当不排序时，不能使用多层切片
df_using_mul.sort_index().loc[('C_2','street_6'):('C_3','street_4')]
#注意此处由于使用了loc，因此仍然包含右端点
df_using_mul.sort_index().loc[('C_2','street_7'):'C_3'].head()
#非元组也是合法的，表示选中该层所有元素
#（b）第一类特殊情况：由元组构成列表
df_using_mul.sort_index().loc[[('C_2','street_7'),('C_3','street_2')]]
#表示选出某几个元素，精确到最内层索引
#(c）第二类特殊情况：由列表构成元组
df_using_mul.sort_index().loc[(['C_2','C_3'],['street_4','street_7']),:]
#选出第一层在‘C_2’和'C_3'中且第二层在'street_4'和'street_7'中的行
#3、索引中的slice对象,应用非常灵活
idx=pd.IndexSlice
df_s.loc[idx['B':,df_s['D']['d']>0.3],idx[df_s.sum()>4]]
#df_s.sum()默认为对列求和，因此返回一个长度为9的数值列表
#4、索引层的交换
（a）swaplevel方法（两层交换）
df_using_mul.head()
df_using_mul.swaplevel(i=1,j=0,axis=0).sort_index().head()#axis=0按列、跨行
df_using_mul.swaplevel(i=1,j=0,axis=0).sort_index().head()#axis=0按列、跨行
#（b）reorder_levels方法（多层交换）
df_muls = df.set_index(['School','Class','Address'])
df_muls.head()
df_muls.reorder_levels([2,0,1],axis=0).sort_index().head() #根据位置多层交换
#如果索引有name，可以直接使用name
df_muls.reorder_levels(['Address','School','Class'],axis=0).sort_index().head()#根据名称多层交换

3、索引设定

更新pg索引 索引的更新_python_03

#1.index_col参数
pd.read_csv('data/table.csv',index_col=['Address','School']).head()#index_col是read_csv中的一个参数，而不是某一个方法：
#2. reindex和reindex_like¶
#reindex是指重新索引，它的重要特性在于索引对齐，很多时候用于重新排序
df.reindex(index=[1101,1203,1206,2402])
df.reindex(columns=['Height','Gender','Average'])
#可以选择缺失值的填充方法：fill_value和method（bfill/ffill/nearest），其中method参数必须索引单调
df.reindex(index=[1101,1203,1206,2402],method='bfill')#bfill表示用所在索引1206的后一个有效行填充，ffill为前一个有效行，nearest是指最近的
df.reindex(index=[1101,1203,1206,2402],method='nearest')#数值上1205比1301更接近1206，因此用前者填充
#reindex_like的作用为生成一个横纵索引完全与参数列表一致的DataFrame，数据使用被调用的表
df_temp = pd.DataFrame({'Weight':np.zeros(5),
                        'Height':np.zeros(5),
                        'ID':[1101,1104,1103,1106,1102]}).set_index('ID')
df_temp.reindex_like(df[0:5][['Weight','Height']])
#如果df_temp单调还可以使用method参数：
df_temp = pd.DataFrame({'Weight':range(5),
                        'Height':range(5),
                        'ID':[1101,1104,1103,1106,1102]}).set_index('ID').sort_index()
df_temp.reindex_like(df[0:5][['Weight','Height']],method='bfill')
#可以自行检验这里的1105的值是否是由bfill规则填充
#用level参数指定哪一层被reset，用col_level参数指定set到哪一层：
L1,L2 = ['A','B','C'],['a','b','c']
mul_index1 = pd.MultiIndex.from_product([L1,L2],names=('Upper', 'Lower'))
L3,L4 = ['D','E','F'],['d','e','f']
mul_index2 = pd.MultiIndex.from_product([L3,L4],names=('Big', 'Small'))
df_temp = pd.DataFrame(np.random.rand(9,9),index=mul_index1,columns=mul_index2)

更新pg索引 索引的更新_更新pg索引_04

df_temp1 = df_temp.reset_index(level=1,col_level=1)
df_temp1.head()

更新pg索引 索引的更新_python_05

#rename_axis是针对多级索引的方法，作用是修改某一层的索引名，而不是索引标签
df_temp.rename_axis(index={'Lower':'LowerLower'},columns={'Big':'BigBig'})
df_temp.rename(index={'A':'T'},columns={'e':'changed_e'}).head()
#rename方法用于修改列或者行索引标签，而不是索引名

4、常用索引函数

常用索引函数包括where()、mask()、query等。

#1. where()函数
df.where(df['Gender']=='M').head()# 不满足条件的行全部被设置为NaN
df.where(df['Gender']=='M').dropna().head()# 通过这种方法筛选结果和[]操作符的结果完全一致
df.where(df['Gender']=='M',np.random.rand(df.shape[0],df.shape[1])).head()#第一个参数为布尔条件，第二个参数为填充值

对不满足布尔条件的根据可以通过第二个参数的设置进行填充。

更新pg索引 索引的更新_Math_06


mask函数与where功能上相反，其余完全一致，即对条件为True的单元进行填充

#2、mask函数
df.mask(df['Gender']=='M').dropna().head()#只会显示'Gender'不是'M'的观测
df.mask(df['Gender']=='M',np.random.rand(df.shape[0],df.shape[1])).head()##显示出所有'Gender'不是M的观测，对于满足条件的则根据第二个参数填充

更新pg索引 索引的更新_多列_07


query函数中的布尔表达式中，下面的符号都是合法的：行列索引名、字符串、and/not/or/&/|/~/not in/in/==/!=、四则运算符

#query函数
df.query('(Address in ["street_6","street_7"])&(Weight>(70+10))&(ID in [1303,2304,2402])')#s三个约束条件，可以多种符号，比较灵活

5、重复值

#重复元素判断
#1. duplicated方法，该方法返回了是否重复的布尔列表
df.duplicated('Class').head()#可选参数keep默认为keep='first'，即首次出现设为不重复为false，其余为TRUE
df.duplicated('Class',keep='last').tail()#keep='first'则最后一次设为不重复显示为false，其余为TRUE
df.duplicated('Class',keep=False).head()#keep=False则所有重复项为TRUE
# 剔除重复项，drop_duplicates方法
df.drop_duplicates('Class')
#参数与duplicate函数类似：
df.drop_duplicates('Class',keep='last')#去除Class相同的观测，保留重复值中最后一个
df.drop_duplicates(['School','Class'])#在传入多列时等价于将多列共同视作一个多级索引，比较多列同时重复项

6、抽样

pandas中自带抽样方法，涉及多个参数,包括常用抽样个数n、抽样比例frac、是否有放回relpace、抽样维度axis、抽样权重weights等。

DataFrame.sample(n=None, frac=None, replace=False, axis=None，weights=None, random_state=None, )
#这里的抽样函数指的就是sample函数
df.sample(n=5)#n为样本量
df.sample(frac=0.05)#frac是抽样比例
df.sample(n=df.shape[0],replace=True).head()#replace为是否放回
df.sample(n=35,replace=True).index.is_unique#返回一个布尔判断结果false，对于有放回的随机抽样，索引不是唯一的，可以有相同
df.sample(n=3,axis=0)#axis为抽样维度，默认为0，此处是随机取出3行观测
df.sample(n=3,axis=1)#此处随机取出三列属性对应所有行观测
df.sample(n=3,weights=np.random.rand(df.shape[0]))#weights为样本权重，自动归一化，#np.random.rand(df.shape[0])会生成数据集行数35个在【0,1）均匀分布的随机数，对应权重越大，越大概率被随机选到
#以某一列为权重，根据属性大小值相应权重，这在抽样理论中很常见
df.sample(n=3,weights=df['Math']).head()

更新pg索引 索引的更新_数据分析_08

7、具体案例分析

【练习一】 一份关于UFO的数据集

df = pd.read_csv('C:/Users/Kingfish/Desktop/joyful-pandas/joyful-pandas/data/UFO.csv')
df.head()
#（a）在所有被观测时间超过60s的时间中，哪个形状最多？
S1=df[(df['duration (seconds)']>60)]
S1['shape'].value_counts().index[0]
#答案是'light'
#（b）对经纬度进行划分：-180°至180°以30°为一个划分，-90°至90°以18°为一个划分，请问哪个区域中报告的UFO事件数量最多？
bins_long = np.linspace(-180,180,13).tolist()
bins_la = np.linspace(-90,90,11).tolist()
cuts_long = pd.cut(df['longitude'],bins=bins_long)
df['cuts_long'] = cuts_long
cuts_la = pd.cut(df['latitude'],bins=bins_la)
df['cuts_la'] = cuts_la
df.set_index(['cuts_long','cuts_la']).index.value_counts().head()

【练习二】 关于口袋妖怪的数据集

df1 = pd.read_csv('C:/Users/Kingfish/Desktop/joyful-pandas/joyful-pandas/data/Pokemon.csv')
#（a）双属性的Pokemon占总体比例的多少？
df11['Type 2'].count()/df1.shape[0]

#（b）在所有种族值（Total）不小于580的Pokemon中，非神兽（Legendary=False）的比例为多少？
df1.query('Total >= 580')['Legendary'].value_counts(normalize=True)

#（c）在第一属性为格斗系（Fighting）的Pokemon中，物攻排名前三高的是哪些？
df1[df1['Type 1']=='Fighting'].sort_values(by='Attack',ascending=False).iloc[:3]