Python中布尔索引的使用

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

展示表格基本信息

# 读取movie，设定行索引是movie_title
pd.options.display.max_columns = 50
movie = pd.read_csv('data/movie.csv', index_col='movie_title')
movie.head()

一、计算布尔值统计信息 

# 判断电影时长是否超过两小时
movie_2_hours = movie['duration'] > 120
movie_2_hours.head(10)
'''
movie_title
Avatar                                         True
Pirates of the Caribbean: At World's End       True
Spectre                                        True
The Dark Knight Rises                          True
Star Wars: Episode VII - The Force Awakens    False
John Carter                                    True
Spider-Man 3                                   True
Tangled                                       False
Avengers: Age of Ultron                        True
Harry Potter and the Half-Blood Prince         True
Name: duration, dtype: bool
'''

# 有多少时长超过两小时的电影
movie_2_hours.sum()
#1039
# 超过两小时的电影的比例
movie_2_hours.mean()
#0.2113506916192026

# 用describe()输出一些该布尔Series信息
movie_2_hours.describe()
# count：总个数
# unique：表示有多少种不同的值
# top：数据中出现次数最高的值
# freq：出现次数最高的那个值（top）的出现频率

count      4916
unique        2
top       False
freq       3877
Name: duration, dtype: object

# 实际上，dureation这列是有缺失值的，要想获得真正的超过两小时的电影的比例，需要先删掉缺失值
movie['duration'].dropna().gt(120).mean() #gt(120)是大于120分钟是 greater than
#107.0907977963681

原理
# 统计False和True值的比例
movie_2_hours.value_counts(normalize=True)
'''
False    0.788649
True     0.211351
Name: duration, dtype: float64
'''

# 比较同一个DataFrame中的两列
actors = movie[['actor_1_facebook_likes', 'actor_2_facebook_likes']].dropna()
(actors['actor_1_facebook_likes'] > actors['actor_2_facebook_likes']).mean()
#0.9777687130328371

二、构建多个布尔条件

# 创建多个布尔条件
criteria1 = movie.imdb_score > 8
criteria2 = movie.content_rating == 'PG-13'
criteria3 = (movie.title_year < 2000) | (movie.title_year >= 2010)
criteria2.head()   
'''
movie_title
Avatar                                         True
Pirates of the Caribbean: At World's End       True
Spectre                                        True
The Dark Knight Rises                          True
Star Wars: Episode VII - The Force Awakens    False
Name: content_rating, dtype: bool
'''

# 将这些布尔条件合并成一个
criteria_final = criteria1 & criteria2 & criteria3
criteria_final.head()

movie_title
Avatar                                        False
Pirates of the Caribbean: At World's End      False
Spectre                                       False
The Dark Knight Rises                          True
Star Wars: Episode VII - The Force Awakens    False
dtype: bool

#在Pandas中，位运算符（&, |, ~）的优先级高于比较运算符，因此前面的运算需要添加括号
(movie.title_year < 2000)| movie.title_year > 2009

movie_title
Avatar                                        False
Pirates of the Caribbean: At World's End      False
Spectre                                       False
The Dark Knight Rises                         False
Star Wars: Episode VII - The Force Awakens    False
                                              ...  
Signed Sealed Delivered                       False
The Following                                 False
A Plague So Pleasant                          False
Shanghai Calling                              False
My Date with Drew                             False
Name: title_year, Length: 4916, dtype: bool

三、用布尔索引过滤

# 读取movie数据集，创建布尔条件
movie = pd.read_csv('data/movie.csv', index_col='movie_title')
crit_a1 = movie.imdb_score > 8
crit_a2 = movie.content_rating == 'PG-13'
crit_a3 = (movie.title_year < 2000) | (movie.title_year > 2009)
final_crit_a = crit_a1 & crit_a2 & crit_a3

# 创建第二个布尔条件
crit_b1 = movie.imdb_score < 5
crit_b2 = movie.content_rating == 'R'
crit_b3 = (movie.title_year >= 2000) & (movie.title_year <= 2010)
final_crit_b = crit_b1 & crit_b2 & crit_b3

