Python Pandas 简明教程
Python Pandas - Introduction
Pandas 是一个开源 Python 库，通过其强大的数据结构提供高性能数据操作和分析工具。Pandas 名称源自术语面板数据 - 多维数据计量经济学。
2008 年，开发人员 Wes McKinney 开始开发 pandas，当时需要高性能、灵活的工具来分析数据。
在 Pandas 之前，Python 主要用于数据整理和准备。它对数据分析的贡献极小。Pandas 解决这个问题。使用 Pandas，我们可以完成数据处理和分析中的五个典型步骤，无论数据的来源如何 - 加载、准备、操作、建模和分析。
带有 Pandas 的 Python 用于广泛的领域，包括学术和商业领域，包括金融、经济学、统计学、分析等。
Python Pandas - Environment Setup
标准 Python 发行版不附带 Pandas 模块。一种轻量级替代方法是使用流行的 Python 软件包安装程序 pip. 安装 NumPy。
pip install pandas如果安装 Anaconda Python 软件包，则 Pandas 将默认安装为以下形式 −
Windows
-
Anaconda （源自 https://www.continuum.io ）是适用于 SciPy 堆栈的免费 Python 发行版。它也适用于 Linux 和 Mac。
-
Canopy ( https://www.enthought.com/products/canopy/ ）作为适用于 Windows、Linux 和 Mac 的完整 SciPy 堆栈的免费和商业发行版提供。
-
Python (x,y) 是一个带有适用于 Windows OS 的 SciPy 堆栈和 Spyder IDE 的免费 Python 分发版。（可从 http://python-xy.github.io/ 处下载）
Linux
各个 Linux 发行版的包管理器用于安装 SciPy 堆栈中的一个或多个包。
For Ubuntu Users
sudo apt-get install python-numpy python-scipy python-matplotlibipythonipythonnotebook
python-pandas python-sympy python-noseFor Fedora Users
sudo yum install numpyscipy python-matplotlibipython python-pandas sympy
python-nose atlas-develIntroduction to Data Structures
熊猫处理以下三个数据结构 −
-
Series
-
DataFrame
-
Panel
这些数据结构建立在 Numpy 阵列的基础上，也就是说它们很快。
Dimension & Description
思考这些数据结构的最佳方式是，高维数据结构是其低维数据结构的一个容器。例如，数据框是序列的容器，面板是数据框的容器。
Data Structure |
Dimensions |
Description |
Series |
1 |
1D 标记的同类阵列，大小不可变。 |
Data Frames |
2 |
通用 2D 标记，具有可变大小的表格结构，具有潜在的异构类型列。 |
Panel |
3 |
常规 3D 标记的、大小可变阵列。 |
构建和处理两个或多个维度阵列是一项繁琐的任务，在编写函数时考虑数据集的方向负担由用户承担。但是，使用 Pandas 数据结构，用户的脑力负担会减轻。
例如，对于表格数据（DataFrame），考虑 index （行）和 columns 比考虑轴 0 和轴 1 在语义上更有帮助。
DataFrame
DataFrame 是一个具有异构数据的二维数组。例如，
Name |
Age |
Gender |
Rating |
Steve |
32 |
Male |
3.45 |
Lia |
28 |
Female |
4.6 |
Vin |
45 |
Male |
3.9 |
Katie |
38 |
Female |
2.78 |
该表表示一个组织的销售团队及其总体绩效评级的表示，数据以行和列表示。每一列表示一个属性，每一行表示一个人。
Python Pandas - Series
Series 是一个一维的带标签阵列，它可以保存任何类型（整数、字符串、浮动、Python 对象等）的数据。轴标签统称为索引。
pandas.Series
可以使用以下构造函数创建 Pandas Series −
pandas.Series( data, index, dtype, copy)构造函数的参数如下：
Sr.No |
Parameter & Description |
1 |
data data 采用 ndarray、list、constants 等各种形式 |
2 |
index Index 值必须唯一且可哈希，与数据等长。如果未传递索引，则默认为 np.arange(n) 。 |
3 |
dtype dtype 表示数据类型。如果为 None，则会推断数据类型 |
4 |
copy Copy data. Default False |
可以使用各种输入创建 series，如：
-
Array
-
Dict
-
Scalar value or constant
Create a Series from ndarray
如果 data 是一个 ndarray，则传入的索引的长度必须相同。如果没有传入索引，则默认的索引是 range(n) ，其中 n 是数组长度，即 [0,1,2,3…. range(len(array))-1].
Create a Series from dict
可以将一个 dict 作为输入，并且如果未指定索引，则会按照排序的顺序取字典作为密钥，以构造索引。如果传递了 index ，则会提取出与索引中标签相对应的 data 中的值。
Create a Series from Scalar
如果 data 是一个标量值，则必须提供一个索引。该值将会重复，以匹配 index 的长度
#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
s = pd.Series(5, index=[0, 1, 2, 3])
print s它的 output 如下所示 −
0 5
1 5
2 5
3 5
dtype: int64Accessing Data from Series with Position
可以通过类似于 ndarray. 中的方式访问 series 中的数据
Example 1
检索第一个元素。正如我们已经知道的那样，数组的计数从零开始，这意味着第一个元素存储在第零个位置，依此类推。
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#retrieve the first element
print s[0]它的 output 如下所示 −
1Retrieve Data Using Label (Index)
Series 就像一个固定大小的 dict ，因为你可以通过索引标签获取和设置值。
Example 1
使用索引标签值检索一个单独的元素。
import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#retrieve a single element
print s['a']它的 output 如下所示 −
1Python Pandas - DataFrame
数据框是一种二维数据结构，即，数据按照表格方式以行和列对齐。
pandas.DataFrame
可以使用以下构造函数创建熊猫数据帧 −
pandas.DataFrame( data, index, columns, dtype, copy)构造函数的参数如下：
Sr.No |
Parameter & Description |
1 |
data data 采用各种形式，如 numpy 数组、序列、映射、列表、字典、常量，以及其他数据帧。 |
2 |
index 对于行标签，要用于结果帧的索引是可选默认值 np.arange(n)，如果未传递索引。 |
3 |
columns 对于列标签，可选默认语法为 - np.arange(n)。这仅在未传递索引时才为 true。 |
4 |
dtype 每列的数据类型。 |
5 |
copy 此命令（或任何其他命令）用于复制数据，如果默认值为 False。 |
Create DataFrame
可以使用各种输入创建熊猫数据帧，例如 −
-
Lists
-
dict
-
Series
-
Numpy ndarrays
-
Another DataFrame
在本章的后续章节中，我们将看到如何使用这些输入创建数据帧。
Create a DataFrame from Lists
可以使用单个列表或列表的列表创建数据帧。
Example 1
import pandas as pd
data = [1,2,3,4,5]
df = pd.DataFrame(data)
print df它的 output 如下所示 −
0
0 1
1 2
2 3
3 4
4 5Create a DataFrame from Dict of ndarrays / Lists
所有 ndarrays 必须具有相同的长度。如果传递了索引，则索引的长度应等于数组的长度。
如果未传递索引，则默认情况下，索引将为 range(n)，其中 n 是数组长度。
Example 1
import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data)
print df它的 output 如下所示 −
Age Name
0 28 Tom
1 34 Jack
2 29 Steve
3 42 RickyNote − 观察值 0、1、2、3。它们是使用函数 range(n) 分配给每个元素的默认索引。
Example 2
现在我们使用数组创建索引数据框。
import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data, index=['rank1','rank2','rank3','rank4'])
print df它的 output 如下所示 −
Age Name
rank1 28 Tom
rank2 34 Jack
rank3 29 Steve
rank4 42 RickyNote − 观察， index 参数为每一行分配一个索引。
Create a DataFrame from List of Dicts
可以将字典列表作为输入数据传递以创建数据帧。默认情况下，字典键被视为列名称。
Example 1
以下示例展示了如何通过传递字典列表来创建数据帧。
import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data)
print df它的 output 如下所示 −
a b c
0 1 2 NaN
1 5 10 20.0Note - 观察，未填充区域中添加 NaN（非数字）。
Example 2
以下示例展示如何通过传递词典列表和行索引来创建 DataFrame。
import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data, index=['first', 'second'])
print df它的 output 如下所示 −
a b c
first 1 2 NaN
second 5 10 20.0Example 3
以下示例展示如何使用词典列表、行索引和列索引来创建 DataFrame。
import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
#With two column indices, values same as dictionary keys
df1 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b'])
#With two column indices with one index with other name
df2 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b1'])
print df1
print df2它的 output 如下所示 −
#df1 output
a b
first 1 2
second 5 10
#df2 output
a b1
first 1 NaN
second 5 NaNNote - 观察，创建 df2 DataFrame，其列索引与词典键不同；因此，在适当的位置添加 NaN。而 df1 的创建中列索引与词典键相同，因此添加 NaN。
Create a DataFrame from Dict of Series
可以传递系列词典以形成 DataFrame。生成索引是传递的所有系列索引的 union。
Example
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print df它的 output 如下所示 −
one two
a 1.0 1
b 2.0 2
c 3.0 3
d NaN 4Note - 观察，对于系列一，没有传递标签 ‘d’ ，但结果中，NaN 标签添加了 NaN。
现在让我们通过示例了解 column selection, addition 和 deletion 。
Column Addition
我们将通过向现有数据框中添加新列来理解这一点。
Example
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
# Adding a new column to an existing DataFrame object with column label by passing new series
print ("Adding a new column by passing as Series:")
df['three']=pd.Series([10,20,30],index=['a','b','c'])
print df
print ("Adding a new column using the existing columns in DataFrame:")
df['four']=df['one']+df['three']
print df它的 output 如下所示 −
Adding a new column by passing as Series:
one two three
a 1.0 1 10.0
b 2.0 2 20.0
c 3.0 3 30.0
d NaN 4 NaN
Adding a new column using the existing columns in DataFrame:
one two three four
a 1.0 1 10.0 11.0
b 2.0 2 20.0 22.0
c 3.0 3 30.0 33.0
d NaN 4 NaN NaNColumn Deletion
可以删除或弹出列；让我们举个例子来了解如何做。
Example
# Using the previous DataFrame, we will delete a column
# using del function
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd']),
'three' : pd.Series([10,20,30], index=['a','b','c'])}
df = pd.DataFrame(d)
print ("Our dataframe is:")
print df
# using del function
print ("Deleting the first column using DEL function:")
del df['one']
print df
# using pop function
print ("Deleting another column using POP function:")
df.pop('two')
print df它的 output 如下所示 −
Our dataframe is:
one three two
a 1.0 10.0 1
b 2.0 20.0 2
c 3.0 30.0 3
d NaN NaN 4
Deleting the first column using DEL function:
three two
a 10.0 1
b 20.0 2
c 30.0 3
d NaN 4
Deleting another column using POP function:
three
a 10.0
b 20.0
c 30.0
d NaNRow Selection, Addition, and Deletion
现在我们将通过示例来了解行选择、添加和删除。让我们从选择的概念开始。
Selection by Label
可以通过向 loc 函数传递行标签来选择行。
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print df.loc['b']它的 output 如下所示 −
one 2.0
two 2.0
Name: b, dtype: float64结果是系列，其标签作为 DataFrame 的列名。并且，系列的名称是检索它的标签。
Selection by integer location
可以通过向 iloc 函数传递整型位置来选择行。
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print df.iloc[2]它的 output 如下所示 −
one 3.0
two 3.0
Name: c, dtype: float64Slice Rows
可以使用 ' : ' 运算符选择多行。
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print df[2:4]它的 output 如下所示 −
one two
c 3.0 3
d NaN 4Addition of Rows
使用 append 函数向 DataFrame 中添置新行。此函数将在末尾添加这些行。
import pandas as pd
df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])
df = df.append(df2)
print df它的 output 如下所示 −
a b
0 1 2
1 3 4
0 5 6
1 7 8Deletion of Rows
使用索引标签从 DataFrame 中删除或丢弃行。如果标签是重复的，则将丢弃多行。
如果你观察，在上面的示例中，这些标签是重复的。让我们丢弃一个标签，然后看看将被丢弃多少行。
import pandas as pd
df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])
df = df.append(df2)
# Drop rows with label 0
df = df.drop(0)
print df它的 output 如下所示 −
a b
1 3 4
1 7 8在上面的示例中，丢弃了两行，这是因为它们包含相同标签 0。
Python Pandas - Panel
panel 是数据的 3D 容器。术语 Panel data 衍生自计量经济学并且部分负责熊猫名称 − pan(el)-da(ta) -s。
3 根轴的名称是为了给描述面板数据的操作赋予一些语义含义。它们是 −
-
items − axis 0，每个项都对应内部包含的一个 DataFrame。
-
major_axis − axis 1，它是每个 DataFrame 的索引（行）。
-
minor_axis − axis 2，它是每个 DataFrame 的列。
pandas.Panel()
可以使用以下构造函数创建一个面板 −
pandas.Panel(data, items, major_axis, minor_axis, dtype, copy)构造函数的参数如下：
Parameter |
Description |
data |
数据采用各种形式，如 ndarray、序列、映射、列表、dict、常量，以及另一个 DataFrame |
items |
axis=0 |
major_axis |
axis=1 |
minor_axis |
axis=2 |
dtype |
每列的数据类型 |
copy |
Copy data. Default, false |
Create Panel
可以使用多种方法创建面板，如 −
-
From ndarrays
-
From dict of DataFrames
From 3D ndarray
# creating an empty panel
import pandas as pd
import numpy as np
data = np.random.rand(2,4,5)
p = pd.Panel(data)
print p它的 output 如下所示 −
<class 'pandas.core.panel.Panel'>
Dimensions: 2 (items) x 4 (major_axis) x 5 (minor_axis)
Items axis: 0 to 1
Major_axis axis: 0 to 3
Minor_axis axis: 0 to 4Note − 观察空面板和上述面板的维度，所有对象都不同。
From dict of DataFrame Objects
#creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)),
'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p它的 output 如下所示 −
Dimensions: 2 (items) x 4 (major_axis) x 3 (minor_axis)
Items axis: Item1 to Item2
Major_axis axis: 0 to 3
Minor_axis axis: 0 to 2Selecting the Data from Panel
使用以下方法从面板中选择数据 −
-
Items
-
Major_axis
-
Minor_axis
Using Items
# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)),
'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p['Item1']它的 output 如下所示 −
0 1 2
0 0.488224 -0.128637 0.930817
1 0.417497 0.896681 0.576657
2 -2.775266 0.571668 0.290082
3 -0.400538 -0.144234 1.110535我们有两项，并且我们检索了 item1。结果是一个带有 4 行和 3 列的 DataFrame，它们是 Major_axis 和 Minor_axis 维度。
Using major_axis
可以使用方法 panel.major_axis(index) 访问数据。
# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)),
'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p.major_xs(1)它的 output 如下所示 −
Item1 Item2
0 0.417497 0.748412
1 0.896681 -0.557322
2 0.576657 NaNUsing minor_axis
可以使用方法 panel.minor_axis(index). 访问数据。
# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)),
'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p.minor_xs(1)它的 output 如下所示 −
Item1 Item2
0 -0.128637 -1.047032
1 0.896681 -0.557322
2 0.571668 0.431953
3 -0.144234 1.302466Note − 观察维度中的变化。
Python Pandas - Basic Functionality
到目前为止，我们了解了这三个 Pandas 数据结构以及如何创建它们。我们将主要关注 DataFrame 对象，因为它在实时数据处理中非常重要，还将讨论一些其他数据结构。
Series Basic Functionality
Sr.No. |
属性或方法和说明 |
1 |
axes 返回行轴标签的列表 |
2 |
dtype 返回对象的 dtype。 |
3 |
empty 如果序列为空，则返回 True。 |
4 |
ndim 根据定义返回基础数据维数，为 1。 |
5 |
size 返回基础数据中的元素数。 |
6 |
values 将 Series 作为 ndarray 返回。 |
7 |
head() 返回前 n 行。 |
8 |
tail() 返回后 n 行。 |
我们现在创建一个 Series，然后查看所有以上表格中的属性操作。
Example
import pandas as pd
import numpy as np
#Create a series with 100 random numbers
s = pd.Series(np.random.randn(4))
print s它的 output 如下所示 −
0 0.967853
1 -0.148368
2 -1.395906
3 -1.758394
dtype: float64axes
返回系列标签列表。
import pandas as pd
import numpy as np
#Create a series with 100 random numbers
s = pd.Series(np.random.randn(4))
print ("The axes are:")
print s.axes它的 output 如下所示 −
The axes are:
[RangeIndex(start=0, stop=4, step=1)]以上结果是以 0 到 5 的值列表的紧凑形式，即 [0,1,2,3,4]。
empty
返回布尔值，表示对象是否为空。True 指示对象为空。
import pandas as pd
import numpy as np
#Create a series with 100 random numbers
s = pd.Series(np.random.randn(4))
print ("Is the Object empty?")
print s.empty它的 output 如下所示 −
Is the Object empty?
Falsendim
返回对象维数。根据定义，Series 是 1D 数据结构，因此它返回
import pandas as pd
import numpy as np
#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print s
print ("The dimensions of the object:")
print s.ndim它的 output 如下所示 −
0 0.175898
1 0.166197
2 -0.609712
3 -1.377000
dtype: float64
The dimensions of the object:
1size
返回系列大小（长度）。
import pandas as pd
import numpy as np
#Create a series with 4 random numbers
s = pd.Series(np.random.randn(2))
print s
print ("The size of the object:")
print s.size它的 output 如下所示 −
0 3.078058
1 -1.207803
dtype: float64
The size of the object:
2values
返回系列中的实际数据作为数组。
import pandas as pd
import numpy as np
#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print s
print ("The actual data series is:")
print s.values它的 output 如下所示 −
0 1.787373
1 -0.605159
2 0.180477
3 -0.140922
dtype: float64
The actual data series is:
[ 1.78737302 -0.60515881 0.18047664 -0.1409218 ]Head & Tail
若要查看 Series 或 DataFrame 对象的小样本，请使用 head() 和 tail() 方法。
head() 返回前 n 行（观察索引值）。要显示的元素默认值为 5，但你可以传递自定义数字。
import pandas as pd
import numpy as np
#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print ("The original series is:")
print s
print ("The first two rows of the data series:")
print s.head(2)它的 output 如下所示 −
The original series is:
0 0.720876
1 -0.765898
2 0.479221
3 -0.139547
dtype: float64
The first two rows of the data series:
0 0.720876
1 -0.765898
dtype: float64tail() 返回后 n 行（观察索引值）。要显示的元素默认值为 5，但你可以传递自定义数字。
import pandas as pd
import numpy as np
#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print ("The original series is:")
print s
print ("The last two rows of the data series:")
print s.tail(2)它的 output 如下所示 −
The original series is:
0 -0.655091
1 -0.881407
2 -0.608592
3 -2.341413
dtype: float64
The last two rows of the data series:
2 -0.608592
3 -2.341413
dtype: float64DataFrame Basic Functionality
我们现在了解什么是 DataFrame 基本功能。下表列出了有助于实现 DataFrame 基本功能的重要属性或方法。
Sr.No. |
属性或方法和说明 |
1 |
T Transposes rows and columns. |
2 |
axes 返回一个列表，其中行轴标签和列轴标签是唯一成员。 |
3 |
dtypes 返回此对象中的数据类型。 |
4 |
empty 如果 NDFrame 完全为空 [无项目]；如果任何轴长度为 0，则为 True。 |
5 |
ndim 轴/数组维数。 |
6 |
shape 返回一个元组表示 DataFrame 的维度。 |
7 |
size NDFrame 中元素的数量。 |
8 |
values Numpy representation of NDFrame. |
9 |
head() 返回前 n 行。 |
10 |
tail() Returns last n rows. |
让我们创建 DataFrame，观察上述属性如何运作。
Example
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our data series is:")
print df它的 output 如下所示 −
Our data series is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80T (Transpose)
返回 DataFrame 的转置。行列将交换。
import pandas as pd
import numpy as np
# Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
# Create a DataFrame
df = pd.DataFrame(d)
print ("The transpose of the data series is:")
print df.T它的 output 如下所示 −
The transpose of the data series is:
0 1 2 3 4 5 6
Age 25 26 25 23 30 29 23
Name Tom James Ricky Vin Steve Smith Jack
Rating 4.23 3.24 3.98 2.56 3.2 4.6 3.8axes
返回行轴标签和列轴标签的列表。
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Row axis labels and column axis labels are:")
print df.axes它的 output 如下所示 −
Row axis labels and column axis labels are:
[RangeIndex(start=0, stop=7, step=1), Index([u'Age', u'Name', u'Rating'],
dtype='object')]dtypes
返回每列的数据类型。
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("The data types of each column are:")
print df.dtypes它的 output 如下所示 −
The data types of each column are:
Age int64
Name object
Rating float64
dtype: objectempty
返回布尔值，指示对象是否为空；True 指示对象为空。
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Is the object empty?")
print df.empty它的 output 如下所示 −
Is the object empty?
Falsendim
返回对象的维度数。根据定义，DataFrame 是 2D 对象。
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The dimension of the object is:")
print df.ndim它的 output 如下所示 −
Our object is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
The dimension of the object is:
2shape
返回一个元组表示 DataFrame 的维度。元组 (a,b)，其中 a 表示行数， b 表示列数。
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The shape of the object is:")
print df.shape它的 output 如下所示 −
Our object is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
The shape of the object is:
(7, 3)size
返回 DataFrame 中的元素数。
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The total number of elements in our object is:")
print df.size它的 output 如下所示 −
Our object is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
The total number of elements in our object is:
21values
以 NDarray. 的形式返回 DataFrame 中的实际数据
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The actual data in our data frame is:")
print df.values它的 output 如下所示 −
Our object is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
The actual data in our data frame is:
[[25 'Tom' 4.23]
[26 'James' 3.24]
[25 'Ricky' 3.98]
[23 'Vin' 2.56]
[30 'Steve' 3.2]
[29 'Smith' 4.6]
[23 'Jack' 3.8]]Head & Tail
要查看 DataFrame 对象的小样本，使用 head() 和 tail() 方法。 head() 返回前 n 行（观察索引值）。显示的元素默认数为 5，但可传递自定义数字。
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our data frame is:")
print df
print ("The first two rows of the data frame is:")
print df.head(2)它的 output 如下所示 −
Our data frame is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
The first two rows of the data frame is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24tail() 返回最后 n 行（观察索引值）。显示的元素默认数为 5，但可传递自定义数字。
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
'Age':pd.Series([25,26,25,23,30,29,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our data frame is:")
print df
print ("The last two rows of the data frame is:")
print df.tail(2)它的 output 如下所示 −
Our data frame is:
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
The last two rows of the data frame is:
Age Name Rating
5 29 Smith 4.6
6 23 Jack 3.8Python Pandas - Descriptive Statistics
许多方法共同计算描述性统计信息和其他对 DataFrame 的相关操作。其中大多数是像 sum(), mean(), 这样的聚合，但其中一些（如 sumsum() ）生成相同大小的对象。通常情况下，这些方法采用 axis 参数，就像 ndarray.{sum, std, …}，但可以按名称或整数指定轴
-
DataFrame − “index”（axis=0，默认值），“columns”（axis=1）
让我们创建 DataFrame，并在本章中针对所有操作使用此对象。
Example
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df它的 output 如下所示 −
Age Name Rating
0 25 Tom 4.23
1 26 James 3.24
2 25 Ricky 3.98
3 23 Vin 2.56
4 30 Steve 3.20
5 29 Smith 4.60
6 23 Jack 3.80
7 34 Lee 3.78
8 40 David 2.98
9 30 Gasper 4.80
10 51 Betina 4.10
11 46 Andres 3.65sum()
返回请求轴上的值的总和。默认情况下，轴为索引 (axis=0)。
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df.sum()它的 output 如下所示 −
Age 382
Name TomJamesRickyVinSteveSmithJackLeeDavidGasperBe...
Rating 44.92
dtype: object单独添加每个列（追加字符串）。
axis=1
此语法将给予如下所示的输出。
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df.sum(1)它的 output 如下所示 −
0 29.23
1 29.24
2 28.98
3 25.56
4 33.20
5 33.60
6 26.80
7 37.78
8 42.98
9 34.80
10 55.10
11 49.65
dtype: float64mean()
返回平均值
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df.mean()它的 output 如下所示 −
Age 31.833333
Rating 3.743333
dtype: float64std()
返回数值列的 Bessel 标准差。
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df.std()它的 output 如下所示 −
Age 9.232682
Rating 0.661628
dtype: float64Functions & Description
让我们现在理解 Python Pandas 中描述性统计下的函数。下表列出了重要函数 -
Sr.No. |
Function |
Description |
1 |
count() |
Number of non-null observations |
2 |
sum() |
Sum of values |
3 |
mean() |
Mean of Values |
4 |
median() |
Median of Values |
5 |
mode() |
Mode of values |
6 |
std() |
值的标准差 |
7 |
min() |
Minimum Value |
8 |
max() |
Maximum Value |
9 |
abs() |
Absolute Value |
10 |
prod() |
Product of Values |
11 |
cumsum() |
Cumulative Sum |
12 |
cumprod() |
Cumulative Product |
Note - 由于 DataFrame 是异构数据结构。通用操作并不适用于所有函数。
-
诸如 sum(), cumsum() 的函数适用于数字和字符（或）字符串数据元素，不会出现任何错误。虽然 n 实践字符聚合通常从不使用，但这些函数不会引发任何异常。
-
诸如 abs(), cumprod() 的函数在 DataFrame 中包含字符或字符串数据时会引发异常，因为无法执行此类操作。
Summarizing Data
describe() 函数计算与 DataFrame 列有关的统计数据摘要。
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df.describe()它的 output 如下所示 −
Age Rating
count 12.000000 12.000000
mean 31.833333 3.743333
std 9.232682 0.661628
min 23.000000 2.560000
25% 25.000000 3.230000
50% 29.500000 3.790000
75% 35.500000 4.132500
max 51.000000 4.800000此函数给出了 mean, std 和 IQR 值。并且，函数排除了字符列并给出了有关数值列的摘要。 'include' 是一个参数，用于传递有关需要考虑哪些列进行总结的必要信息。采用值列表；默认情况下为“number”。
-
object - 总结字符串列
-
number - 总结数值列
-
all - 一起总结所有列（不应将其作为列表值传递）
现在，在程序中使用以下语句并检查输出 -
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df.describe(include=['object'])它的 output 如下所示 −
Name
count 12
unique 12
top Ricky
freq 1现在，使用以下语句并检查输出 -
import pandas as pd
import numpy as np
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
'Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
#Create a DataFrame
df = pd.DataFrame(d)
print df. describe(include='all')它的 output 如下所示 −
Age Name Rating
count 12.000000 12 12.000000
unique NaN 12 NaN
top NaN Ricky NaN
freq NaN 1 NaN
mean 31.833333 NaN 3.743333
std 9.232682 NaN 0.661628
min 23.000000 NaN 2.560000
25% 25.000000 NaN 3.230000
50% 29.500000 NaN 3.790000
75% 35.500000 NaN 4.132500
max 51.000000 NaN 4.800000Python Pandas - Function Application
要将自己的函数或其他库的函数应用于 Pandas 对象，您应该注意这三种重要方法。下面讨论了这些方法。使用哪种合适的方法取决于您的函数是否期望对整个 DataFrame、面向行或列或按元素进行操作。
-
按表方式应用函数：pipe()
-
按行或列方式应用函数：apply()
-
按元素方式应用函数：applymap()
Table-wise Function Application
自定义操作可以通过传递函数和适量参数作为管道参数来执行。因此，操作将对整个 DataFrame 执行。
例如，给 DataFrame 中所有的元素添加值 2。然后，
adder function
adder 函数将两个数字值作为参数添加，并返回和。
def adder(ele1,ele2):
return ele1+ele2我们现在将使用自定义函数对 DataFrame 执行操作。
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.pipe(adder,2)让我们看一下完整的程序 −
import pandas as pd
import numpy as np
def adder(ele1,ele2):
return ele1+ele2
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.pipe(adder,2)
print df.apply(np.mean)它的 output 如下所示 −
col1 col2 col3
0 2.176704 2.219691 1.509360
1 2.222378 2.422167 3.953921
2 2.241096 1.135424 2.696432
3 2.355763 0.376672 1.182570
4 2.308743 2.714767 2.130288Row or Column Wise Function Application
任意函数可以使用 apply() 方法沿 DataFrame 或 Panel 的轴应用，该方法与描述性统计方法类似，接受可选的 axis 参数。默认情况下，操作按列执行，将每一列视为类似数组。
Example 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.apply(np.mean)
print df.apply(np.mean)它的 output 如下所示 −
col1 -0.288022
col2 1.044839
col3 -0.187009
dtype: float64通过传递 axis 参数，可以按行执行操作。
Element Wise Function Application
并非所有函数都可以向量化（既不能返回另一个数组的 NumPy 数组，也不能返回任何值），DataFrame 上的 applymap() 方法和 Series 上的 analogously map() 方法接受任何 Python 函数，该函数取单个值并返回单个值。
Python Pandas - Reindexing
Reindexing 更改 DataFrame 的行标签和列标签。重新索引是指使数据符合沿特定轴匹配的一组给定标签。
可以通过索引完成多个操作，如下所示 −
-
重新排列现有数据以匹配一组新标签。
-
在不存在标签数据的标签位置插入缺失值 (NA) 标记。
Example
import pandas as pd
import numpy as np
N=20
df = pd.DataFrame({
'A': pd.date_range(start='2016-01-01',periods=N,freq='D'),
'x': np.linspace(0,stop=N-1,num=N),
'y': np.random.rand(N),
'C': np.random.choice(['Low','Medium','High'],N).tolist(),
'D': np.random.normal(100, 10, size=(N)).tolist()
})
#reindex the DataFrame
df_reindexed = df.reindex(index=[0,2,5], columns=['A', 'C', 'B'])
print df_reindexed它的 output 如下所示 −
A C B
0 2016-01-01 Low NaN
2 2016-01-03 High NaN
5 2016-01-06 Low NaNReindex to Align with Other Objects
你可以获取一个对象并重新索引其轴以与另一个对象相同进行标记。考虑下面的示例来理解它。
Example
import pandas as pd
import numpy as np
df1 = pd.DataFrame(np.random.randn(10,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(7,3),columns=['col1','col2','col3'])
df1 = df1.reindex_like(df2)
print df1它的 output 如下所示 −
col1 col2 col3
0 -2.467652 -1.211687 -0.391761
1 -0.287396 0.522350 0.562512
2 -0.255409 -0.483250 1.866258
3 -1.150467 -0.646493 -0.222462
4 0.152768 -2.056643 1.877233
5 -1.155997 1.528719 -1.343719
6 -1.015606 -1.245936 -0.295275Note − 在这里， df1 DataFrame 被更改并重新索引为 df2 。列名应该匹配，否则将为整个列标签添加 NAN。
Filling while ReIndexing
reindex() 接受一个可选参数 method，该参数是一个填充方法，其值如下 −
-
pad/ffill − 向前填充值
-
bfill/backfill − 向后填充值
-
nearest − 从最近的索引值填充
Example
import pandas as pd
import numpy as np
df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(2,3),columns=['col1','col2','col3'])
# Padding NAN's
print df2.reindex_like(df1)
# Now Fill the NAN's with preceding Values
print ("Data Frame with Forward Fill:")
print df2.reindex_like(df1,method='ffill')它的 output 如下所示 −
col1 col2 col3
0 1.311620 -0.707176 0.599863
1 -0.423455 -0.700265 1.133371
2 NaN NaN NaN
3 NaN NaN NaN
4 NaN NaN NaN
5 NaN NaN NaN
Data Frame with Forward Fill:
col1 col2 col3
0 1.311620 -0.707176 0.599863
1 -0.423455 -0.700265 1.133371
2 -0.423455 -0.700265 1.133371
3 -0.423455 -0.700265 1.133371
4 -0.423455 -0.700265 1.133371
5 -0.423455 -0.700265 1.133371Note − 填充最后四行。
Limits on Filling while Reindexing
limit 参数在重新索引时提供对填充的额外控制。Limit 指定连续匹配的最大计数。我们考虑以下示例来理解它 −
Example
import pandas as pd
import numpy as np
df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(2,3),columns=['col1','col2','col3'])
# Padding NAN's
print df2.reindex_like(df1)
# Now Fill the NAN's with preceding Values
print ("Data Frame with Forward Fill limiting to 1:")
print df2.reindex_like(df1,method='ffill',limit=1)它的 output 如下所示 −
col1 col2 col3
0 0.247784 2.128727 0.702576
1 -0.055713 -0.021732 -0.174577
2 NaN NaN NaN
3 NaN NaN NaN
4 NaN NaN NaN
5 NaN NaN NaN
Data Frame with Forward Fill limiting to 1:
col1 col2 col3
0 0.247784 2.128727 0.702576
1 -0.055713 -0.021732 -0.174577
2 -0.055713 -0.021732 -0.174577
3 NaN NaN NaN
4 NaN NaN NaN
5 NaN NaN NaNNote − 观察到，只有第 7 行被前面的第 6 行填充。然后，这些行会保持原样。
Renaming
rename() 方法允许你根据某些映射（一个字典或 Series）或一个任意函数来重新标记一个轴。
我们考虑以下示例来理解它 −
import pandas as pd
import numpy as np
df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
print df1
print ("After renaming the rows and columns:")
print df1.rename(columns={'col1' : 'c1', 'col2' : 'c2'},
index = {0 : 'apple', 1 : 'banana', 2 : 'durian'})它的 output 如下所示 −
col1 col2 col3
0 0.486791 0.105759 1.540122
1 -0.990237 1.007885 -0.217896
2 -0.483855 -1.645027 -1.194113
3 -0.122316 0.566277 -0.366028
4 -0.231524 -0.721172 -0.112007
5 0.438810 0.000225 0.435479
After renaming the rows and columns:
c1 c2 col3
apple 0.486791 0.105759 1.540122
banana -0.990237 1.007885 -0.217896
durian -0.483855 -1.645027 -1.194113
3 -0.122316 0.566277 -0.366028
4 -0.231524 -0.721172 -0.112007
5 0.438810 0.000225 0.435479rename() 方法提供了一个 inplace 命名参数，其默认值为 False，并复制底层数据。传递 inplace=True 来原地重命名数据。
Python Pandas - Iteration
对 Pandas 对象进行基本迭代的行为取决于类型。当对 Series 迭代时，它被视为类似于数组，并且基本迭代会生成值。其他数据结构，例如 DataFrame 和 Panel，遵循 dict-like 约定，即对对象的 keys 进行迭代。
简而言之，基本迭代（对于 i 在对象中）生成 −
-
Series − values
-
DataFrame − column labels
-
Panel − item labels
Iterating a DataFrame
迭代一个 DataFrame 会给出列名。我们考虑以下示例来理解它。
import pandas as pd
import numpy as np
N=20
df = pd.DataFrame({
'A': pd.date_range(start='2016-01-01',periods=N,freq='D'),
'x': np.linspace(0,stop=N-1,num=N),
'y': np.random.rand(N),
'C': np.random.choice(['Low','Medium','High'],N).tolist(),
'D': np.random.normal(100, 10, size=(N)).tolist()
})
for col in df:
print col它的 output 如下所示 −
A
C
D
x
y为了对 DataFrame 的行进行迭代，我们可以使用以下函数 −
-
iteritems() − 迭代 (key，value) 对
-
iterrows() − 将行作为 (index，series) 对进行迭代
-
itertuples() − 将行作为命名元组进行迭代
iteritems()
以密钥作为密钥，以列值作为 Series 对象对每一列进行迭代。
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(4,3),columns=['col1','col2','col3'])
for key,value in df.iteritems():
print key,value它的 output 如下所示 −
col1 0 0.802390
1 0.324060
2 0.256811
3 0.839186
Name: col1, dtype: float64
col2 0 1.624313
1 -1.033582
2 1.796663
3 1.856277
Name: col2, dtype: float64
col3 0 -0.022142
1 -0.230820
2 1.160691
3 -0.830279
Name: col3, dtype: float64观察，每一列都以 Series 中的键值对形式单独进行迭代。
iterrows()
iterrows() 返回迭代器，生成每一行索引值以及包含每一行数据的 series。
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])
for row_index,row in df.iterrows():
print row_index,row它的 output 如下所示 −
0 col1 1.529759
col2 0.762811
col3 -0.634691
Name: 0, dtype: float64
1 col1 -0.944087
col2 1.420919
col3 -0.507895
Name: 1, dtype: float64
2 col1 -0.077287
col2 -0.858556
col3 -0.663385
Name: 2, dtype: float64
3 col1 -1.638578
col2 0.059866
col3 0.493482
Name: 3, dtype: float64Note − 因为 iterrows() 迭代行，所以它不会保留行中的数据类型。0、1、2 是行索引，col1、col2、col3 是列索引。
itertuples()
itertuples() 方法将返回一个迭代器，该迭代器会为 DataFrame 中的每一行生成一个命名元组。元组的第一个元素将是行的相应索引值，而其余的值是行值。
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])
for row in df.itertuples():
print row它的 output 如下所示 −
Pandas(Index=0, col1=1.5297586201375899, col2=0.76281127433814944, col3=-
0.6346908238310438)
Pandas(Index=1, col1=-0.94408735763808649, col2=1.4209186418359423, col3=-
0.50789517967096232)
Pandas(Index=2, col1=-0.07728664756791935, col2=-0.85855574139699076, col3=-
0.6633852507207626)
Pandas(Index=3, col1=0.65734942534106289, col2=-0.95057710432604969,
col3=0.80344487462316527)Note − 在进行迭代时，不要尝试修改任何对象。迭代目的是为了读取，而迭代器返回原始对象（一个视图）的副本，因此更改不会反映在原始对象中。
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])
for index, row in df.iterrows():
row['a'] = 10
print df它的 output 如下所示 −
col1 col2 col3
0 -1.739815 0.735595 -0.295589
1 0.635485 0.106803 1.527922
2 -0.939064 0.547095 0.038585
3 -1.016509 -0.116580 -0.523158观察，没有反映出的更改。
Python Pandas - Sorting
Pandas 提供两种排序方式。它们是-
-
By label
-
By Actual Value
我们考虑一个有输出的示例。
import pandas as pd
import numpy as np
unsorted_df=pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
mns=['col2','col1'])
print unsorted_df它的 output 如下所示 −
col2 col1
1 -2.063177 0.537527
4 0.142932 -0.684884
6 0.012667 -0.389340
2 -0.548797 1.848743
3 -1.044160 0.837381
5 0.385605 1.300185
9 1.031425 -1.002967
8 -0.407374 -0.435142
0 2.237453 -1.067139
7 -1.445831 -1.701035在 unsorted_df 中， labels 和 values 未排序。让我们看看如何对它们进行排序。
By Label
使用 sort_index() 方法，通过传递axis参数和排序顺序，可以对DataFrame进行排序。默认情况下，按行标签升序排序。
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
mns = ['col2','col1'])
sorted_df=unsorted_df.sort_index()
print sorted_df它的 output 如下所示 −
col2 col1
0 0.208464 0.627037
1 0.641004 0.331352
2 -0.038067 -0.464730
3 -0.638456 -0.021466
4 0.014646 -0.737438
5 -0.290761 -1.669827
6 -0.797303 -0.018737
7 0.525753 1.628921
8 -0.567031 0.775951
9 0.060724 -0.322425Order of Sorting
通过将布尔值传递给ascending参数，可以控制排序顺序。我们考虑以下示例来理解它。
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
mns = ['col2','col1'])
sorted_df = unsorted_df.sort_index(ascending=False)
print sorted_df它的 output 如下所示 −
col2 col1
9 0.825697 0.374463
8 -1.699509 0.510373
7 -0.581378 0.622958
6 -0.202951 0.954300
5 -1.289321 -1.551250
4 1.302561 0.851385
3 -0.157915 -0.388659
2 -1.222295 0.166609
1 0.584890 -0.291048
0 0.668444 -0.061294Sort the Columns
通过将axis参数传递一个值0或1，可以在列标签上进行排序。默认情况下，axis=0，按行排序。我们考虑以下示例来理解它。
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
mns = ['col2','col1'])
sorted_df=unsorted_df.sort_index(axis=1)
print sorted_df它的 output 如下所示 −
col1 col2
1 -0.291048 0.584890
4 0.851385 1.302561
6 0.954300 -0.202951
2 0.166609 -1.222295
3 -0.388659 -0.157915
5 -1.551250 -1.289321
9 0.374463 0.825697
8 0.510373 -1.699509
0 -0.061294 0.668444
7 0.622958 -0.581378By Value
与索引排序一样， sort_values() 是按值排序的方法。它接受一个“by”参数，它将使用要对其进行值排序的DataFrame的列名。
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by='col1')
print sorted_df它的 output 如下所示 −
col1 col2
1 1 3
2 1 2
3 1 4
0 2 1注意，col1值已排序，并且相应的col2值和行索引将与col1一起改变。因此，它们看起来是未排序的。
'by' 参数采用列值列表。
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by=['col1','col2'])
print sorted_df它的 output 如下所示 −
col1 col2
2 1 2
1 1 3
3 1 4
0 2 1Sorting Algorithm
sort_values() 提供了一个从mergesort、heapsort和quicksort中选择算法的条款。Mergesort是唯一稳定的算法。
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by='col1' ,kind='mergesort')
print sorted_df它的 output 如下所示 −
col1 col2
1 1 3
2 1 2
3 1 4
0 2 1Python Pandas - Working with Text Data
在本节中，我们将讨论使用基本Series/Index进行字符串操作。在后续章节中，我们将学习如何在DataFrame上应用这些字符串函数。
Pandas 提供了一组字符串函数，使其易于对字符串数据进行操作。最重要的是，这些函数忽略（或排除）缺失/NaN 值。
几乎所有这些方法都适用于 Python 字符串函数（参考： https://docs.python.org/3/library/stdtypes.html#string-methods ）。因此，将Series对象转换为字符串对象，然后执行操作。
现在让我们看看每个操作如何执行。
Sr.No |
Function & Description |
1 |
lower() 将Series/Index中的字符串转换为小写。 |
2 |
upper() 将Series/Index中的字符串转换为大写。 |
3 |
len() Computes String length(). |
4 |
strip() 帮助从Series/index中的每个字符串的両侧去除空白（包括换行符）。 |
5 |
split(' ') 使用给定的模式对每个字符串进行拆分。 |
6 |
cat(sep=' ') 使用给定的分隔符连接series/index元素。 |
7 |
get_dummies() 返回使用One-Hot编码值的DataFrame。 |
8 |
contains(pattern) 如果子字符串包含在元素中，则为每个元素返回布尔值True，否则返回False。 |
9 |
replace(a,b) 将值 a 替换为值 b 。 |
10 |
repeat(value) 按指定次数重复每个元素。 |
11 |
count(pattern) 返回每个元素中模式出现的次数。 |
12 |
startswith(pattern) 如果Series/Index中的元素以模式开头，则返回true。 |
13 |
endswith(pattern) 如果Series/Index中的元素以模式结尾，则返回true。 |
14 |
find(pattern) 返回模式首次出现的第一个位置。 |
15 |
findall(pattern) 返回模式的所有出现位置列表。 |
16 |
swapcase Swaps the case lower/upper. |
17 |
islower() 检查Series/Index中每个字符串中的所有字符是否全部为小写。返回布尔值 |
18 |
isupper() 检查Series/Index中每个字符串中的所有字符是否全部为大写。返回布尔值。 |
19 |
isnumeric() 检查Series/Index中每个字符串中的所有字符是否都是数字。返回布尔值。 |
现在，我们创建一个Series，看看上述所有函数如何工作。
import pandas as pd
import numpy as np
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])
print s它的 output 如下所示 −
0 Tom
1 William Rick
2 John
3 Alber@t
4 NaN
5 1234
6 Steve Smith
dtype: objectlower()
import pandas as pd
import numpy as np
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])
print s.str.lower()它的 output 如下所示 −
0 tom
1 william rick
2 john
3 alber@t
4 NaN
5 1234
6 steve smith
dtype: objectupper()
import pandas as pd
import numpy as np
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])
print s.str.upper()它的 output 如下所示 −
0 TOM
1 WILLIAM RICK
2 JOHN
3 ALBER@T
4 NaN
5 1234
6 STEVE SMITH
dtype: objectlen()
import pandas as pd
import numpy as np
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])
print s.str.len()它的 output 如下所示 −
0 3.0
1 12.0
2 4.0
3 7.0
4 NaN
5 4.0
6 10.0
dtype: float64strip()
import pandas as pd
import numpy as np
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s
print ("After Stripping:")
print s.str.strip()它的 output 如下所示 −
0 Tom
1 William Rick
2 John
3 Alber@t
dtype: object
After Stripping:
0 Tom
1 William Rick
2 John
3 Alber@t
dtype: objectsplit(pattern)
import pandas as pd
import numpy as np
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s
print ("Split Pattern:")
print s.str.split(' ')它的 output 如下所示 −
0 Tom
1 William Rick
2 John
3 Alber@t
dtype: object
Split Pattern:
0 [Tom, , , , , , , , , , ]
1 [, , , , , William, Rick]
2 [John]
3 [Alber@t]
dtype: objectcat(sep=pattern)
import pandas as pd
import numpy as np
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s.str.cat(sep='_')它的 output 如下所示 −
Tom _ William Rick_John_Alber@tget_dummies()
import pandas as pd
import numpy as np
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s.str.get_dummies()它的 output 如下所示 −
William Rick Alber@t John Tom
0 0 0 0 1
1 1 0 0 0
2 0 0 1 0
3 0 1 0 0contains ()
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s.str.contains(' ')它的 output 如下所示 −
0 True
1 True
2 False
3 False
dtype: boolreplace(a,b)
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s
print ("After replacing @ with $:")
print s.str.replace('@','$')它的 output 如下所示 −
0 Tom
1 William Rick
2 John
3 Alber@t
dtype: object
After replacing @ with $:
0 Tom
1 William Rick
2 John
3 Alber$t
dtype: objectrepeat(value)
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s.str.repeat(2)它的 output 如下所示 −
0 Tom Tom
1 William Rick William Rick
2 JohnJohn
3 Alber@tAlber@t
dtype: objectcount(pattern)
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print ("The number of 'm's in each string:")
print s.str.count('m')它的 output 如下所示 −
The number of 'm's in each string:
0 1
1 1
2 0
3 0startswith(pattern)
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print ("Strings that start with 'T':")
print s.str. startswith ('T')它的 output 如下所示 −
0 True
1 False
2 False
3 False
dtype: boolendswith(pattern)
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print ("Strings that end with 't':")
print s.str.endswith('t')它的 output 如下所示 −
Strings that end with 't':
0 False
1 False
2 False
3 True
dtype: boolfind(pattern)
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s.str.find('e')它的 output 如下所示 −
0 -1
1 -1
2 -1
3 3
dtype: int64“-1”表示元素中没有此类模式。
findall(pattern)
import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s.str.findall('e')它的 output 如下所示 −
0 []
1 []
2 []
3 [e]
dtype: object空列表([ ])表示元素中没有此类模式。
swapcase()
import pandas as pd
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])
print s.str.swapcase()它的 output 如下所示 −
0 tOM
1 wILLIAM rICK
2 jOHN
3 aLBER@T
dtype: objectislower()
import pandas as pd
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])
print s.str.islower()它的 output 如下所示 −
0 False
1 False
2 False
3 False
dtype: boolPython Pandas - Options and Customization
Pandas提供API来定制某些行为，显示最常用的。
该API由五个相关函数组成。它们是−
-
get_option()
-
set_option()
-
reset_option()
-
describe_option()
-
option_context()
现在，我们了解一下函数如何操作。
get_option(param)
get_option获取一个单个参数，并返回如下输出所示的值−
set_option(param,value)
set_option 接受两个参数并设置参数的值，如下所示：
describe_option(param)
describe_option 打印参数的描述。
display.max_rows
使用 reset_option()，我们可以将值更改回默认显示的行数。
import pandas as pd
pd.describe_option("display.max_rows")它的 output 如下所示 −
display.max_rows : int
If max_rows is exceeded, switch to truncate view. Depending on
'large_repr', objects are either centrally truncated or printed as
a summary view. 'None' value means unlimited.
In case python/IPython is running in a terminal and `large_repr`
equals 'truncate' this can be set to 0 and pandas will auto-detect
the height of the terminal and print a truncated object which fits
the screen height. The IPython notebook, IPython qtconsole, or
IDLE do not run in a terminal and hence it is not possible to do
correct auto-detection.
[default: 60] [currently: 60]option_context()
option_context 上下文管理器用于设置 with statement 中的选项。退出 with block 时，选项值会自动恢复。
display.max_rows
使用 option_context()，我们可以暂时设置该值。
import pandas as pd
with pd.option_context("display.max_rows",10):
print(pd.get_option("display.max_rows"))
print(pd.get_option("display.max_rows"))它的 output 如下所示 −
10
10请注意，第一个和第二个打印语句之间的差异。第一个语句打印的是 option_context() 设置的值，它暂时存在于 with context 本身内。在 with context 之后，第二个打印语句打印配置值。
Python Pandas - Indexing and Selecting Data
在本章中，我们将讨论如何对日期进行切片和划分，通常获得 Pandas 对象的子集。
Python 和 NumPy 索引运算符 “[ ]” 和属性运算符 “.” 可以在各种用例中快速简便地访问 Pandas 数据结构。但是，由于要访问的数据类型是事先不知道的，因此直接使用标准运算符会带来一些优化限制。对于生产代码，我们建议你利用本章中介绍的经过优化的 Pandas 数据访问方法。
Pandas 现在支持三种多轴索引；以下表中提到了这三种类型：
Sr.No |
Indexing & Description |
1 |
.loc() Label based |
2 |
.iloc() Integer based |
3 |
.ix() 标签和整数为基础 |
.loc()
Pandas 提供了多种方法来拥有纯粹的 label based indexing 。切片时，也包括起始边界。整数有效标签，但它们指的是该标签，而不是该位置。
.loc() 有多种访问方法，如 −
-
A single scalar label
-
A list of labels
-
A slice object
-
A Boolean array
loc 使用两个由“,”分隔的单一/列表/范围运算符。第一个指示行，而第二个指示列。
Example 1
#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])
#select all rows for a specific column
print df.loc[:,'A']它的 output 如下所示 −
a 0.391548
b -0.070649
c -0.317212
d -2.162406
e 2.202797
f 0.613709
g 1.050559
h 1.122680
Name: A, dtype: float64Example 2
# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])
# Select all rows for multiple columns, say list[]
print df.loc[:,['A','C']]它的 output 如下所示 −
A C
a 0.391548 0.745623
b -0.070649 1.620406
c -0.317212 1.448365
d -2.162406 -0.873557
e 2.202797 0.528067
f 0.613709 0.286414
g 1.050559 0.216526
h 1.122680 -1.621420Example 3
# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])
# Select few rows for multiple columns, say list[]
print df.loc[['a','b','f','h'],['A','C']]它的 output 如下所示 −
A C
a 0.391548 0.745623
b -0.070649 1.620406
f 0.613709 0.286414
h 1.122680 -1.621420Example 4
# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])
# Select range of rows for all columns
print df.loc['a':'h']它的 output 如下所示 −
A B C D
a 0.391548 -0.224297 0.745623 0.054301
b -0.070649 -0.880130 1.620406 1.419743
c -0.317212 -1.929698 1.448365 0.616899
d -2.162406 0.614256 -0.873557 1.093958
e 2.202797 -2.315915 0.528067 0.612482
f 0.613709 -0.157674 0.286414 -0.500517
g 1.050559 -2.272099 0.216526 0.928449
h 1.122680 0.324368 -1.621420 -0.741470Example 5
# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])
# for getting values with a boolean array
print df.loc['a']>0它的 output 如下所示 −
A False
B True
C False
D False
Name: a, dtype: bool.iloc()
Pandas 提供多种方法来获取纯基于整数的索引。如同 python 和 numpy，这些是 0-based 索引。
各种访问方法如下所示 −
-
An Integer
-
A list of integers
-
A range of values
Example 1
# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
# select all rows for a specific column
print df.iloc[:4]它的 output 如下所示 −
A B C D
0 0.699435 0.256239 -1.270702 -0.645195
1 -0.685354 0.890791 -0.813012 0.631615
2 -0.783192 -0.531378 0.025070 0.230806
3 0.539042 -1.284314 0.826977 -0.026251Example 2
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
# Integer slicing
print df.iloc[:4]
print df.iloc[1:5, 2:4]它的 output 如下所示 −
A B C D
0 0.699435 0.256239 -1.270702 -0.645195
1 -0.685354 0.890791 -0.813012 0.631615
2 -0.783192 -0.531378 0.025070 0.230806
3 0.539042 -1.284314 0.826977 -0.026251
C D
1 -0.813012 0.631615
2 0.025070 0.230806
3 0.826977 -0.026251
4 1.423332 1.130568Example 3
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
# Slicing through list of values
print df.iloc[[1, 3, 5], [1, 3]]
print df.iloc[1:3, :]
print df.iloc[:,1:3]它的 output 如下所示 −
B D
1 0.890791 0.631615
3 -1.284314 -0.026251
5 -0.512888 -0.518930
A B C D
1 -0.685354 0.890791 -0.813012 0.631615
2 -0.783192 -0.531378 0.025070 0.230806
B C
0 0.256239 -1.270702
1 0.890791 -0.813012
2 -0.531378 0.025070
3 -1.284314 0.826977
4 -0.460729 1.423332
5 -0.512888 0.581409
6 -1.204853 0.098060
7 -0.947857 0.641358.ix()
除了基于纯标签和基于整数之外，Pandas 提供了一种混合方法来选择和子集化对象，使用 .ix() 运算符。
Example 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
# Integer slicing
print df.ix[:4]它的 output 如下所示 −
A B C D
0 0.699435 0.256239 -1.270702 -0.645195
1 -0.685354 0.890791 -0.813012 0.631615
2 -0.783192 -0.531378 0.025070 0.230806
3 0.539042 -1.284314 0.826977 -0.026251Use of Notations
使用多轴索引从 Pandas 对象获取值使用以下表示法 −
Object |
Indexers |
Return Type |
Series |
s.loc[indexer] |
Scalar value |
DataFrame |
df.loc[row_index,col_index] |
Series object |
Panel |
p.loc[item_index,major_index, minor_index] |
p.loc[item_index,major_index, minor_index] |
Note − .iloc() & .ix() 应用相同的索引选项和返回值。
现在让我们看看如何在 DataFrame 对象上执行每个操作。我们将使用基本的索引运算符“[ ]” −
Example 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
print df['A']它的 output 如下所示 −
0 -0.478893
1 0.391931
2 0.336825
3 -1.055102
4 -0.165218
5 -0.328641
6 0.567721
7 -0.759399
Name: A, dtype: float64Note − 我们可以将一个值列表传递给 [ ] 来选择这些列。
Example 2
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
print df[['A','B']]它的 output 如下所示 −
A B
0 -0.478893 -0.606311
1 0.391931 -0.949025
2 0.336825 0.093717
3 -1.055102 -0.012944
4 -0.165218 1.550310
5 -0.328641 -0.226363
6 0.567721 -0.312585
7 -0.759399 -0.372696Python Pandas - Statistical Functions
统计方法有助于理解和分析数据的行为。我们现在将学习一些可以在 Pandas 对象上应用的统计函数。
Percent_change
Series、DatFrames 和 Panel 都具有函数 pct_change() 。此函数将每个元素与其之前的元素进行比较并计算变化百分比。
import pandas as pd
import numpy as np
s = pd.Series([1,2,3,4,5,4])
print s.pct_change()
df = pd.DataFrame(np.random.randn(5, 2))
print df.pct_change()它的 output 如下所示 −
0 NaN
1 1.000000
2 0.500000
3 0.333333
4 0.250000
5 -0.200000
dtype: float64
0 1
0 NaN NaN
1 -15.151902 0.174730
2 -0.746374 -1.449088
3 -3.582229 -3.165836
4 15.601150 -1.860434默认情况下， pct_change() 在列上运行；如果你想应用同一行，则使用 axis=1() 参数。
Covariance
协方差应用于序列数据。Series 对象有一个方法 cov 来计算序列对象之间的协方差。NA 将自动排除。
Cov Series
import pandas as pd
import numpy as np
s1 = pd.Series(np.random.randn(10))
s2 = pd.Series(np.random.randn(10))
print s1.cov(s2)它的 output 如下所示 −
-0.12978405324协方差方法在应用于 DataFrame 时，计算所有列之间的 cov 。
import pandas as pd
import numpy as np
frame = pd.DataFrame(np.random.randn(10, 5), columns=['a', 'b', 'c', 'd', 'e'])
print frame['a'].cov(frame['b'])
print frame.cov()它的 output 如下所示 −
-0.58312921152741437
a b c d e
a 1.780628 -0.583129 -0.185575 0.003679 -0.136558
b -0.583129 1.297011 0.136530 -0.523719 0.251064
c -0.185575 0.136530 0.915227 -0.053881 -0.058926
d 0.003679 -0.523719 -0.053881 1.521426 -0.487694
e -0.136558 0.251064 -0.058926 -0.487694 0.960761Note − 观察第一条语句中 a 和 b 的 cov ，DataFrame 上的 cov 返回的值也相同。
Correlation
相关性显示任何两个值数组（序列）之间的线性关系。有多种计算相关性的方法，如 pearson（默认）、spearman 和 kendall。
import pandas as pd
import numpy as np
frame = pd.DataFrame(np.random.randn(10, 5), columns=['a', 'b', 'c', 'd', 'e'])
print frame['a'].corr(frame['b'])
print frame.corr()它的 output 如下所示 −
-0.383712785514
a b c d e
a 1.000000 -0.383713 -0.145368 0.002235 -0.104405
b -0.383713 1.000000 0.125311 -0.372821 0.224908
c -0.145368 0.125311 1.000000 -0.045661 -0.062840
d 0.002235 -0.372821 -0.045661 1.000000 -0.403380
e -0.104405 0.224908 -0.062840 -0.403380 1.000000如果 DataFrame 中存在任何非数字列，则会自动将其排除。
Data Ranking
数据排序为数组中的每个元素产生排序。在存在并列的情况下，分配平均等级。
import pandas as pd
import numpy as np
s = pd.Series(np.random.np.random.randn(5), index=list('abcde'))
s['d'] = s['b'] # so there's a tie
print s.rank()它的 output 如下所示 −
a 1.0
b 3.5
c 2.0
d 3.5
e 5.0
dtype: float64Rank 可选地采用 ascending 参数，该参数的默认值为 true；为 false 时，数据将以逆序排名，并将较大的值分配给较小的排名。
Rank 支持不同的平局打破方法，通过 method 参数指定−
-
average − 平局组的平均排名
-
min − 组中最低的排名
-
max − 组中最高的排名
-
first − 以它们在数组中出现的顺序分配等级
Python Pandas - Window Functions
为了处理数值数据，Pandas 提供了几个变体，例如窗口统计的滚动、扩展和指数移动加权。其中包括 sum, mean, median, variance, covariance, correlation, 等。
我们现在将学习如何将这些中的每一个应用于 DataFrame 对象。
.rolling() Function
此函数可以应用于一系列数据。指定 window=n 参数并在其上应用适当的统计函数。
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df.rolling(window=3).mean()它的 output 如下所示 −
A B C D
2000-01-01 NaN NaN NaN NaN
2000-01-02 NaN NaN NaN NaN
2000-01-03 0.434553 -0.667940 -1.051718 -0.826452
2000-01-04 0.628267 -0.047040 -0.287467 -0.161110
2000-01-05 0.398233 0.003517 0.099126 -0.405565
2000-01-06 0.641798 0.656184 -0.322728 0.428015
2000-01-07 0.188403 0.010913 -0.708645 0.160932
2000-01-08 0.188043 -0.253039 -0.818125 -0.108485
2000-01-09 0.682819 -0.606846 -0.178411 -0.404127
2000-01-10 0.688583 0.127786 0.513832 -1.067156Note − 由于窗口大小为 3，对于前两个元素，有空值，从第三个元素开始，值将是 n 、 n-1 和 n-2 元素的平均值。因此，我们还可以应用如上所述的各种函数。
.expanding() Function
此函数可以应用于一系列数据。指定 min_periods=n 参数并在其上应用适当的统计函数。
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df.expanding(min_periods=3).mean()它的 output 如下所示 −
A B C D
2000-01-01 NaN NaN NaN NaN
2000-01-02 NaN NaN NaN NaN
2000-01-03 0.434553 -0.667940 -1.051718 -0.826452
2000-01-04 0.743328 -0.198015 -0.852462 -0.262547
2000-01-05 0.614776 -0.205649 -0.583641 -0.303254
2000-01-06 0.538175 -0.005878 -0.687223 -0.199219
2000-01-07 0.505503 -0.108475 -0.790826 -0.081056
2000-01-08 0.454751 -0.223420 -0.671572 -0.230215
2000-01-09 0.586390 -0.206201 -0.517619 -0.267521
2000-01-10 0.560427 -0.037597 -0.399429 -0.376886.ewm() Function
ewm 应用于一系列数据。指定任何 com、span、 halflife 参数并在其上应用适当的统计函数。它指数分配权重。
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df.ewm(com=0.5).mean()它的 output 如下所示 −
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 0.865131 -0.453626 -1.137961 0.058747
2000-01-03 -0.132245 -0.807671 -0.308308 -1.491002
2000-01-04 1.084036 0.555444 -0.272119 0.480111
2000-01-05 0.425682 0.025511 0.239162 -0.153290
2000-01-06 0.245094 0.671373 -0.725025 0.163310
2000-01-07 0.288030 -0.259337 -1.183515 0.473191
2000-01-08 0.162317 -0.771884 -0.285564 -0.692001
2000-01-09 1.147156 -0.302900 0.380851 -0.607976
2000-01-10 0.600216 0.885614 0.569808 -1.110113窗口函数主要用于通过平滑曲线在图形中查找数据内的趋势。如果每天的数据变化很大，并且有大量可用的数据点，那么抽样和绘制是一个方法，而应用窗口计算并在结果上绘制图形是另一种方法。通过这些方法，我们可以平滑曲线或趋势。
Python Pandas - Aggregations
一旦创建了滚动、扩展和 ewm 对象，就可以使用几种方法对数据执行聚合。
Applying Aggregations on DataFrame
让我们创建一个数据框，并在上面应用聚合。
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r它的 output 如下所示 −
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 0.790670 -0.387854 -0.668132 0.267283
2000-01-03 -0.575523 -0.965025 0.060427 -2.179780
2000-01-04 1.669653 1.211759 -0.254695 1.429166
2000-01-05 0.100568 -0.236184 0.491646 -0.466081
2000-01-06 0.155172 0.992975 -1.205134 0.320958
2000-01-07 0.309468 -0.724053 -1.412446 0.627919
2000-01-08 0.099489 -1.028040 0.163206 -1.274331
2000-01-09 1.639500 -0.068443 0.714008 -0.565969
2000-01-10 0.326761 1.479841 0.664282 -1.361169
Rolling [window=3,min_periods=1,center=False,axis=0]我们可以通过将一个函数传递给整个数据框，或通过标准 get item 方法选择一个列，来进行聚合。
Apply Aggregation on a Whole Dataframe
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r.aggregate(np.sum)它的 output 如下所示 −
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 1.879182 -1.038796 -3.215581 -0.299575
2000-01-03 1.303660 -2.003821 -3.155154 -2.479355
2000-01-04 1.884801 -0.141119 -0.862400 -0.483331
2000-01-05 1.194699 0.010551 0.297378 -1.216695
2000-01-06 1.925393 1.968551 -0.968183 1.284044
2000-01-07 0.565208 0.032738 -2.125934 0.482797
2000-01-08 0.564129 -0.759118 -2.454374 -0.325454
2000-01-09 2.048458 -1.820537 -0.535232 -1.212381
2000-01-10 2.065750 0.383357 1.541496 -3.201469
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 1.879182 -1.038796 -3.215581 -0.299575
2000-01-03 1.303660 -2.003821 -3.155154 -2.479355
2000-01-04 1.884801 -0.141119 -0.862400 -0.483331
2000-01-05 1.194699 0.010551 0.297378 -1.216695
2000-01-06 1.925393 1.968551 -0.968183 1.284044
2000-01-07 0.565208 0.032738 -2.125934 0.482797
2000-01-08 0.564129 -0.759118 -2.454374 -0.325454
2000-01-09 2.048458 -1.820537 -0.535232 -1.212381
2000-01-10 2.065750 0.383357 1.541496 -3.201469Apply Aggregation on a Single Column of a Dataframe
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r['A'].aggregate(np.sum)它的 output 如下所示 −
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 1.879182 -1.038796 -3.215581 -0.299575
2000-01-03 1.303660 -2.003821 -3.155154 -2.479355
2000-01-04 1.884801 -0.141119 -0.862400 -0.483331
2000-01-05 1.194699 0.010551 0.297378 -1.216695
2000-01-06 1.925393 1.968551 -0.968183 1.284044
2000-01-07 0.565208 0.032738 -2.125934 0.482797
2000-01-08 0.564129 -0.759118 -2.454374 -0.325454
2000-01-09 2.048458 -1.820537 -0.535232 -1.212381
2000-01-10 2.065750 0.383357 1.541496 -3.201469
2000-01-01 1.088512
2000-01-02 1.879182
2000-01-03 1.303660
2000-01-04 1.884801
2000-01-05 1.194699
2000-01-06 1.925393
2000-01-07 0.565208
2000-01-08 0.564129
2000-01-09 2.048458
2000-01-10 2.065750
Freq: D, Name: A, dtype: float64Apply Aggregation on Multiple Columns of a DataFrame
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r[['A','B']].aggregate(np.sum)它的 output 如下所示 −
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 1.879182 -1.038796 -3.215581 -0.299575
2000-01-03 1.303660 -2.003821 -3.155154 -2.479355
2000-01-04 1.884801 -0.141119 -0.862400 -0.483331
2000-01-05 1.194699 0.010551 0.297378 -1.216695
2000-01-06 1.925393 1.968551 -0.968183 1.284044
2000-01-07 0.565208 0.032738 -2.125934 0.482797
2000-01-08 0.564129 -0.759118 -2.454374 -0.325454
2000-01-09 2.048458 -1.820537 -0.535232 -1.212381
2000-01-10 2.065750 0.383357 1.541496 -3.201469
A B
2000-01-01 1.088512 -0.650942
2000-01-02 1.879182 -1.038796
2000-01-03 1.303660 -2.003821
2000-01-04 1.884801 -0.141119
2000-01-05 1.194699 0.010551
2000-01-06 1.925393 1.968551
2000-01-07 0.565208 0.032738
2000-01-08 0.564129 -0.759118
2000-01-09 2.048458 -1.820537
2000-01-10 2.065750 0.383357Apply Multiple Functions on a Single Column of a DataFrame
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r['A'].aggregate([np.sum,np.mean])它的 output 如下所示 −
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 1.879182 -1.038796 -3.215581 -0.299575
2000-01-03 1.303660 -2.003821 -3.155154 -2.479355
2000-01-04 1.884801 -0.141119 -0.862400 -0.483331
2000-01-05 1.194699 0.010551 0.297378 -1.216695
2000-01-06 1.925393 1.968551 -0.968183 1.284044
2000-01-07 0.565208 0.032738 -2.125934 0.482797
2000-01-08 0.564129 -0.759118 -2.454374 -0.325454
2000-01-09 2.048458 -1.820537 -0.535232 -1.212381
2000-01-10 2.065750 0.383357 1.541496 -3.201469
sum mean
2000-01-01 1.088512 1.088512
2000-01-02 1.879182 0.939591
2000-01-03 1.303660 0.434553
2000-01-04 1.884801 0.628267
2000-01-05 1.194699 0.398233
2000-01-06 1.925393 0.641798
2000-01-07 0.565208 0.188403
2000-01-08 0.564129 0.188043
2000-01-09 2.048458 0.682819
2000-01-10 2.065750 0.688583Apply Multiple Functions on Multiple Columns of a DataFrame
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10, 4),
index = pd.date_range('1/1/2000', periods=10),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r[['A','B']].aggregate([np.sum,np.mean])它的 output 如下所示 −
A B C D
2000-01-01 1.088512 -0.650942 -2.547450 -0.566858
2000-01-02 1.879182 -1.038796 -3.215581 -0.299575
2000-01-03 1.303660 -2.003821 -3.155154 -2.479355
2000-01-04 1.884801 -0.141119 -0.862400 -0.483331
2000-01-05 1.194699 0.010551 0.297378 -1.216695
2000-01-06 1.925393 1.968551 -0.968183 1.284044
2000-01-07 0.565208 0.032738 -2.125934 0.482797
2000-01-08 0.564129 -0.759118 -2.454374 -0.325454
2000-01-09 2.048458 -1.820537 -0.535232 -1.212381
2000-01-10 2.065750 0.383357 1.541496 -3.201469
A B
sum mean sum mean
2000-01-01 1.088512 1.088512 -0.650942 -0.650942
2000-01-02 1.879182 0.939591 -1.038796 -0.519398
2000-01-03 1.303660 0.434553 -2.003821 -0.667940
2000-01-04 1.884801 0.628267 -0.141119 -0.047040
2000-01-05 1.194699 0.398233 0.010551 0.003517
2000-01-06 1.925393 0.641798 1.968551 0.656184
2000-01-07 0.565208 0.188403 0.032738 0.010913
2000-01-08 0.564129 0.188043 -0.759118 -0.253039
2000-01-09 2.048458 0.682819 -1.820537 -0.606846
2000-01-10 2.065750 0.688583 0.383357 0.127786Apply Different Functions to Different Columns of a Dataframe
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(3, 4),
index = pd.date_range('1/1/2000', periods=3),
columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r.aggregate({'A' : np.sum,'B' : np.mean})它的 output 如下所示 −
A B C D
2000-01-01 -1.575749 -1.018105 0.317797 0.545081
2000-01-02 -0.164917 -1.361068 0.258240 1.113091
2000-01-03 1.258111 1.037941 -0.047487 0.867371
A B
2000-01-01 -1.575749 -1.018105
2000-01-02 -1.740666 -1.189587
2000-01-03 -0.482555 -0.447078Python Pandas - Missing Data
缺失数据在实际生活中始终是一个问题。由于由缺失值导致的数据质量低，机器学习和数据挖掘等领域在其模型预测的准确性方面面临严重问题。在这些领域，缺失值处理是使其模型更准确、更有效的重点。
When and Why Is Data Missed?
我们考虑一下一个产品的在线调查。很多时候，人们不会分享与他们相关的所有信息。很少有人分享他们的体验，但不会分享他们使用该产品的时间；很少有人分享他们使用该产品的时间、体验但不会分享他们的联系信息。因此，或多或少总有部分数据缺失，而且这在实时中是非常常见的。
现在让我们看看如何使用 Pandas 处理缺失值（例如 NA 或 NaN）。
# import the pandas library
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df它的 output 如下所示 −
one two three
a 0.077988 0.476149 0.965836
b NaN NaN NaN
c -0.390208 -0.551605 -2.301950
d NaN NaN NaN
e -2.000303 -0.788201 1.510072
f -0.930230 -0.670473 1.146615
g NaN NaN NaN
h 0.085100 0.532791 0.887415使用 reindexing，我们创建了一个包含缺失值的 DataFrame。在输出中， NaN 意味着 Not a Number.
Check for Missing Values
为了使检测缺失值更容易（并且跨不同的数组数据类型），Pandas 提供了 isnull() 和 notnull() 函数，它们也是 Series 和 DataFrame 对象上的方法 −
Example 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df['one'].isnull()它的 output 如下所示 −
a False
b True
c False
d True
e False
f False
g True
h False
Name: one, dtype: boolExample 2
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df['one'].notnull()它的 output 如下所示 −
a True
b False
c True
d False
e True
f True
g False
h True
Name: one, dtype: boolReplace NaN with a Scalar Value
以下程序显示了如何将“NaN”替换为“0”。
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(3, 3), index=['a', 'c', 'e'],columns=['one',
'two', 'three'])
df = df.reindex(['a', 'b', 'c'])
print df
print ("NaN replaced with '0':")
print df.fillna(0)它的 output 如下所示 −
one two three
a -0.576991 -0.741695 0.553172
b NaN NaN NaN
c 0.744328 -1.735166 1.749580
NaN replaced with '0':
one two three
a -0.576991 -0.741695 0.553172
b 0.000000 0.000000 0.000000
c 0.744328 -1.735166 1.749580在这里，我们用值 0 来填充；相反，我们也可以用任何其他值来填充。
Fill NA Forward and Backward
利用重新索引章节中讨论的填充概念，我们将填充缺失值。
Sr.No |
Method & Action |
1 |
pad/fill Fill methods Forward |
2 |
bfill/backfill Fill methods Backward |
Example 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df.fillna(method='pad')它的 output 如下所示 −
one two three
a 0.077988 0.476149 0.965836
b 0.077988 0.476149 0.965836
c -0.390208 -0.551605 -2.301950
d -0.390208 -0.551605 -2.301950
e -2.000303 -0.788201 1.510072
f -0.930230 -0.670473 1.146615
g -0.930230 -0.670473 1.146615
h 0.085100 0.532791 0.887415Example 2
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df.fillna(method='backfill')它的 output 如下所示 −
one two three
a 0.077988 0.476149 0.965836
b -0.390208 -0.551605 -2.301950
c -0.390208 -0.551605 -2.301950
d -2.000303 -0.788201 1.510072
e -2.000303 -0.788201 1.510072
f -0.930230 -0.670473 1.146615
g 0.085100 0.532791 0.887415
h 0.085100 0.532791 0.887415Drop Missing Values
如果你只想排除缺失值，那么使用 dropna 函数以及 axis 参数。默认情况下，axis=0，即沿着行，这意味着如果一行内的任何值都为 NA，则整行都会被排除在外。
Example 1
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df.dropna()它的 output 如下所示 −
one two three
a 0.077988 0.476149 0.965836
c -0.390208 -0.551605 -2.301950
e -2.000303 -0.788201 1.510072
f -0.930230 -0.670473 1.146615
h 0.085100 0.532791 0.887415Example 2
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df.dropna(axis=1)它的 output 如下所示 −
Empty DataFrame
Columns: [ ]
Index: [a, b, c, d, e, f, g, h]Replace Missing (or) Generic Values
很多时候，我们必须用某个特定值替换一个通用值。我们可以通过应用 replace 方法来实现此目的。
使用标量值替换 NA 与 fillna() 函数的行为相同。
Python Pandas - GroupBy
任何 groupby 操作都涉及对原始对象执行以下操作之一。它们是 −
-
Splitting the Object
-
Applying a function
-
Combining the results
在许多情况下，我们将数据分成集合，并对每个子集应用一些功能。在应用功能中，我们可以执行以下操作 −
-
Aggregation − 计算汇总统计信息
-
Transformation - 执行某些特定组操作
-
Filtration - 丢弃某些条件下的数据
现在，让我们创建一个 DataFrame 对象，并针对其执行所有操作 -
#import the pandas library
import pandas as pd
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
print df它的 output 如下所示 −
Points Rank Team Year
0 876 1 Riders 2014
1 789 2 Riders 2015
2 863 2 Devils 2014
3 673 3 Devils 2015
4 741 3 Kings 2014
5 812 4 kings 2015
6 756 1 Kings 2016
7 788 1 Kings 2017
8 694 2 Riders 2016
9 701 4 Royals 2014
10 804 1 Royals 2015
11 690 2 Riders 2017Split Data into Groups
Pandas 对象可以拆分成它们的对象。有多种拆分对象的方式，例如 -
-
obj.groupby('key')
-
obj.groupby(['key1','key2'])
-
obj.groupby(key,axis=1)
现在，让我们看看如何将分组对象应用到 DataFrame 对象
Example
# import the pandas library
import pandas as pd
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
print df.groupby('Team')它的 output 如下所示 −
<pandas.core.groupby.DataFrameGroupBy object at 0x7fa46a977e50>View Groups
# import the pandas library
import pandas as pd
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
print df.groupby('Team').groups它的 output 如下所示 −
{'Kings': Int64Index([4, 6, 7], dtype='int64'),
'Devils': Int64Index([2, 3], dtype='int64'),
'Riders': Int64Index([0, 1, 8, 11], dtype='int64'),
'Royals': Int64Index([9, 10], dtype='int64'),
'kings' : Int64Index([5], dtype='int64')}Example
Group by 具有多列 -
# import the pandas library
import pandas as pd
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
print df.groupby(['Team','Year']).groups它的 output 如下所示 −
{('Kings', 2014): Int64Index([4], dtype='int64'),
('Royals', 2014): Int64Index([9], dtype='int64'),
('Riders', 2014): Int64Index([0], dtype='int64'),
('Riders', 2015): Int64Index([1], dtype='int64'),
('Kings', 2016): Int64Index([6], dtype='int64'),
('Riders', 2016): Int64Index([8], dtype='int64'),
('Riders', 2017): Int64Index([11], dtype='int64'),
('Devils', 2014): Int64Index([2], dtype='int64'),
('Devils', 2015): Int64Index([3], dtype='int64'),
('kings', 2015): Int64Index([5], dtype='int64'),
('Royals', 2015): Int64Index([10], dtype='int64'),
('Kings', 2017): Int64Index([7], dtype='int64')}Iterating through Groups
有了 groupby 对象，我们可以遍历该对象类似于迭代器。
# import the pandas library
import pandas as pd
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
grouped = df.groupby('Year')
for name,group in grouped:
print name
print group它的 output 如下所示 −
2014
Points Rank Team Year
0 876 1 Riders 2014
2 863 2 Devils 2014
4 741 3 Kings 2014
9 701 4 Royals 2014
2015
Points Rank Team Year
1 789 2 Riders 2015
3 673 3 Devils 2015
5 812 4 kings 2015
10 804 1 Royals 2015
2016
Points Rank Team Year
6 756 1 Kings 2016
8 694 2 Riders 2016
2017
Points Rank Team Year
7 788 1 Kings 2017
11 690 2 Riders 2017默认情况下， groupby 对象具有与组名称相同标签名称。
Select a Group
使用 get_group() 方法，我们可以选择单个组。
# import the pandas library
import pandas as pd
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
grouped = df.groupby('Year')
print grouped.get_group(2014)它的 output 如下所示 −
Points Rank Team Year
0 876 1 Riders 2014
2 863 2 Devils 2014
4 741 3 Kings 2014
9 701 4 Royals 2014Aggregations
聚合函数为每个组返回单个聚合值。创建 group by 对象后，可以在分组数据上执行多个聚合操作。
显而易见的是，通过聚合或等效的 agg 方法进行聚合 -
# import the pandas library
import pandas as pd
import numpy as np
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
grouped = df.groupby('Year')
print grouped['Points'].agg(np.mean)它的 output 如下所示 −
Year
2014 795.25
2015 769.50
2016 725.00
2017 739.00
Name: Points, dtype: float64查看每个组大小的另一种方法是应用 size() 函数 -
import pandas as pd
import numpy as np
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
Attribute Access in Python Pandas
grouped = df.groupby('Team')
print grouped.agg(np.size)它的 output 如下所示 −
Points Rank Year
Team
Devils 2 2 2
Kings 3 3 3
Riders 4 4 4
Royals 2 2 2
kings 1 1 1Applying Multiple Aggregation Functions at Once
对于已分组的 Series，您还可以传递 list 或 dict of functions 来聚合，并生成 DataFrame 作为输出 -
# import the pandas library
import pandas as pd
import numpy as np
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
grouped = df.groupby('Team')
print grouped['Points'].agg([np.sum, np.mean, np.std])它的 output 如下所示 −
Team sum mean std
Devils 1536 768.000000 134.350288
Kings 2285 761.666667 24.006943
Riders 3049 762.250000 88.567771
Royals 1505 752.500000 72.831998
kings 812 812.000000 NaNTransformations
对组或列进行转换会返回一个对象，该对象的索引大小与所分组的对象的索引大小相同。因此，转换应该返回一个大小与组块相同的结果。
# import the pandas library
import pandas as pd
import numpy as np
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
grouped = df.groupby('Team')
score = lambda x: (x - x.mean()) / x.std()*10
print grouped.transform(score)它的 output 如下所示 −
Points Rank Year
0 12.843272 -15.000000 -11.618950
1 3.020286 5.000000 -3.872983
2 7.071068 -7.071068 -7.071068
3 -7.071068 7.071068 7.071068
4 -8.608621 11.547005 -10.910895
5 NaN NaN NaN
6 -2.360428 -5.773503 2.182179
7 10.969049 -5.773503 8.728716
8 -7.705963 5.000000 3.872983
9 -7.071068 7.071068 -7.071068
10 7.071068 -7.071068 7.071068
11 -8.157595 5.000000 11.618950Filtration
过滤会根据定义好的准则过滤数据，并返回数据的子集。 filter() 函数用于过滤数据。
import pandas as pd
import numpy as np
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
print df.groupby('Team').filter(lambda x: len(x) >= 3)它的 output 如下所示 −
Points Rank Team Year
0 876 1 Riders 2014
1 789 2 Riders 2015
4 741 3 Kings 2014
6 756 1 Kings 2016
7 788 1 Kings 2017
8 694 2 Riders 2016
11 690 2 Riders 2017在上述过滤器条件中，我们要求返回参加过三次或以上 IPL 比赛的球队。
Python Pandas - Merging/Joining
Pandas 具有功能全面、性能卓越的内存中连接操作，与 SQL 等关系数据库极为相似。
Pandas 提供了一个函数 merge ，作为 DataFrame 对象之间所有标准数据库连接操作的入口点 -
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
left_index=False, right_index=False, sort=True)此处，我们使用了以下参数 -
-
left − 数据框对象。
-
right − 另一个数据框对象。
-
on − 要连接的列（名称）。必须同时在左数据框和右数据框对象中找到。
-
left_on − 从左数据框中作为键使用的列。可以是列名或长度等于数据框长度的数组。
-
right_on − 从右数据框中作为键使用的列。可以是列名或长度等于数据框长度的数组。
-
left_index − 如果 True, 使用左数据框的索引（行标签）作为其连接键。如果数据框具有多重索引 (分级)，则级别的数量必须匹配右数据框的连接键的数量。
-
right_index − 与右数据框的 left_index 相同用法。
-
how − 'left', 'right', 'outer', 'inner' 之一。默认为 inner。每种方法都在下面进行了描述。
-
sort − 按字典顺序对结果数据框按连接键进行排序。默认为 True，在许多情况下设置为 False 将大幅提高性能。
现在让我们创建两个不同的 DataFrame 并对它们执行合并操作。
# import the pandas library
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame(
{'id':[1,2,3,4,5],
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print left
print right它的 output 如下所示 −
Name id subject_id
0 Alex 1 sub1
1 Amy 2 sub2
2 Allen 3 sub4
3 Alice 4 sub6
4 Ayoung 5 sub5
Name id subject_id
0 Billy 1 sub2
1 Brian 2 sub4
2 Bran 3 sub3
3 Bryce 4 sub6
4 Betty 5 sub5Merge Two DataFrames on a Key
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left,right,on='id')它的 output 如下所示 −
Name_x id subject_id_x Name_y subject_id_y
0 Alex 1 sub1 Billy sub2
1 Amy 2 sub2 Brian sub4
2 Allen 3 sub4 Bran sub3
3 Alice 4 sub6 Bryce sub6
4 Ayoung 5 sub5 Betty sub5Merge Two DataFrames on Multiple Keys
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left,right,on=['id','subject_id'])它的 output 如下所示 −
Name_x id subject_id Name_y
0 Alice 4 sub6 Bryce
1 Ayoung 5 sub5 BettyMerge Using 'how' Argument
merge 的 how 参数指定如何确定要包含在结果表中的键。如果键组合没有出现在左表或右表中，则连接表中的值将为 NA。
以下是 how 选项及其 SQL 等价名称的摘要 −
Merge Method |
SQL Equivalent |
Description |
left |
LEFT OUTER JOIN |
使用左对象的键 |
right |
RIGHT OUTER JOIN |
使用右对象的键 |
outer |
FULL OUTER JOIN |
Use union of keys |
inner |
INNER JOIN |
Use intersection of keys |
Left Join
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, on='subject_id', how='left')它的 output 如下所示 −
Name_x id_x subject_id Name_y id_y
0 Alex 1 sub1 NaN NaN
1 Amy 2 sub2 Billy 1.0
2 Allen 3 sub4 Brian 2.0
3 Alice 4 sub6 Bryce 4.0
4 Ayoung 5 sub5 Betty 5.0Right Join
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, on='subject_id', how='right')它的 output 如下所示 −
Name_x id_x subject_id Name_y id_y
0 Amy 2.0 sub2 Billy 1
1 Allen 3.0 sub4 Brian 2
2 Alice 4.0 sub6 Bryce 4
3 Ayoung 5.0 sub5 Betty 5
4 NaN NaN sub3 Bran 3Outer Join
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, how='outer', on='subject_id')它的 output 如下所示 −
Name_x id_x subject_id Name_y id_y
0 Alex 1.0 sub1 NaN NaN
1 Amy 2.0 sub2 Billy 1.0
2 Allen 3.0 sub4 Brian 2.0
3 Alice 4.0 sub6 Bryce 4.0
4 Ayoung 5.0 sub5 Betty 5.0
5 NaN NaN sub3 Bran 3.0Inner Join
连接将在索引上执行。连接操作会遵守对其进行调用的对象。因此， a.join(b) 不等于 b.join(a) 。
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
'id':[1,2,3,4,5],
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, on='subject_id', how='inner')它的 output 如下所示 −
Name_x id_x subject_id Name_y id_y
0 Amy 2 sub2 Billy 1
1 Allen 3 sub4 Brian 2
2 Alice 4 sub6 Bryce 4
3 Ayoung 5 sub5 Betty 5Python Pandas - Concatenation
Pandas 提供了多种功能，可轻松组合 Series, DataFrame 和 Panel 对象。
pd.concat(objs,axis=0,join='outer',join_axes=None,
ignore_index=False)-
objs − 这是 Series、DataFrame 或 Panel 对象的序列或映射。
-
axis − {0, 1, …}，默认为 0。这是要沿其连接的轴。
-
join − {‘inner’, ‘outer’}，默认为 ‘outer’。如何处理其他轴上的索引。Outer 用于并集，inner 用于交集。
-
ignore_index − 布尔值，默认为 False。如果为 True，则不使用连接轴上的索引值。结果轴将被标记为 0、…、n - 1。
-
join_axes −这是索引对象列表。用于其他 (n-1) 轴的特定索引，而不是执行内部/外部设置逻辑。
Concatenating Objects
concat 函数执行沿轴执行串联操作的所有繁重工作。让我们创建不同的对象并进行串联。
import pandas as pd
one = pd.DataFrame({
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5'],
'Marks_scored':[98,90,87,69,78]},
index=[1,2,3,4,5])
two = pd.DataFrame({
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5'],
'Marks_scored':[89,80,79,97,88]},
index=[1,2,3,4,5])
print pd.concat([one,two])它的 output 如下所示 −
Marks_scored Name subject_id
1 98 Alex sub1
2 90 Amy sub2
3 87 Allen sub4
4 69 Alice sub6
5 78 Ayoung sub5
1 89 Billy sub2
2 80 Brian sub4
3 79 Bran sub3
4 97 Bryce sub6
5 88 Betty sub5假设我们希望将特定键与切片的每个 DataFrame 片段相关联。我们可以通过使用 keys 参数来实现此目的−
import pandas as pd
one = pd.DataFrame({
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5'],
'Marks_scored':[98,90,87,69,78]},
index=[1,2,3,4,5])
two = pd.DataFrame({
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5'],
'Marks_scored':[89,80,79,97,88]},
index=[1,2,3,4,5])
print pd.concat([one,two],keys=['x','y'])它的 output 如下所示 −
x 1 98 Alex sub1
2 90 Amy sub2
3 87 Allen sub4
4 69 Alice sub6
5 78 Ayoung sub5
y 1 89 Billy sub2
2 80 Brian sub4
3 79 Bran sub3
4 97 Bryce sub6
5 88 Betty sub5结果索引被复制；每个索引都被重复。
如果结果对象必须遵循其自己的索引，则将 ignore_index 设置为 True 。
import pandas as pd
one = pd.DataFrame({
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5'],
'Marks_scored':[98,90,87,69,78]},
index=[1,2,3,4,5])
two = pd.DataFrame({
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5'],
'Marks_scored':[89,80,79,97,88]},
index=[1,2,3,4,5])
print pd.concat([one,two],keys=['x','y'],ignore_index=True)它的 output 如下所示 −
Marks_scored Name subject_id
0 98 Alex sub1
1 90 Amy sub2
2 87 Allen sub4
3 69 Alice sub6
4 78 Ayoung sub5
5 89 Billy sub2
6 80 Brian sub4
7 79 Bran sub3
8 97 Bryce sub6
9 88 Betty sub5请观察，索引完全更改，并且键也被覆盖。
如果两个对象需要沿 axis=1 添加，那么将追加新列。
import pandas as pd
one = pd.DataFrame({
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5'],
'Marks_scored':[98,90,87,69,78]},
index=[1,2,3,4,5])
two = pd.DataFrame({
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5'],
'Marks_scored':[89,80,79,97,88]},
index=[1,2,3,4,5])
print pd.concat([one,two],axis=1)它的 output 如下所示 −
Marks_scored Name subject_id Marks_scored Name subject_id
1 98 Alex sub1 89 Billy sub2
2 90 Amy sub2 80 Brian sub4
3 87 Allen sub4 79 Bran sub3
4 69 Alice sub6 97 Bryce sub6
5 78 Ayoung sub5 88 Betty sub5Concatenating Using append
一个有用的串联快捷方式是 Series 和 DataFrame 上的 append 实例方法。这些方法实际上早于 concat。它们沿 axis=0 串联，即索引−
import pandas as pd
one = pd.DataFrame({
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5'],
'Marks_scored':[98,90,87,69,78]},
index=[1,2,3,4,5])
two = pd.DataFrame({
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5'],
'Marks_scored':[89,80,79,97,88]},
index=[1,2,3,4,5])
print one.append(two)它的 output 如下所示 −
Marks_scored Name subject_id
1 98 Alex sub1
2 90 Amy sub2
3 87 Allen sub4
4 69 Alice sub6
5 78 Ayoung sub5
1 89 Billy sub2
2 80 Brian sub4
3 79 Bran sub3
4 97 Bryce sub6
5 88 Betty sub5append 函数也可以接受多个对象−
import pandas as pd
one = pd.DataFrame({
'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
'subject_id':['sub1','sub2','sub4','sub6','sub5'],
'Marks_scored':[98,90,87,69,78]},
index=[1,2,3,4,5])
two = pd.DataFrame({
'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
'subject_id':['sub2','sub4','sub3','sub6','sub5'],
'Marks_scored':[89,80,79,97,88]},
index=[1,2,3,4,5])
print one.append([two,one,two])它的 output 如下所示 −
Marks_scored Name subject_id
1 98 Alex sub1
2 90 Amy sub2
3 87 Allen sub4
4 69 Alice sub6
5 78 Ayoung sub5
1 89 Billy sub2
2 80 Brian sub4
3 79 Bran sub3
4 97 Bryce sub6
5 88 Betty sub5
1 98 Alex sub1
2 90 Amy sub2
3 87 Allen sub4
4 69 Alice sub6
5 78 Ayoung sub5
1 89 Billy sub2
2 80 Brian sub4
3 79 Bran sub3
4 97 Bryce sub6
5 88 Betty sub5Time Series
Pandas 提供了一个强大的工具，用于使用时间序列数据进行工作时间，尤其是在金融领域。在使用时间序列数据时，我们经常会遇到以下问题 −
-
Generating sequence of time
-
将时间序列转换为不同频率
Pandas 提供了一组相对紧凑和独立的工具来执行上述任务。
Get Current Time
datetime.now() 为您提供当前日期和时间。
import pandas as pd
print pd.datetime.now()它的 output 如下所示 −
2017-05-11 06:10:13.393147Create a TimeStamp
时间戳数据是最基本类型的时间序列数据，它将值与时间点相关联。对于 pandas 对象，这意味着使用时间点。我们来看一个例子−
import pandas as pd
print pd.Timestamp('2017-03-01')它的 output 如下所示 −
2017-03-01 00:00:00还可以转换整数或浮点数时间戳。它们的默认单位是纳秒（因为这是 Timestamp 的存储方式）。但是，时间戳经常存储在另一个单位中，该单位可以被指定。我们来看另一个例子
import pandas as pd
print pd.Timestamp(1587687255,unit='s')它的 output 如下所示 −
2020-04-24 00:14:15Create a Range of Time
import pandas as pd
print pd.date_range("11:00", "13:30", freq="30min").time它的 output 如下所示 −
[datetime.time(11, 0) datetime.time(11, 30) datetime.time(12, 0)
datetime.time(12, 30) datetime.time(13, 0) datetime.time(13, 30)]Change the Frequency of Time
import pandas as pd
print pd.date_range("11:00", "13:30", freq="H").time它的 output 如下所示 −
[datetime.time(11, 0) datetime.time(12, 0) datetime.time(13, 0)]Converting to Timestamps
要转换Series 或类似列表的类似日期的对象，例如字符串、时间戳或混合，可以使用 to_datetime 函数。传递时，它返回一个 Series（具有相同的索引），而 list-like 将转换为 DatetimeIndex 。请看以下示例 −
import pandas as pd
print pd.to_datetime(pd.Series(['Jul 31, 2009','2010-01-10', None]))它的 output 如下所示 −
0 2009-07-31
1 2010-01-10
2 NaT
dtype: datetime64[ns]NaT 表示 Not a Time （等同于 NaN）
我们来看另一个例子。
import pandas as pd
print pd.to_datetime(['2005/11/23', '2010.12.31', None])它的 output 如下所示 −
DatetimeIndex(['2005-11-23', '2010-12-31', 'NaT'], dtype='datetime64[ns]', freq=None)Python Pandas - Date Functionality
扩展时间序列，日期功能在金融数据分析中扮演着重要角色。在使用日期数据时，我们经常会遇到以下问题−
-
Generating sequence of dates
-
将日期序列转换为不同的频率
Create a Range of Dates
通过指定周期和频率使用 date.range() 函数，我们可以创建日期序列。默认情况下，范围的频率为天。
import pandas as pd
print pd.date_range('1/1/2011', periods=5)它的 output 如下所示 −
DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
dtype='datetime64[ns]', freq='D')Change the Date Frequency
import pandas as pd
print pd.date_range('1/1/2011', periods=5,freq='M')它的 output 如下所示 −
DatetimeIndex(['2011-01-31', '2011-02-28', '2011-03-31', '2011-04-30', '2011-05-31'],
dtype='datetime64[ns]', freq='M')bdate_range
bdate_range() 代表业务日期范围。不同于 date_range()，它排除了星期六和星期日。
import pandas as pd
print pd.date_range('1/1/2011', periods=5)它的 output 如下所示 −
DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
dtype='datetime64[ns]', freq='D')注意，在 3 月 3 日之后，日期跳到 3 月 6 日，排除了 4 日和 5 日。只需查看您日历中的天数即可。
像 date_range 和 bdate_range 这样的便捷函数利用了各种频率别名。date_range 的默认频率是日历日，而 bdate_range 的默认频率是工作日。
import pandas as pd
start = pd.datetime(2011, 1, 1)
end = pd.datetime(2011, 1, 5)
print pd.date_range(start, end)它的 output 如下所示 −
DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
dtype='datetime64[ns]', freq='D')Offset Aliases
将许多字符串别名提供给有用的常见时间序列频率。我们将这些别名称为偏移别名。
Alias |
Description |
Alias |
Description |
B |
business day frequency |
BQS |
business quarter start frequency |
D |
calendar day frequency |
A |
annual(Year) end frequency |
W |
weekly frequency |
BA |
business year end frequency |
M |
month end frequency |
BAS |
business year start frequency |
SM |
semi-month end frequency |
BH |
business hour frequency |
BM |
business month end frequency |
H |
hourly frequency |
MS |
month start frequency |
T, min |
minutely frequency |
SMS |
短信半月开始频率 |
S |
secondly frequency |
BMS |
business month start frequency |
L, ms |
milliseconds |
Q |
quarter end frequency |
U, us |
microseconds |
BQ |
business quarter end frequency |
N |
nanoseconds |
QS |
quarter start frequency |
Python Pandas - Timedelta
时间差是时间差异，表示为差分单位，例如天、小时、分钟、秒。它们既可以是正值，也可以是负值。
我们可以使用各种参数来创建 Timedelta 对象，如下所示：
String
通过传递字符串文字，我们可以创建一个 timedelta 对象。
import pandas as pd
print pd.Timedelta('2 days 2 hours 15 minutes 30 seconds')它的 output 如下所示 −
2 days 02:15:30Integer
通过使用单位的整数值作为参数创建一个 Timedelta 对象。
import pandas as pd
print pd.Timedelta(6,unit='h')它的 output 如下所示 −
0 days 06:00:00Data Offsets
在构造中还可以使用数据偏移量，例如 - 周、天、小时、分钟、秒、毫秒、微秒、纳秒。
import pandas as pd
print pd.Timedelta(days=2)它的 output 如下所示 −
2 days 00:00:00to_timedelta()
使用顶级 pd.to_timedelta ，你可以将标量、数组、列表或序列从公认 timedelta 格式/值转换为 Timedelta 类型。如果输入是序列，它将构建序列；如果输入是标量，它将构建标量；否则，将输出一个 TimedeltaIndex 。
import pandas as pd
print pd.Timedelta(days=2)它的 output 如下所示 −
2 days 00:00:00Operations
你可以操作 Series/ DataFrame，并通过对 datetime64[ns] Series 或时间戳执行减法操作来构建 timedelta64[ns] Series。
现在，我们创建一个包含 Timedelta 和日期时间对象的 DataFrame，并对其执行一些算术运算：
import pandas as pd
s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
td = pd.Series([ pd.Timedelta(days=i) for i in range(3) ])
df = pd.DataFrame(dict(A = s, B = td))
print df它的 output 如下所示 −
A B
0 2012-01-01 0 days
1 2012-01-02 1 days
2 2012-01-03 2 daysAddition Operations
import pandas as pd
s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
td = pd.Series([ pd.Timedelta(days=i) for i in range(3) ])
df = pd.DataFrame(dict(A = s, B = td))
df['C']=df['A']+df['B']
print df它的 output 如下所示 −
A B C
0 2012-01-01 0 days 2012-01-01
1 2012-01-02 1 days 2012-01-03
2 2012-01-03 2 days 2012-01-05Subtraction Operation
import pandas as pd
s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
td = pd.Series([ pd.Timedelta(days=i) for i in range(3) ])
df = pd.DataFrame(dict(A = s, B = td))
df['C']=df['A']+df['B']
df['D']=df['C']+df['B']
print df它的 output 如下所示 −
A B C D
0 2012-01-01 0 days 2012-01-01 2012-01-01
1 2012-01-02 1 days 2012-01-03 2012-01-04
2 2012-01-03 2 days 2012-01-05 2012-01-07Python Pandas - Categorical Data
通常在实时数据中，将包含重复的文本列。性别、国家和代码等要素始终是重复的。这些是分类数据的示例。
分类变量只能取有限且通常是固定数量的可能值。除了固定长度外，分类数据可能存在顺序，但不能执行数值操作。分类是熊猫数据类型。
分类数据类型在以下情况下有用−
-
仅包含几个不同值的字符串变量。将这种字符串变量转换为分类变量将节省一些内存。
-
变量的字典顺序与逻辑顺序不同（“一”、“二”、“三”）。通过转换为分类并在类别上指定顺序，排序和 min/max 将使用逻辑顺序而不是字典顺序。
-
作为对其他 Python 库的信号，表明此列应视为分类变量（例如，使用合适的统计方法或绘图类型）。
Object Creation
分类对象可以通过多种方式创建。以下介绍了不同的方式-
category
在熊猫对象创建中将 dtype 指定为“类别”。
import pandas as pd
s = pd.Series(["a","b","c","a"], dtype="category")
print s它的 output 如下所示 −
0 a
1 b
2 c
3 a
dtype: category
Categories (3, object): [a, b, c]传递给 series 对象的元素数量为四个，但类别只有三个。在输出类别中观察相同的内容。
pd.Categorical
使用标准的 pandas 分类构造函数，我们可以创建一个类别对象。
pandas.Categorical(values, categories, ordered)让我们举个例子-
import pandas as pd
cat = pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c'])
print cat它的 output 如下所示 −
[a, b, c, a, b, c]
Categories (3, object): [a, b, c]我们举另一个例子-
import pandas as pd
cat = cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'])
print cat它的 output 如下所示 −
[a, b, c, a, b, c, NaN]
Categories (3, object): [c, b, a]在此，第二个参数表示类别。因此，在类别中不存在的任何值都将被视为 NaN 。
现在，看下面的例子 -
import pandas as pd
cat = cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'],ordered=True)
print cat它的 output 如下所示 −
[a, b, c, a, b, c, NaN]
Categories (3, object): [c < b < a]从逻辑上来说，该顺序表示 a 大于 b ， b 大于 c 。
Description
使用分类数据上的 .describe() 命令，我们得到一个类似于 type 字符串中的 Series 或 DataFrame 的输出。
import pandas as pd
import numpy as np
cat = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
df = pd.DataFrame({"cat":cat, "s":["a", "c", "c", np.nan]})
print df.describe()
print df["cat"].describe()它的 output 如下所示 −
cat s
count 3 3
unique 2 2
top c c
freq 2 2
count 3
unique 2
top c
freq 2
Name: cat, dtype: objectGet the Properties of the Category
obj.cat.categories 命令用于获取 categories of the object 。
import pandas as pd
import numpy as np
s = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
print s.categories它的 output 如下所示 −
Index([u'b', u'a', u'c'], dtype='object')obj.ordered 命令用于获取对象的顺序。
import pandas as pd
import numpy as np
cat = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
print cat.ordered它的 output 如下所示 −
False函数返回 false ，因为我们没有指定任何顺序。
Renaming Categories
通过将新值赋值给 *series.cat.categories*series.cat.categories 属性来重新命名类别。
import pandas as pd
s = pd.Series(["a","b","c","a"], dtype="category")
s.cat.categories = ["Group %s" % g for g in s.cat.categories]
print s.cat.categories它的 output 如下所示 −
Index([u'Group a', u'Group b', u'Group c'], dtype='object')对象的 s.cat.categories 属性更新了初始类别 [a,b,c] 。
Appending New Categories
使用 Categorical.add.categories() 方法可以附加新类别。
import pandas as pd
s = pd.Series(["a","b","c","a"], dtype="category")
s = s.cat.add_categories([4])
print s.cat.categories它的 output 如下所示 −
Index([u'a', u'b', u'c', 4], dtype='object')Removing Categories
使用 Categorical.remove_categories() 方法可以删除不需要的类别。
import pandas as pd
s = pd.Series(["a","b","c","a"], dtype="category")
print ("Original object:")
print s
print ("After removal:")
print s.cat.remove_categories("a")它的 output 如下所示 −
Original object:
0 a
1 b
2 c
3 a
dtype: category
Categories (3, object): [a, b, c]
After removal:
0 NaN
1 b
2 c
3 NaN
dtype: category
Categories (2, object): [b, c]Comparison of Categorical Data
在三个情况下，分类数据与其他对象进行比较 -
-
与与分类数据长度相同的类似列表的对象（列表、序列、数组等）比较相等（== 和 !=）。
-
当 ordered==True 且类别相同时，将分类数据与另一个分类序列进行所有比较（==、!=、>、>=、< 和 ⇐）。
-
将分类数据与标量进行所有比较。
请看以下示例：
import pandas as pd
cat = pd.Series([1,2,3]).astype("category", categories=[1,2,3], ordered=True)
cat1 = pd.Series([2,2,2]).astype("category", categories=[1,2,3], ordered=True)
print cat>cat1它的 output 如下所示 −
0 False
1 False
2 True
dtype: boolPython Pandas - Visualization
Basic Plotting: plot
Series 和 DataFrame 上的此功能只是对 matplotlib libraries plot() 方法的简单包装。
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10,4),index=pd.date_range('1/1/2000',
periods=10), columns=list('ABCD'))
df.plot()它的 output 如下所示 −
如果索引包含日期，它将调用 gct().autofmt_xdate() 将 x 轴格式化为如上图所示。
我们可以使用 x 和 y 关键字将一列与另一列作对比。
绘图方法允许一些绘图样式，这些样式与默认的线图不同。这些方法可以作为 plot() 的 kind 关键字参数提供。它们包括 -
-
适用于条形图的 bar 或 barh
-
hist for histogram
-
box for boxplot
-
'area' for area plots
-
'scatter' for scatter plots
Bar Plot
让我们通过创建一个条形图来看一个条形图是什么。条形图可以通过以下方式创建 -
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')
df.plot.bar()它的 output 如下所示 −
若要制作堆叠条形图，使用 pass stacked=True −
import pandas as pd
df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')
df.plot.bar(stacked=True)它的 output 如下所示 −
若要获得水平条形图，使用 barh 方法 −
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')
df.plot.barh(stacked=True)它的 output 如下所示 −
Histograms
可以使用 plot.hist() 方法绘制直方图。我们可以指定柱的数量。
import pandas as pd
import numpy as np
df = pd.DataFrame({'a':np.random.randn(1000)+1,'b':np.random.randn(1000),'c':
np.random.randn(1000) - 1}, columns=['a', 'b', 'c'])
df.plot.hist(bins=20)它的 output 如下所示 −
若要针对每一列绘制不同的直方图，使用以下代码 −
import pandas as pd
import numpy as np
df=pd.DataFrame({'a':np.random.randn(1000)+1,'b':np.random.randn(1000),'c':
np.random.randn(1000) - 1}, columns=['a', 'b', 'c'])
df.diff.hist(bins=20)它的 output 如下所示 −
Box Plots
可以通过调用 Series.box.plot() 和 DataFrame.box.plot() 或 DataFrame.boxplot() 绘制箱形图，以可视化每列中的值分布。
例如，这里是一个箱线图，表示在 [0,1) 上的均匀随机变量的 10 次观测的五次试验。
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(10, 5), columns=['A', 'B', 'C', 'D', 'E'])
df.plot.box()它的 output 如下所示 −
Area Plot
可以使用 Series.plot.area() 或 DataFrame.plot.area() 方法创建面积图。
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(10, 4), columns=['a', 'b', 'c', 'd'])
df.plot.area()它的 output 如下所示 −
Python Pandas - IO Tools
Pandas I/O API 是一个顶级读取器函数集，其访问方式类似于 pd.read_csv() ，它通常返回一个 Pandas 对象。
用于读取文本文件（或平面文件）的两个主力函数是 read_csv() 和 read_table() 。它们都使用相同的解析代码，将表格数据智能地转换为一个 DataFrame 对象：
pandas.read_csv(filepath_or_buffer, sep=',', delimiter=None, header='infer',
names=None, index_col=None, usecols=Nonepandas.read_csv(filepath_or_buffer, sep='\t', delimiter=None, header='infer',
names=None, index_col=None, usecols=None以下是 csv 文件数据的样子 −
S.No,Name,Age,City,Salary
1,Tom,28,Toronto,20000
2,Lee,32,HongKong,3000
3,Steven,43,Bay Area,8300
4,Ram,38,Hyderabad,3900将这些数据另存为 temp.csv 并对其进行操作。
S.No,Name,Age,City,Salary
1,Tom,28,Toronto,20000
2,Lee,32,HongKong,3000
3,Steven,43,Bay Area,8300
4,Ram,38,Hyderabad,3900将这些数据另存为 temp.csv 并对其进行操作。
read.csv
read.csv 从 csv 文件中读取数据并创建一个 DataFrame 对象。
import pandas as pd
df=pd.read_csv("temp.csv")
print df它的 output 如下所示 −
S.No Name Age City Salary
0 1 Tom 28 Toronto 20000
1 2 Lee 32 HongKong 3000
2 3 Steven 43 Bay Area 8300
3 4 Ram 38 Hyderabad 3900custom index
这指定 csv 文件中使用 index_col. 自定义索引的列。
import pandas as pd
df=pd.read_csv("temp.csv",index_col=['S.No'])
print df它的 output 如下所示 −
S.No Name Age City Salary
1 Tom 28 Toronto 20000
2 Lee 32 HongKong 3000
3 Steven 43 Bay Area 8300
4 Ram 38 Hyderabad 3900Converters
列的 dtype 可以作为 dict 传递。
import pandas as pd
df = pd.read_csv("temp.csv", dtype={'Salary': np.float64})
print df.dtypes它的 output 如下所示 −
S.No int64
Name object
Age int64
City object
Salary float64
dtype: object默认情况下，Salary 列的 dtype 为 int ，但结果显示为 float ，因为我们已显式地强制转换了该类型。
因此，数据看起来像浮点数 −
S.No Name Age City Salary
0 1 Tom 28 Toronto 20000.0
1 2 Lee 32 HongKong 3000.0
2 3 Steven 43 Bay Area 8300.0
3 4 Ram 38 Hyderabad 3900.0header_names
使用 names 参数指定标头名称。
import pandas as pd
df=pd.read_csv("temp.csv", names=['a', 'b', 'c','d','e'])
print df它的 output 如下所示 −
a b c d e
0 S.No Name Age City Salary
1 1 Tom 28 Toronto 20000
2 2 Lee 32 HongKong 3000
3 3 Steven 43 Bay Area 8300
4 4 Ram 38 Hyderabad 3900请注意，标头名称附加自定义名称，但文件中的标头尚未消除。现在，我们使用 header 参数来删除该标头。
如果标头不在第一行，则将行号传递给 header。这将跳过前几行。
import pandas as pd
df=pd.read_csv("temp.csv",names=['a','b','c','d','e'],header=0)
print df它的 output 如下所示 −
a b c d e
0 S.No Name Age City Salary
1 1 Tom 28 Toronto 20000
2 2 Lee 32 HongKong 3000
3 3 Steven 43 Bay Area 8300
4 4 Ram 38 Hyderabad 3900Python Pandas - Sparse Data
当省略任何与特定值（NaN/空白值，但可以选择任何值）匹配的数据时，“压缩”稀疏对象。一个特殊的 SparseIndex 对象会追踪数据被“稀疏化”的位置。这将在一个示例中更有意义。所有标准 Pandas 数据结构都会应用 to_sparse 方法 −
import pandas as pd
import numpy as np
ts = pd.Series(np.random.randn(10))
ts[2:-2] = np.nan
sts = ts.to_sparse()
print sts它的 output 如下所示 −
0 -0.810497
1 -1.419954
2 NaN
3 NaN
4 NaN
5 NaN
6 NaN
7 NaN
8 0.439240
9 -1.095910
dtype: float64
BlockIndex
Block locations: array([0, 8], dtype=int32)
Block lengths: array([2, 2], dtype=int32)稀疏对象的存在是为了提高内存效率。
让我们假设你有一个较大的 NA DataFrame 并执行以下代码 −
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(10000, 4))
df.ix[:9998] = np.nan
sdf = df.to_sparse()
print sdf.density它的 output 如下所示 −
0.0001可以使用 to_dense 将任何稀疏对象转换回标准的密集形式 −
import pandas as pd
import numpy as np
ts = pd.Series(np.random.randn(10))
ts[2:-2] = np.nan
sts = ts.to_sparse()
print sts.to_dense()它的 output 如下所示 −
0 -0.810497
1 -1.419954
2 NaN
3 NaN
4 NaN
5 NaN
6 NaN
7 NaN
8 0.439240
9 -1.095910
dtype: float64Sparse Dtypes
稀疏数据应该与其密集表示形式具有相同的 dtype。当前，支持 float64, int64 和 booldtypes 。根据原始 dtype, fill_value default 更改 −
-
float64 − np.nan
-
int64 − 0
-
bool − False
让我们执行以下代码来理解这一点 −
import pandas as pd
import numpy as np
s = pd.Series([1, np.nan, np.nan])
print s
s.to_sparse()
print s它的 output 如下所示 −
0 1.0
1 NaN
2 NaN
dtype: float64
0 1.0
1 NaN
2 NaN
dtype: float64Python Pandas - Caveats & Gotchas
警告是指警示而意外问题是指不可预见的问题。
Using If/Truth Statement with Pandas
当您尝试将某个内容转换成 bool 时，Pandas 遵循 numpy 惯例发出错误。这发生在 if 中或 when 中，使用布尔运算以及 or 或 not 。结果应该是什么还不清楚。它应该是 True 因为它不是零长度吗？还是 False 因为存在 False 值？还不清楚，因此，Pandas 会发出 ValueError −
import pandas as pd
if pd.Series([False, True, False]):
print 'I am True'它的 output 如下所示 −
ValueError: The truth value of a Series is ambiguous.
Use a.empty, a.bool() a.item(),a.any() or a.all().在 if 条件中，不清楚该对其做什么。错误暗示应使用 None 还是 any of those 。
import pandas as pd
if pd.Series([False, True, False]).any():
print("I am any")它的 output 如下所示 −
I am any若要在布尔上下文中评估单元素 pandas 对象，使用 .bool() 方法 −
import pandas as pd
print pd.Series([True]).bool()它的 output 如下所示 −
TrueBitwise Boolean
Bitwise 布尔运算符（如 == 和 ! ）将返回一个布尔序列，这几乎总是所需。
import pandas as pd
s = pd.Series(range(5))
print s==4它的 output 如下所示 −
0 False
1 False
2 False
3 False
4 True
dtype: boolisin Operation
这返回一个布尔序列，显示 Series 中的每个元素是否恰好包含在传递的值序列中。
import pandas as pd
s = pd.Series(list('abc'))
s = s.isin(['a', 'c', 'e'])
print s它的 output 如下所示 −
0 True
1 False
2 True
dtype: boolReindexing vs ix Gotcha
许多用户会发现自己使用 ix indexing capabilities 作为从 Pandas 对象选择数据的一种简洁方式 −
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))
print df
print df.ix[['b', 'c', 'e']]它的 output 如下所示 −
one two three four
a -1.582025 1.335773 0.961417 -1.272084
b 1.461512 0.111372 -0.072225 0.553058
c -1.240671 0.762185 1.511936 -0.630920
d -2.380648 -0.029981 0.196489 0.531714
e 1.846746 0.148149 0.275398 -0.244559
f -1.842662 -0.933195 2.303949 0.677641
one two three four
b 1.461512 0.111372 -0.072225 0.553058
c -1.240671 0.762185 1.511936 -0.630920
e 1.846746 0.148149 0.275398 -0.244559这当然与使用 reindex 方法在此情况下完全等效 −
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))
print df
print df.reindex(['b', 'c', 'e'])它的 output 如下所示 −
one two three four
a 1.639081 1.369838 0.261287 -1.662003
b -0.173359 0.242447 -0.494384 0.346882
c -0.106411 0.623568 0.282401 -0.916361
d -1.078791 -0.612607 -0.897289 -1.146893
e 0.465215 1.552873 -1.841959 0.329404
f 0.966022 -0.190077 1.324247 0.678064
one two three four
b -0.173359 0.242447 -0.494384 0.346882
c -0.106411 0.623568 0.282401 -0.916361
e 0.465215 1.552873 -1.841959 0.329404有人可能由此得出 ix 和 reindex 100% 等效的结论。除整型索引的情形外，这确实成立。例如，上述操作也可以表述为 −
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))
print df
print df.ix[[1, 2, 4]]
print df.reindex([1, 2, 4])它的 output 如下所示 −
one two three four
a -1.015695 -0.553847 1.106235 -0.784460
b -0.527398 -0.518198 -0.710546 -0.512036
c -0.842803 -1.050374 0.787146 0.205147
d -1.238016 -0.749554 -0.547470 -0.029045
e -0.056788 1.063999 -0.767220 0.212476
f 1.139714 0.036159 0.201912 0.710119
one two three four
b -0.527398 -0.518198 -0.710546 -0.512036
c -0.842803 -1.050374 0.787146 0.205147
e -0.056788 1.063999 -0.767220 0.212476
one two three four
1 NaN NaN NaN NaN
2 NaN NaN NaN NaN
4 NaN NaN NaN NaN记住 reindex is strict label indexing only 非常重要。在病理病例中，其中索引同时包含（例如）整型和字符串时，这会产生一些可能令人惊讶的结果。
Python Pandas - Comparison with SQL
由于许多潜在的 Pandas 用户对 SQL 有些熟悉，本页旨在提供有关如何在 pandas 中执行各种 SQL 操作的一些示例。
import pandas as pd
url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'
tips=pd.read_csv(url)
print tips.head()它的 output 如下所示 −
total_bill tip sex smoker day time size
0 16.99 1.01 Female No Sun Dinner 2
1 10.34 1.66 Male No Sun Dinner 3
2 21.01 3.50 Male No Sun Dinner 3
3 23.68 3.31 Male No Sun Dinner 2
4 24.59 3.61 Female No Sun Dinner 4SELECT
在 SQL 中，选择是使用一个逗号分隔的列表完成的，列出你选择的列（或一个 * 来选择所有列） −
SELECT total_bill, tip, smoker, time
FROM tips
LIMIT 5;使用 Pandas，列选择是通过将列名列表传递给 DataFrame 完成的 −
tips[['total_bill', 'tip', 'smoker', 'time']].head(5)让我们检查完整程序 −
import pandas as pd
url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'
tips=pd.read_csv(url)
print tips[['total_bill', 'tip', 'smoker', 'time']].head(5)它的 output 如下所示 −
total_bill tip smoker time
0 16.99 1.01 No Dinner
1 10.34 1.66 No Dinner
2 21.01 3.50 No Dinner
3 23.68 3.31 No Dinner
4 24.59 3.61 No Dinner不带列名列表地调用 DataFrame 将显示所有列（类似于 SQL 的 *）。
WHERE
在 SQL 中，筛选是通过 WHERE 子句完成的。
SELECT * FROM tips WHERE time = 'Dinner' LIMIT 5;DataFrame 可以通过多种方式筛选；其中最直观的是使用布尔索引。
tips[tips['time'] == 'Dinner'].head(5)让我们检查完整程序 −
import pandas as pd
url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'
tips=pd.read_csv(url)
print tips[tips['time'] == 'Dinner'].head(5)它的 output 如下所示 −
total_bill tip sex smoker day time size
0 16.99 1.01 Female No Sun Dinner 2
1 10.34 1.66 Male No Sun Dinner 3
2 21.01 3.50 Male No Sun Dinner 3
3 23.68 3.31 Male No Sun Dinner 2
4 24.59 3.61 Female No Sun Dinner 4以上语句将一个 True/False 对象的 Series 传递给 DataFrame，返回所有带有 True 的行。
GroupBy
此操作获取整个数据集中每个组中的记录计数。例如，一个查询获取我们按性别留下的提示数量 −
SELECT sex, count(*)
FROM tips
GROUP BY sex;Pandas 等效项是 −
tips.groupby('sex').size()让我们检查完整程序 −
import pandas as pd
url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'
tips=pd.read_csv(url)
print tips.groupby('sex').size()它的 output 如下所示 −
sex
Female 87
Male 157
dtype: int64Top N rows
SQL 返回 top n rows ，使用 LIMIT −
SELECT * FROM tips
LIMIT 5 ;Pandas 等效项是 −
tips.head(5)我们来检查完整示例 −
import pandas as pd
url = 'https://raw.github.com/pandas-dev/pandas/master/pandas/tests/data/tips.csv'
tips=pd.read_csv(url)
tips = tips[['smoker', 'day', 'time']].head(5)
print tips它的 output 如下所示 −
smoker day time
0 No Sun Dinner
1 No Sun Dinner
2 No Sun Dinner
3 No Sun Dinner
4 No Sun Dinner这些是我们比较的一些基本操作，这即是我们之前在 Pandas 库的章节所了解的内容。