Pandas教程：使用Python进行数据分析：第1部分

Python is a great language for doing data analysis, primarily because of the fantastic ecosystem of data-centric Python packages. Pandas is one of those packages, and makes importing and analyzing data much easier. Pandas builds on packages like NumPy and matplotlib to give you a single, convenient, place to do most of your data analysis and visualization work.

Python是进行数据分析的一种出色语言，主要是因为以数据为中心的Python软件包拥有一个奇妙的生态系统。 Pandas是其中的一种，使导入和分析数据更加容易。 Pandas建立在NumPy和matplotlib之类的软件包的基础上，为您提供一个方便，方便的地方来进行大多数数据分析和可视化工作。

In this introduction, we’ll use Pandas to analyze data on video game reviews from IGN, a popular video game review site. The data was scraped by Eric Grinstein, and can be found here. As we analyze the video game reviews, we’ll learn key Pandas concepts like indexing.

在本简介中，我们将使用Pandas分析来自流行视频游戏评论网站IGN的视频游戏评论数据。 数据由Eric Grinstein抓取 ，可以在此处找到。 在分析视频游戏评论时，我们将学习熊猫的关键概念，例如索引。

Do games like the Witcher 3 tend to get better reviews on the PS4 than the Xbox One? This dataset can help us find out.

像《巫师3》这样的游戏是否在PS4上获得比Xbox One更好的评论？ 该数据集可以帮助我们找出答案。

Just as a note, we’ll be using Python 3.5 and Jupyter Notebook to do our analysis.

请注意，我们将使用Python 3.5和Jupyter Notebook进行分析。

用熊猫导入数据 (Importing Data with Pandas)

The first step we’ll take is to read the data in. The data is stored as a comma-separated values, or csv, file, where each row is separated by a new line, and each column by a comma (,). Here are the first few rows of the ign.csv file:

我们将采取的第一步是读取数据。数据以逗号分隔的值或csv文件存储，其中每行用换行分隔，每列用逗号（ , ）分隔。 以下是ign.csv文件的前几行：

,score_phrase,title,url,platform,score,genre,editors_choice,release_year,release_month,release_day
0,Amazing,LittleBigPlanet PS Vita,/games/littlebigplanet-vita/vita-98907,PlayStation Vita,9.0,Platformer,Y,2012,9,12
1,Amazing,LittleBigPlanet PS Vita -- Marvel Super Hero Edition,/games/littlebigplanet-ps-vita-marvel-super-hero-edition/vita-20027059,PlayStation Vita,9.0,Platformer,Y,2012,9,12
2,Great,Splice: Tree of Life,/games/splice/ipad-141070,iPad,8.5,Puzzle,N,2012,9,12
3,Great,NHL 13,/games/nhl-13/xbox-360-128182,Xbox 360,8.5,Sports,N,2012,9,11
,score_phrase,title,url,platform,score,genre,editors_choice,release_year,release_month,release_day
0,Amazing,LittleBigPlanet PS Vita,/games/littlebigplanet-vita/vita-98907,PlayStation Vita,9.0,Platformer,Y,2012,9,12
1,Amazing,LittleBigPlanet PS Vita -- Marvel Super Hero Edition,/games/littlebigplanet-ps-vita-marvel-super-hero-edition/vita-20027059,PlayStation Vita,9.0,Platformer,Y,2012,9,12
2,Great,Splice: Tree of Life,/games/splice/ipad-141070,iPad,8.5,Puzzle,N,2012,9,12
3,Great,NHL 13,/games/nhl-13/xbox-360-128182,Xbox 360,8.5,Sports,N,2012,9,11

As you can see above, each row in the data represents a single game that was reviewed by IGN. The columns contain information about that game:

正如您在上面看到的，数据中的每一行代表一个由IGN审核的游戏。 这些列包含有关该游戏的信息：

• score_phrase – how IGN described the game in one word. This is linked to the score it received.
• title – the name of the game.
• url – the URL where you can see the full review.
• platform – the platform the game was reviewed on (PC, PS4, etc).
• score – the score for the game, from 1.0 to 10.0.
• genre – the genre of the game.
• editors_choice – N if the game wasn’t an editor’s choice, Y if it was. This is tied to score.
• release_year – the year the game was released.
• release_month – the month the game was released.
• release_day – the day the game was released.

