利用 Pandas 分析 IGN 游戏发行数据（下）

Pandas Series（序列）对象

我们可以通过 Pandas 不同方法来检索一个单个列。到目前为止，我们已经两种类型的语法：

• reviews.iloc[:,1] - 检索第二列

• reviews.loc[:," core_phrase"] - 同样也是第二列

还有第三种，甚至更容易的方式检索整个列。 我们可以在方括号中指定列名，就像字典一样：

reviews["score"]

1. 0         9.0

2. 1         9.0

3. 2         8.5

4. 3         8.5

5. 4         8.5

6. 5         7.0

7. ...
   

8. 29        6.5

9.         ...

10. 18595     4.4

11. 18596     6.5

12. 18597     4.9

13. 18598     6.8

14. 18599     7.0

15. 18600     7.4

16. 18601     7.4

17. 18602     7.4

18. 18603     7.8

19. 18604     8.6

20. ...
    

21. 18620     7.6

22. 18621     9.0

23. 18622     5.8

24. 18623    10.0

25. 18624    10.0

26. Name: score, dtype: float64

我们依然可以使用列表的方式：

reviews[["score", "release_year"]]

score	release_year
0	9.0	2012
1	9.0	2012
2	8.5	2012
27	7.5	2012
28	8.0	2012
29	6.5	2012
...	...	...
18595	4.4	2016
18596	6.5	2016
18597	4.9	2016
18598	6.8	2016
18599	7.0	2016
18600	7.4	2016
18601	7.4	2016
18602	7.4	2016
18603	7.8	2016
18624	10.0	2016

18625 rows × 2 columns

当我们检索单个列时，我们实际上检索了一个 Pandas Series 对象。 DataFrame 存储表格数据，但是 Series 存储单个数据列或行。

我们可以验证单个列是否为系列：

type(reviews["score"])

pandas.core.series.Series

我们可以手动创建一个 Series，以更好地了解它是如何工作的。 创建一个 Series，当我们实例化它时，我们需要将一个 list 类型或 NumPy 数组传递给 Series 对象：

s1 = pd.Series([1, 2])s1

0    11    2dtype: int64

Serise 可以包含任何类型的数据，包括混合类型。 在这里，我们创建一个包含字符串对象的 Serise：

s2 = pd.Series(["Boris Yeltsin", "Mikhail Gorbachev"])s2

0        Boris Yeltsin1    Mikhail Gorbachevdtype: object

通过 Pandas 创建 数据帧 DataFrame

我们可以通过将多个 Series 对象传递给 DataFrame 类来创建一个 DataFrame。 在这里，我们传入我们刚刚创建的两个 Series 对象， s1 作为第一行， s2 作为第二行：

pd.DataFrame([s1, s2])

	0	1
0	1	2
1	Boris Yeltsin	Mikhail Gorbachev

我们也可以通过传递成员为列表的列表来完成同样的事情。 每个内部列表在结果 DataFrame 中被视为一行：

pd.DataFrame(    [        [1,2],        ["Boris Yeltsin", "Mikhail Gorbachev"]    ])

	0	1
0	1	2
1	Boris Yeltsin	Mikhail Gorbachev

我们可以在创建 DataFrame 时指定列标签：

pd.DataFrame(    [        [1,2],        ["Boris Yeltsin", "Mikhail Gorbachev"]    ],    columns=["column1", "column2"])

	column1	column2
0	1	2
1	Boris Yeltsin	Mikhail Gorbachev

同样可以指定行标签（即索引 index ）：

frame = pd.DataFrame(    [        [1, 2],        ["Boris Yeltsin", "Mikhail Gorbachev"]    ],    index=["row1", "row2"],    columns=["column1", "column2"])frame

	column1	column2
row1	1	2
row2	Boris Yeltsin	Mikhail Gorbachev

然后，我们可以使用以下标签对DataFrame建立索引：

frame.loc["row1":"row2", "column1"]

row1                1row2    Boris YeltsinName: column1, dtype: object

如果我们将字典传递给 DataFrame 的构造函数，那么我们可以跳过指定 column 关键字参数。 这将会自动为列设置名称：

