本篇文章出自于《利用Python进行数据分析》示例数据
GroupLens实验室提供了一些从MoviesLens用户那里收集的20世纪90年代末到21世纪初的电影评分数据的集合。浙西数据提供了电影的评分、流派、年份和观众数据（年龄、邮编、性别、职业） 。
MovisLens1M数据集包含6000 个用户对4000 部电影的100万 个评分。数据分布在三个表格之中：分别包含评分、用户信息和电影信息 。
(1) 首先载入一些python数据分析的库，并且给予它们简称。
import numpy as np
import pandas as pd
import matplotlib. pyplot as plt
import seaborn as sns
(2)
unames = [ "user_id" , "gender" , "age" , "occupation" , "zip" ]
users = pd. read_table( "datasets/movielens/users.dat" , sep= "::" ,
header= None , names= unames, engine= "python" )
rnames = [ "user_id" , "movie_id" , "rating" , "timestamp" ]
ratings = pd. read_table( "datasets/movielens/ratings.dat" , sep= "::" ,
header= None , names= rnames, engine= "python" )
mnames = [ "movie_id" , "title" , "genres" ]
movies = pd. read_table( "datasets/movielens/movies.dat" , sep= "::" ,
header= None , names= mnames, engine= "python" )
unames代表用户信息 rnames代表评分信息 mnames代表电影信息 下面介绍一下pd.read_tablie的用法：
第一个参数是filepath_or_buffer(文件)
第二个参数是sep(分隔符) 逗号 分隔
第三个参数是 header(表头)
第四个参数是names(列名)
第五个参数是engine(引擎)
当然，参数不止这些，但需要使用的话可搜索pandas文档。
分析功能：
用户信息表（users）：这段代码从文件users.dat中读取用户信息数据，并创建了一个名为users的DataFrame对象。使用read_table函数指定了文件路径、分隔符为::，没有指定列名行，而是使用了自定义的列名列表unames。engine="python"参数指定使用Python解析引擎。数据中的列包括用户ID、性别、年龄、职业和邮编。 评分表（ratings）：这段代码从文件ratings.dat中读取评分数据，并创建了一个名为ratings的DataFrame对象。同样，使用了read_table函数指定了文件路径、分隔符为::，没有指定列名行，而是使用了自定义的列名列表rnames。数据中的列包括用户ID、电影ID、评分和时间戳。 电影信息表（movies）：这段代码从文件movies.dat中读取电影信息数据，并创建了一个名为movies的DataFrame对象。同样，使用了read_table函数指定了文件路径、分隔符为::，没有指定列名行，而是使用了自定义的列名列表mnames。数据中的列包括电影ID、标题和流派。 （3）
users. head( 5 )
ratings. head( 5 )
movies. head( 5 )
ratings
输出结果： 分析功能：
上述代码将打印出users、ratings和movies的前5行数据，并显示ratings的整个DataFrame。 (4)
data = pd. merge( pd. merge( ratings, users) , movies)
data
data. iloc[ 0 ]
输出结果：
使用pd.merge()函数将ratings、users和movies三个DataFrame进行合并，并将结果存储在data中。接下来，使用data打印了整个DataFrame和第一行的数据。 (5)
mean_ratings = data. pivot_table( "rating" , index= "title" ,
columns= "gender" , aggfunc= "mean" )
mean_ratings. head( 5 )
输出结果：
pivot_table()函数以data作为数据源，通过指定"rating"作为值列（要计算的列）、"title"作为行索引列（要进行分组的列）以及"gender"作为列索引列（要进行分组的列），并使用"mean"作为聚合函数，计算了不同电影在不同性别下的平均评分。 通过执行mean_ratings.head(5)，可以查看前5行的结果。 (6)
ratings_by_title = data. groupby( "title" ) . size( )
ratings_by_title. head( )
active_titles = ratings_by_title. index[ ratings_by_title >= 250 ]
active_titles
输出结果： 分析功能：
首先使用groupby()函数对data进行分组，按照电影标题（“title”）进行分组，并使用size()函数计算每个电影标题对应的评分数量。 接下来，使用head()函数查看了前几行的结果，其中每一行代表一个电影标题，对应的值表示该电影标题的评分数量。 然后，根据评分数量筛选出活跃的电影标题，通过使用index属性获取评分数量大于等于250的电影标题索引。这样得到的active_titles是一个包含活跃电影标题的索引列表。 (7)
mean_ratings = mean_ratings. loc[ active_titles]
mean_ratings
输出结果： 分析功能：
使用loc索引器将mean_ratings数据框筛选为只包含活跃电影标题的部分。active_titles是一个索引列表，代表了活跃电影标题的索引。 mean_ratings = mean_ratings. rename( index= { "Seven Samurai (The Magnificent Seven) (Shichinin no samurai) (1954)" :
"Seven Samurai (Shichinin no samurai) (1954)" } )
功能分析：
使用rename()函数将索引中的一个电影标题修改为新的标题。具体来说，将索引中的 “Seven Samurai (The Magnificent Seven) (Shichinin no samurai) (1954)” 修改为 “Seven Samurai (Shichinin no samurai) (1954)”。 (9)
top_female_ratings = mean_ratings. sort_values( "F" , ascending= False )
top_female_ratings. head( )
输出结果： 分析功能：
使用sort_values()函数根据女性观众的平均评分对mean_ratings进行降序排序。 通过top_female_ratings.head()，可以查看排序后的前几行结果。 (10)
mean_ratings[ "diff" ] = mean_ratings[ "M" ] - mean_ratings[ "F" ]
分析功能：
首先，代码使用mean_ratings[“M”] - mean_ratings[“F”]计算了男性和女性用户对每部电影的平均评分之差。 然后，使用赋值语句将结果存储在mean_ratings的新列"diff"中。 最终，mean_ratings 多了一列"diff"，表示男性和女性用户对每部电影的平均评分之差。 (11)
sorted_by_diff = mean_ratings. sort_values( "diff" )
sorted_by_diff. head( )
输出结果： 分析功能：
这段代码使用sort_values函数对mean_ratings按照"diff"列进行排序。sort_values函数的第一个参数是要排序的列名，这里是"diff"。由于没有指定ascending参数，所以默认按升序排序。 最终生成一个新的DataFrame对象，命名为sorted_by_diff。然后，代码使用.head()函数显示了sorted_by_diff的前五行数据。 (12)
sorted_by_diff[ : : - 1 ] . head( )
输出结果： 分析功能：
这段代码使用切片语法[::-1]来翻转sorted_by_diff的顺序，然后使用.head()函数显示了翻转后的前五行数据。 (13)
rating_std_by_title = data. groupby( "title" ) [ "rating" ] . std( )
rating_std_by_title = rating_std_by_title. loc[ active_titles]
rating_std_by_title. head( )
输出结果： 分析功能：
这段代码首先使用 groupby 函数对 data 按照 “title” 列进行分组，然后使用 std 函数计算每组的标准差，也就是每部电影的评分标准差。最终生成一个新的 Series 对象，命名为 rating_std_by_title。 接下来，代码使用 .loc[] 选择器来选择 rating_std_by_title 中行索引在 active_titles 中的行。最终，rating_std_by_title 只包含了评分数量大于等于 250 的电影的评分标准差数据。 然后，代码使用 .head() 函数显示了 rating_std_by_title 的前五行数据。 (14)
rating_std_by_title. sort_values( ascending= False ) [ : 10 ]
输出结果： 分析功能：
这段代码使用 sort_values 函数对 rating_std_by_title 进行排序。sort_values 函数的第一个参数 ascending=False 表示按降序排序。然后，使用切片语法 [:10] 来选择排序后的前十行数据。 (15)
movies[ "genres" ] . head( )
movies[ "genres" ] . head( ) . str . split( "|" )
movies[ "genre" ] = movies. pop( "genres" ) . str . split( "|" )
movies. head( )
输出结果： 分析功能：
这段代码首先使用 .head() 函数显示了 movies 的 “genres” 列的前五行数据。 接下来，代码使用 .str.split(“|”) 函数来分割 “genres” 列中的字符串。.str.split(“|”) 函数会将每个字符串按照 “|” 分隔符分割成一个列表。然后，代码使用 .head() 函数显示了分割后的前五行数据。 然后，代码使用 pop 函数弹出了 movies 的 “genres” 列，并将其分割后的结果存储在新列 “genre” 中。pop 函数会从 DataFrame 对象中弹出指定的列，并返回该列的数据。 最后，代码使用 .head() 函数显示了更新后的 movies 的前五行数据。现在，movies 多了一列 “genre”，表示电影类型的列表。 (16)
movies_exploded = movies. explode( "genre" )
movies_exploded[ : 10 ]
输出结果： 分析功能；
这段代码使用 explode 函数将 movies 的 “genre” 列拆分成多行。explode 函数会将指定列中的列表拆分成多行，每行包含列表中的一个元素。 最终生成一个新的 DataFrame 对象，命名为 movies_exploded。然后，代码使用切片语法 [:10] 来选择前十行数据。 (17)
ratings_with_genre = pd. merge( pd. merge( movies_exploded, ratings) , users)
ratings_with_genre. iloc[ 0 ]
genre_ratings = ( ratings_with_genre. groupby( [ "genre" , "age" ] )
[ "rating" ] . mean( )
. unstack( "age" ) )
genre_ratings[ : 10 ]
输出结果： 分析功能：
这段代码首先使用 pd.merge() 函数将 movies_exploded、ratings 和 users 三个 DataFrame 对象合并在一起。最终生成一个新的 DataFrame 对象，命名为 ratings_with_genre。 接下来，代码使用 .iloc[0] 选择器来获取 ratings_with_genre 的第一行数据。 然后，代码使用 groupby 函数对 ratings_with_genre 按照 “genre” 和 “age” 列进行分组，然后使用 mean 函数计算每组的平均值，也就是每个类型和年龄段的平均评分。最后使用 unstack 函数将 “age” 列拆分成多列。 最终生成一个新的 DataFrame 对象，命名为 genre_ratings。然后，代码使用切片语法 [:10] 来选择前十行数据。 美国社会保障局（SSA）提供了从1880年至现在的婴儿姓名频率的数据。可以使用这些数据做很多事情：
(1)
!head - n 10 datasets/ babynames/ yob1880. txt
分析功能：
这段代码使用了Python中的pandas库来读取一个名为"yob1880.txt"的CSV文件。该文件包含了1880年的婴儿名字相关的数据，包括"姓名"、“性别"和"出生数"等列。通过在names参数中指定"姓名”、"性别"和"出生数"这些列的名称，可以将适当的列标签赋予DataFrame。 (2)
names1880 = pd. read_csv( "datasets/babynames/yob1880.txt" ,
names= [ "name" , "sex" , "births" ] )
names1880
输出结果：
首先，groupby(“sex”) 将数据按照 “sex” 列的不同取值进行分组。这将创建两个组，一个是男性 (“M”)，另一个是女性 (“F”)。 然后，[“births”] 选择了分组后的每个组中的 “births” 列。 最后，.sum() 对选定的 “births” 列进行求和操作，计算每个组中的出生数总和。 总结起来，这行代码的作用是计算在名为 names1880 的 DataFrame 中，按照性别分组后，每个组的出生数总和。 (3)
names1880. groupby( "sex" ) [ "births" ] . sum ( )
输出结果： 分析功能：
首先，创建了一个空列表pieces来存储每年的DataFrame。 然后，通过循环从1880年到2010年（不包括2011年），构建每个年份对应的文件路径。文件路径中的年份是通过{year}的方式动态插入到字符串中的。 接下来，使用pd.read_csv函数读取每个文件，并指定列名为[“name”, “sex”, “births”]，将每个年份的数据读取为一个DataFrame。 随后，通过添加一个名为"year"的列来为每个DataFrame增加一个年份信息，该列的值为当前循环的年份。 每次循环，将读取的DataFrame追加到pieces列表中。 循环结束后，使用pd.concat函数将所有的DataFrame连接成一个单一的DataFrame，设置ignore_index=True参数来重置索引，确保索引是连续的。 最终得到的names DataFrame 包含了从1880年到2010年的所有婴儿名字数据，其中每一行表示一个特定年份的婴儿名字数据。 (4)
pieces = [ ]
for year in range ( 1880 , 2011 ) :
path = f"datasets/babynames/yob { year} .txt" = pd. read_csv( path, names= [ "name" , "sex" , "births" ] )
frame[ "year" ] = year
pieces. append( frame)
names = pd. concat( pieces, ignore_index= True )
names
输出结果： 分析功能：
首先，total_births是通过使用pivot_table函数计算得到的。该函数用于创建数据透视表，其中"births"列被用作值，"year"列作为行索引，"sex"列作为列索引。聚合函数sum被应用于"births"列，以计算每个年份和性别的出生总数。这样，total_births是一个新的DataFrame，其中的行表示年份，列表示性别，单元格的值是每个年份和性别的出生总数。 接下来，total_births.tail()用于显示total_births DataFrame 的最后几行，这将输出最近几年的数据。 最后，total_births.plot(title=“Total births by sex and year”)用于将total_births DataFrame 的数据绘制成一个图表。图表的标题为"Total births by sex and year"，横轴表示年份，纵轴表示出生总数。图表的形式可以根据数据的分布和趋势进行进一步的分析和可视化。 (5)
total_births = names. pivot_table( "births" , index= "year" ,
columns= "sex" , aggfunc= sum )
total_births. tail( )
total_births. plot( title= "Total births by sex and year" )
输出结果： 分析功能：
函数add_prop接受一个分组（group）作为输入，并对该分组进行操作。在这种情况下，分组是根据"year"和"sex"两列进行的。在函数内部，通过计算每个分组中的"births"列占该分组总出生数的比例，将结果保存在一个名为"prop"的新列中。这是通过将"births"列除以该分组中"births"列的总和来实现的。最后，函数返回被操作后的分组。 接下来，names DataFrame 被按照"year"和"sex"两列进行分组，并通过groupby函数进行分组操作。group_keys=False参数表示不将分组的键作为索引。 然后，apply函数将add_prop函数应用于每个分组。这将在每个分组上执行add_prop函数中定义的操作，即计算每个分组中"births"列的比例，并将结果保存在"prop"列中。 最终，返回一个新的DataFrame names，其中包含添加了"prop"列的每个分组的数据。这使得我们可以分析每个年份和性别中每个名字在其所在组中的比例。 (6)
def add_prop ( group) :
group[ "prop" ] = group[ "births" ] / group[ "births" ] . sum ( )
return group
names = names. groupby( [ "year" , "sex" ] , group_keys= False ) . apply ( add_prop)
names
输出结果： 分析功能：
首先，groupby([“year”, “sex”]) 将数据按照 “year” 和 “sex” 两列进行分组。这将创建一个多级索引，其中第一级索引为 “year”，第二级索引为 “sex”。 然后，[“prop”] 选择了分组后的每个组中的 “prop” 列。这是在之前的步骤中使用 add_prop 函数计算并添加到 DataFrame 中的比例列。 最后，.sum() 对选定的 “prop” 列进行求和操作，计算每个组中的比例总和。 (7)
names. groupby( [ "year" , "sex" ] ) [ "prop" ] . sum ( )
输出结果： 分析功能：
get_top1000 函数接受一个分组（group）作为输入，并根据"births"列的值降序排序该分组。然后，返回排序后的前1000行数据。这样，该函数返回每个分组中出生数最高的1000个记录。 接下来，names DataFrame 被按照 “year” 和 “sex” 两列进行分组，并使用 groupby 函数进行分组操作。这将创建一个分组对象 grouped 然后，apply 函数将 get_top1000 函数应用于每个分组。这将在每个分组上执行 get_top1000 函数中定义的操作，即按出生数降序排序，并返回每个分组中的前1000行数据。 最后，将返回的结果赋值给 top1000，它将是一个包含每个年份和性别组合中出生数最高的1000个记录的新 DataFrame。 (8)
def get_top1000 ( group) :
return group. sort_values( "births" , ascending= False ) [ : 1000 ]
grouped = names. groupby( [ "year" , "sex" ] )
top1000 = grouped. apply ( get_top1000)
top1000. head( )
输出结果： 分析功能：
首先，top1000.reset_index(drop=True) 用于重置 top1000 DataFrame 的索引。设置 drop=True 参数表示重置索引时不保留原有的索引列。通过重置索引，可以将索引重新设置为连续的整数序列。 然后，top1000.head() 用于显示重置索引后的 top1000 DataFrame 的前几行数据。这将输出重置索引后的 DataFrame 的前几行，以便查看数据。 总结起来，这段代码的作用是将 top1000 DataFrame 的索引重置为连续的整数序列，并显示重置索引后的 DataFrame 的前几行数据。这样做可以更方便地访问和处理数据，并确保索引的一致性 (9)
top1000 = top1000. reset_index( drop= True )
(10)
top1000. head( )
输出结果： 分析功能：
首先，boys = top1000[top1000[“sex”] == “M”] 用于从 top1000 DataFrame 中筛选出性别为男性的记录。这将创建一个新的 DataFrame boys，其中包含了所有性别为男性的记录。 接下来，girls = top1000[top1000[“sex”] == “F”] 用于从 top1000 DataFrame 中筛选出性别为女性的记录。这将创建一个新的 DataFrame girls，其中包含了所有性别为女性的记录。 然后，total_births = top1000.pivot_table(“births”, index=“year”, columns=“name”, aggfunc=sum) 通过使用 pivot_table 函数，计算每个年份和姓名组合的出生总数。该函数以 “births” 列作为值，“year” 列作为行索引，“name” 列作为列索引。聚合函数 sum 被应用于 “births” 列，以计算每个年份和姓名组合的出生总数。这样，total_births 是一个新的 DataFrame，其中的行表示年份，列表示姓名，单元格的值是每个年份和姓名组合的出生总数。 接下来，total_births.info() 用于显示 total_births DataFrame 的相关信息，包括每列的数据类型和非空值的数量等。 然后，subset = total_births[[“John”, “Harry”, “Mary”, “Marilyn”]] 从 total_births DataFrame 中筛选出特定的姓名列，包括 “John”、“Harry”、“Mary” 和 “Marilyn”。这将创建一个新的 DataFrame subset，其中只包含这些特定姓名的列。 最后，subset.plot(subplots=True, figsize=(12, 10), title=“Number of births per year”) 用于将 subset DataFrame 的数据绘制成一个图表。每个姓名列将显示在不同的子图中，子图的排列方式为垂直布局。图表的大小为 (12, 10)，标题为 “Number of births per year”。图表可以用来观察每个姓名随时间的出生数变化情况。 (11)
boys = top1000[ top1000[ "sex" ] == "M" ]
girls = top1000[ top1000[ "sex" ] == "F" ]
(12)
total_births = top1000. pivot_table( "births" , index= "year" ,
columns= "name" ,
aggfunc= sum )
(13)
total_births. info( )
subset = total_births[ [ "John" , "Harry" , "Mary" , "Marilyn" ] ]
subset. plot( subplots= True , figsize= ( 12 , 10 ) ,
title= "Number of births per year" )
输出结果：
plt. figure( )
输出结果： 分析功能：
首先，table = top1000.pivot_table(“prop”, index=“year”, columns=“sex”, aggfunc=sum) 使用 pivot_table 函数计算每个年份和性别组合中的比例总和。该函数以 “prop” 列作为值，“year” 列作为行索引，“sex” 列作为列索引。聚合函数 sum 被应用于 “prop” 列，以计算每个年份和性别组合中的比例总和。这样，table 是一个新的 DataFrame，其中的行表示年份，列表示性别，单元格的值是每个年份和性别组合中的比例总和。 接下来，table.plot(title=“Sum of table1000.prop by year and sex”, yticks=np.linspace(0, 1.2, 13)) 用于将 table DataFrame 的数据绘制成一个图表。图表的标题为 “Sum of table1000.prop by year and sex”。横轴表示年份，纵轴表示比例总和。yticks=np.linspace(0, 1.2, 13) 参数用于设置纵轴上的刻度值，np.linspace(0, 1.2, 13) 生成了一个从 0 到 1.2 之间的 13 个均匀间隔的刻度值。这样可以确保纵轴的刻度范围适合数据的取值范围。图表可以用来观察每个年份和性别组合中的比例总和随时间的变化情况。 (15)
table = top1000. pivot_table( "prop" , index= "year" ,
columns= "sex" , aggfunc= sum )
table. plot( title= "Sum of table1000.prop by year and sex" ,
yticks= np. linspace( 0 , 1.2 , 13 ) )
输出结果： 分析功能：
首先，df = boys[boys[“year”] == 2010] 从 boys DataFrame 中筛选出 “year” 列等于 2010 的记录。这将创建一个新的 DataFrame df，其中包含了性别为男性且年份为2010的记录。 (16)
df = boys[ boys[ "year" ] == 2010 ]
df
输出结果： 分析功能：
首先，prop_cumsum = df[“prop”].sort_values(ascending=False).cumsum() 用于对 df DataFrame 的 “prop” 列进行降序排序，并计算其累积和。这将创建一个新的 Series prop_cumsum，其中的每个元素是根据 “prop” 列降序排序后的累积和。 然后，prop_cumsum[:10] 用于显示 prop_cumsum Series 的前10个元素。这将输出累积和排序后的前10个值，用于查看对应的比例累积。 最后，prop_cumsum.searchsorted(0.5) 使用 searchsorted 函数来查找累积和达到或超过0.5的第一个位置。这将返回一个整数，表示第一个累积和超过或等于0.5的索引位置。 (17)
prop_cumsum = df[ "prop" ] . sort_values( ascending= False ) . cumsum( )
prop_cumsum[ : 10 ]
prop_cumsum. searchsorted( 0.5 )
分析功能：
首先，df = boys[boys.year == 1900] 从 boys DataFrame 中筛选出 “year” 列等于 1900 的记录。这将创建一个新的 DataFrame df，其中包含了性别为男性且年份为 1900 的记录。 然后，in1900 = df.sort_values(“prop”, ascending=False).prop.cumsum() 对 df DataFrame 按 “prop” 列进行降序排序，并计算该列的累积和。这将创建一个新的 Series in1900，其中每个元素是根据 “prop” 列降序排序后的累积和。 接下来，in1900.searchsorted(0.5) + 1 使用 searchsorted 函数查找累积和达到或超过 0.5 的第一个位置，并将结果加上 1。这将返回一个整数，表示在 1900 年男性名字中需要多少个名字才能使累积比例超过或等于 0.5。 (18)
df = boys[ boys. year == 1900 ]
in1900 = df. sort_values( "prop" , ascending= False ) . prop. cumsum( )
in1900. searchsorted( 0.5 ) + 1
分析功能：
首先，定义了一个名为 get_quantile_count 的函数。该函数接受一个分组（group）作为输入，并可选地指定一个分位数（默认为 0.5）。在函数内部，对分组按照 “prop” 列的值进行降序排序。然后，计算 “prop” 列的累积和，并使用 searchsorted 函数找到累积和达到或超过指定分位数的第一个位置。最后，返回这个位置加 1，表示达到该分位数所需的数量。 接下来，diversity = top1000.groupby([“year”, “sex”]).apply(get_quantile_count) 对 top1000 DataFrame 进行分组操作。按照 “year” 和 “sex” 两列进行分组，并应用 get_quantile_count 函数。这将在每个分组上执行 get_quantile_count 函数，计算每个年份和性别组合中达到指定分位数的名字数量。 然后，diversity = diversity.unstack() 使用 unstack 函数将多级索引的 Series 转换为 DataFrame。这将将 “year” 列和 “sex” 列的层级索引转换为列，得到一个新的 DataFrame diversity。其中的行表示年份，列表示性别，单元格的值表示每个年份和性别组合中达到指定分位数的名字数量。 (19)
def get_quantile_count ( group, q= 0.5 ) :
group = group. sort_values( "prop" , ascending= False )
return group. prop. cumsum( ) . searchsorted( q) + 1
diversity = top1000. groupby( [ "year" , "sex" ] ) . apply ( get_quantile_count)
diversity = diversity. unstack( )
(20)
fig = plt. figure( )
输出结果： 分析功能：
首先，diversity.head() 用于显示 diversity DataFrame 的前几行数据。这将输出 DataFrame 的前几行，用于查看每个年份和性别组合中达到指定分位数的名字数量。 接下来，diversity.plot(title=“Number of popular names in top 50%”) 用于将 diversity DataFrame 的数据绘制成一个图表。图表的标题为 “Number of popular names in top 50%”。横轴表示年份，纵轴表示达到指定分位数的名字数量。图表可以用来观察每个年份和性别组合中达到指定分位数的名字数量的变化情况。 (21)
diversity. head( )
diversity. plot( title= "Number of popular names in top 50%" )
输出结果： 分析功能：
首先，定义了一个名为 get_last_letter 的函数。该函数接受一个字符串作为输入，并返回该字符串的最后一个字母。 然后，last_letters = names[“name”].map(get_last_letter) 使用 map 函数将 get_last_letter 函数应用于 names[“name”] 列中 