• score_phrase – IGN如何用一个词形容游戏。 这链接到它收到的分数。
• title –游戏名称。
• url –您可以在其中查看完整评论的URL。
• platform –审查游戏的平台（PC，PS4等）。
• score –游戏的得分，从1.0到10.0 。
• genre –游戏的体裁。
• editors_choice –如果游戏不是编辑选择， editors_choice N否则为Y 这与得分息息相关。
• release_year –游戏发布的年份。
• release_month –游戏发布的月份。
• release_day –游戏发布的日期。

There’s also a leading column that contains row index values. We can safely ignore this column, but we’ll dive into what index values are later on. In order to be able to work with the data in Python, we’ll need to read the csv file into a Pandas DataFrame. A DataFrame is a way to represent and work with tabular data. Tabular data has rows and columns, just like our csv file.

还有一个前导列，其中包含行索引值。 我们可以放心地忽略此列，但稍后将深入探讨哪些索引值。 为了能够使用Python中的数据，我们需要将csv文件读取到Pandas DataFrame中 。 DataFrame是表示和使用表格数据的一种方式。 表格数据具有行和列，就像我们的csv文件一样。

In order to read in the data, we’ll need to use the pandas.read_csv function. This function will take in a csv file and return a DataFrame. The below code will:

为了读入数据，我们需要使用pandas.read_csv函数。 此函数将接收一个csv文件并返回一个DataFrame。 下面的代码将：

• Import the pandas library. We rename it to pd so it’s faster to type out.
• Read ign.csv into a DataFrame, and assign the result to reviews.

• 导入pandas库。 我们将其重命名为pd这样可以更快地进行输入。
• 阅读ign.csv成数据帧，并分配结果reviews 。

Once we read in a DataFrame, Pandas gives us two methods that make it fast to print out the data. These functions are:

读取DataFrame后，Pandas为我们提供了两种方法，可以快速打印出数据。 这些功能是：

We’ll use the head method to see what’s in reviews:

我们将使用head方法查看reviews ：

reviewsreviews .. headhead ()
()

We can also access the pandas.DataFrame.shape property to see row many rows and columns are in reviews:

我们还可以访问pandas.DataFrame.shape属性，以查看reviews行，行和列：

 
(18625, 11)

As you can see, everything has been read in properly – we have 18625 rows and 11 columns.

如您所见，所有内容均已正确读取-我们有18625行和11列。

One of the big advantages of Pandas vs just using NumPy is that Pandas allows you to have columns with different data types. reviews has columns that store float values, like score, string values, like score_phrase, and integers, like release_year.

与仅使用NumPy相比，Pandas的一大优点是Pandas允许您使用具有不同数据类型的列。 reviews列存储浮点值（例如score ，字符串值（例如score_phrase ）和整数（例如release_year 。

Now that we’ve read the data in properly, let’s work on indexing reviews to get the rows and columns that we want.

现在，我们已经在读的正确数据，让我们对索引工作reviews来获得我们想要的行和列。

用Pandas索引数据帧 (Indexing DataFrames with Pandas)

Earlier, we used the head method to print the first 5 rows of reviews. We could accomplish the same thing using the pandas.DataFrame.iloc method. The iloc method allows us to retrieve rows and columns by position. In order to do that, we’ll need to specify the positions of the rows that we want, and the positions of the columns that we want as well.

之前，我们使用head方法打印reviews的前5行。 我们可以使用pandas.DataFrame.iloc方法完成同样的事情。 iloc方法允许我们按位置检索行和列。 为此，我们需要指定所需行的位置以及所需列的位置。

The below code will replicate reviews.head():

以下代码将复制reviews.head() ：

reviewsreviews .. ilociloc [[ 00 :: 55 ,:]
,:]

As you can see above, we specified that we wanted rows 0:5. This means that we wanted the rows from position 0 up to, but not including, position 5. The first row is considered to be in position 0. This gives us the rows at positions 0, 1, 2, 3, and 4.

正如您在上面看到的，我们指定了要0:5行。 这意味着我们想要从位置0到但不包括位置5 。 第一行被认为是在位置0 。 这给我们的位置处的行0 ， 1 ， 2 ， 3 ，和4 。

