Pandas 是一个开源的高性能库，可用于数据分析、机器学习和特征工程等多种用途。
Pandas 库是数据科学家武器库中的关键工具之一，它是一个用于数据分析和操作的强大 Python 包。
Python 熊猫安装
打开命令行（Mac/Linux 为终端，Windows 为命令提示符）并键入以下命令：
pip install pandas
如果您使用的是 Anaconda 这样的 Python 环境，则可以使用 conda 包管理器来安装 pandas：
conda install pandas
安装后，您可以在 Python 脚本中导入 pandas，如下所示：
import pandas as pd
习惯上是在alias下导入pandaspd为简洁起见。
熊猫数据结构
Pandas 主要提供 2 种数据结构 –数据框和Series。这两个结构建立在NumPy，另一个强大的 Python 包，使 pandas 中的数据操作成为一项灵活而高效的任务。
让我们快速浏览一下这些数据结构：
数据框
DataFrame 是具有不同类型列的二维标记数据结构。您可以将其视为电子表格或 SQL 表，或者 Series 对象的字典。它们通常是最常用的 Pandas 对象。
import pandas as pd
data = {
'Name': ['John', 'Anna', 'Peter', 'Linda'],
'Age': [28, 24, 35, 32],
'City': ['New York', 'Paris', 'Berlin', 'London']
}
df = pd.DataFrame(data)
print(df)
Output:
Name Age City
0 John 28 New York
1 Anna 24 Paris
2 Peter 35 Berlin
3 Linda 32 London
第一行数字（0到3）是DataFrame的索引，它是自动生成的。
阅读更多关于如何创建 Pandas 数据框.
Series
Series 是一个一维标记数组，可以保存任何数据类型。它本质上是 DataFrame 的单列，轴标签统称为索引。
以下是如何从 Python 的内置数据类型（列表、字典和元组）创建 Pandas Series：
import pandas as pd
import numpy as np
s = pd.Series([1, 3, 5, np.nan, 6, 8])
print(s)
Output:
0 1.0
1 3.0
2 5.0
3 NaN
4 6.0
5 8.0
dtype: float64
我们刚刚从列表创建了一个 pandas Series，它可以包含任何数据类型。请注意，np.nan 用于表示缺失值。
导入 CSV 文件
假设我们的 Python 脚本在同一目录中有一个名为“sample.csv”的 CSV 文件，我们可以按如下方式导入此数据：
import pandas as pd
df = pd.read_csv('sample.csv')
print(df.head())
假设输出如下：
ID Age Gender Occupation Salary Experience
0 1 35 M Engineer 50000 10.0
1 2 42 F Scientist 65000 12.0
2 3 30 M Astronaut 82000 9.0
3 4 25 F Data Analyst 62000 5.0
4 5 NaN M Technician 48000 NaN
The read_csv读取 CSV 文件并将其转换为 DataFrame。这head()函数从 DataFrame 中检索前五行，这对于快速测试对象中是否包含正确的数据类型非常有用。
示例数据包括 ID、年龄、性别、职业、薪水和经验列。
请注意，“年龄”和“经验”列中存在一些缺失值以及一些重复值，我们将在接下来的部分中处理这些值。
阅读更多关于如何使用 Pandas read_csv 读取 CSV 文件.
导入 Excel 文件
Pandas 还能够从 Excel 文件导入数据。如果您的数据位于 Excel 文件中，您可以使用以下命令将其读入 pandas DataFrameread_excel功能。让我们看看如何做到这一点。
import pandas as pd
df_excel = pd.read_excel('sample.xlsx')
print(df_excel.head())
Output:
ID Age Gender Occupation Salary Experience
0 1 35 M Engineer 50000 10.0
1 2 42 F Scientist 65000 12.0
2 3 30 M Astronaut 82000 9.0
3 4 25 F Data Analyst 62000 5.0
4 5 NaN M Technician 48000 NaN
The read_excel函数将 Excel 文件读取到 pandas DataFrame 中。如同read_csv.
Excel 文件中的数据结构和值与前面的 CSV 示例类似，但缺少值。
阅读更多关于如何使用 Pandas read_excel 读取 Excel 文件.
导入 JSON 文件
您可能遇到的另一种常见数据格式是 JSON（JavaScript 对象表示法），尤其是在处理来自 Web 服务和 API 的数据时。
Pandas提供了一个函数，read_json，轻松将 JSON 文件导入 pandas DataFrame。
让我们导入一个名为“sample.json”的 JSON 文件：
import pandas as pd
df_json = pd.read_json('sample.json')
print(df_json.head())
输出（取决于您的文件）：
ID Age Gender Occupation Salary Experience
0 1 35 M Engineer 50000 10.0
1 2 42 F Scientist 65000 12.0
2 3 30 M Astronaut 82000 9.0
3 4 25 F Data Analyst 62000 5.0
4 5 NaN M Technician 48000 NaN
The read_json函数将 JSON 文件读取到 DataFrame 中。与前面的示例一样。
阅读更多关于如何使用 Pandas read_json 读取 JSON 文件.
导入 SQL 文件
熊猫提供了read_sql函数，它允许您执行 SQL 查询并以 Pandas DataFrame 形式获取结果。
假设您有一个 SQLite 数据库（名为“sample.db”），并且想要从名为“employees”的表中读取数据。
首先，您需要与数据库建立连接。 Python 有几个库可以连接各种数据库——我们将使用 sqlite3对于 SQLite 数据库：
import pandas as pd
import sqlite3
conn = sqlite3.connect('sample.db')
sql_query = "SELECT * FROM employees"
df_sql = pd.read_sql(sql_query, conn)
conn.close()
print(df_sql.head())
输出将是：
ID Age Gender Occupation Salary Experience
0 1 35 M Engineer 50000 10.0
1 2 42 F Scientist 65000 12.0
2 3 30 M Astronaut 82000 9.0
3 4 25 F Data Analyst 62000 5.0
4 5 NaN M Technician 48000 NaN
阅读更多关于如何使用 read_sql 将 SQL 查询读入 DataFrame.
导入 HTML
Pandas 还提供了使用以下方法将 HTML 表直接读取到 DataFrame 中的功能：read_html()功能。
它搜索table元素并且仅适用于tr, th, and td每个内的标签table.
您还需要拥有lxml, beautifulsoup4 and html5lib安装了 Python 软件包。您可以通过 pip 安装它们：
!pip install lxml beautifulsoup4 html5lib
让我们考虑一个简单的例子，我们试图从维基百科页面获取表格。
import pandas as pd
url = 'https://en.wikipedia.org/wiki/List_of_largest_companies_by_revenue'
dfs = pd.read_html(url)
print(f"Total tables: {len(dfs)}")
print("First table:")
print(dfs[0])
Output:
Total tables: 5
First table:
Rank Name ... State-owned Ref.
Rank Name ... State-owned Ref.
0 1 Walmart ... NaN [1]
1 2 Amazon.com, Inc. ... NaN [4]
...
...
阅读更多关于如何使用 Pandas read_html 读取 HTML 表格.
导入 XML 文件
假设你有一个名为shapes.xml:
<data>
<row>
<shape>square</shape>
<degrees>360</degrees>
<sides>4.0</sides>
</row>
<row>
<shape>circle</shape>
<degrees>360</degrees>
</row>
</data>
您可以将此文件读入 DataFrame，如下所示：
import pandas as pd
df = pd.read_xml("shapes.xml")
print(df)
Output:
shape degrees sides
0 square 360 4.0
1 circle 360 NaN
阅读更多关于使用 Pandas read_xml 将 XML 文件解析为 DataFrame.
导入 Parquet 文件
要读取镶木地板文件，您将使用read_parquet来自 pandas 的函数。此函数接收要读取的 parquet 文件的路径作为参数。
import pandas as pd
df = pd.read_parquet('data.parquet')
的输出read_parquet函数是一个数据帧。 parquet 文件中的所有数据现在都已加载到此 DataFrame 中，您可以开始操作和分析它。
为了能够使用read_parquet函数，您需要安装 Pyarrow 或 fastparquet 库。
pip install pyarrow fastparquet
阅读更多关于如何使用 Pandas read_parquet 读取 Parquet 文件.
选择和索引
在 Pandas 中，有多种方法来选择和索引数据。让我们使用给定的示例数据深入研究其中的一些内容。
import pandas as pd
data = {
'Name': ['John', 'Anna', 'Peter', 'Linda'],
'Age': [28, 24, 35, 32],
'City': ['New York', 'Paris', 'Berlin', 'London']
}
df = pd.DataFrame(data)
切片范围
我们可以直接在 DataFrame 上使用 Python 的列表切片语法来选择一系列行。
# Selecting rows 1 through 2 (end index is exclusive)
print(df[1:3])
Output:
Name Age City
1 Anna 24 Paris
2 Peter 35 Berlin
使用标签 (.loc)
The .loc索引器与行或列的标签一起使用。这里，标签是索引值。
# Selecting the row with index 1
print(df.loc[1])
Output:
Name Anna
Age 24
City Paris
Name: 1, dtype: object
阅读更多关于使用 Pandas DataFrame loc 属性进行基于标签的访问.
使用整数位置 (.iloc)
您可以使用.iloc带有整数位置的索引器来选择一行。这里，位置就像Python列表中的索引，从0开始。
# Selecting the row at position 1 (which has index 1 in this case)
print(df.iloc[1])
Output:
Name Anna
Age 24
City Paris
Name: 1, dtype: object
阅读更多关于使用 Pandas DataFrame iloc 属性进行基于索引的访问.
可调用函数
可调用函数可用于选择行/列。此函数将 DataFrame 作为输入并输出 DataFrame、Series 或索引。
# Selecting rows where 'Age' is greater than 30
print(df.loc[lambda df: df['Age'] > 30])
Output:
Name Age City
2 Peter 35 Berlin
3 Linda 32 London
query Method
The .query()方法允许您使用布尔表达式过滤数据。在处理复杂查询时，此方法更易于阅读。
# Selecting rows where 'Age' is greater than 30
print(df.query('Age > 30'))
Output:
Name Age City
2 Peter 35 Berlin
3 Linda 32 London
阅读更多关于熊猫查询方法.
where Method
The where方法用于替换条件为假的值。当您想要维护 DataFrame 的形状时，这非常有用，因为它返回相同形状的 DataFrame。
# Using 'where' to replace ages less than 30 with NaN
print(df.where(df['Age'] > 30))
Output:
Name Age City
0 NaN NaN NaN
1 NaN NaN NaN
2 Peter 35.0 Berlin
3 Linda 32.0 London
阅读更多关于熊猫 where() 方法.
get Method
The get方法从 DataFrame 返回特定列。如果该列不存在，它将返回默认值（如果未指定则返回 None）。
# Get the 'Age' column
print(df.get('Age'))
# Try to get a non-existing column, return default 'Column not found'
print(df.get('Salary', 'Column not found'))
Output:
0 28
1 24
2 35
3 32
Name: Age, dtype: int64
Column not found
at Method
The at方法用于检索作为参数传递的特定行和列对的单个值。必须指定行和列标签。
# Use 'at' to get the name of the person in the second row
print(df.at[1, 'Name'])
Output:
Anna
iat Method
The iat方法类似于at，但它不使用标签，而是使用基于整数的位置来访问值。访问特定列和行的单个值速度更快。
# Use 'iat' to get the age of the person in the third row
print(df.iat[2, 1])
Output:
35
isin Method
The isin方法用于过滤DataFrame。它返回一个布尔数据帧，显示数据帧中的每个元素是否包含在值中。
# Use 'isin' to find rows where 'City' is either 'Paris' or 'London'
print(df[df['City'].isin(['Paris', 'London'])])
Output:
Name Age City
1 Anna 24 Paris
3 Linda 32 London
阅读更多关于熊猫isin法.
导出数据框
Pandas 不仅提供从各种文件格式导入数据的功能，还允许您将 DataFrame 导出回这些格式。
导出为 CSV
The to_csv函数允许您将 DataFrame 保存为 CSV 文件。
df.to_csv('sample_export.csv', index=False)
With index=False，我们选择不写行名称（索引）。
阅读更多关于如何使用 to_csv 将 Pandas DataFrame 导出到 CSV 文件.
导出到 Excel
The to_excel函数允许您将 DataFrame 保存为 Excel 文件。
df.to_excel('sample_export.xlsx', index=False)
阅读更多关于如何使用 to_excel 将 Pandas DataFrame 导出到 Excel.
导出到 SQL
要将 DataFrame 导出到 SQL 数据库，您可以使用to_sql功能。
import sqlite3
conn = sqlite3.connect('sample.db')
df.to_sql('new_table', conn, if_exists='replace', index=False)
conn.close()
In the to_sql函数，则if_exists参数确定表已存在时要采取的操作。选项有“失败”、“替换”和“追加”。
阅读更多关于如何使用 to_sql 将 Pandas DataFrame 导出到 SQL.
导出为 JSON
The to_json函数允许您将 DataFrame 保存为 JSON 文件。
df.to_json('sample_export.json', orient='records')
The orient参数指定 JSON 字符串的格式。 “records”选项指定 JSON 字符串将被写入记录列表。
使用 pandas，您可以根据需要将 DataFrame 导出为各种文件格式，从而使您可以更轻松地共享您的发现或在不同环境中使用处理后的数据。
阅读更多关于如何使用 to_json 将 Pandas DataFrame 转换为 JSON.
导出为 HTML
to_html 函数允许您将 DataFrame 导出到 HTML 表。
df.to_html('sample.html')
这将创建一个名为的 HTML 文件data.html在您当前的目录中。该文件将包含 DataFrame 的表格表示。
阅读更多关于如何使用 to_html 将 Pandas DataFrame 转换为 HTML 表.
导出为 XML
to_xml 函数允许您将 DataFrame 导出为 XML 格式。
df.to_xml('sample.xml')
这将从 DataFrame 生成一个 XML 文件。
阅读更多关于如何使用 to_xml 将 Pandas DataFrame 转换为 XML 文件.
导出到 NumPy
您可以使用to_numpy()将 Pandas DataFrame 导出到 NumPy 的函数。
让我们首先确保导入 Pandas 和 numpy：
import pandas as pd
import numpy as np
接下来，让我们创建一个示例 DataFrame：
data = {
'Name': ['John', 'Anna', 'Peter', 'Linda'],
'Age': [28, 24, 35, 32],
'City': ['New York', 'Paris', 'Berlin', 'London']
}
df = pd.DataFrame(data)
要将此 DataFrame 转换为 NumPy 数组，请使用to_numpy()功能：
numpy_array = df.to_numpy()
输出，numpy_array，是一个包含 DataFrame 数据的 2D NumPy 数组。
print(numpy_array)
Output:
[['John' 28 'New York']
['Anna' 24 'Paris']
['Peter' 35 'Berlin']
['Linda' 32 'London']]
阅读更多关于如何使用 to_numpy() 将 Pandas DataFrame 转换为 NumPy 数组.
导出到 BigQuery
您可以使用to_gbq函数来自pandas导出您的数据框：
import pandas as pd
df = pd.DataFrame({
'a': [1, 2, 3],
'b': ['A', 'B', 'C']
})
project_id = 'YOUR_PROJECT_ID'
table_id = 'YOUR_DATASET.YOUR_TABLE'
if_exists = 'replace' # 'fail', 'replace', 'append' are the options
df.to_gbq(table_id, project_id=project_id, if_exists=if_exists)
详细了解如何使用 to_gbq 将 Pandas DataFrame 导出到 Google BigQuery.
酸洗和脱酸
您可以使用to_pickle() and read_pickle()pickle 或 unpickle DataFrames 或 Series。让我们用一个简单的 DataFrame 来说明这一点：
import pandas as pd
import numpy as np
df = pd.DataFrame({
'A': 1.,
'B': pd.Timestamp('20230102'),
'C': pd.Series(1, index=list(range(4)), dtype='float32'),
'D': np.array([3] * 4, dtype='int32'),
'E': pd.Categorical(["test", "train", "test", "train"]),
'F': 'foo'
})
print(df)
这将输出：
A B C D E F
0 1.0 2023-01-02 1.0 3 test foo
1 1.0 2023-01-02 1.0 3 train foo
2 1.0 2023-01-02 1.0 3 test foo
3 1.0 2023-01-02 1.0 3 train foo
现在，让我们来pickle这个DataFrame：
df.to_pickle('df.pkl')
这将在您的工作目录中创建一个名为“df.pkl”的腌制文件。要将这个 pickle 文件加载回 DataFrame (Unpickle)，您可以使用：
df_new = pd.read_pickle('df.pkl')
print(df_new)
处理其他文件格式
CSV、Excel、SQL 和 JSON 是数据科学中最常见的格式。让我们讨论其中的一些：
HDF5 文件
分层数据格式（HDF）旨在存储和组织大量数据。这read_hdf函数可以读取HDF5文件，而to_hdf函数可以写入它们。
df_hdf = pd.read_hdf('sample.h5')
df.to_hdf('sample.h5', key='df')
数据帧过滤
过滤 pandas DataFrames 中的数据是任何数据分析工作流程的重要组成部分。您可以根据特定条件过滤数据以重点关注数据的子集。具体做法如下：
import pandas as pd
df = pd.DataFrame({
'Age': [22, 25, 30, 35, 40, 45, 50, 55, 60, 65],
'Salary': [30000, 35000, 40000, 45000, 50000, 55000, 60000, 65000, 70000, 75000]
})
df_filtered = df[df['Age'] > 40]
The df['Age'] > 40操作返回一系列 True/False 值（布尔掩码），然后我们用它来索引 DataFrame。此操作返回一个新的 DataFrame，仅包含掩码值所在的行True.
print(df_filtered)
Age Salary
5 45 55000
6 50 60000
7 55 65000
8 60 70000
9 65 75000
正如您所看到的，生成的 DataFrame 仅包含“Age”大于 40 的行。您可以使用任何返回布尔掩码的条件以这种方式过滤 DataFrame。
阅读更多关于如何过滤 Pandas DataFrame.
数据清理
数据清理是任何数据分析过程中的关键步骤，使用 Pandas 这样的库可以显着简化此过程。
处理缺失值
让我们首先识别 DataFrame 中的缺失值：
print(df.isnull().sum())
Output:
ID 0
Age 1
Gender 0
Occupation 0
Salary 0
Experience 1
dtype: int64
The isnull函数返回一个 DataFrame，其中每个单元格要么为 True（如果原始单元格包含缺失值），要么为 False。当我们对每列求和时，我们得到每列中缺失值的数量。
有几种处理缺失数据的策略：
删除行
一种方法是使用以下命令简单地删除具有缺失值的行dropna功能。
df_drop = df.dropna()
print(df_drop.isnull().sum())
填充缺失值
或者，您可以使用平均值、中位数或众数等检验统计量来填充缺失值fillna功能。
df_filled = df.fillna(df.mean())
print(df_filled.isnull().sum())
在本例中，Pandas 计算“年龄”和“经验”列的平均值，并使用这些值填充相应列中的缺失值。
删除重复项
数据集中的重复条目可能会扭曲您的分析并导致错误的结论。幸运的是，Pandas 提供了易于使用的功能来检测和删除重复行。
我们首先检查 DataFrame 中是否有重复项：
print(df.duplicated().sum())
The duplicated如果行是重复的，函数返回一个布尔序列，该序列为 True。
如果存在重复项，您必须将其删除以获得准确的结果。操作方法如下：
df_unique = df.drop_duplicates()
print(df_unique.duplicated().sum())
Output:
0
The drop_duplicates函数返回删除了重复行的 DataFrame 副本。
然后，您可以通过检查来确认重复项已被删除duplicated().sum()在新的数据框架上。
值得一提的是drop_duplicates默认情况下考虑所有列。
但是，如果您想根据某些列专门删除重复项，可以通过在函数中传递这些列名称来实现，如下所示：
df_unique = df.drop_duplicates(subset=['Gender', 'Occupation'])
这将删除“性别”和“职业”组合相同的重复项。
字符串操作
Pandas 提供了一组强大的字符串操作，可以轻松操作以文本形式存储的数据。这些操作可以通过.str系列和索引的属性。
让我们探讨一些常见的字符串操作。假设我们的 DataFramedf有一个名为“职业”的列。
转换为小写或大写
如果您想将“职业”列转换为小写或大写，您可以使用lower or upper method:
df['Occupation'] = df['Occupation'].str.lower()
df['Occupation'] = df['Occupation'].str.upper()
分割字符串
有时您可能需要将字符串列拆分为多个列。您可以使用split方法用于此。例如，如果“职业”具有“Data_Analyst”等值，并且您想将“Data”和“Analyst”分开，则可以这样做：
df[['First','Last']] = df['Occupation'].str.split('_', expand=True)
这将创建两个新列“First”和“Last”，分别包含下划线之前和之后的字符串。
替换子字符串
您可以使用replace方法将特定子字符串替换为另一个子字符串。例如，如果您想将“职业”中的“数据”替换为“信息”，您可以这样做：
df['Occupation'] = df['Occupation'].str.replace('Data', 'Information')
您可以使用extract从正则表达式的第一个匹配中提取组的方法：
df['Extracted'] = df['Occupation'].str.extract('(Data)')
这将创建一个新列“Extracted”，其中包含在“Occupation”中找到的“Data”。
请记住，这些只是几个例子。
更改数据类型
Pandas 提供了更改 DataFrame 数据类型的功能，这通常是数据清理和准备的一部分。
首先，让我们检查一下 DataFrame 的当前数据类型：
print(df.dtypes)
这将提供一个输出，显示每个列名称及其相应的数据类型。
现在，假设我们的 DataFrame 中有一个列“Age”，当前存储为“float64”，但我们希望它作为整数（即“int64”）。操作方法如下：
df['Age'] = df['Age'].astype('int64')
print(df.dtypes)
在这里，我们使用了astype更改数据类型的函数。
请记住，转换为整数类型时，请确保您的列没有任何缺少值，因为“NaN”值被 pandas 视为浮点数。如果存在缺失值，您可能需要在更改数据类型之前填充或删除它们。
此外，您可以将数值数据转换为分类数据类型。当您处理分类变量时，这在机器学习中特别有用。
df['Age'] = df['Age'].astype('category')
print(df.dtypes)
聚合数据
假设我们的 DataFrame 有列：“性别”、“职业”和“薪水”。我们想要计算平均和最高工资，以及每个“性别”和“职业”的总人数。我们可以这样做：
grouped = df.groupby(['Gender', 'Occupation'])
agg_data = grouped['Salary'].agg(['mean', 'max', 'count'])
print(agg_data)
Output:
mean max count
Gender Occupation
Female Data Analyst 59000 65000 10
Data Scientist 61000 67000 12
Male Data Analyst 63000 69000 11
Data Scientist 67000 72000 15
在这里，agg函数用于一次执行多个聚合。它将函数列表作为输入，并将每个函数应用到每个组的“薪水”列。
数据分组
pandas 提供的强大功能之一是根据特定条件对数据进行分组，类似于 SQL 中的“GROUP BY”语句。
这使我们能够独立分析数据的子集。
假设我们的 DataFrame 中有一个“性别”列，我们想通过这个变量对数据进行分组：
grouped = df.groupby('Gender')
一旦数据被分组，我们就可以应用聚合函数，例如mean, sum, max等这些群体。例如，如果您想知道每个性别的平均工资，您可以这样做：
mean_salary = grouped['Salary'].mean()
print(mean_salary)
Output:
Gender
Female 60000
Male 65000
dtype: int64
在这里，groupby函数用于根据“性别”将数据分组。然后，我们使用以下公式计算每个组的平均工资：mean功能。
我们还可以按多列进行分组。例如，如果您想按“性别”和“职业”进行分组，您可以这样做：
grouped = df.groupby(['Gender', 'Occupation'])
mean_salary = grouped['Salary'].mean()
print(mean_salary)
Output:
Gender Occupation
Female Data Analyst 59000
Data Scientist 61000
Male Data Analyst 63000
Data Scientist 67000
dtype: int64
数据透视表
数据透视表用于汇总、分析、探索和呈现数据的汇总统计信息。当您有长数据需要重新调整以进行特定分析时，它们特别有用。
Pandas 提供了一种方法“pivot_table”来创建 MS Excel 电子表格样式的数据透视表。
例如，假设我们有一个 DataFramedf包含“性别”、“职业”和“薪水”列。如果我们想创建一个数据透视表来查看按性别和职业划分的平均工资，我们可以这样做：
pivot = df.pivot_table(values='Salary', index='Occupation', columns='Gender', aggfunc='mean')
print(pivot)
Output:
Gender Female Male
Occupation
Data Analyst 59000.0 63000.0
Data Scientist 61000.0 67000.0
在这里，pivot_table函数接受三个参数：
-
values：这是您要总结的专栏。在本例中，它是“薪水”列。
-
index：要设置为输出表索引的列。这里是“职业”栏。
-
columns：要转换为输出表中的列的列。这里是“性别”栏。
-
aggfunc：您要应用的聚合函数。在这里，我们使用“平均值”来计算平均工资。
相关性
Pandas提供了一种方法，corr，计算 DataFrame 中列之间的相关性。
假设我们有一个 DataFramedf其中包括“年龄”、“薪水”和“经验”列。为了找出这些列之间的相关性，我们可以使用：
correlation = df[['Age', 'Salary', 'Experience']].corr()
print(correlation)
Output:
Age Salary Experience
Age 1.0000 0.7467 0.9801
Salary 0.7467 1.0000 0.7698
Experience 0.9801 0.7698 1.0000
这是一个相关矩阵，其中表中的每个单元格显示两个变量之间的相关性。 A相关性为 1 表示完全正相关, while -1表示完全负相关. A 相关性为 0 表示不存在关系.
我们使用了corr方法，默认计算皮尔逊相关性。其他相关方法如 Spearman 和 Kendall 也可以使用method范围。
描述性统计
描述性统计总结和组织数据集的特征。 Pandas 提供了多种功能，可以轻松地在高层次上探索和理解数据。
假设我们有一个包含“年龄”、“薪水”和“经验”列的 DataFrame。如果我们想获得这些列的一些快速描述性统计数据，我们可以使用describe功能：
desc_stats = df[['Age', 'Salary', 'Experience']].describe()
print(desc_stats)
Output:
Age Salary Experience
count 100.000000 100.000000 100.000000
mean 29.710000 65000.000000 7.500000
std 6.982456 7055.473572 2.293098
min 22.000000 50000.000000 3.000000
25% 25.000000 60000.000000 6.000000
50% 28.000000 65000.000000 7.000000
75% 32.000000 70000.000000 9.000000
max 45.000000 80000.000000 13.000000
Here, count是非 NA/空值的数量，mean是值的平均值，std是标准差，min and max分别是最小值和最大值。25%, 50%, and 75%分别是下四分位数、中位数和上四分位数。
合并数据框
您可以使用以下方法组合 Pandas 中的 DataFramemerge功能。让我们考虑两个示例 DataFrame：
import pandas as pd
df1 = pd.DataFrame({
'EmployeeID': ['1', '2', '3', '4'],
'Name': ['Amy', 'Bob', 'Charlie', 'Dave'],
'Department': ['HR', 'Sales', 'IT', 'Marketing']
})
df2 = pd.DataFrame({
'EmployeeID': ['3', '4', '5', '6'],
'Age': [25, 30, 35, 40],
'Salary': [70000, 80000, 90000, 100000]
})
如果你想根据‘EmployeeID’合并这些DataFrame，你可以这样做：
df = pd.merge(df1, df2, on='EmployeeID')
print(df)
Output:
EmployeeID Name Department Age Salary
0 3 Charlie IT 25 70000
1 4 Dave Marketing 30 80000
在这里，Pandas 匹配两个 DataFrame 中的“EmployeeID”值并将它们连接在一起。默认情况下，merge执行内部联接，这意味着只有两个 DataFrame 中存在的键才会组合在一起。
如果您想包含两个 DataFrame 中的所有键，您可以指定how='outer':
df = pd.merge(df1, df2, on='EmployeeID', how='outer')
print(df)
Output:
EmployeeID Name Department Age Salary
0 1 Amy HR NaN NaN
1 2 Bob Sales NaN NaN
2 3 Charlie IT 25.0 70000.0
3 4 Dave Marketing 30.0 80000.0
4 5 NaN NaN 35.0 90000.0
5 6 NaN NaN 40.0 100000.0
连接数据框
连接是在 pandas 中组合 DataFrame 的另一种方法。当您想要将一个 DataFrame 中的行或列附加到另一个 DataFrame 时，通常会使用此方法。让我们考虑两个示例 DataFrame：
df1 = pd.DataFrame({
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']},
index=[0, 1, 2, 3])
df2 = pd.DataFrame({
'A': ['A4', 'A5', 'A6', 'A7'],
'B': ['B4', 'B5', 'B6', 'B7'],
'C': ['C4', 'C5', 'C6', 'C7'],
'D': ['D4', 'D5', 'D6', 'D7']},
index=[4, 5, 6, 7])
如果您想沿行轴连接这些 DataFrame（即将 df2 作为新行附加到 df1），您可以执行以下操作：
df = pd.concat([df1, df2])
print(df)
Output:
A B C D
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
4 A4 B4 C4 D4
5 A5 B5 C5 D5
6 A6 B6 C6 D6
7 A7 B7 C7 D7
默认情况下，concat沿 axis=0 连接（即，它作为行附加）。如果您想沿列轴连接（即，将 df2 作为新列附加到 df1），您可以指定axis=1:
df = pd.concat([df1, df2], axis=1)
连接 DataFrame 在数据整理中通常很有用，其中数据分为多个部分，并且您希望将它们合并到单个 DataFrame 中以进行进一步分析。
重塑数据框
您可以使用melt and pivot重塑你的数据框的函数。
Melt
您可以使用melt将数据转换或重塑为一种格式的函数，其中一列或多列是标识符变量，而所有其他列被视为测量变量。
让我们考虑一个示例 DataFrame：
import pandas as pd
df = pd.DataFrame({
'Date': ['2023-06-01', '2023-06-01', '2023-06-02', '2023-06-02'],
'City': ['New York', 'Los Angeles', 'New York', 'Los Angeles'],
'Temperature': [75, 77, 76, 78],
'Humidity': [80, 70, 78, 85]
})
print(df)
Output:
Date City Temperature Humidity
0 2023-06-01 New York 75 80
1 2023-06-01 Los Angeles 77 70
2 2023-06-02 New York 76 78
3 2023-06-02 Los Angeles 78 85
如果你想融化这个DataFrame，你可以这样做：
melted = df.melt(id_vars=['Date', 'City'], var_name='Measurement', value_name='Value')
print(melted)
Output:
Date City Measurement Value
0 2023-06-01 New York Temperature 75
1 2023-06-01 Los Angeles Temperature 77
2 2023-06-02 New York Temperature 76
3 2023-06-02 Los Angeles Temperature 78
4 2023-06-01 New York Humidity 80
5 2023-06-01 Los Angeles Humidity 70
6 2023-06-02 New York Humidity 78
7 2023-06-02 Los Angeles Humidity 85
Pivot
The pivot函数是的反函数melt。它允许您通过将一列中的唯一值转换为 DataFrame 中的单独列来转换或重塑数据，然后使用适当的值填充相应的单元格。
继续melted上一个示例中的 DataFrame，如果你想将其恢复到原来的形式，你可以这样做：
pivoted = melted.pivot(index=['Date', 'City'], columns='Measurement', values='Value')
print(pivoted.reset_index())
Output:
Date City Measurement Value
0 2023-06-01 New York Temperature 75
1 2023-06-01 Los Angeles Temperature 77
2 2023-06-02 New York Temperature 76
3 2023-06-02 Los Angeles Temperature 78
4 2023-06-01 New York Humidity 80
5 2023-06-01 Los Angeles Humidity 70
6 2023-06-02 New York Humidity 78
7 2023-06-02 Los Angeles Humidity 85
列操作
您可以对列执行多种操作，例如选择、重命名、创建和删除列。让我们考虑一个示例 DataFrame：
import pandas as pd
df = pd.DataFrame({
'Name': ['Amy', 'Bob', 'Charlie', 'Dave'],
'Age': [23, 25, 22, 21],
'Salary': [70000, 80000, 90000, 85000]
})
选择列
您可以使用括号表示法和列名称来选择单个列：
names = df['Name']
print(names)
Output:
0 Amy
1 Bob
2 Charlie
3 Dave
Name: Name, dtype: object
重命名列
要重命名列，您可以使用rename功能：
df = df.rename(columns={'Name': 'Employee Name'})
print(df)
创建列
要创建新列，您可以根据现有列定义它：
df['Age Next Year'] = df['Age'] + 1
print(df)
删除列
要删除列，您可以使用drop功能：
df = df.drop(columns='Age Next Year')
print(df)
日期和时间处理
首先，让我们创建一个包含日期字符串的示例 DataFrame：
import pandas as pd
df = pd.DataFrame({
'Name': ['Amy', 'Bob', 'Charlie', 'Dave'],
'DOB': ['1995-05-01', '1996-07-23', '1997-08-15', '1998-01-10']
})
将字符串转换为日期时间
通常，日期以字符串形式出现，将它们转换为日期时间对象以执行与日期相关的操作将是有益的：
df['DOB'] = pd.to_datetime(df['DOB'])
print(df['DOB'].dtype) # Output: datetime64[ns]
一旦我们有了日期时间列，我们就可以提取各种组成部分，如年、月、日等：
df['Year'] = df['DOB'].dt.year
print(df)
时间增量
时间增量表示持续时间或时间差。假设您有带有时间戳的数据，并且您想要计算事件之间的时间差：
import pandas as pd
time_data = pd.Series(pd.date_range('2023-01-01', periods=3, freq='D'))
print(time_data)
Output:
0 2023-01-01
1 2023-01-02
2 2023-01-03
dtype: datetime64[ns]
要获取这些日期之间的时间差 (Timedelta)，您可以使用diff()功能：
time_delta = time_data.diff()
print(time_delta)
Output:
0 NaT
1 1 days
2 1 days
dtype: timedelta64[ns]
在这里，diff()函数计算系列中当前元素和先前元素之间的差异。
由于第一个时间戳没有先验元素，因此结果为NaT（不是时间），这是缺失或空时间数据的 pandas 表示。
更改日期格式
您还可以使用以下命令更改日期格式strftime功能：
df['DOB'] = df['DOB'].dt.strftime('%d/%m/%Y')
print(df)
数据可视化
Pandas通过不同的功能提供数据可视化，您可以根据需要以多种方式绘制数据。
线图
折线图是数据可视化中最常用的图表类型之一。它们对于可视化值随时间的变化特别有用。
您可以使用DataFrame.plot.line()在 pandas 中生成线图的函数。让我们考虑一个包含每月销售数据的 DataFrame：
import pandas as pd
df = pd.DataFrame({
'Month': pd.date_range(start='01-01-2023', periods=12, freq='M'),
'Sales': [15, 18, 20, 22, 25, 23, 30, 33, 40, 45, 50, 55]
})
df.set_index('Month', inplace=True)
现在，您可以绘制销售数据：
df.plot.line(title='Monthly Sales')
这将生成一个折线图，其中 x 轴为月份，y 轴为销售额。
请记住，如果您使用 Jupyter Notebook，则无需执行任何特殊操作即可查看绘图，但如果您使用不同的环境，则应使用 Matplotlib 来显示绘图，否则绘图将不会显示可见的。
import matplotlib.pyplot as plt
df.plot.line(title='Monthly Sales')
plt.show()
Bar Plot
您可以使用DataFrame.plot.bar()函数创建条形图。让我们考虑一个包含不同类别销售数据的 DataFrame：
import pandas as pd
df = pd.DataFrame({
'Category': ['Electronics', 'Clothing', 'Home & Kitchen', 'Health & Beauty'],
'Sales': [15000, 12000, 18000, 20000]
})
df.set_index('Category', inplace=True)
现在，生成条形图：
df.plot.bar(title='Sales by Category', color='blue', alpha=0.75)
在生成的条形图中，每个类别（电子、服装、家居和厨房、健康与美容）都有一个与之关联的条形图，条形图的长度对应于该类别中的销售额。
我们使用了color设置条形颜色的参数，以及alpha参数设置条形的透明度。图表的标题是使用title争论。
散点图
散点图用于显示两个数值变量之间的关系。对于 pandas，您可以使用DataFrame.plot.scatter()函数创建散点图。让我们考虑一个包含年龄和工资数据的 DataFrame：
import pandas as pd
df = pd.DataFrame({
'Age': [22, 25, 30, 35, 40, 45, 50, 55, 60, 65],
'Salary': [30000, 35000, 40000, 45000, 50000, 55000, 60000, 65000, 70000, 75000]
})
要生成散点图来检查年龄和工资之间的关系：
df.plot.scatter(x='Age', y='Salary', title='Age vs Salary')
在散点图中，每个点代表一个人的年龄（x 轴）和工资（y 轴）。如果点的分布有清晰的模式，则表明两个变量之间存在关系。
直方图
直方图是将一组数据点组织到指定范围内的图形表示。
在 Pandas 中，您可以使用DataFrame.plot.hist()创建直方图的函数。让我们考虑一个包含年龄数据的 DataFrame：
import pandas as pd
df = pd.DataFrame({
'Age': [22, 25, 22, 35, 40, 35, 22, 40, 35, 22, 30, 25, 30, 25, 40, 30, 35, 40]
})
要生成直方图以可视化年龄分布：
df['Age'].plot.hist(bins=6, alpha=0.5, title='Age Distribution')
在此直方图中，年龄（x 轴）被分组为箱（年龄范围），每个范围的出现次数显示在 y 轴上。这bins参数设置直方图中的箱数。这alpha参数设置条形的透明度。
在这种情况下，直方图将显示年龄大多集中在 30-35 岁左右。
Box Plot
您可以使用DataFrame.plot.box()函数来创建箱线图。让我们考虑一个包含工资数据的 DataFrame：
import pandas as pd
df = pd.DataFrame({
'Salary': [35000, 40000, 36000, 41000, 39000, 38000, 37000, 42000, 43000, 45000, 44000, 50000, 55000]
})
现在，生成工资数据的箱线图：
df['Salary'].plot.box(title='Salary Distribution')
在此箱线图中，方框代表四分位数范围 (IQR)，即数据的第 25 到 75 个百分点，方框内的线是中位数（第 50 个百分点），须线通常代表其余数据的范围数据。
须线之外的任何点都可以被视为异常值。
熊猫前来救援
一家美国大型零售公司与我接洽，要求进行一个相当复杂的数据分析项目。
他们正在处理分布在多个 Excel 和 CSV 文件中的销售数据，每个文件包含数十万行和 40 多列数据。
数据文件位于他们的云存储上，并且每天更新。我的任务是创建一个能够有效处理这些数据、执行大量转换并每天生成富有洞察力的报告的系统。
首先，我用老式的方式尝试解决这个问题：我编写了一些利用内置函数的 Python 代码csv库来读取和解析数据。
我很快就遇到了问题：数据量太大，无法在常规 Python 中进行有效处理。
即使是简单的任务，例如计算平均值或根据条件过滤数据，也变得非常缓慢。
处理一个文件大约需要 2 小时，这意味着处理一整天的文件可能需要超过 48 小时！我很快意识到这种方法行不通。
这时，我转向了熊猫。确实是一个强大的工具。使用它，我可以直接从云存储读取文件，立即对整个数据集执行必要的转换，并处理丢失或错误的数据，同时享受其高度优化的性能带来的好处。
使用 Pandas，读取单个文件只需 2 分钟，比最初的 2 小时缩短了 – 速度提高了 60 倍！
处理一个文件（包括所有转换和计算）所需的平均时间约为 15 分钟。
这意味着我可以在不到 12 小时的时间内处理一整天的文件，而不是最初预计的 48 小时，从而将总时间减少了 75%。
此外，使用 Pandas 的代码更加简洁且更易于维护。由于它允许同时对整个数据结构进行操作，因此代码行数减少了大约 65%。
使用 Pandas 的另一个显着优势是它可以稳健地处理丢失或不正确的数据。其他方法如Python 的 csv每个单独的操作都需要复杂且耗时的错误处理。对于 Pandas，这几乎是自动处理的，预计总体开发时间额外节省了 20%。
我花在该项目上的时间减少了近 80%，客户对每日报告的效率和准确性感到满意。
最终，这是一个鲜明的提醒：在数据科学领域，正确的工具可以发挥重要作用。
