Pandas 是一个主要使用的 Python 数据分析库。它提供了许多功能和方法来加快数据分析过程。pandas 如此普遍的原因在于它的功能、灵活性和简单的语法。

在这篇文章中，我将通过示例解释 20 个 pandas 函数。其中一些非常常见，我相信您以前用过。其中一些对您来说可能是新的。但是，所有这些都会为您的数据分析过程增加价值。

话不多说，我们开始吧！

首先导入必要的库：

import numpy as np
import pandas as pd

1. Query

我们有时需要根据条件过滤数据帧或应用掩码来获取某些值。过滤数据框的一种简单方法是Query功能。让我们首先创建一个示例数据框。

value_1 = np.random.randint(10, size=10)
value_2 = np.random.randint(10, size=10)
years = np.arange(2010, 2020)
groups = ['A', 'A', 'B', 'A', 'B', 'B', 'C', 'A', 'C', 'C']

df = pd.DataFrame({'groups': groups, 'years': years, 'value_1': value_1, 'value_2': value_2})
df

使用查询功能非常简单，只需要编写过滤条件即可。

df.query('value_1 < value_2')

2. Insert

当我们想要向数据框中添加新列时，默认情况下会将其添加到末尾。但是，pandas 提供了使用插入功能在任何位置添加新列的选项。

我们需要通过传递索引作为第一个参数来指定位置。该值必须是整数。列索引从零开始，就像行索引一样。第二个参数是列名，第三个参数是包含值的对象，这些值可以是系列或类似数组的对象。

# new column
new_col = np.random.randn(10)
# insert the new column at position 2 
df.insert(2, 'new_col', new_col)

df

3. Cumsum

该数据框包含 3 个不同组的一些年度值。我们可能只对年度值感兴趣，但在某些情况下我们还需要累计总和。Pandas 提供了一个易于使用的函数来计算累积和，即cumsum。

如果我们只应用 cumsum，组（A、B、C）将被忽略。这种累积值在某些情况下可能没有用，因为我们无法区分不同的组。不用担心！对于这个问题有一个非常简单且方便的解决方案。我们可以应用groupby然后应用cumsum函数。

df['cumsum_2'] = df[['value_2', 'groups']].groupby('groups').cumsum()
df

4. Sample

Sample 方法允许您从Series或DataFrame中随机选择值。当我们想从分布中选择随机样本时，它很有用。

sample = df.sample(n=3)
sample

我们使用 n 参数指定值的数量，但我们也可以将比率传递给frac参数。例如，0.5 将返回一半的行。

sample2 = df.sample(frac=0.5)
sample2

为了获得可重复的样本，我们可以使用random_state参数。如果将整数值传递给 random_state，则每次运行代码时都会生成相同的样本。

5. Where

“Where”用于根据条件替换行或列中的值。默认替换值为 NaN，但我们也可以指定要作为替换的值。

df['new_col'].where(df['new_col'] > 0, 0)

“where”的工作方式是选择符合条件的值，并将剩余值替换为指定值。where(df['new_col']>0, 0)选择new_col中所有大于0的值，其余值替换为0。因此，where也可以被认为是掩码操作。

重要的一点是，Pandas 和 NumPy 的“ where ”并不完全相同。我们可以达到相同的结果，但语法略有不同。使用DataFrame.where ，按原样选择符合条件的值，并将其他值替换为指定值。np.where还需要指定符合条件的值。以下两行返回相同的结果：

df['new_col'].where(df['new_col'] > 0, 0)
np.where(df['new_col'] > 0, df['new_col'], 0)

6. Isin

在处理数据帧时，我们经常使用过滤或选择方法。isin方法是一种高级过滤方法。例如，我们可以根据选择列表过滤值。

years = [2010, 2014, 2017]
df[df['years'].isin(years)]

7. Loc 和 iloc

Loc 和 iloc 用于选择行和列。

• loc：按标签选择
• iloc：按位置选择

loc用于按标签选择数据。列的标签是列名称。我们需要小心行标签。如果我们不指定任何特定索引，pandas 默认创建整数索引。因此，行标签是从 0 开始向上的整数。与iloc一起使用的行位置也是从 0 开始的整数。