frame = pd.DataFrame(    {        "column1": [1, 2],        "column2": ["Boris Yeltsin", "Mikhail Gorbachev"]    })frame

	column1	column2
0	1	Boris Yeltsin
1	2	Mikhail Gorbachev

Pandas DataFrame 方法

正如之前我们提到的，DataFrame 的每一个列都是一个 Series 对象

type(reviews["title"])

pandas.core.series.Series

那些对 DataFrame 适用的方法大多同样也适用于 Series 对象，包括 head：

reviews["title"].head()

0                              LittleBigPlanet PS Vita1    LittleBigPlanet PS Vita -- Marvel Super Hero E...2                                 Splice: Tree of Life3                                               NHL 134                                               NHL 13Name: title, dtype: object

Pandas Series 和 DataFrames 中也有其他方法，使计算更简单。 例如，我们可以使用 pandas.Series.mean 方法来查找一个 Series 的平均值：

reviews['score'].mean()

6.950459060402685

我们也可以调用类似的 pandas.DataFrame.mean 方法，它将在默认情况下找到 DataFrame 中每个数字列的平均值：

reviews.mean()

score               6.950459release_year     2006.515329release_month       7.138470release_day        15.603866dtype: float64

我们可以通过给 mean 方法添加 axis关键字参数，用来计算每行或者每列的平均值。 axis 的缺省值为 0 ，并计算每一列的平均值。也可以设置为 1 来计算每一行的平均值。请注意，这只会计算每一行中类型为数值的平均值：

reviews.mean(axis=1)

1. 0        510.500

2. 1        510.500

3. 2        510.375

4. 3        510.125

5. 4        510.125

6. 5        509.750

7. 6        508.750

8. 7        510.250

9. 8        508.750

10. 9        509.750

11. 
    

12.          ...

13. 18595    510.850

14. 18596    510.875

15. 18597    510.225

16. 18598    510.700

17. 18599    510.750

18. 18600    512.600

19. 18601    512.600

20. 18602    512.600

21. 18603    512.450

22. 18604    512.400

23. 18605    511.500

24. 18606    508.600

25. 18607    510.750

26. 18608    510.350

27. 18609    510.750

28. 18610    510.250

29. 18611    508.700

30. 18612    509.200

31. 18613    508.000

32. 18614    515.050

33. 18615    515.050

34. 18616    508.375

35. 18617    508.600

36. 18618    515.025

37. 18619    514.725

38. 18620    514.650

39. 18621    515.000

40. 18622    513.950

41. 18623    515.000

42. 18624    515.000

43. dtype: float64

在 Series 和 DataFrames 上有很多方法，它们的行为类似于 mean。 这里有一些常见的：

• pandas.DataFrame.corr – 查找 DataFrame 中列之间的相关性。

• pandas.DataFrame.count – 计算每个 DataFrame 列中的非空值的数量。

• pandas.DataFrame.max – 查找每个列中的最大值。

• pandas.DataFrame.min – 查找每个列中的最小值。

• pandas.DataFrame.median – 查找每列的中位数。

• pandas.DataFrame.std – 查找每列的标准差。

我们可以使用 corr 方法来查看是否有任何列与 score 相关。 例如，通过这种方式我们可以得到，最近发布的游戏是否获得了更高的评价（releaseyear），或者是否年底发布的游戏得分更好（releasemonth）：

reviews.corr()

如上所述，我们的数字列都不与 score 相关，这意味着发布时间与审核分数没有线性关系。

Dataframe Math with Pandas

我们还可以对 Series 或 DataFrame 对象执行数学运算。 例如，我们可以将核心列中的每个值除以 2，将比例从 0-10 切换到 0-5：

reviews["score"] / 2

1. 0        4.50

2. 1        4.50

3. 2        4.25

4. 3        4.25

5. 4        4.25

6. 5        3.50

7. 6        1.50

8. 7        4.50

9. 8        1.50

10. 9        3.50

11. 10       3.75

12. 11       3.75

13. 12       3.50

14. 13       4.50

15. 14       4.50

16. 15       3.25

17. 16       3.25

18. ...
    

19. 29       3.25

20.         ...

21. 18595    2.20

22. 18596    3.25

23. 18597    2.45

24. 18598    3.40

25. 18599    3.50

26. 18600    3.70