If we leave off the first position value, like :5, it’s assumed we mean 0. If we leave off the last position value, like 0:, it’s assumed we mean the last row or column in the DataFrame.

如果我们忽略第一个位置值，例如:5 ，则假定我们的意思是0 。 如果我们忽略了最后一个位置值（例如0: ：），则假定我们是指DataFrame中的最后一行或最后一列。

We wanted all of the columns, so we specified just a colon (:), without any positions. This gave us the columns from 0 to the last column.

我们希望所有的列，所以我们只指定了一个冒号（ : ），没有任何职位。 这给了我们从0到最后一列的列。

Here are some indexing examples, along with the results:

以下是一些索引示例以及结果：

• reviews.iloc[:5,:] – the first 5 rows, and all of the columns for those rows.
• reviews.iloc[:,:] – the entire DataFrame.
• reviews.iloc[5:,5:] – rows from position 5 onwards, and columns from position 5 onwards.
• reviews.iloc[:,0] – the first column, and all of the rows for the column.
• reviews.iloc[9,:] – the 10th row, and all of the columns for that row.

• reviews.iloc[:5,:] –前5行，以及这些行的所有列。
• reviews.iloc[:,:] –整个DataFrame。
• reviews.iloc[5:,5:] -从位置行5起，并从位置列5起。
• reviews.iloc[:,0] –第一列，以及该列的所有行。
• reviews.iloc[9,:] –第十行，以及该行的所有列。

Indexing by position is very similar to NumPy indexing. If you want to learn more, you can read our NumPy tutorial here.

按位置索引与NumPy索引非常相似。 如果您想了解更多信息，可以在此处阅读我们的NumPy教程。

Now that we know how to index by position, let’s remove the first column, which doesn’t have any useful information:

现在我们知道了如何按位置索引，让我们删除第一列，该列没有任何有用的信息：

在熊猫中使用标签建立索引 (Indexing Using Labels in Pandas)

Now that we know how to retrieve rows and columns by position, it’s worth looking into the other major way to work with DataFrames, which is to retrieve rows and columns by label.

既然我们知道如何按位置检索行和列，就值得研究使用DataFrames的另一种主要方法，即按标签检索行和列。

A major advantage of Pandas over NumPy is that each of the columns and rows has a label. Working with column positions is possible, but it can be hard to keep track of which number corresponds to which column.

与NumPy相比，Pandas的主要优势在于，每一列和每一行都有一个标签。 可以处理列的位置，但是很难跟踪哪个数字对应于哪个列。

We can work with labels using the pandas.DataFrame.loc method, which allows us to index using labels instead of positions.

我们可以使用pandas.DataFrame.loc方法处理标签，该方法允许我们使用标签而不是位置进行索引。

We can display the first five rows of reviews using the loc method like this:

我们可以使用loc方法显示reviews的前五行，如下所示：

reviewsreviews .. locloc [[ 00 :: 55 ,:]
,:]

The above doesn’t actually look much different from reviews.iloc[0:5,:]. This is because while row labels can take on any values, our row labels match the positions exactly. You can see the row labels on the very left of the table above (they’re in bold). You can also see them by accessing the index property of a DataFrame. We’ll display the row indexes for reviews:

上面的内容实际上与reviews.iloc[0:5,:]并没有太大区别。 这是因为尽管行标签可以采用任何值，但我们的行标签与位置完全匹配。 您可以在上方表格的最左侧看到行标签（它们以粗体显示）。 您还可以通过访问DataFrame的index属性来查看它们。 我们将显示reviews的行索引：

 
Int64Index([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, ...], dtype='int64')

Indexes don’t always have to match up with positions, though. In the below code cell, we’ll:

但是，索引不一定总是与位置匹配。 在下面的代码单元中，我们将：

• Get row 10 to row 20 of reviews, and assign the result to some_reviews.
• Display the first 5 rows of some_reviews.

• 获取行10至行20的reviews ，并分配结果some_reviews 。
• 显示some_reviews的前5行。

some_reviews some_reviews = = reviewsreviews .. ilociloc [[ 1010 :: 2020 ,]
,]
some_reviewssome_reviews .. headhead ()
()

As you can see above, in some_reviews, the row indexes start at 10 and end at 20. Thus, trying loc along with numbers lower than 10 or higher than 20 will result in an error:

如上所示，在some_reviews ，行索引从10开始，在20结束。 因此，将loc与小于10或大于20数字一起尝试将导致错误：

---------------------------------------------------------------------------
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
KeyError                                  Traceback (most recent call last)
<ipython-input-76-5378b774c9a7> in <ipython-input-76-5378b774c9a7> in <module><module> ()
()
----> 1----> 1  some_reviews some_reviews .loc. loc [[ 99 :: 2121 ,, :: ]
 
]
 
/Users/vik/python_envs/dsserver/lib/python3.4/site-packages/pandas/core/indexing.py in /Users/vik/python_envs/dsserver/lib/python3.4/site-packages/pandas/core/indexing.py in __getitem____getitem__ (self, key)
(self, key)
   1198        1198     def __getitem__def __getitem__ (self( self , key, key )) :
:
   1199            1199         if typeif type (key( key ) ) is tupleis tuple :
:
-> 1200-> 1200                            return selfreturn self ._getitem_tuple. _getitem_tuple (key( key )
)
   1201            1201         elseelse :
:
   1202                1202             return selfreturn self ._getitem_axis. _getitem_axis (key( key , axis, axis == 00 )
 
)
 
/Users/vik/python_envs/dsserver/lib/python3.4/site-packages/pandas/core/indexing.py in /Users/vik/python_envs/dsserver/lib/python3.4/site-packages/pandas/core/indexing.py in _getitem_tuple_getitem_tuple (self, tup)
(self, tup)
    702 
    702 
    703             703         # no multi-index, so validate all of the indexers
# no multi-index, so validate all of the indexers
--> 704--> 704          self         self ._has_valid_tuple. _has_valid_tuple (tup( tup )
)
    705 
    705 
    706             706         # ugly hack for GH #836
 
# ugly hack for GH #836
 
/Users/vik/python_envs/dsserver/lib/python3.4/site-packages/pandas/core/indexing.py in /Users/vik/python_envs/dsserver/lib/python3.4/site-packages/pandas/core/indexing.py in _has_valid_tuple_has_valid_tuple (self, key)
(self, key)
    129                 129             if i if i >= self>= self .obj. obj .ndim. ndim :
:
    130                     130                 raise IndexingErrorraise IndexingError (( 'Too many indexers''Too many indexers' )
)
--> 131--> 131                            if if not selfnot self ._has_valid_type. _has_valid_type (k( k , i, i )) :
:
    132                 raise ValueError("Location based indexing can only have [%s] "
    132                 raise ValueError("Location based indexing can only have [%s] "
    133                                  "types" % self._valid_types)
 
    133                                  "types" % self._valid_types)
 
/Users/vik/python_envs/dsserver/lib/python3.4/site-packages/pandas/core/indexing.py in /Users/vik/python_envs/dsserver/lib/python3.4/site-packages/pandas/core/indexing.py in _has_valid_type_has_valid_type (self, key, axis)
(self, key, axis)
   1258                         raise KeyError(
   1258                         raise KeyError(
   1259                                1259                             "start bound [%s] is not the [%s]" "start bound [%s] is not the [%s]" %
%
-> 1260-> 1260                                                            (key( key .start. start , self, self .obj. obj ._get_axis_name. _get_axis_name (axis( axis )) )
)
   1261                         )
   1261                         )
   1262                    1262                 if keyif key .stop . stop is is not not NoneNone :
 
:
 
KeyError: 'start bound [9] is not the [index]'
KeyError : 'start bound [9] is not the [index]'

As we mentioned earlier, column labels can make life much easier when you’re working with data. We can specify column labels in the loc method to retrieve columns by label instead of by position.

如前所述，在使用数据时，列标签可以使工作更加轻松。 我们可以在loc方法中指定列标签，以按标签而不是按位置检索列。

 
0    9.0
1    9.0
2    8.5
3    8.5
4    8.5
5    7.0
Name: score, dtype: float64

We can also specify more than one column at a time by passing in a list:

我们还可以通过传递列表来一次指定多个列：

reviewsreviews .. locloc [:[: 55 ,[,[ "score""score" , , "release_year""release_year" ]]
]]

熊猫系列物件 (Pandas Series Objects)

We can retrieve an individual column in Pandas a few different ways. So far, we’ve seen two types of syntax for this:

我们可以通过几种不同的方式在Pandas中检索单个列。 到目前为止，我们已经看到了两种语法：

• reviews.iloc[:,1] – will retrieve the second column.
• reviews.loc[:,"score_phrase"] – will also retrieve the second column.

• reviews.iloc[:,1] –将检索第二列。
• reviews.loc[:,"score_phrase"] –还将检索第二列。

There’s a third, even easier, way to retrieve a whole column. We can just specify the column name in square brackets, like with a dictionary:

还有第三种甚至更简单的方法来检索整列。 我们可以在方括号中指定列名称，例如使用字典：

 
0     9.0
1     9.0
2     8.5
3     8.5
4     8.5
5     7.0
6     3.0
7     9.0
8     3.0
9     7.0
10    7.5
11    7.5
12    7.0
13    9.0
14    9.0
...
18610     6.0
18611     5.8
18612     7.8
18613     8.0
18614     9.2
18615     9.2
18616     7.5
18617     8.4
18618     9.1
18619     7.9
18620     7.6
18621     9.0
18622     5.8
18623    10.0
18624    10.0
Name: score, Length: 18625, dtype: float64

We can also use lists of columns with this method:

我们还可以通过以下方法使用列列表：

reviewsreviews [[[[ "score""score" , , "release_year""release_year" ]]
]]

When we retrieve a single column, we’re actually retrieving a Pandas Series object. A DataFrame stores tabular data, but a Series stores a single column or row of data.

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

We can verify that a single column is a Series:

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

 
pandas.core.series.Series

We can create a Series manually to better understand how it works. To create a Series, we pass a list or NumPy array into the Series object when we instantiate it:

我们可以手动创建系列以更好地了解其工作原理。 要创建一个Series，我们在实例化它时将一个列表或NumPy数组传递给Series对象：

s1 s1 = = pdpd .. SeriesSeries ([([ 11 ,, 22 ])
])
s1
s1

 
0    1
1    2
dtype: int64

A Series can contain any type of data, including mixed types. Here, we create a Series that contains string objects:

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

 
0        Boris Yeltsin
1    Mikhail Gorbachev
dtype: object

在熊猫中创建一个DataFrame (Creating A DataFrame in Pandas)

We can create a DataFrame by passing multiple Series into the DataFrame class. Here, we pass in the two Series objects we just created, s1 as the first row, and s2 as the second row:

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

pdpd .. DataFrameDataFrame ([([ s1s1 ,, s2s2 ])
])

We can also accomplish the same thing with a list of lists. Each inner list is treated as a row in the resulting DataFrame:

我们还可以使用列表列表完成同样的事情。 每个内部列表在结果DataFrame中被视为一行：

We can specify the column labels when we create a DataFrame:

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

pdpd .. DataFrameDataFrame (
    (
    [
        [
        [[ 11 ,, 22 ],
        ],
        [[ "Boris Yeltsin""Boris Yeltsin" , , "Mikhail Gorbachev""Mikhail Gorbachev" ]
    ]
    ],
    ],
    columnscolumns == [[ "column1""column1" , , "column2""column2" ]
]
)
)

As well as the row labels (the index):

以及行标签（索引）：

We’re then able index the DataFrame using the labels:

然后，我们可以使用标签为DataFrame编制索引：

frameframe .. locloc [[ "row1""row1" :: "row2""row2" , , "column1""column1" ]
]

 
row1                1
row2    Boris Yeltsin
Name: column1, dtype: object

We can skip specifying the columns keyword argument if we pass a dictionary into the DataFrame constructor. This will automatically setup column names:

如果将字典传递给DataFrame构造函数，则可以跳过指定columns关键字参数的DataFrame 。 这将自动设置列名称：

熊猫DataFrame方法 (Pandas DataFrame Methods)

As we mentioned earlier, each column in a DataFrame is a Series object:

如前所述，DataFrame中的每一列都是一个Series对象：

typetype (( reviewsreviews [[ "title""title" ])
])

 
pandas.core.series.Series

We can call most of the same methods on a Series object that we can on a DataFrame, including head:

我们可以在Series对象上调用与在DataFrame上可以调用的大多数相同方法，包括head ：

 
0                              LittleBigPlanet PS Vita
1    LittleBigPlanet PS Vita -- Marvel Super Hero E...
2                                 Splice: Tree of Life
3                                               NHL 13
4                                               NHL 13
Name: title, dtype: object

Pandas Series and DataFrames also have other methods that make calculations simpler. For example, we can use the pandas.Series.mean method to find the mean of a Series:

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

reviewsreviews [[ "score""score" ]] .. meanmean ()
()

 
6.950459060402685

We can also call the similar pandas.DataFrame.mean method, which will find the mean of each numerical column in a DataFrame by default:

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

 
score               6.950459
release_year     2006.515329
release_month       7.138470
release_day        15.603866
dtype: float64

We can modify the axis keyword argument to mean in order to compute the mean of each row or of each column. By default, axis is equal to 0, and will compute the mean of each column. We can also set it to 1 to compute the mean of each row. Note that this will only compute the mean of the numerical values in each row:

我们可以将axis关键字参数修改为mean ，以便计算每一行或每一列的平均值。 默认情况下， axis等于0 ，并将计算每列的平均值。 我们还可以将其设置为1以计算每行的平均值。 请注意，这只会计算每行中数值的平均值：

reviewsreviews .. meanmean (( axisaxis == 11 )
)

 
0     510.500
1     510.500
2     510.375
3     510.125
4     510.125
5     509.750
6     508.750
7     510.250
8     508.750
9     509.750
10    509.875
11    509.875
12    509.500
13    509.250
14    509.250
...
18610    510.250
18611    508.700
18612    509.200
18613    508.000
18614    515.050
18615    515.050
18616    508.375
18617    508.600
18618    515.025
18619    514.725
18620    514.650
18621    515.000
18622    513.950
18623    515.000
18624    515.000
Length: 18625, dtype: float64

There are quite a few methods on Series and DataFrames that behave like mean. Here are some handy ones:

Series和DataFrame上有很多方法的行为类似于mean 。 这里有一些方便的东西：

We can use the corr method to see if any columns correlation with score. For instance, this would tell us if games released more recently have been getting higher reviews (release_year), or if games released towards the end of the year score better (release_month):

我们可以使用corr方法查看是否有任何列与score相关。 例如，这可以告诉我们最近发布的游戏获得了更高的评价（ release_year ），还是在年底之前发布的游戏获得了更好的评分（ release_month ）：

As you can see above, none of our numeric columns correlates with score, meaning that release timing doesn’t linearly relate to review score.

正如您在上面看到的那样，我们的所有数字列都没有与score相关，这意味着发布时间与评论得分没有线性关系。

DataFrame Math与Pandas (DataFrame Math with Pandas)

We can also perform math operations on Series or DataFrame objects. For example, we can divide every value in the score column by 2 to switch the scale from 0–10 to 0–5:

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

reviewsreviews [[ "score""score" ] ] / / 2
2

 
0     4.50
1     4.50
2     4.25
3     4.25
4     4.25
5     3.50
6     1.50
7     4.50
8     1.50
9     3.50
10    3.75
11    3.75
12    3.50
13    4.50
14    4.50
...
18610    3.00
18611    2.90
18612    3.90
18613    4.00
18614    4.60
18615    4.60
18616    3.75
18617    4.20
18618    4.55
18619    3.95
18620    3.80
18621    4.50
18622    2.90
18623    5.00
18624    5.00
Name: score, Length: 18625, dtype: float64

All the common mathematical operators that work in Python, like +, -, *, /, and ^ will work, and will apply to each element in a DataFrame or a Series.

所有在Python中运行的常用数学运算符，例如+ ， - ， * ， /和^都可以使用，并将应用于DataFrame或Series中的每个元素。

熊猫中的布尔索引 (Boolean Indexing in Pandas)

As we saw above, the mean of all the values in the score column of reviews is around 7. What if we wanted to find all the games that got an above average score? We could start by doing a comparison. The comparison compares each value in a Series to a specified value, then generate a Series full of Boolean values indicating the status of the comparison. For example, we can see which of the rows have a score value higher than 7:

正如我们在上面看到的， reviews的score栏中所有值的平均值约为7 。 如果我们想找到所有得分都高于平均水平的游戏怎么办？ 我们可以先进行比较。 比较会将“系列”中的每个值与指定值进行比较，然后生成一个“系列”，其中包含表示比较状态的布尔值。 例如，我们可以看到哪些行的score值高于7 ：

 
0      True
1      True
2      True
3      True
4      True
5     False
6     False
7      True
8     False
9     False
10     True
11     True
12    False
13     True
14     True
...
18610    False
18611    False
18612     True
18613     True
18614     True
18615     True
18616     True
18617     True
18618     True
18619     True
18620     True
18621     True
18622    False
18623     True
18624     True
Name: score, Length: 18625, dtype: bool

Once we have a Boolean Series, we can use it to select only rows in a DataFrame where the Series contains the value True. So, we could only select rows in reviews where score is greater than 7:

一旦有了Boolean Series，我们就可以使用它来选择DataFrame中Series包含值True 。 因此，我们只能在score大于7 reviews中选择行：

filtered_reviews filtered_reviews = = reviewsreviews [[ score_filterscore_filter ]
]
filtered_reviewsfiltered_reviews .. headhead ()
()

It’s possible to use multiple conditions for filtering. Let’s say we want to find games released for the Xbox One that have a score of more than 7. In the below code, we:

可以使用多个条件进行过滤。 假设我们要查找为Xbox One发行的得分超过7 。 在下面的代码中，我们：

• Setup a filter with two conditions:
  • Check if score is greater than 7.
  • Check if platform equals Xbox One
• Apply the filter to reviews to get only the rows we want.
• Use the head method to print the first 5 rows of filtered_reviews.

• 设置具有两个条件的过滤器：
  • 检查score是否大于7 。
  • 检查platform等于Xbox One
• 将过滤器应用于reviews以仅获取所需的行。
• 使用head方法打印前5行filtered_reviews 。

When filtering with multiple conditions, it’s important to put each condition in parentheses, and separate them with a single ampersand (&).

当与多个条件滤波，它把每个条件括号，并将它们与一个单一的符号（分离是很重要的& ）。

熊猫图 (Pandas Plotting)

Now that we know how to filter, we can create plots to observe the review distribution for the Xbox One vs the review distribution for the PlayStation 4. This will help us figure out which console has better games. We can do this via a histogram, which will plot the frequencies for different score ranges. This will tell us which console has more highly reviewed games.

现在我们知道如何过滤，我们可以创建图来观察Xbox One的评论分布与PlayStation 4的评论分布。 这将帮助我们确定哪个控制台具有更好的游戏。 我们可以通过直方图来做到这一点，直方图将绘制不同分数范围的频率。 这将告诉我们哪个控制台具有更受好评的游戏。

We can make a histogram for each console using the pandas.DataFrame.plot method. This method utilizes matplotlib, the popular Python plotting library, under the hood to generate good-looking plots.

我们可以使用pandas.DataFrame.plot方法为每个控制台制作一个直方图。 该方法利用内部流行的Python绘图库matplotlib生成美观的绘图。

The plot method defaults to drawing a line graph. We’ll need to pass in the keyword argument kind="hist" to draw a histogram instead.

plot方法默认为绘制折线图。 我们需要传入关键字参数kind="hist"来绘制直方图。

In the below code, we:

在下面的代码中，我们：

• Call %matplotlib inline to setup plotting inside a Jupyter notebook.
• Filter reviews to only have data about the Xbox One.
• Plot the score column.

• %matplotlib inline调用%matplotlib inline以在Jupyter笔记本中设置打印。
• 筛选reviews以仅包含有关Xbox One数据。
• 绘制score列。

%% matplotlib inline
matplotlib inline
reviewsreviews [[ reviewsreviews [[ "platform""platform" ] ] == == "Xbox One""Xbox One" ][][ "score""score" ]] .. plotplot (( kindkind == "hist""hist" )
)

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

We can also do the same for the PS4:

我们也可以对PS4做同样的事情：

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

It appears from our histogram that the PlayStation 4 has many more highly rated games than the Xbox One.

从我们的直方图中可以看出， PlayStation 4比Xbox One具有更高的评价。

filtered_reviewsfiltered_reviews [[ "score""score" ]] .. histhist ()
()

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

进一步阅读 (Further Reading)

翻译自: https://www.pybloggers.com/2016/10/pandas-tutorial-data-analysis-with-python-part-1/