使用 iloc 选择前 3 行和前 2 列：

df.iloc[:3, :2]

使用 loc 选择前 3 行和前 2 列：

df.loc[:2, ['groups', 'years']]

注意：使用 loc 时包含索引的上边界，而使用 iloc 时则排除索引的上边界。

选择行“1”、“3”、“5”和列“year”和“value_1”：

df.loc[[1, 3, 5], ['years', 'value_1']]

8. Pct_change

此函数用于计算一系列值的百分比变化。假设我们有一个包含 [2,3,6] 的序列。如果我们将 pct_change 应用于该系列，则返回的系列将为 [NaN, 0.5, 1.0]。从第一个元素到第二个元素增加了 50%，从第二个元素到第三个元素增加了 100%。Pct_change 函数可用于比较时间序列元素的变化百分比。

df.value_1.pct_change()

9. Rank

Rank 函数将排名分配给值。假设我们有一个包含 [1,7,5,3] 的系列 s。分配给这些值的等级将为 [1,4,3,2]。

df['rank_1'] = df['value_1'].rank()

10. Melt

Melt 用于将宽数据帧转换为窄数据帧。我所说的宽是指具有大量列的数据框。某些数据帧的结构方式是将连续的测量值或变量表示为列。在某些情况下，将这些列表示为行可能更适合我们的任务。考虑以下数据框：

df_wide = pd.DataFrame({'city': ['A', 'B', 'C'],
                        'day1': [22, 25, 28],
                        'day2': [10, 14, 13],
                        'day3': [25, 22, 26], 
                        'day4': [18, 15, 17],
                        'day5': [12, 14, 18]})
df_wide

我们在三个不同的城市进行了不同日期的测量。我们决定将这些天表示为列中的行。还有一栏显示测量值。我们可以通过使用melt函数轻松实现这一点：

df_wide.melt(id_vars=['city'])

默认情况下给出变量和值列名称。我们可以使用melt函数的var_name和value_name参数来分配新的列名。

df_wide.melt(id_vars=['city'], var_name='date (day)', value_name='xx_value')

11. Explode

假设您的数据集在单个观察（行）上包含某个要素的多个条目，但您希望在不同的行上分析它们。

df1 = pd.DataFrame({'ID': ['a', 'b', 'c'],
                    'measurement': [4, 6, [2, 3, 8]],
                    'day': [1, 1, 1]})
df1

我们希望在不同的行上查看第“1”天“c”的测量值，这可以使用爆炸轻松完成。

df1.explode('measurement').reset_index(drop=True)

12. Nunique

Nunique 计算列或行上唯一条目的数量。它在分类特征中非常有用，特别是在我们事先不知道类别数量的情况下。让我们看一下我们的初始数据框：

df

df.years.nunique()
10
df.groups.nunique()
3

我们可以直接将 nunique 函数应用于数据框并查看每列中唯一值的数量：

df.nunique()

如果axis参数设置为 1，则 nunique 返回每行中唯一值的数量。

13. Lookup

它可用于根据其他行、列对上的值查找 DataFrame 中的值。通过示例可以最好地解释此功能。假设我们有以下 DataFrame：

df_look = pd.DataFrame({'Day': np.arange(1, 9),
                        'Person': ['Alex', 'John', 'Alex', 'Derek', 
                              'Oscar', 'John', 'Derek', 'Oscar'],
                        'John': [4, 7, 8, 9, 2, 6, 6, 5], 
                        'Alex': [4, 6, 9, 2, 6, 6, 5, 5],
                        'Oscar': [4, 2, 3, 5, 1, 4, 5, 9], 
                        'Derek': [6, 2, 1, 8, 7, 8, 4, 5]})
df_look

每天，我们都会测量 4 个人的数据，并有一列包含这 4 个人的姓名。我们想要创建一个新列来显示“人员”列中人员的测量值。因此，对于第一行，新列中的值将为 4（“Alex”列中的值）。

注：由于在新版pandas中 lookup 方法已被弃用，所以要实现查找匹配功能我们可以使用以下自定义方法：

def lookup(row):
    person = row['Person']
    return row[person]