# 将这两个条件用或运算合并起来
final_crit_all = final_crit_a | final_crit_b
final_crit_all.head()
'''
movie_title
Avatar                                        False
Pirates of the Caribbean: At World's End      False
Spectre                                       False
The Dark Knight Rises                          True
Star Wars: Episode VII - The Force Awakens    False
dtype: bool
'''
# 用最终的布尔条件过滤数据
movie[final_crit_all].head()

# 使用loc，对指定的列做过滤操作，可以清楚地看到过滤是否起作用
cols = ['imdb_score', 'content_rating', 'title_year']
movie_filtered = movie.loc[final_crit_all, cols]
movie_filtered.head(10)

# 用一个长布尔表达式代替前面由短表达式生成的布尔条件((movie.title_year < 2000) | (movie.title_year > 2009))
final_crit_a2 = (movie.imdb_score > 8) & \
                         (movie.content_rating == 'PG-13') & \
                         ((movie.title_year < 2000) | (movie.title_year > 2009))
final_crit_a2.equals(final_crit_a)
#True

四、用标签索引代替布尔索引

# 用布尔索引选取所有得克萨斯州的学校
college = pd.read_csv('data/college.csv')
college[college['STABBR'] == 'TX'].head()

# 用STABBR作为行索引，然后用loc选取
college2 = college.set_index('STABBR')
college2.loc['TX'].head()

# 比较二者的速度(使用loc比直接取值更节省时间)
%timeit college[college['STABBR'] == 'TX']
#4.33 ms ± 743 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit college2.loc['TX']
#2.05 ms ± 327 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

# 使用STABBR作为行索引所用的时间
%timeit college2 = college.set_index('STABBR')
#6.83 ms ± 1.35 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)

使用布尔索引和标签选取多列isin()

# 使用布尔索引和标签选取多列
states =['TX', 'CA', 'NY']
college[college['STABBR'].isin(states)]
college2.loc[states].head()

五. 用唯一和有序索引选取

# 读取college数据集，使用STABBR作为行索引，检查行索引是否有序
college = pd.read_csv('data/college.csv')
college2 = college.set_index('STABBR')

college2.index.is_monotonic #检验一个数组是否是单调的,先确定一个方向，然后遍历这个数组，看看是否破坏之前的方向。破坏就是不单调
#False

# 将college2排序，存储成另一个对象，查看其是否有序
college3 = college2.sort_index()
college3.index.is_monotonic
#True

# 从这三个DataFrame选取得克萨斯州，比较速度
%timeit college[college['STABBR'] == 'TX']
#4.32 ms ± 1.11 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit college2.loc['TX']
#2.63 ms ± 395 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit college3.loc['TX']
#942 µs ± 235 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

# 使用INSTNM作为行索引，检测行索引是否唯一
college_unique = college.set_index('INSTNM')
college_unique.index.is_unique
#True

# 用布尔索引选取斯坦福大学
college[college['INSTNM'] == 'Stanford University']

# 用行索引标签选取斯坦福大学
college_unique.loc['Stanford University']

# 比较两种方法的速度(直接索引慢一点)
%timeit college[college['INSTNM'] == 'Stanford University']
#3.89 ms ± 745 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit college_unique.loc['Stanford University']
#597 µs ± 87.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

# 使用CITY和STABBR两列作为行索引，并进行排序
college.index = college['CITY'] + ', ' + college['STABBR']
college = college.sort_index()
college.head()

# 选取所有Miami, FL的大学
college.loc['Miami, FL'].head()

# 速度比较
%timeit crit1 = college['CITY'] == 'Miami' 
crit2 = college['STABBR'] == 'FL'
college[crit1 & crit2]
#2.3 ms ± 826 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit college.loc['Miami, FL']
#1.01 ms ± 199 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

# 判断这两个条件是否相同
college[(college['CITY'] == 'Miami') & (college['STABBR'] == 'FL')].equals(college.loc['Miami, FL'])
#True

loc索引消耗的时间比直接取值用时少。