27. 18601    3.70

28. 18602    3.70

29. ...
    

30. 18612    3.90

31. 18613    4.00

32. 18614    4.60

33. 18615    4.60

34. 18616    3.75

35. 18617    4.20

36. 18618    4.55

37. 18619    3.95

38. 18620    3.80

39. 18621    4.50

40. 18622    2.90

41. 18623    5.00

42. 18624    5.00

43. Name: score, dtype: float64

在 Python 中所有常见数学运算符（如 +， - ， *， /和 ^）对于 DataFrame 或 Series 都起作用，并且对其中的每个元素也都适用。

Boolean Indexing in Pandas

如上所述， reviews 的 score 列中的所有值的平均值大约为 7。 我们如何找到所有得分超过这个平均分的游戏呢？ 通长开始我们会做比较，将 Series 中的每个值与指定值进行比较，然后生成一个布尔类型的 Series，用来表示比较的状态。 例如，我们可以看到哪些行的 score 值大于 7：

score_filter = reviews["score"] > 7score_filter

1. 0         True

2. 1         True

3. 2         True

4. 3         True

5. 4         True

6. 5        False

7. 6        False

8. 7         True

9. ...
   

10. ...
    

11. 
    

12. 18604     True

13. 18605    False

14. 18606    False

15. 18607    False

16. 18608    False

17. 18609     True

18. 18610    False

19. 18611    False

20. 18612     True

21. 18613     True

22. 18614     True

23. 18615     True

24. 18616     True

25. 18617     True

26. 18618     True

27. 18619     True

28. 18620     True

29. 18621     True

30. 18622    False

31. 18623     True

32. 18624     True

33. Name: score, dtype: bool

一旦我们有一个 Boolean Series，我们可以使用它只选择 DataFrame 中的 Series 值 为 True 行。 因此，我们可以从 reviews 中只选择 score 大于 7 的行：

filtered_reviews = reviews[score_filter]filtered_reviews.head()

可以使用多个条件进行过滤。 让我们找找在 Xbox One 发布得分超过 7 的游戏。 在下面的代码中：

• 为过滤器设置两个条件：

• 检查 score 是否大于 7

• 检查 platform 是否是 Xbox One

  • 给 reviews 应用上边的顾虑器来获取我们想要的行。

• 使用 head 方法打印 filtered_review的前 5 行。

xbox_one_filter = (reviews['score'] > 7) & (reviews['platform']=='Xbox one')filter_reviews = reviews[xbox_one_filter]filtered_reviews.head()

当使用多个条件进行过滤时，将每个过滤条件放在括号中，并用 & 符号把它们连接起来。

Pandas Plotting

现在我们知道如何进行过滤，我们可以创建图来观察 Xbox One 的评论分布与 PS 4 的评论分布。 这将帮助我们了解哪个平台有更好的游戏。 我们可以通过直方图来做到这一点，这将绘制不同得分范围的游戏出现的次数，这将告诉我们哪个平台更多的高评级游戏。

我们可以使用 pandas.DataFrame.plot 方法，为每个平台创建一个直方图。这个方法利用流行的 Python 绘图库 matplotlib，从而生成好看的图标。

译者注： pip3 install matplotlib 安装 matplotlib 包

绘图方法默认为绘制线图。 我们需要传入关键字参数 kind=“hit” 来绘制一个直方图。

在下面的代码中，我们：

• 在 Jupyter notebook 中调用 ％matplotlib inline 设置绘图。

• 从 reviews 中筛选只有 Xbox One 的数据。

• 绘制 score列。

%matplotlib inlinereviews[reviews["platform"] == "Xbox One"]["score"].plot(kind="hist")

<matplotlib.axes._subplots.AxesSubplot at 0x113988860>

我们同样可以绘制 PS 4 的直方图：

reviews[reviews["platform"] == "PlayStation 4"]["score"].plot(kind="hist")

<matplotlib.axes._subplots.AxesSubplot at 0x113a8d588>

从直方图看来，PS 4 具有比 Xbox One 更多的高评级游戏。

filtered_reviews["score"].hist()

<matplotlib.axes._subplots.AxesSubplot at 0x113cb6b70>

---

题图：pexels，CC0 授权。