df_look['Person_point'] = df_look.apply(lookup, axis=1)
df_look

14. Infer_objects

Pandas 支持多种数据类型，其中之一是object。对象涵盖文本或混合（数字和非数字）值。但是，如果有不同的选项可用，则不建议使用对象数据类型。使用更具体的数据类型，某些操作执行得更快。例如，我们更喜欢使用整数或浮点数据类型来表示数值。

infer_objects尝试为对象列推断更好的数据类型。考虑以下数据框：

df2 = pd.DataFrame({'A': np.arange(1, 5), 
                    'B': [2.1, 1.5, 2, 2.1], 
                    'C': [True, False, False, True], 
                    'D': ['b', 'c', 'd', 'f']}, dtype=object)
df2

df2.dtypes

所有数据类型都是对象。让我们看看推断的数据类型是什么：

df2.infer_objects().dtypes

它可能看起来微不足道，但当有很多列时肯定会很有用。

15. Memory_usage

Memory_usage() 返回每列使用的内存量（以字节为单位）。当我们处理大型数据帧时，它尤其有用。考虑以下包含 100 万行的数据框。

df_large = pd.DataFrame({'A': np.random.randn(1000000), 
                         'B': np.random.randint(100, size=1000000)})
df_large.shape
(1000000, 2)

每列的内存使用量（以字节为单位）：

df_large.memory_usage()

整个数据帧的内存使用量（以兆字节为单位）：

df_large.memory_usage().sum() / (1024**2)    # Converting to megabytes
11.444217681884766

16. Describe

描述函数计算数字列的基本统计数据，包括计数、平均值、标准差、最小值和最大值、中位数、第一和第三四分位数。因此，它提供了数据帧的统计摘要。

df.describe()

17. Merge

Merge() 根据共享列中的值组合 DataFrame。考虑以下两个数据框。

df1 = pd.DataFrame({'column_a': [1, 2, 3, 4],
                    'column_b': ['a', 'b', 'c', 'd'],
                    'column_c': [True, True, False, True]})
df1

df2 = pd.DataFrame({'column_a': [1, 2, 9, 10],
                    'column_b': ['a', 'k', 'l', 'm'],
                    'column_c': [False, False, False, True]})
df2

我们可以根据列中的共享值将它们合并。设置合并条件的参数是“ on ”参数。

df_merge = pd.merge(df1, df2, on='column_a')
df_merge

df1和df2根据column_a中的公共值进行合并。merge 函数的 how参数允许以不同的方式组合数据帧。how 的可能值为“inner”、“outer”、“left”、“right”。

• inner：仅在on参数指定的列中具有相同值的行（how参数的默认值）
• outer：两个DataFrame 中的所有行
• left：左侧 DataFrame 中的所有行
• right：右 DataFrame 中的所有行

18. Select_dtypes

Select_dtypes 函数根据数据类型上设置的条件返回 DataFrame 列的子集。它允许使用include和exclude参数来包含或排除某些数据类型。

df.select_dtypes(include='int')

df.select_dtypes(exclude='int')

19. Replace

顾名思义，它允许替换数据框中的值。

df.replace('A', 'A_1')

第一个参数是要替换的值，第二个参数是新值。我们还可以传入一个字典来同时进行多个替换。

df.replace({'A': 'A_1', 'B': 'B_1'})

20. Applymap

Applymap 函数用于将函数按元素应用于数据帧。请注意，如果操作的矢量化版本可用，则应优先于 applymap。例如，如果我们想将每个元素乘以一个数字，我们不需要也不应该使用 applymap 函数。在这种情况下，简单的向量化操作（例如 df * 4 ）要快得多。

但是，在某些情况下，我们可能无法选择矢量化操作。例如，我们可以使用pandas 数据框的Style属性更改数据框的样式。以下函数将负值的颜色更改为红色。

def color_negative_values(val):
    color = 'red' if val < 0 else 'black'
    return 'color: %s' % color

我们需要使用 applymap 函数将此函数应用于数据帧。

df3 = pd.DataFrame({'A': np.random.randn(5),
                    'B': np.random.randn(5)})
df3.style.applymap(color_negative_values)