Pandas 2.2 中文官方教程和指南（四）

ApacheCN_飞龙

发布于 2024-04-26 08:21:49

1180

发布于 2024-04-26 08:21:49

文章被收录于专栏：信数据得永生信数据得永生

原文：pandas.pydata.org/docs/

与 SQL 比较

原文：pandas.pydata.org/docs/getting_started/comparison/comparison_with_sql.html

由于许多潜在的 pandas 用户对 SQL 有一定的了解，本页旨在提供使用 pandas 执行各种 SQL 操作的一些示例。

如果你是 pandas 的新手，你可能想先阅读 10 分钟入门 pandas 来熟悉这个库。

惯例上，我们导入 pandas 和 NumPy 如下：

In [1]: import pandas as pd

In [2]: import numpy as np

大多数示例将利用 pandas 测试中找到的 tips 数据集。我们将数据读入一个名为 tips 的 DataFrame，并假设我们有一个具有相同名称和结构的数据库表。

In [3]: url = (
 ...:    "https://raw.githubusercontent.com/pandas-dev"
 ...:    "/pandas/main/pandas/tests/io/data/csv/tips.csv"
 ...: )
 ...: 

In [4]: tips = pd.read_csv(url)

In [5]: tips
Out[5]: 
 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
..          ...   ...     ...    ...   ...     ...   ...
239       29.03  5.92    Male     No   Sat  Dinner     3
240       27.18  2.00  Female    Yes   Sat  Dinner     2
241       22.67  2.00    Male    Yes   Sat  Dinner     2
242       17.82  1.75    Male     No   Sat  Dinner     2
243       18.78  3.00  Female     No  Thur  Dinner     2

[244 rows x 7 columns]

复制 vs. 原地操作

大多数 pandas 操作返回 Series/DataFrame 的副本。要使更改“生效”，你需要将其分配给一个新变量：

sorted_df = df.sort_values("col1")

或者覆盖原始的：

df = df.sort_values("col1")

注意

对于一些方法（如 dropna），可以看到一个 inplace=True 或 copy=False 的关键字参数：

df.replace(5, inplace=True)

有关取消和移除大多数方法（例如 dropna）的 inplace 和 copy 的活跃讨论，除了非常小的一部分方法（包括 replace）之外，这两个关键字在 Copy-on-Write 的上下文中将不再需要。提案可以在这里找到。

SELECT

在 SQL 中，使用逗号分隔的列列表来进行选择（或者使用 * 来选择所有列）：

SELECT  total_bill,  tip,  smoker,  time
FROM  tips;

使用 pandas，列选择是通过将列名列表传递给你的 DataFrame 完成的：

In [6]: tips[["total_bill", "tip", "smoker", "time"]]
Out[6]: 
 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
..          ...   ...    ...     ...
239       29.03  5.92     No  Dinner
240       27.18  2.00    Yes  Dinner
241       22.67  2.00    Yes  Dinner
242       17.82  1.75     No  Dinner
243       18.78  3.00     No  Dinner

[244 rows x 4 columns]

在没有列名列表的情况下调用 DataFrame 将显示所有列（类似于 SQL 的 *）。

在 SQL 中，你可以添加一个计算列：

SELECT  *,  tip/total_bill  as  tip_rate
FROM  tips;

使用 pandas，你可以使用 DataFrame 的 DataFrame.assign() 方法来追加一个新列：

In [7]: tips.assign(tip_rate=tips["tip"] / tips["total_bill"])
Out[7]: 
 total_bill   tip     sex smoker   day    time  size  tip_rate
0         16.99  1.01  Female     No   Sun  Dinner     2  0.059447
1         10.34  1.66    Male     No   Sun  Dinner     3  0.160542
2         21.01  3.50    Male     No   Sun  Dinner     3  0.166587
3         23.68  3.31    Male     No   Sun  Dinner     2  0.139780
4         24.59  3.61  Female     No   Sun  Dinner     4  0.146808
..          ...   ...     ...    ...   ...     ...   ...       ...
239       29.03  5.92    Male     No   Sat  Dinner     3  0.203927
240       27.18  2.00  Female    Yes   Sat  Dinner     2  0.073584
241       22.67  2.00    Male    Yes   Sat  Dinner     2  0.088222
242       17.82  1.75    Male     No   Sat  Dinner     2  0.098204
243       18.78  3.00  Female     No  Thur  Dinner     2  0.159744

[244 rows x 8 columns]

WHERE

在 SQL 中，过滤是通过 WHERE 子句完成的。

SELECT  *
FROM  tips
WHERE  time  =  'Dinner';

DataFrames 可以以多种方式进行过滤；其中最直观的是使用布尔索引。

In [8]: tips[tips["total_bill"] > 10]
Out[8]: 
 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
..          ...   ...     ...    ...   ...     ...   ...
239       29.03  5.92    Male     No   Sat  Dinner     3
240       27.18  2.00  Female    Yes   Sat  Dinner     2
241       22.67  2.00    Male    Yes   Sat  Dinner     2
242       17.82  1.75    Male     No   Sat  Dinner     2
243       18.78  3.00  Female     No  Thur  Dinner     2

[227 rows x 7 columns]

上述语句简单地将一系列 True/False 对象传递给 DataFrame，返回所有带有 True 的行。

In [9]: is_dinner = tips["time"] == "Dinner"

In [10]: is_dinner
Out[10]: 
0      True
1      True
2      True
3      True
4      True
 ... 
239    True
240    True
241    True
242    True
243    True
Name: time, Length: 244, dtype: bool

In [11]: is_dinner.value_counts()
Out[11]: 
time
True     176
False     68
Name: count, dtype: int64

In [12]: tips[is_dinner]
Out[12]: 
 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
..          ...   ...     ...    ...   ...     ...   ...
239       29.03  5.92    Male     No   Sat  Dinner     3
240       27.18  2.00  Female    Yes   Sat  Dinner     2
241       22.67  2.00    Male    Yes   Sat  Dinner     2
242       17.82  1.75    Male     No   Sat  Dinner     2
243       18.78  3.00  Female     No  Thur  Dinner     2

[176 rows x 7 columns]

就像 SQL 的 OR 和 AND 一样，可以使用 |（OR）和 &（AND）将多个条件传递给 DataFrame。

晚餐小费超过 $5 的提示：

SELECT  *
FROM  tips
WHERE  time  =  'Dinner'  AND  tip  >  5.00;

In [13]: tips[(tips["time"] == "Dinner") & (tips["tip"] > 5.00)]
Out[13]: 
 total_bill    tip     sex smoker  day    time  size
23        39.42   7.58    Male     No  Sat  Dinner     4
44        30.40   5.60    Male     No  Sun  Dinner     4
47        32.40   6.00    Male     No  Sun  Dinner     4
52        34.81   5.20  Female     No  Sun  Dinner     4
59        48.27   6.73    Male     No  Sat  Dinner     4
116       29.93   5.07    Male     No  Sun  Dinner     4
155       29.85   5.14  Female     No  Sun  Dinner     5
170       50.81  10.00    Male    Yes  Sat  Dinner     3
172        7.25   5.15    Male    Yes  Sun  Dinner     2
181       23.33   5.65    Male    Yes  Sun  Dinner     2
183       23.17   6.50    Male    Yes  Sun  Dinner     4
211       25.89   5.16    Male    Yes  Sat  Dinner     4
212       48.33   9.00    Male     No  Sat  Dinner     4
214       28.17   6.50  Female    Yes  Sat  Dinner     3
239       29.03   5.92    Male     No  Sat  Dinner     3

至少有 5 名用餐者的小费或者账单总额超过 $45 的小费：

SELECT  *
FROM  tips
WHERE  size  >=  5  OR  total_bill  >  45;

In [14]: tips[(tips["size"] >= 5) | (tips["total_bill"] > 45)]
Out[14]: 
 total_bill    tip     sex smoker   day    time  size
59        48.27   6.73    Male     No   Sat  Dinner     4
125       29.80   4.20  Female     No  Thur   Lunch     6
141       34.30   6.70    Male     No  Thur   Lunch     6
142       41.19   5.00    Male     No  Thur   Lunch     5
143       27.05   5.00  Female     No  Thur   Lunch     6
155       29.85   5.14  Female     No   Sun  Dinner     5
156       48.17   5.00    Male     No   Sun  Dinner     6
170       50.81  10.00    Male    Yes   Sat  Dinner     3
182       45.35   3.50    Male    Yes   Sun  Dinner     3
185       20.69   5.00    Male     No   Sun  Dinner     5
187       30.46   2.00    Male    Yes   Sun  Dinner     5
212       48.33   9.00    Male     No   Sat  Dinner     4
216       28.15   3.00    Male    Yes   Sat  Dinner     5

使用 notna() 和 isna() 方法进行 NULL 检查。

In [15]: frame = pd.DataFrame(
 ....:    {"col1": ["A", "B", np.nan, "C", "D"], "col2": ["F", np.nan, "G", "H", "I"]}
 ....: )
 ....: 

In [16]: frame
Out[16]: 
 col1 col2
0    A    F
1    B  NaN
2  NaN    G
3    C    H
4    D    I

假设我们有一个与上面的 DataFrame 结构相同的表。我们可以使用以下查询仅查看 col2 为 NULL 的记录：

SELECT  *
FROM  frame
WHERE  col2  IS  NULL;

In [17]: frame[frame["col2"].isna()]
Out[17]: 
 col1 col2
1    B  NaN

可以使用 notna() 来获取 col1 IS NOT NULL 的项目。

SELECT  *
FROM  frame
WHERE  col1  IS  NOT  NULL;

In [18]: frame[frame["col1"].notna()]
Out[18]: 
 col1 col2
0    A    F
1    B  NaN
3    C    H
4    D    I

GROUP BY

在 pandas 中，SQL 的 GROUP BY 操作是使用同名的 groupby() 方法执行的。groupby() 通常指的是将数据集拆分为组，应用某些函数（通常是聚合函数），然后将组合并在一起的过程。

一种常见的 SQL 操作是在数据集中获取每个组中记录的计数。例如，一个查询可以获取性别留下的小费数目：

SELECT  sex,  count(*)
FROM  tips
GROUP  BY  sex;
/*
Female     87
Male      157
*/

pandas 的等价方法将是：

In [19]: tips.groupby("sex").size()
Out[19]: 
sex
Female     87
Male      157
dtype: int64

请注意，在 pandas 代码中我们使用了 DataFrameGroupBy.size() 而不是 DataFrameGroupBy.count()。这是因为 DataFrameGroupBy.count() 将函数应用于每列，返回每列中的 NOT NULL 记录数。

In [20]: tips.groupby("sex").count()
Out[20]: 
 total_bill  tip  smoker  day  time  size
sex 
Female          87   87      87   87    87    87
Male           157  157     157  157   157   157

或者，我们可以将 DataFrameGroupBy.count() 方法应用于单个列：

In [21]: tips.groupby("sex")["total_bill"].count()
Out[21]: 
sex
Female     87
Male      157
Name: total_bill, dtype: int64

还可以一次应用多个函数。例如，假设我们想看到小费金额如何随一周中的日期而异 - DataFrameGroupBy.agg() 允许您将字典传递给您的分组 DataFrame，指示要应用于特定列的函数。

SELECT  day,  AVG(tip),  COUNT(*)
FROM  tips
GROUP  BY  day;
/*
Fri   2.734737   19
Sat   2.993103   87
Sun   3.255132   76
Thu  2.771452   62
*/

In [22]: tips.groupby("day").agg({"tip": "mean", "day": "size"})
Out[22]: 
 tip  day
day 
Fri   2.734737   19
Sat   2.993103   87
Sun   3.255132   76
Thur  2.771452   62

通过将列的列表传递给 groupby() 方法来进行按多列分组。

SELECT  smoker,  day,  COUNT(*),  AVG(tip)
FROM  tips
GROUP  BY  smoker,  day;
/*
smoker day
No     Fri      4  2.812500
 Sat     45  3.102889
 Sun     57  3.167895
 Thu    45  2.673778
Yes    Fri     15  2.714000
 Sat     42  2.875476
 Sun     19  3.516842
 Thu    17  3.030000
*/

In [23]: tips.groupby(["smoker", "day"]).agg({"tip": ["size", "mean"]})
Out[23]: 
 tip 
 size      mean
smoker day 
No     Fri     4  2.812500
 Sat    45  3.102889
 Sun    57  3.167895
 Thur   45  2.673778
Yes    Fri    15  2.714000
 Sat    42  2.875476
 Sun    19  3.516842
 Thur   17  3.030000

JOIN

可以使用 join() 或 merge() 执行 JOIN。默认情况下，join() 将在它们的索引上连接数据框。每种方法都有参数，允许您指定要执行的连接类型（LEFT、RIGHT、INNER、FULL）或要连接的列（列名或索引）。

警告

如果两个关键列都包含键为 null 值的行，则这些行将相互匹配。这与通常的 SQL 连接行为不同，可能会导致意外结果。

In [24]: df1 = pd.DataFrame({"key": ["A", "B", "C", "D"], "value": np.random.randn(4)})

In [25]: df2 = pd.DataFrame({"key": ["B", "D", "D", "E"], "value": np.random.randn(4)})

假设我们有两个与我们的 DataFrame 具有相同名称和结构的数据库表。

现在让我们来看看各种类型的JOIN。

内连接

SELECT  *
FROM  df1
INNER  JOIN  df2
  ON  df1.key  =  df2.key;

# merge performs an INNER JOIN by default
In [26]: pd.merge(df1, df2, on="key")
Out[26]: 
 key   value_x   value_y
0   B -0.282863  1.212112
1   D -1.135632 -0.173215
2   D -1.135632  0.119209

merge() 还提供了参数，用于当你想要将一个 DataFrame 的列与另一个 DataFrame 的索引进行连接时。

In [27]: indexed_df2 = df2.set_index("key")

In [28]: pd.merge(df1, indexed_df2, left_on="key", right_index=True)
Out[28]: 
 key   value_x   value_y
1   B -0.282863  1.212112
3   D -1.135632 -0.173215
3   D -1.135632  0.119209

左外连接

显示所有来自df1的记录。

SELECT  *
FROM  df1
LEFT  OUTER  JOIN  df2
  ON  df1.key  =  df2.key;

In [29]: pd.merge(df1, df2, on="key", how="left")
Out[29]: 
 key   value_x   value_y
0   A  0.469112       NaN
1   B -0.282863  1.212112
2   C -1.509059       NaN
3   D -1.135632 -0.173215
4   D -1.135632  0.119209

右外连接

显示所有来自df2的记录。

SELECT  *
FROM  df1
RIGHT  OUTER  JOIN  df2
  ON  df1.key  =  df2.key;

In [30]: pd.merge(df1, df2, on="key", how="right")
Out[30]: 
 key   value_x   value_y
0   B -0.282863  1.212112
1   D -1.135632 -0.173215
2   D -1.135632  0.119209
3   E       NaN -1.044236

全连接

pandas 还允许进行FULL JOIN，它显示数据集的两侧，无论连接的列是否找到匹配。截至目前，不是所有的 RDBMS（MySQL）都支持FULL JOIN。

显示两个表中的所有记录。

SELECT  *
FROM  df1
FULL  OUTER  JOIN  df2
  ON  df1.key  =  df2.key;

In [31]: pd.merge(df1, df2, on="key", how="outer")
Out[31]: 
 key   value_x   value_y
0   A  0.469112       NaN
1   B -0.282863  1.212112
2   C -1.509059       NaN
3   D -1.135632 -0.173215
4   D -1.135632  0.119209
5   E       NaN -1.044236

UNION

使用concat()可以执行UNION ALL。

In [32]: df1 = pd.DataFrame(
 ....:    {"city": ["Chicago", "San Francisco", "New York City"], "rank": range(1, 4)}
 ....: )
 ....: 

In [33]: df2 = pd.DataFrame(
 ....:    {"city": ["Chicago", "Boston", "Los Angeles"], "rank": [1, 4, 5]}
 ....: )
 ....:

SELECT  city,  rank
FROM  df1
UNION  ALL
SELECT  city,  rank
FROM  df2;
/*
 city  rank
 Chicago     1
San Francisco     2
New York City     3
 Chicago     1
 Boston     4
 Los Angeles     5
*/

In [34]: pd.concat([df1, df2])
Out[34]: 
 city  rank
0        Chicago     1
1  San Francisco     2
2  New York City     3
0        Chicago     1
1         Boston     4
2    Los Angeles     5

SQL 的UNION类似于UNION ALL，但UNION将删除重复行。

SELECT  city,  rank
FROM  df1
UNION
SELECT  city,  rank
FROM  df2;
-- notice that there is only one Chicago record this time
/*
 city  rank
 Chicago     1
San Francisco     2
New York City     3
 Boston     4
 Los Angeles     5
*/

在 pandas 中，您可以使用concat()与drop_duplicates()结合使用。

In [35]: pd.concat([df1, df2]).drop_duplicates()
Out[35]: 
 city  rank
0        Chicago     1
1  San Francisco     2
2  New York City     3
1         Boston     4
2    Los Angeles     5

限制

SELECT  *  FROM  tips
LIMIT  10;

In [36]: tips.head(10)
Out[36]: 
 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
5       25.29  4.71    Male     No  Sun  Dinner     4
6        8.77  2.00    Male     No  Sun  Dinner     2
7       26.88  3.12    Male     No  Sun  Dinner     4
8       15.04  1.96    Male     No  Sun  Dinner     2
9       14.78  3.23    Male     No  Sun  Dinner     2

一些 SQL 分析和聚合函数的 pandas 等效函数

带有偏移的前 n 行

-- MySQL
SELECT  *  FROM  tips
ORDER  BY  tip  DESC
LIMIT  10  OFFSET  5;

In [37]: tips.nlargest(10 + 5, columns="tip").tail(10)
Out[37]: 
 total_bill   tip     sex smoker   day    time  size
183       23.17  6.50    Male    Yes   Sun  Dinner     4
214       28.17  6.50  Female    Yes   Sat  Dinner     3
47        32.40  6.00    Male     No   Sun  Dinner     4
239       29.03  5.92    Male     No   Sat  Dinner     3
88        24.71  5.85    Male     No  Thur   Lunch     2
181       23.33  5.65    Male    Yes   Sun  Dinner     2
44        30.40  5.60    Male     No   Sun  Dinner     4
52        34.81  5.20  Female     No   Sun  Dinner     4
85        34.83  5.17  Female     No  Thur   Lunch     4
211       25.89  5.16    Male    Yes   Sat  Dinner     4

每个组的前 n 行

-- Oracle's ROW_NUMBER() analytic function
SELECT  *  FROM  (
  SELECT
  t.*,
  ROW_NUMBER()  OVER(PARTITION  BY  day  ORDER  BY  total_bill  DESC)  AS  rn
  FROM  tips  t
)
WHERE  rn  <  3
ORDER  BY  day,  rn;

In [38]: (
 ....:    tips.assign(
 ....:        rn=tips.sort_values(["total_bill"], ascending=False)
 ....:        .groupby(["day"])
 ....:        .cumcount()
 ....:        + 1
 ....:    )
 ....:    .query("rn < 3")
 ....:    .sort_values(["day", "rn"])
 ....: )
 ....: 
Out[38]: 
 total_bill    tip     sex smoker   day    time  size  rn
95        40.17   4.73    Male    Yes   Fri  Dinner     4   1
90        28.97   3.00    Male    Yes   Fri  Dinner     2   2
170       50.81  10.00    Male    Yes   Sat  Dinner     3   1
212       48.33   9.00    Male     No   Sat  Dinner     4   2
156       48.17   5.00    Male     No   Sun  Dinner     6   1
182       45.35   3.50    Male    Yes   Sun  Dinner     3   2
197       43.11   5.00  Female    Yes  Thur   Lunch     4   1
142       41.19   5.00    Male     No  Thur   Lunch     5   2

使用rank(method='first')函数也是一样的

In [39]: (
 ....:    tips.assign(
 ....:        rnk=tips.groupby(["day"])["total_bill"].rank(
 ....:            method="first", ascending=False
 ....:        )
 ....:    )
 ....:    .query("rnk < 3")
 ....:    .sort_values(["day", "rnk"])
 ....: )
 ....: 
Out[39]: 
 total_bill    tip     sex smoker   day    time  size  rnk
95        40.17   4.73    Male    Yes   Fri  Dinner     4  1.0
90        28.97   3.00    Male    Yes   Fri  Dinner     2  2.0
170       50.81  10.00    Male    Yes   Sat  Dinner     3  1.0
212       48.33   9.00    Male     No   Sat  Dinner     4  2.0
156       48.17   5.00    Male     No   Sun  Dinner     6  1.0
182       45.35   3.50    Male    Yes   Sun  Dinner     3  2.0
197       43.11   5.00  Female    Yes  Thur   Lunch     4  1.0
142       41.19   5.00    Male     No  Thur   Lunch     5  2.0

-- Oracle's RANK() analytic function
SELECT  *  FROM  (
  SELECT
  t.*,
  RANK()  OVER(PARTITION  BY  sex  ORDER  BY  tip)  AS  rnk
  FROM  tips  t
  WHERE  tip  <  2
)
WHERE  rnk  <  3
ORDER  BY  sex,  rnk;

让我们找出每个性别组中（rank < 3）的小费小于 2 的提示。请注意，当使用rank(method='min')函数时，rnk_min对于相同的tip（类似于 Oracle 的RANK()函数）保持不变。

In [40]: (
 ....:    tips[tips["tip"] < 2]
 ....:    .assign(rnk_min=tips.groupby(["sex"])["tip"].rank(method="min"))
 ....:    .query("rnk_min < 3")
 ....:    .sort_values(["sex", "rnk_min"])
 ....: )
 ....: 
Out[40]: 
 total_bill   tip     sex smoker  day    time  size  rnk_min
67         3.07  1.00  Female    Yes  Sat  Dinner     1      1.0
92         5.75  1.00  Female    Yes  Fri  Dinner     2      1.0
111        7.25  1.00  Female     No  Sat  Dinner     1      1.0
236       12.60  1.00    Male    Yes  Sat  Dinner     2      1.0
237       32.83  1.17    Male    Yes  Sat  Dinner     2      2.0

更新

UPDATE  tips
SET  tip  =  tip*2
WHERE  tip  <  2;

In [41]: tips.loc[tips["tip"] < 2, "tip"] *= 2

删除

DELETE  FROM  tips
WHERE  tip  >  9;

在 pandas 中，我们选择应保留的行而不是删除它们：

In [42]: tips = tips.loc[tips["tip"] <= 9]

复制与原地操作

大多数 pandas 操作返回Series/DataFrame的副本。要使更改“生效”，您需要将其分配给一个新变量：

sorted_df = df.sort_values("col1")

或覆盖原始数据：

df = df.sort_values("col1")

注意

对于一些方法，您将看到一个可用的inplace=True或copy=False关键字参数：

df.replace(5, inplace=True)

关于在大多数方法（例如dropna）中弃用和移除inplace和copy进行了活跃的讨论，除了一小部分方法（包括replace）。在写时复制的情况下，这两个关键字将不再是必需的。提案可以在这里找到。

选择

在 SQL 中，使用逗号分隔的列列表来进行选择（或使用*选择所有列）：

SELECT  total_bill,  tip,  smoker,  time
FROM  tips;

在 pandas 中，通过将列名列表传递给 DataFrame 来进行列选择：

In [6]: tips[["total_bill", "tip", "smoker", "time"]]
Out[6]: 
 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
..          ...   ...    ...     ...
239       29.03  5.92     No  Dinner
240       27.18  2.00    Yes  Dinner
241       22.67  2.00    Yes  Dinner
242       17.82  1.75     No  Dinner
243       18.78  3.00     No  Dinner

[244 rows x 4 columns]

调用不带列名列表的 DataFrame 将显示所有列（类似于 SQL 的*）。

在 SQL 中，您可以添加一个计算列：

SELECT  *,  tip/total_bill  as  tip_rate
FROM  tips;

在 pandas 中，您可以使用 DataFrame 的DataFrame.assign()方法来附加一个新列：

In [7]: tips.assign(tip_rate=tips["tip"] / tips["total_bill"])
Out[7]: 
 total_bill   tip     sex smoker   day    time  size  tip_rate
0         16.99  1.01  Female     No   Sun  Dinner     2  0.059447
1         10.34  1.66    Male     No   Sun  Dinner     3  0.160542
2         21.01  3.50    Male     No   Sun  Dinner     3  0.166587
3         23.68  3.31    Male     No   Sun  Dinner     2  0.139780
4         24.59  3.61  Female     No   Sun  Dinner     4  0.146808
..          ...   ...     ...    ...   ...     ...   ...       ...
239       29.03  5.92    Male     No   Sat  Dinner     3  0.203927
240       27.18  2.00  Female    Yes   Sat  Dinner     2  0.073584
241       22.67  2.00    Male    Yes   Sat  Dinner     2  0.088222
242       17.82  1.75    Male     No   Sat  Dinner     2  0.098204
243       18.78  3.00  Female     No  Thur  Dinner     2  0.159744

[244 rows x 8 columns]

WHERE

在 SQL 中，过滤是通过 WHERE 子句完成的。

SELECT  *
FROM  tips
WHERE  time  =  'Dinner';

DataFrame 可以通过多种方式进行过滤；其中最直观的是使用布尔索引。

In [8]: tips[tips["total_bill"] > 10]
Out[8]: 
 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
..          ...   ...     ...    ...   ...     ...   ...
239       29.03  5.92    Male     No   Sat  Dinner     3
240       27.18  2.00  Female    Yes   Sat  Dinner     2
241       22.67  2.00    Male    Yes   Sat  Dinner     2
242       17.82  1.75    Male     No   Sat  Dinner     2
243       18.78  3.00  Female     No  Thur  Dinner     2

[227 rows x 7 columns]

上述语句简单地将 True/False 对象的 Series 传递给 DataFrame，返回所有具有 True 的行。

In [9]: is_dinner = tips["time"] == "Dinner"

In [10]: is_dinner
Out[10]: 
0      True
1      True
2      True
3      True
4      True
 ... 
239    True
240    True
241    True
242    True
243    True
Name: time, Length: 244, dtype: bool

In [11]: is_dinner.value_counts()
Out[11]: 
time
True     176
False     68
Name: count, dtype: int64

In [12]: tips[is_dinner]
Out[12]: 
 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
..          ...   ...     ...    ...   ...     ...   ...
239       29.03  5.92    Male     No   Sat  Dinner     3
240       27.18  2.00  Female    Yes   Sat  Dinner     2
241       22.67  2.00    Male    Yes   Sat  Dinner     2
242       17.82  1.75    Male     No   Sat  Dinner     2
243       18.78  3.00  Female     No  Thur  Dinner     2

[176 rows x 7 columns]

就像 SQL 的 OR 和 AND 一样，可以使用 |（OR）和 &（AND）将多个条件传递给 DataFrame。

晚餐小费超过 $5：

SELECT  *
FROM  tips
WHERE  time  =  'Dinner'  AND  tip  >  5.00;

In [13]: tips[(tips["time"] == "Dinner") & (tips["tip"] > 5.00)]
Out[13]: 
 total_bill    tip     sex smoker  day    time  size
23        39.42   7.58    Male     No  Sat  Dinner     4
44        30.40   5.60    Male     No  Sun  Dinner     4
47        32.40   6.00    Male     No  Sun  Dinner     4
52        34.81   5.20  Female     No  Sun  Dinner     4
59        48.27   6.73    Male     No  Sat  Dinner     4
116       29.93   5.07    Male     No  Sun  Dinner     4
155       29.85   5.14  Female     No  Sun  Dinner     5
170       50.81  10.00    Male    Yes  Sat  Dinner     3
172        7.25   5.15    Male    Yes  Sun  Dinner     2
181       23.33   5.65    Male    Yes  Sun  Dinner     2
183       23.17   6.50    Male    Yes  Sun  Dinner     4
211       25.89   5.16    Male    Yes  Sat  Dinner     4
212       48.33   9.00    Male     No  Sat  Dinner     4
214       28.17   6.50  Female    Yes  Sat  Dinner     3
239       29.03   5.92    Male     No  Sat  Dinner     3

5 人以上的派对小费或者账单总额超过 $45：

SELECT  *
FROM  tips
WHERE  size  >=  5  OR  total_bill  >  45;

In [14]: tips[(tips["size"] >= 5) | (tips["total_bill"] > 45)]
Out[14]: 
 total_bill    tip     sex smoker   day    time  size
59        48.27   6.73    Male     No   Sat  Dinner     4
125       29.80   4.20  Female     No  Thur   Lunch     6
141       34.30   6.70    Male     No  Thur   Lunch     6
142       41.19   5.00    Male     No  Thur   Lunch     5
143       27.05   5.00  Female     No  Thur   Lunch     6
155       29.85   5.14  Female     No   Sun  Dinner     5
156       48.17   5.00    Male     No   Sun  Dinner     6
170       50.81  10.00    Male    Yes   Sat  Dinner     3
182       45.35   3.50    Male    Yes   Sun  Dinner     3
185       20.69   5.00    Male     No   Sun  Dinner     5
187       30.46   2.00    Male    Yes   Sun  Dinner     5
212       48.33   9.00    Male     No   Sat  Dinner     4
216       28.15   3.00    Male    Yes   Sat  Dinner     5

使用 notna() 和 isna() 方法进行 NULL 检查。

In [15]: frame = pd.DataFrame(
 ....:    {"col1": ["A", "B", np.nan, "C", "D"], "col2": ["F", np.nan, "G", "H", "I"]}
 ....: )
 ....: 

In [16]: frame
Out[16]: 
 col1 col2
0    A    F
1    B  NaN
2  NaN    G
3    C    H
4    D    I

假设我们有一张与上面 DataFrame 结构相同的表格。我们可以使用以下查询仅查看 col2 为空的记录：

SELECT  *
FROM  frame
WHERE  col2  IS  NULL;

In [17]: frame[frame["col2"].isna()]
Out[17]: 
 col1 col2
1    B  NaN

使用 notna() 可以获取 col1 不为空的项。

SELECT  *
FROM  frame
WHERE  col1  IS  NOT  NULL;

In [18]: frame[frame["col1"].notna()]
Out[18]: 
 col1 col2
0    A    F
1    B  NaN
3    C    H
4    D    I

GROUP BY

在 pandas 中，使用同名的 groupby() 方法执行 SQL 的 GROUP BY 操作。groupby() 通常指的是将数据集拆分为组，应用某些函数（通常是聚合），然后将组合并在一起的过程。

一个常见的 SQL 操作是获取数据集中每个组中记录的计数。例如，一个查询可以获取按性别留下的小费数量：

SELECT  sex,  count(*)
FROM  tips
GROUP  BY  sex;
/*
Female     87
Male      157
*/

pandas 中的等效操作将是：

In [19]: tips.groupby("sex").size()
Out[19]: 
sex
Female     87
Male      157
dtype: int64

请注意，在 pandas 代码中，我们使用的是 DataFrameGroupBy.size() 而不是 DataFrameGroupBy.count()。这是因为 DataFrameGroupBy.count() 将函数应用于每列，返回每列中 NOT NULL 记录的数量。

In [20]: tips.groupby("sex").count()
Out[20]: 
 total_bill  tip  smoker  day  time  size
sex 
Female          87   87      87   87    87    87
Male           157  157     157  157   157   157

或者，我们可以将 DataFrameGroupBy.count() 方法应用于单个列：

In [21]: tips.groupby("sex")["total_bill"].count()
Out[21]: 
sex
Female     87
Male      157
Name: total_bill, dtype: int64

还可以一次应用多个函数。例如，假设我们想看到小费金额如何随一周中的日期而变化 - DataFrameGroupBy.agg()允许您向分组的数据框传递一个字典，指示要应用于特定列的函数。

SELECT  day,  AVG(tip),  COUNT(*)
FROM  tips
GROUP  BY  day;
/*
Fri   2.734737   19
Sat   2.993103   87
Sun   3.255132   76
Thu  2.771452   62
*/

In [22]: tips.groupby("day").agg({"tip": "mean", "day": "size"})
Out[22]: 
 tip  day
day 
Fri   2.734737   19
Sat   2.993103   87
Sun   3.255132   76
Thur  2.771452   62

通过将列的列表传递给groupby()方法，可以按多个列进行分组。

SELECT  smoker,  day,  COUNT(*),  AVG(tip)
FROM  tips
GROUP  BY  smoker,  day;
/*
smoker day
No     Fri      4  2.812500
 Sat     45  3.102889
 Sun     57  3.167895
 Thu    45  2.673778
Yes    Fri     15  2.714000
 Sat     42  2.875476
 Sun     19  3.516842
 Thu    17  3.030000
*/

In [23]: tips.groupby(["smoker", "day"]).agg({"tip": ["size", "mean"]})
Out[23]: 
 tip 
 size      mean
smoker day 
No     Fri     4  2.812500
 Sat    45  3.102889
 Sun    57  3.167895
 Thur   45  2.673778
Yes    Fri    15  2.714000
 Sat    42  2.875476
 Sun    19  3.516842
 Thur   17  3.030000

JOIN

可以使用join()或merge()执行JOIN。默认情况下，join()将在它们的索引上连接数据框。每种方法都有参数，允许您指定要执行的连接类型（LEFT、RIGHT、INNER、FULL）或要连接的列（列名或索引）。

警告

如果两个关键列都包含键为 null 值的行，则这些行将相互匹配。这与通常的 SQL 连接行为不同，可能会导致意外结果。

In [24]: df1 = pd.DataFrame({"key": ["A", "B", "C", "D"], "value": np.random.randn(4)})

In [25]: df2 = pd.DataFrame({"key": ["B", "D", "D", "E"], "value": np.random.randn(4)})

假设我们有两个与我们的数据框相同名称和结构的数据库表。

现在让我们来了解各种类型的JOIN。

INNER JOIN

SELECT  *
FROM  df1
INNER  JOIN  df2
  ON  df1.key  =  df2.key;

# merge performs an INNER JOIN by default
In [26]: pd.merge(df1, df2, on="key")
Out[26]: 
 key   value_x   value_y
0   B -0.282863  1.212112
1   D -1.135632 -0.173215
2   D -1.135632  0.119209

merge()还提供参数，用于在您希望将一个数据框的列与另一个数据框的索引进行连接的情况。

In [27]: indexed_df2 = df2.set_index("key")

In [28]: pd.merge(df1, indexed_df2, left_on="key", right_index=True)
Out[28]: 
 key   value_x   value_y
1   B -0.282863  1.212112
3   D -1.135632 -0.173215
3   D -1.135632  0.119209

LEFT OUTER JOIN

显示df1中的所有记录。

SELECT  *
FROM  df1
LEFT  OUTER  JOIN  df2
  ON  df1.key  =  df2.key;

In [29]: pd.merge(df1, df2, on="key", how="left")
Out[29]: 
 key   value_x   value_y
0   A  0.469112       NaN
1   B -0.282863  1.212112
2   C -1.509059       NaN
3   D -1.135632 -0.173215
4   D -1.135632  0.119209

RIGHT JOIN

显示df2中的所有记录。

SELECT  *
FROM  df1
RIGHT  OUTER  JOIN  df2
  ON  df1.key  =  df2.key;

In [30]: pd.merge(df1, df2, on="key", how="right")
Out[30]: 
 key   value_x   value_y
0   B -0.282863  1.212112
1   D -1.135632 -0.173215
2   D -1.135632  0.119209
3   E       NaN -1.044236

FULL JOIN

pandas 还允许进行FULL JOIN，它会显示数据集的两侧，无论连接列是否找到匹配。截至目前，不是所有的 RDBMS（MySQL）都支持FULL JOIN。

显示两个表中的所有记录。

SELECT  *
FROM  df1
FULL  OUTER  JOIN  df2
  ON  df1.key  =  df2.key;

In [31]: pd.merge(df1, df2, on="key", how="outer")
Out[31]: 
 key   value_x   value_y
0   A  0.469112       NaN
1   B -0.282863  1.212112
2   C -1.509059       NaN
3   D -1.135632 -0.173215
4   D -1.135632  0.119209
5   E       NaN -1.044236

INNER JOIN

SELECT  *
FROM  df1
INNER  JOIN  df2
  ON  df1.key  =  df2.key;

# merge performs an INNER JOIN by default
In [26]: pd.merge(df1, df2, on="key")
Out[26]: 
 key   value_x   value_y
0   B -0.282863  1.212112
1   D -1.135632 -0.173215
2   D -1.135632  0.119209

merge()还提供参数，用于在您希望将一个数据框的列与另一个数据框的索引进行连接的情况。

In [27]: indexed_df2 = df2.set_index("key")

In [28]: pd.merge(df1, indexed_df2, left_on="key", right_index=True)
Out[28]: 
 key   value_x   value_y
1   B -0.282863  1.212112
3   D -1.135632 -0.173215
3   D -1.135632  0.119209

LEFT OUTER JOIN

显示df1中的所有记录。

SELECT  *
FROM  df1
LEFT  OUTER  JOIN  df2
  ON  df1.key  =  df2.key;

In [29]: pd.merge(df1, df2, on="key", how="left")
Out[29]: 
 key   value_x   value_y
0   A  0.469112       NaN
1   B -0.282863  1.212112
2   C -1.509059       NaN
3   D -1.135632 -0.173215
4   D -1.135632  0.119209

RIGHT JOIN

显示df2中的所有记录。

SELECT  *
FROM  df1
RIGHT  OUTER  JOIN  df2
  ON  df1.key  =  df2.key;

In [30]: pd.merge(df1, df2, on="key", how="right")
Out[30]: 
 key   value_x   value_y
0   B -0.282863  1.212112
1   D -1.135632 -0.173215
2   D -1.135632  0.119209
3   E       NaN -1.044236

FULL JOIN

pandas 还允许进行FULL JOIN，它会显示数据集的两侧，无论连接列是否找到匹配。截至目前，不是所有的 RDBMS（MySQL）都支持FULL JOIN。

显示两个表中的所有记录。

SELECT  *
FROM  df1
FULL  OUTER  JOIN  df2
  ON  df1.key  =  df2.key;

In [31]: pd.merge(df1, df2, on="key", how="outer")
Out[31]: 
 key   value_x   value_y
0   A  0.469112       NaN
1   B -0.282863  1.212112
2   C -1.509059       NaN
3   D -1.135632 -0.173215
4   D -1.135632  0.119209
5   E       NaN -1.044236

UNION

可以使用concat()执行UNION ALL。

In [32]: df1 = pd.DataFrame(
 ....:    {"city": ["Chicago", "San Francisco", "New York City"], "rank": range(1, 4)}
 ....: )
 ....: 

In [33]: df2 = pd.DataFrame(
 ....:    {"city": ["Chicago", "Boston", "Los Angeles"], "rank": [1, 4, 5]}
 ....: )
 ....:

SELECT  city,  rank
FROM  df1
UNION  ALL
SELECT  city,  rank
FROM  df2;
/*
 city  rank
 Chicago     1
San Francisco     2
New York City     3
 Chicago     1
 Boston     4
 Los Angeles     5
*/

In [34]: pd.concat([df1, df2])
Out[34]: 
 city  rank
0        Chicago     1
1  San Francisco     2
2  New York City     3
0        Chicago     1
1         Boston     4
2    Los Angeles     5

SQL 的UNION类似于UNION ALL，但UNION会删除重复行。

SELECT  city,  rank
FROM  df1
UNION
SELECT  city,  rank
FROM  df2;
-- notice that there is only one Chicago record this time
/*
 city  rank
 Chicago     1
San Francisco     2
New York City     3
 Boston     4
 Los Angeles     5
*/

在 pandas 中，您可以结合使用 concat() 和 drop_duplicates()。

In [35]: pd.concat([df1, df2]).drop_duplicates()
Out[35]: 
 city  rank
0        Chicago     1
1  San Francisco     2
2  New York City     3
1         Boston     4
2    Los Angeles     5

限制

SELECT  *  FROM  tips
LIMIT  10;

In [36]: tips.head(10)
Out[36]: 
 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
5       25.29  4.71    Male     No  Sun  Dinner     4
6        8.77  2.00    Male     No  Sun  Dinner     2
7       26.88  3.12    Male     No  Sun  Dinner     4
8       15.04  1.96    Male     No  Sun  Dinner     2
9       14.78  3.23    Male     No  Sun  Dinner     2

pandas 中一些 SQL 分析和聚合函数的等效函数

带有偏移的前 n 行

-- MySQL
SELECT  *  FROM  tips
ORDER  BY  tip  DESC
LIMIT  10  OFFSET  5;

In [37]: tips.nlargest(10 + 5, columns="tip").tail(10)
Out[37]: 
 total_bill   tip     sex smoker   day    time  size
183       23.17  6.50    Male    Yes   Sun  Dinner     4
214       28.17  6.50  Female    Yes   Sat  Dinner     3
47        32.40  6.00    Male     No   Sun  Dinner     4
239       29.03  5.92    Male     No   Sat  Dinner     3
88        24.71  5.85    Male     No  Thur   Lunch     2
181       23.33  5.65    Male    Yes   Sun  Dinner     2
44        30.40  5.60    Male     No   Sun  Dinner     4
52        34.81  5.20  Female     No   Sun  Dinner     4
85        34.83  5.17  Female     No  Thur   Lunch     4
211       25.89  5.16    Male    Yes   Sat  Dinner     4

每个组的前 n 行

-- Oracle's ROW_NUMBER() analytic function
SELECT  *  FROM  (
  SELECT
  t.*,
  ROW_NUMBER()  OVER(PARTITION  BY  day  ORDER  BY  total_bill  DESC)  AS  rn
  FROM  tips  t
)
WHERE  rn  <  3
ORDER  BY  day,  rn;

In [38]: (
 ....:    tips.assign(
 ....:        rn=tips.sort_values(["total_bill"], ascending=False)
 ....:        .groupby(["day"])
 ....:        .cumcount()
 ....:        + 1
 ....:    )
 ....:    .query("rn < 3")
 ....:    .sort_values(["day", "rn"])
 ....: )
 ....: 
Out[38]: 
 total_bill    tip     sex smoker   day    time  size  rn
95        40.17   4.73    Male    Yes   Fri  Dinner     4   1
90        28.97   3.00    Male    Yes   Fri  Dinner     2   2
170       50.81  10.00    Male    Yes   Sat  Dinner     3   1
212       48.33   9.00    Male     No   Sat  Dinner     4   2
156       48.17   5.00    Male     No   Sun  Dinner     6   1
182       45.35   3.50    Male    Yes   Sun  Dinner     3   2
197       43.11   5.00  Female    Yes  Thur   Lunch     4   1
142       41.19   5.00    Male     No  Thur   Lunch     5   2

使用 rank(method='first') 函数相同

In [39]: (
 ....:    tips.assign(
 ....:        rnk=tips.groupby(["day"])["total_bill"].rank(
 ....:            method="first", ascending=False
 ....:        )
 ....:    )
 ....:    .query("rnk < 3")
 ....:    .sort_values(["day", "rnk"])
 ....: )
 ....: 
Out[39]: 
 total_bill    tip     sex smoker   day    time  size  rnk
95        40.17   4.73    Male    Yes   Fri  Dinner     4  1.0
90        28.97   3.00    Male    Yes   Fri  Dinner     2  2.0
170       50.81  10.00    Male    Yes   Sat  Dinner     3  1.0
212       48.33   9.00    Male     No   Sat  Dinner     4  2.0
156       48.17   5.00    Male     No   Sun  Dinner     6  1.0
182       45.35   3.50    Male    Yes   Sun  Dinner     3  2.0
197       43.11   5.00  Female    Yes  Thur   Lunch     4  1.0
142       41.19   5.00    Male     No  Thur   Lunch     5  2.0

-- Oracle's RANK() analytic function
SELECT  *  FROM  (
  SELECT
  t.*,
  RANK()  OVER(PARTITION  BY  sex  ORDER  BY  tip)  AS  rnk
  FROM  tips  t
  WHERE  tip  <  2
)
WHERE  rnk  <  3
ORDER  BY  sex,  rnk;

让我们找到每个性别组中 (rank < 3) 的小费，对于 (tips < 2)。请注意，当使用 rank(method='min') 函数时，相同 tip 的 rnk_min 保持不变（类似于 Oracle 的 RANK() 函数）

In [40]: (
 ....:    tips[tips["tip"] < 2]
 ....:    .assign(rnk_min=tips.groupby(["sex"])["tip"].rank(method="min"))
 ....:    .query("rnk_min < 3")
 ....:    .sort_values(["sex", "rnk_min"])
 ....: )
 ....: 
Out[40]: 
 total_bill   tip     sex smoker  day    time  size  rnk_min
67         3.07  1.00  Female    Yes  Sat  Dinner     1      1.0
92         5.75  1.00  Female    Yes  Fri  Dinner     2      1.0
111        7.25  1.00  Female     No  Sat  Dinner     1      1.0
236       12.60  1.00    Male    Yes  Sat  Dinner     2      1.0
237       32.83  1.17    Male    Yes  Sat  Dinner     2      2.0

带有偏移的前 n 行

-- MySQL
SELECT  *  FROM  tips
ORDER  BY  tip  DESC
LIMIT  10  OFFSET  5;

In [37]: tips.nlargest(10 + 5, columns="tip").tail(10)
Out[37]: 
 total_bill   tip     sex smoker   day    time  size
183       23.17  6.50    Male    Yes   Sun  Dinner     4
214       28.17  6.50  Female    Yes   Sat  Dinner     3
47        32.40  6.00    Male     No   Sun  Dinner     4
239       29.03  5.92    Male     No   Sat  Dinner     3
88        24.71  5.85    Male     No  Thur   Lunch     2
181       23.33  5.65    Male    Yes   Sun  Dinner     2
44        30.40  5.60    Male     No   Sun  Dinner     4
52        34.81  5.20  Female     No   Sun  Dinner     4
85        34.83  5.17  Female     No  Thur   Lunch     4
211       25.89  5.16    Male    Yes   Sat  Dinner     4

每个组的前 n 行

-- Oracle's ROW_NUMBER() analytic function
SELECT  *  FROM  (
  SELECT
  t.*,
  ROW_NUMBER()  OVER(PARTITION  BY  day  ORDER  BY  total_bill  DESC)  AS  rn
  FROM  tips  t
)
WHERE  rn  <  3
ORDER  BY  day,  rn;

In [38]: (
 ....:    tips.assign(
 ....:        rn=tips.sort_values(["total_bill"], ascending=False)
 ....:        .groupby(["day"])
 ....:        .cumcount()
 ....:        + 1
 ....:    )
 ....:    .query("rn < 3")
 ....:    .sort_values(["day", "rn"])
 ....: )
 ....: 
Out[38]: 
 total_bill    tip     sex smoker   day    time  size  rn
95        40.17   4.73    Male    Yes   Fri  Dinner     4   1
90        28.97   3.00    Male    Yes   Fri  Dinner     2   2
170       50.81  10.00    Male    Yes   Sat  Dinner     3   1
212       48.33   9.00    Male     No   Sat  Dinner     4   2
156       48.17   5.00    Male     No   Sun  Dinner     6   1
182       45.35   3.50    Male    Yes   Sun  Dinner     3   2
197       43.11   5.00  Female    Yes  Thur   Lunch     4   1
142       41.19   5.00    Male     No  Thur   Lunch     5   2

使用 rank(method='first') 函数相同

In [39]: (
 ....:    tips.assign(
 ....:        rnk=tips.groupby(["day"])["total_bill"].rank(
 ....:            method="first", ascending=False
 ....:        )
 ....:    )
 ....:    .query("rnk < 3")
 ....:    .sort_values(["day", "rnk"])
 ....: )
 ....: 
Out[39]: 
 total_bill    tip     sex smoker   day    time  size  rnk
95        40.17   4.73    Male    Yes   Fri  Dinner     4  1.0
90        28.97   3.00    Male    Yes   Fri  Dinner     2  2.0
170       50.81  10.00    Male    Yes   Sat  Dinner     3  1.0
212       48.33   9.00    Male     No   Sat  Dinner     4  2.0
156       48.17   5.00    Male     No   Sun  Dinner     6  1.0
182       45.35   3.50    Male    Yes   Sun  Dinner     3  2.0
197       43.11   5.00  Female    Yes  Thur   Lunch     4  1.0
142       41.19   5.00    Male     No  Thur   Lunch     5  2.0

-- Oracle's RANK() analytic function
SELECT  *  FROM  (
  SELECT
  t.*,
  RANK()  OVER(PARTITION  BY  sex  ORDER  BY  tip)  AS  rnk
  FROM  tips  t
  WHERE  tip  <  2
)
WHERE  rnk  <  3
ORDER  BY  sex,  rnk;

In [40]: (
 ....:    tips[tips["tip"] < 2]
 ....:    .assign(rnk_min=tips.groupby(["sex"])["tip"].rank(method="min"))
 ....:    .query("rnk_min < 3")
 ....:    .sort_values(["sex", "rnk_min"])
 ....: )
 ....: 
Out[40]: 
 total_bill   tip     sex smoker  day    time  size  rnk_min
67         3.07  1.00  Female    Yes  Sat  Dinner     1      1.0
92         5.75  1.00  Female    Yes  Fri  Dinner     2      1.0
111        7.25  1.00  Female     No  Sat  Dinner     1      1.0
236       12.60  1.00    Male    Yes  Sat  Dinner     2      1.0
237       32.83  1.17    Male    Yes  Sat  Dinner     2      2.0

更新

UPDATE  tips
SET  tip  =  tip*2
WHERE  tip  <  2;

In [41]: tips.loc[tips["tip"] < 2, "tip"] *= 2

删除

DELETE  FROM  tips
WHERE  tip  >  9;

在 pandas 中，我们选择应该保留的行，而不是删除它们：

In [42]: tips = tips.loc[tips["tip"] <= 9]

与电子表格的比较

原文：pandas.pydata.org/docs/getting_started/comparison/comparison_with_spreadsheets.html

由于许多潜在的 pandas 用户对电子表格程序（如 Excel）有一定的了解，因此本页面旨在提供使用 pandas 执行各种电子表格操作的示例。本页面将使用 Excel 的术语和链接到文档，但在 Google Sheets、LibreOffice Calc、Apple Numbers 和其他兼容 Excel 的电子表格软件中，情况将是相同/类似的。

如果您是 pandas 的新手，您可能首先想阅读 10 分钟入门 pandas 来熟悉该库。

惯例上，我们导入 pandas 和 NumPy 如下：

In [1]: import pandas as pd

In [2]: import numpy as np

数据结构

通用术语翻译

pandas	Excel
DataFrame	工作表
Series	列
Index	行标题
行	行
NaN	空单元格

`DataFrame`

在 pandas 中，DataFrame类似于 Excel 工作表。虽然 Excel 工作簿可以包含多个工作表，但 pandas 的DataFrame是独立存在的。

`Series`

Series 是表示DataFrame的一列的数据结构。与处理电子表格的列类似，操作Series。

`Index`

每个DataFrame和Series都有一个Index，这些是数据的行上的标签。在 pandas 中，如果没有指定索引，默认使用 RangeIndex（第一行 = 0，第二行 = 1，依此类推），类似于电子表格中的行标题/编号。

在 pandas 中，索引可以设置为一个（或多个）唯一值，就像在工作表中使用作为行标识符的列一样。与大多数电子表格不同，这些Index值实际上可以用于引用行。（请注意，在 Excel 中可以使用结构引用执行此操作。）例如，在电子表格中，您可以将第一行引用为A1:Z1，而在 pandas 中，您可以使用populations.loc['Chicago']。

索引值也是持久的，因此��果重新排列DataFrame中的行，特定行的标签不会改变。

查看索引文档以了解如何有效使用Index。

复制 vs. 原地操作

大多数 pandas 操作返回Series/DataFrame的副本。要使更改“生效”，您需要将其分配给一个新变量：

sorted_df = df.sort_values("col1")

或覆盖原始数据：

df = df.sort_values("col1")

注意

您将看到一些方法可用的 inplace=True 或 copy=False 关键字参数：

df.replace(5, inplace=True)

目前正在就大多数方法（例如 dropna）废弃和移除 inplace 和 copy 进行积极讨论，除了一小部分方法（包括 replace）之外。在写时复制的情况下，这两个关键字将不再必要。提案可以在这里找到。

数据输入/输出

从值构建 DataFrame

在电子表格中，值可以直接输入到单元格中。

一个 pandas DataFrame 可以以许多不同的方式构建，但对于少量值，通常将其指定为 Python 字典是方便的，其中键是列名，值是数据。

In [3]: df = pd.DataFrame({"x": [1, 3, 5], "y": [2, 4, 6]})

In [4]: df
Out[4]: 
 x  y
0  1  2
1  3  4
2  5  6

读取外部数据

Excel 和 pandas 都可以从各种来源以各种格式导入数据。

CSV

让我们加载并显示来自 pandas 测试的tips数据集，这是一个 CSV 文件。在 Excel 中，您会下载然后打开 CSV。在 pandas 中，您将 URL 或本地路径传递给 read_csv()：

In [5]: url = (
 ...:    "https://raw.githubusercontent.com/pandas-dev"
 ...:    "/pandas/main/pandas/tests/io/data/csv/tips.csv"
 ...: )
 ...: 

In [6]: tips = pd.read_csv(url)

In [7]: tips
Out[7]: 
 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
..          ...   ...     ...    ...   ...     ...   ...
239       29.03  5.92    Male     No   Sat  Dinner     3
240       27.18  2.00  Female    Yes   Sat  Dinner     2
241       22.67  2.00    Male    Yes   Sat  Dinner     2
242       17.82  1.75    Male     No   Sat  Dinner     2
243       18.78  3.00  Female     No  Thur  Dinner     2

[244 rows x 7 columns]

像Excel 的文本导入向导一样，read_csv 可以接受多个参数来指定数据应如何解析。例如，如果数据实际上是制表符分隔的，并且没有列名，那么 pandas 命令将是：

tips = pd.read_csv("tips.csv", sep="\t", header=None)

# alternatively, read_table is an alias to read_csv with tab delimiter
tips = pd.read_table("tips.csv", header=None)

Excel 文件

Excel 通过双击打开各种 Excel 文件格式，或使用打开菜单。在 pandas 中，您可以使用特殊方法来读取和写入 Excel 文件。

让我们首先根据上面示例中的 tips 数据框创建一个新的 Excel 文件：

tips.to_excel("./tips.xlsx")

如果您希望随后访问 tips.xlsx 文件中的数据，可以使用以下方式将其读入您的模块中

tips_df = pd.read_excel("./tips.xlsx", index_col=0)

你刚刚使用 pandas 读取了一个 Excel 文件！

限制输出

电子表格程序一次只会显示一个屏幕的数据，然后允许你滚动，因此实际上不需要限制输出。在 pandas 中，你需要更多地考虑如何控制你的DataFrame的显示方式。

默认情况下，pandas 会截断大型DataFrame的输出以显示第一行和最后一行。这可以通过更改 pandas 选项，或使用DataFrame.head()或DataFrame.tail()来覆盖。

In [8]: tips.head(5)
Out[8]: 
 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

导出数据

默认情况下，桌面电子表格软件会保存到其相应的文件格式（.xlsx，.ods等）。但是，你可以保存到其他文件格式。

pandas 可以创建 Excel 文件，CSV，或其他多种格式。

数据操作

列上的操作

在电子表格中，公式通常在单独的单元格中创建，然后通过拖动到其他单元格中以计算其他列的值。在 pandas 中，你可以直接对整列进行操作。

pandas 通过在DataFrame中指定单独的Series提供矢量化操作。新列可以以相同的方式分配。DataFrame.drop()方法从DataFrame中删除列。

In [9]: tips["total_bill"] = tips["total_bill"] - 2

In [10]: tips["new_bill"] = tips["total_bill"] / 2

In [11]: tips
Out[11]: 
 total_bill   tip     sex smoker   day    time  size  new_bill
0         14.99  1.01  Female     No   Sun  Dinner     2     7.495
1          8.34  1.66    Male     No   Sun  Dinner     3     4.170
2         19.01  3.50    Male     No   Sun  Dinner     3     9.505
3         21.68  3.31    Male     No   Sun  Dinner     2    10.840
4         22.59  3.61  Female     No   Sun  Dinner     4    11.295
..          ...   ...     ...    ...   ...     ...   ...       ...
239       27.03  5.92    Male     No   Sat  Dinner     3    13.515
240       25.18  2.00  Female    Yes   Sat  Dinner     2    12.590
241       20.67  2.00    Male    Yes   Sat  Dinner     2    10.335
242       15.82  1.75    Male     No   Sat  Dinner     2     7.910
243       16.78  3.00  Female     No  Thur  Dinner     2     8.390

[244 rows x 8 columns]

In [12]: tips = tips.drop("new_bill", axis=1)

请注意，我们不需要逐个单元格地告诉它执行减法 — pandas 会为我们处理。查看如何从现有列创建新列。

过滤

在 Excel 中，过滤是通过图形菜单完成的。

数据框可以通过多种方式进行过滤；其中最直观的是使用布尔索引。

In [13]: tips[tips["total_bill"] > 10]
Out[13]: 
 total_bill   tip     sex smoker   day    time  size
0         14.99  1.01  Female     No   Sun  Dinner     2
2         19.01  3.50    Male     No   Sun  Dinner     3
3         21.68  3.31    Male     No   Sun  Dinner     2
4         22.59  3.61  Female     No   Sun  Dinner     4
5         23.29  4.71    Male     No   Sun  Dinner     4
..          ...   ...     ...    ...   ...     ...   ...
239       27.03  5.92    Male     No   Sat  Dinner     3
240       25.18  2.00  Female    Yes   Sat  Dinner     2
241       20.67  2.00    Male    Yes   Sat  Dinner     2
242       15.82  1.75    Male     No   Sat  Dinner     2
243       16.78  3.00  Female     No  Thur  Dinner     2

[204 rows x 7 columns]

上述语句只是将True/False对象的Series传递给数据框，返回所有具有True的��。

In [14]: is_dinner = tips["time"] == "Dinner"

In [15]: is_dinner
Out[15]: 
0      True
1      True
2      True
3      True
4      True
 ... 
239    True
240    True
241    True
242    True
243    True
Name: time, Length: 244, dtype: bool

In [16]: is_dinner.value_counts()
Out[16]: 
time
True     176
False     68
Name: count, dtype: int64

In [17]: tips[is_dinner]
Out[17]: 
 total_bill   tip     sex smoker   day    time  size
0         14.99  1.01  Female     No   Sun  Dinner     2
1          8.34  1.66    Male     No   Sun  Dinner     3
2         19.01  3.50    Male     No   Sun  Dinner     3
3         21.68  3.31    Male     No   Sun  Dinner     2
4         22.59  3.61  Female     No   Sun  Dinner     4
..          ...   ...     ...    ...   ...     ...   ...
239       27.03  5.92    Male     No   Sat  Dinner     3
240       25.18  2.00  Female    Yes   Sat  Dinner     2
241       20.67  2.00    Male    Yes   Sat  Dinner     2
242       15.82  1.75    Male     No   Sat  Dinner     2
243       16.78  3.00  Female     No  Thur  Dinner     2

[176 rows x 7 columns]

If/then 逻辑

假设我们想要根据total_bill是小于还是大于$10 来创建一个bucket列，值为low和high。

在电子表格中，可以使用条件公式进行逻辑比较。我们会使用公式=IF(A2 < 10, "low", "high")，拖动到新的bucket列中的所有单元格。

在 pandas 中，可以使用numpy中的where方法来完成相同的操作。

In [18]: tips["bucket"] = np.where(tips["total_bill"] < 10, "low", "high")

In [19]: tips
Out[19]: 
 total_bill   tip     sex smoker   day    time  size bucket
0         14.99  1.01  Female     No   Sun  Dinner     2   high
1          8.34  1.66    Male     No   Sun  Dinner     3    low
2         19.01  3.50    Male     No   Sun  Dinner     3   high
3         21.68  3.31    Male     No   Sun  Dinner     2   high
4         22.59  3.61  Female     No   Sun  Dinner     4   high
..          ...   ...     ...    ...   ...     ...   ...    ...
239       27.03  5.92    Male     No   Sat  Dinner     3   high
240       25.18  2.00  Female    Yes   Sat  Dinner     2   high
241       20.67  2.00    Male    Yes   Sat  Dinner     2   high
242       15.82  1.75    Male     No   Sat  Dinner     2   high
243       16.78  3.00  Female     No  Thur  Dinner     2   high

[244 rows x 8 columns]

日期功能

本节将涉及“日期”，但时间戳处理方式类似。

我们可以将日期功能分为两部分：解析和输出。在电子表格中，日期值通常会自动解析，尽管如果需要，可以使用DATEVALUE函数。在 pandas 中，您需要显式将纯文本转换为日期时间对象，可以在从 CSV 读取时或在 DataFrame 中的某个时刻进行转换。

解析后，电子表格会以默认格式显示日期，尽管格式可以更改。在 pandas 中，您通常希望在进行计算时将日期保留为datetime对象。在电子表格中，输出日期的部分（如年份）是通过日期函数完成的，在 pandas 中则通过 datetime 属性完成。

在电子表格中，如果在列A和B中给出date1和date2，你可能会有这些公式：

列	公式
date1_year	=YEAR(A2)
date2_month	=MONTH(B2)
date1_next	=DATE(YEAR(A2),MONTH(A2)+1,1)
months_between	=DATEDIF(A2,B2,"M")

下面显示了等效的 pandas 操作。

In [20]: tips["date1"] = pd.Timestamp("2013-01-15")

In [21]: tips["date2"] = pd.Timestamp("2015-02-15")

In [22]: tips["date1_year"] = tips["date1"].dt.year

In [23]: tips["date2_month"] = tips["date2"].dt.month

In [24]: tips["date1_next"] = tips["date1"] + pd.offsets.MonthBegin()

In [25]: tips["months_between"] = tips["date2"].dt.to_period("M") - tips[
 ....:    "date1"
 ....: ].dt.to_period("M")
 ....: 

In [26]: tips[
 ....:    ["date1", "date2", "date1_year", "date2_month", "date1_next", "months_between"]
 ....: ]
 ....: 
Out[26]: 
 date1      date2  date1_year  date2_month date1_next    months_between
0   2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
1   2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
2   2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
3   2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
4   2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
..         ...        ...         ...          ...        ...               ...
239 2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
240 2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
241 2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
242 2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
243 2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>

[244 rows x 6 columns]

查看时间序列/日期功能以获取更多详细信息。

列的选择

在电子表格中，您可以通过以下方式选择要选择的列：

隐藏列
删除列
引用范围从一个工作表到另一个工作表

由于电子表格列通常在标题行中命名，所以重命名列只是简单地更改该第一个单元格中的文本。

pandas 中使用相同的操作如下所示。

保留某些列

In [27]: tips[["sex", "total_bill", "tip"]]
Out[27]: 
 sex  total_bill   tip
0    Female       14.99  1.01
1      Male        8.34  1.66
2      Male       19.01  3.50
3      Male       21.68  3.31
4    Female       22.59  3.61
..      ...         ...   ...
239    Male       27.03  5.92
240  Female       25.18  2.00
241    Male       20.67  2.00
242    Male       15.82  1.75
243  Female       16.78  3.00

[244 rows x 3 columns]

删除列

In [28]: tips.drop("sex", axis=1)
Out[28]: 
 total_bill   tip smoker   day    time  size
0         14.99  1.01     No   Sun  Dinner     2
1          8.34  1.66     No   Sun  Dinner     3
2         19.01  3.50     No   Sun  Dinner     3
3         21.68  3.31     No   Sun  Dinner     2
4         22.59  3.61     No   Sun  Dinner     4
..          ...   ...    ...   ...     ...   ...
239       27.03  5.92     No   Sat  Dinner     3
240       25.18  2.00    Yes   Sat  Dinner     2
241       20.67  2.00    Yes   Sat  Dinner     2
242       15.82  1.75     No   Sat  Dinner     2
243       16.78  3.00     No  Thur  Dinner     2

[244 rows x 6 columns]

重命名列

In [29]: tips.rename(columns={"total_bill": "total_bill_2"})
Out[29]: 
 total_bill_2   tip     sex smoker   day    time  size
0           14.99  1.01  Female     No   Sun  Dinner     2
1            8.34  1.66    Male     No   Sun  Dinner     3
2           19.01  3.50    Male     No   Sun  Dinner     3
3           21.68  3.31    Male     No   Sun  Dinner     2
4           22.59  3.61  Female     No   Sun  Dinner     4
..            ...   ...     ...    ...   ...     ...   ...
239         27.03  5.92    Male     No   Sat  Dinner     3
240         25.18  2.00  Female    Yes   Sat  Dinner     2
241         20.67  2.00    Male    Yes   Sat  Dinner     2
242         15.82  1.75    Male     No   Sat  Dinner     2
243         16.78  3.00  Female     No  Thur  Dinner     2

[244 rows x 7 columns]

按值排序

在电子表格中进行排序是通过排序对话框完成的。

pandas 有一个DataFrame.sort_values()方法，它接受要按列排序的列列表。

In [30]: tips = tips.sort_values(["sex", "total_bill"])

In [31]: tips
Out[31]: 
 total_bill    tip     sex smoker   day    time  size
67         1.07   1.00  Female    Yes   Sat  Dinner     1
92         3.75   1.00  Female    Yes   Fri  Dinner     2
111        5.25   1.00  Female     No   Sat  Dinner     1
145        6.35   1.50  Female     No  Thur   Lunch     2
135        6.51   1.25  Female     No  Thur   Lunch     2
..          ...    ...     ...    ...   ...     ...   ...
182       43.35   3.50    Male    Yes   Sun  Dinner     3
156       46.17   5.00    Male     No   Sun  Dinner     6
59        46.27   6.73    Male     No   Sat  Dinner     4
212       46.33   9.00    Male     No   Sat  Dinner     4
170       48.81  10.00    Male    Yes   Sat  Dinner     3

[244 rows x 7 columns]

字符串处理

查找字符串的长度

在电子表格中，可以使用LEN函数找到文本中的字符数。这可以与TRIM函数一起使用以删除额外的空格。

=LEN(TRIM(A2))

您可以使用Series.str.len()找到字符字符串的长度。在 Python 3 中，所有字符串都是 Unicode 字符串。len包括尾随空格。使用len和rstrip排除尾随空格。

In [32]: tips["time"].str.len()
Out[32]: 
67     6
92     6
111    6
145    5
135    5
 ..
182    6
156    6
59     6
212    6
170    6
Name: time, Length: 244, dtype: int64

In [33]: tips["time"].str.rstrip().str.len()
Out[33]: 
67     6
92     6
111    6
145    5
135    5
 ..
182    6
156    6
59     6
212    6
170    6
Name: time, Length: 244, dtype: int64

请注意，这仍将包括字符串中的多个空格，因此不是 100%等效。

查找子串的位置

FIND电子表格函数返回子字符串的位置，第一个字符为1。

您可以使用Series.str.find()方法在字符串列中查找字符的位置。find搜索子字符串的第一个位置。如果找到子字符串，则该方法返回其位置。如果未找到，则返回-1。请记住，Python 索引是从零开始的。

In [34]: tips["sex"].str.find("ale")
Out[34]: 
67     3
92     3
111    3
145    3
135    3
 ..
182    1
156    1
59     1
212    1
170    1
Name: sex, Length: 244, dtype: int64

根据位置提取子串

电子表格中有一个MID公式，用于从给定位置提取子串。要获取第一个字符：

=MID(A2,1,1)

使用 pandas，您可以使用[]符号根据位置提取字符串中的子串。请记住，Python 索引是从零开始的。

In [35]: tips["sex"].str[0:1]
Out[35]: 
67     F
92     F
111    F
145    F
135    F
 ..
182    M
156    M
59     M
212    M
170    M
Name: sex, Length: 244, dtype: object

提取第 n 个单词

在 Excel 中，您可能会使用文本分列向导来拆分文本并检索特定列。（注意也可以通过公式来实现。）

在 pandas 中提取单词的最简单方法是通过空格拆分字符串，然后按索引引用单词。注意，如果需要的话，还有更强大的方法。

In [36]: firstlast = pd.DataFrame({"String": ["John Smith", "Jane Cook"]})

In [37]: firstlast["First_Name"] = firstlast["String"].str.split(" ", expand=True)[0]

In [38]: firstlast["Last_Name"] = firstlast["String"].str.rsplit(" ", expand=True)[1]

In [39]: firstlast
Out[39]: 
 String First_Name Last_Name
0  John Smith       John     Smith
1   Jane Cook       Jane      Cook

更改大小写

电子表格提供UPPER、LOWER 和 PROPER 函数，分别用于将文本转换为大写、小写和首字母大写。

等效的 pandas 方法分别是Series.str.upper()、Series.str.lower() 和Series.str.title()。

In [40]: firstlast = pd.DataFrame({"string": ["John Smith", "Jane Cook"]})

In [41]: firstlast["upper"] = firstlast["string"].str.upper()

In [42]: firstlast["lower"] = firstlast["string"].str.lower()

In [43]: firstlast["title"] = firstlast["string"].str.title()

In [44]: firstlast
Out[44]: 
 string       upper       lower       title
0  John Smith  JOHN SMITH  john smith  John Smith
1   Jane Cook   JANE COOK   jane cook   Jane Cook

合并

下面的表将用于合并示例：

In [45]: df1 = pd.DataFrame({"key": ["A", "B", "C", "D"], "value": np.random.randn(4)})

In [46]: df1
Out[46]: 
 key     value
0   A  0.469112
1   B -0.282863
2   C -1.509059
3   D -1.135632

In [47]: df2 = pd.DataFrame({"key": ["B", "D", "D", "E"], "value": np.random.randn(4)})

In [48]: df2
Out[48]: 
 key     value
0   B  1.212112
1   D -0.173215
2   D  0.119209
3   E -1.044236

在 Excel 中，可以通过 VLOOKUP 合并表格。

显示 Excel 中两个表格之间 VLOOKUP 公式的截图，其中一些值已填充，而其他值显示为“#N/A”

pandas 数据帧有一个merge()方法，提供类似的功能。数据不需要提前排序，并且不同的连接类型通过how关键字实现。

In [49]: inner_join = df1.merge(df2, on=["key"], how="inner")

In [50]: inner_join
Out[50]: 
 key   value_x   value_y
0   B -0.282863  1.212112
1   D -1.135632 -0.173215
2   D -1.135632  0.119209

In [51]: left_join = df1.merge(df2, on=["key"], how="left")

In [52]: left_join
Out[52]: 
 key   value_x   value_y
0   A  0.469112       NaN
1   B -0.282863  1.212112
2   C -1.509059       NaN
3   D -1.135632 -0.173215
4   D -1.135632  0.119209

In [53]: right_join = df1.merge(df2, on=["key"], how="right")

In [54]: right_join
Out[54]: 
 key   value_x   value_y
0   B -0.282863  1.212112
1   D -1.135632 -0.173215
2   D -1.135632  0.119209
3   E       NaN -1.044236

In [55]: outer_join = df1.merge(df2, on=["key"], how="outer")

In [56]: outer_join
Out[56]: 
 key   value_x   value_y
0   A  0.469112       NaN
1   B -0.282863  1.212112
2   C -1.509059       NaN
3   D -1.135632 -0.173215
4   D -1.135632  0.119209
5   E       NaN -1.044236

merge相对于VLOOKUP有一些优势：

查找值不需要是查找表的第一列
如果匹配了多行，则每个匹配都会有一行，而不仅仅是第一个
它将包括查找表中的所有列，而不仅仅是单个指定的列
它支持更复杂的连接操作

其他考虑事项

填充手柄

在一定的一系列单元格中创建一个遵循特定模式的数字序列。在电子表格中，这可以通过输入第一个数字后按住 Shift+拖动，或者输入前两个或三个值然后拖动来完成。

这可以通过创建一个系列并将其分配给所需的单元格来实现。

In [57]: df = pd.DataFrame({"AAA": [1] * 8, "BBB": list(range(0, 8))})

In [58]: df
Out[58]: 
 AAA  BBB
0    1    0
1    1    1
2    1    2
3    1    3
4    1    4
5    1    5
6    1    6
7    1    7

In [59]: series = list(range(1, 5))

In [60]: series
Out[60]: [1, 2, 3, 4]

In [61]: df.loc[2:5, "AAA"] = series

In [62]: df
Out[62]: 
 AAA  BBB
0    1    0
1    1    1
2    1    2
3    2    3
4    3    4
5    4    5
6    1    6
7    1    7

删除重复项

Excel 内置功能可用于删除重复值。在 pandas 中通过 drop_duplicates() 支持此功能。

In [63]: df = pd.DataFrame(
 ....:    {
 ....:        "class": ["A", "A", "A", "B", "C", "D"],
 ....:        "student_count": [42, 35, 42, 50, 47, 45],
 ....:        "all_pass": ["Yes", "Yes", "Yes", "No", "No", "Yes"],
 ....:    }
 ....: )
 ....: 

In [64]: df.drop_duplicates()
Out[64]: 
 class  student_count all_pass
0     A             42      Yes
1     A             35      Yes
3     B             50       No
4     C             47       No
5     D             45      Yes

In [65]: df.drop_duplicates(["class", "student_count"])
Out[65]: 
 class  student_count all_pass
0     A             42      Yes
1     A             35      Yes
3     B             50       No
4     C             47       No
5     D             45      Yes

透视表

电子表格的数据透视表可以通过数据重塑和数据透视表在 pandas 中复制。再次使用 tips 数据集，让我们找到按照客人数量和服务员性别的平均小费。

在 Excel 中，我们使用以下配置进行数据透视表：

屏幕截图显示 Excel 中的数据透视表，使用性别作为列，大小作为行，然后平均小费作为值

pandas 中的等价物：

In [66]: pd.pivot_table(
 ....:    tips, values="tip", index=["size"], columns=["sex"], aggfunc=np.average
 ....: )
 ....: 
Out[66]: 
sex     Female      Male
size 
1     1.276667  1.920000
2     2.528448  2.614184
3     3.250000  3.476667
4     4.021111  4.172143
5     5.140000  3.750000
6     4.600000  5.850000

添加一行

假设我们使用的是 RangeIndex（编号为 0、1 等），我们可以使用 concat() 将一行添加到 DataFrame 的底部。

In [67]: df
Out[67]: 
 class  student_count all_pass
0     A             42      Yes
1     A             35      Yes
2     A             42      Yes
3     B             50       No
4     C             47       No
5     D             45      Yes

In [68]: new_row = pd.DataFrame([["E", 51, True]],
 ....:                       columns=["class", "student_count", "all_pass"])
 ....: 

In [69]: pd.concat([df, new_row])
Out[69]: 
 class  student_count all_pass
0     A             42      Yes
1     A             35      Yes
2     A             42      Yes
3     B             50       No
4     C             47       No
5     D             45      Yes
0     E             51     True

查找和替换

Excel 的查找对话框将逐个匹配的单元格显示出来。在 pandas 中，此操作通常针对整个列或 DataFrame 一次性进行，通过条件表达式。

In [70]: tips
Out[70]: 
 total_bill    tip     sex smoker   day    time  size
67         1.07   1.00  Female    Yes   Sat  Dinner     1
92         3.75   1.00  Female    Yes   Fri  Dinner     2
111        5.25   1.00  Female     No   Sat  Dinner     1
145        6.35   1.50  Female     No  Thur   Lunch     2
135        6.51   1.25  Female     No  Thur   Lunch     2
..          ...    ...     ...    ...   ...     ...   ...
182       43.35   3.50    Male    Yes   Sun  Dinner     3
156       46.17   5.00    Male     No   Sun  Dinner     6
59        46.27   6.73    Male     No   Sat  Dinner     4
212       46.33   9.00    Male     No   Sat  Dinner     4
170       48.81  10.00    Male    Yes   Sat  Dinner     3

[244 rows x 7 columns]

In [71]: tips == "Sun"
Out[71]: 
 total_bill    tip    sex  smoker    day   time   size
67        False  False  False   False  False  False  False
92        False  False  False   False  False  False  False
111       False  False  False   False  False  False  False
145       False  False  False   False  False  False  False
135       False  False  False   False  False  False  False
..          ...    ...    ...     ...    ...    ...    ...
182       False  False  False   False   True  False  False
156       False  False  False   False   True  False  False
59        False  False  False   False  False  False  False
212       False  False  False   False  False  False  False
170       False  False  False   False  False  False  False

[244 rows x 7 columns]

In [72]: tips["day"].str.contains("S")
Out[72]: 
67      True
92     False
111     True
145    False
135    False
 ... 
182     True
156     True
59      True
212     True
170     True
Name: day, Length: 244, dtype: bool

pandas 的 replace() 类似于 Excel 的 全部替换。

In [73]: tips.replace("Thu", "Thursday")
Out[73]: 
 total_bill    tip     sex smoker   day    time  size
67         1.07   1.00  Female    Yes   Sat  Dinner     1
92         3.75   1.00  Female    Yes   Fri  Dinner     2
111        5.25   1.00  Female     No   Sat  Dinner     1
145        6.35   1.50  Female     No  Thur   Lunch     2
135        6.51   1.25  Female     No  Thur   Lunch     2
..          ...    ...     ...    ...   ...     ...   ...
182       43.35   3.50    Male    Yes   Sun  Dinner     3
156       46.17   5.00    Male     No   Sun  Dinner     6
59        46.27   6.73    Male     No   Sat  Dinner     4
212       46.33   9.00    Male     No   Sat  Dinner     4
170       48.81  10.00    Male    Yes   Sat  Dinner     3

[244 rows x 7 columns]

数据结构

一般术语翻译

pandas	Excel
DataFrame	工作表
Series	列
Index	行标题
行	行
NaN	空单元格

`DataFrame`

在 pandas 中，DataFrame 类似于 Excel 的工作表。虽然 Excel 工作簿可以包含多个工作表，但 pandas 的 DataFrame 是独立存在的。

`Series`

Series 是代表 DataFrame 的一列的数据结构。与处理电子表格的列类似，处理 Series。

`Index`

每个 DataFrame 和 Series 都有一个 Index，这些是数据的行上的标签。在 pandas 中，如果没有指定索引，则默认使用 RangeIndex（第一行 = 0，第二行 = 1，依此类推），类似于电子表格中的行标题/行号。

在 pandas 中，索引可以设置为一个（或多个）唯一值，这类似于在工作表中使用作为行标识符的列。与大多数电子表格不同，这些Index值实际上可以用于引用行。（请注意，Excel 中可以使用结构化引用执行此操作。）例如，在电子表格中，您可以引用第一行为A1:Z1，而在 pandas 中，您可以使用populations.loc['Chicago']。

索引值也是持久的，因此如果重新排序DataFrame的行，则特定行的标签不会更改。

查看索引文档以获取更多关于如何有效使用Index的信息。

副本 vs. 原地操作

大多数 pandas 操作都返回Series/DataFrame的副本。要使更改“生效”，您需要将其分配给一个新变量：

sorted_df = df.sort_values("col1")

或覆盖原始的：

df = df.sort_values("col1")

注意

对于某些方法，您会看到一个可用的inplace=True或copy=False关键字参数：

df.replace(5, inplace=True)

关于大多数方法（例如dropna）的逐步弃用和移除inplace和copy存在活跃讨论，除了极少数方法（包括replace）。在写时复制的情况下，这两个关键字将不再需要。提案可以在这里找到。

一般术语翻译

pandas	Excel
DataFrame	工作表
Series	列
Index	行标题
行	行
NaN	空单元格

`DataFrame`

在 pandas 中，DataFrame 类似于 Excel 中的工作表。虽然 Excel 工作簿可以包含多个工作表，但 pandas 的DataFrame存在独立于此。

`Series`

Series 是表示DataFrame的一列的数据结构。与引用电子表格列类似，与Series一起工作。

`Index`

每个DataFrame和Series都有一个Index，这些是数据的行上的标签。在 pandas 中，如果未指定索引，则默认使用RangeIndex（第一行= 0，第二行= 1，依此类推），类似于电子表格中的行标题/数字。

索引值也是持久的，因此如果重新排列DataFrame中的行，则特定行的标签不会更改。

查看索引文档以了解如何有效地使用Index。

复制与原地操作

大多数 pandas 操作返回Series/DataFrame的副本。要使更改“生效”，您需要将其分配给一个新变量：

sorted_df = df.sort_values("col1")

或覆盖原始数据：

df = df.sort_values("col1")

注意

您将看到一些方法可用的inplace=True或copy=False关键字参数：

df.replace(5, inplace=True)

关于在大多数方法（例如dropna）中弃用和删除inplace和copy的讨论正在进行中，除了一小部分方法（包括replace）。在 Copy-on-Write 的上下文中，这两个关键字将不再是必需的。提案可以在这里找到。

数据输入/输出

从值构建 DataFrame

在电子表格中，可以直接在单元格中输入值。

pandas 的DataFrame可以以许多不同的方式构建，但对于少量值来说，通常将其指定为 Python 字典是方便的，其中键是列名，值是数据。

In [3]: df = pd.DataFrame({"x": [1, 3, 5], "y": [2, 4, 6]})

In [4]: df
Out[4]: 
 x  y
0  1  2
1  3  4
2  5  6

读取外部数据

Excel 和 pandas 都可以从各种来源以各种格式导入数据。

CSV

让我们加载并显示来自 pandas 测试的tips数据集，这是一个 CSV 文件。在 Excel 中，您将下载然后打开 CSV 文件。在 pandas 中，您将 URL 或 CSV 文件的本地路径传递给read_csv()：

In [5]: url = (
 ...:    "https://raw.githubusercontent.com/pandas-dev"
 ...:    "/pandas/main/pandas/tests/io/data/csv/tips.csv"
 ...: )
 ...: 

In [6]: tips = pd.read_csv(url)

In [7]: tips
Out[7]: 
 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
..          ...   ...     ...    ...   ...     ...   ...
239       29.03  5.92    Male     No   Sat  Dinner     3
240       27.18  2.00  Female    Yes   Sat  Dinner     2
241       22.67  2.00    Male    Yes   Sat  Dinner     2
242       17.82  1.75    Male     No   Sat  Dinner     2
243       18.78  3.00  Female     No  Thur  Dinner     2

[244 rows x 7 columns]

像Excel 的文本导入向导一样，read_csv可以接受多个参数来指定数据应该如何解析。例如，如果数据是制表符分隔的，并且没有列名，那么 pandas 命令将是：

tips = pd.read_csv("tips.csv", sep="\t", header=None)

# alternatively, read_table is an alias to read_csv with tab delimiter
tips = pd.read_table("tips.csv", header=None)

Excel 文件

Excel 通过双击或使用打开菜单打开各种 Excel 文件格式。在 pandas 中，您可以使用特殊方法来读取和写入 Excel 文件。

让我们首先根据上面示例中的tips数据框创建一个新的 Excel 文件：

tips.to_excel("./tips.xlsx")

如果您希望随后访问tips.xlsx文件中的数据，可以使用以下方式将其读入模块中

tips_df = pd.read_excel("./tips.xlsx", index_col=0)

您刚刚使用 pandas 读取了一个 Excel 文件！

限制输出

电子表格程序一次只会显示一个屏幕的数据，然后允许您滚动，因此实际上没有必要限制输出。在 pandas 中，您需要更多地考虑如何控制您的DataFrame的显示方式。

默认情况下，pandas 会截断大型DataFrame的输出以显示第一行和最后一行。这可以通过更改 pandas 选项，或使用DataFrame.head()或DataFrame.tail()来覆盖。

In [8]: tips.head(5)
Out[8]: 
 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

导出数据

默认情况下，桌面电子表格软件将保存为其相应的文件格式（.xlsx，.ods等）。但是，您可以保存为其他文件格式。

pandas 可以创建 Excel 文件，CSV，或者其他多种格式。

从值构建 DataFrame

在电子表格中，可以直接在单元格中输入值。

可以以许多不同的方式构建 pandas DataFrame，但对于少量值，通常将其指定为 Python 字典是方便的，其中键是列名，值是数据。

In [3]: df = pd.DataFrame({"x": [1, 3, 5], "y": [2, 4, 6]})

In [4]: df
Out[4]: 
 x  y
0  1  2
1  3  4
2  5  6

读取外部数据

Excel和 pandas 都可以从各种来源以各种格式导入数据。

CSV

让我们加载并显示来自 pandas 测试的tips数据集，这是一个 CSV 文件。在 Excel 中，您将下载然后打开 CSV 文件。在 pandas 中，您将 CSV 文件的 URL 或本地路径传递给read_csv()：

In [5]: url = (
 ...:    "https://raw.githubusercontent.com/pandas-dev"
 ...:    "/pandas/main/pandas/tests/io/data/csv/tips.csv"
 ...: )
 ...: 

In [6]: tips = pd.read_csv(url)

In [7]: tips
Out[7]: 
 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
..          ...   ...     ...    ...   ...     ...   ...
239       29.03  5.92    Male     No   Sat  Dinner     3
240       27.18  2.00  Female    Yes   Sat  Dinner     2
241       22.67  2.00    Male    Yes   Sat  Dinner     2
242       17.82  1.75    Male     No   Sat  Dinner     2
243       18.78  3.00  Female     No  Thur  Dinner     2

[244 rows x 7 columns]

像 Excel 的文本导入向导一样，read_csv 可以使用多个参数来指定数据应如何解析。例如，如果数据是以制表符分隔的，并且没有列名，那么 pandas 命令将是：

tips = pd.read_csv("tips.csv", sep="\t", header=None)

# alternatively, read_table is an alias to read_csv with tab delimiter
tips = pd.read_table("tips.csv", header=None)

Excel 文件

通过双击或使用打开菜单打开各种 Excel 文件格式。在 pandas 中，您使用特殊的方法来读取和写入 Excel 文件。

首先，基于上面示例中的 tips 数据框，让我们创建一个新的 Excel 文件：

tips.to_excel("./tips.xlsx")

如果您希望随后访问 tips.xlsx 文件中的数据，可以使用以下命令将其读入您的模块中：

tips_df = pd.read_excel("./tips.xlsx", index_col=0)

您刚刚使用 pandas 读取了一个 Excel 文件！

CSV

让我们加载并显示来自 pandas 测试的 tips 数据集，这是一个 CSV 文件。在 Excel 中，您将下载然后打开 CSV。在 pandas 中，您将 CSV 文件的 URL 或本地路径传递给 read_csv()：

In [5]: url = (
 ...:    "https://raw.githubusercontent.com/pandas-dev"
 ...:    "/pandas/main/pandas/tests/io/data/csv/tips.csv"
 ...: )
 ...: 

In [6]: tips = pd.read_csv(url)

In [7]: tips
Out[7]: 
 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
..          ...   ...     ...    ...   ...     ...   ...
239       29.03  5.92    Male     No   Sat  Dinner     3
240       27.18  2.00  Female    Yes   Sat  Dinner     2
241       22.67  2.00    Male    Yes   Sat  Dinner     2
242       17.82  1.75    Male     No   Sat  Dinner     2
243       18.78  3.00  Female     No  Thur  Dinner     2

[244 rows x 7 columns]

tips = pd.read_csv("tips.csv", sep="\t", header=None)

# alternatively, read_table is an alias to read_csv with tab delimiter
tips = pd.read_table("tips.csv", header=None)

Excel 文件

通过双击或使用打开菜单打开各种 Excel 文件格式。在 pandas 中，您使用特殊的方法来读取和写入 Excel 文件。

首先，基于上面示例中的 tips 数据框，让我们创建一个新的 Excel 文件：

tips.to_excel("./tips.xlsx")

如果您希望随后访问 tips.xlsx 文件中的数据，可以使用以下命令将其读入您的模块中：

tips_df = pd.read_excel("./tips.xlsx", index_col=0)

您刚刚使用 pandas 读取了一个 Excel 文件！

限制输出

电子表格程序一次只会显示一个屏幕的数据，然后允许您滚动，因此实际上不需要限制输出。在 pandas 中，您需要更多地思考如何控制您的 DataFrame 的显示。

默认情况下，pandas 会截断大型 DataFrame 的输出，以显示第一行和最后一行。可以通过更改 pandas 选项，或使用 DataFrame.head() 或 DataFrame.tail() 来覆盖此行为。

In [8]: tips.head(5)
Out[8]: 
 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

数据导出

默认情况下，桌面电子表格软件将保存为其相应的文件格式（.xlsx，.ods 等）。但是，您可以保存到其他文件格式。

pandas 可以创建 Excel 文件，CSV，或许多其他格式。

数据操作

列上的操作

在电子表格中，公式通常在单个单元格中创建，然后拖动到其他单元格以计算其他列的值。在 pandas 中，您可以直接对整个列进行操作。

通过在 DataFrame 中指定单独的 Series 来提供向量化操作。新列可以以相同的方式分配。DataFrame.drop() 方法从 DataFrame 中删除列。

In [9]: tips["total_bill"] = tips["total_bill"] - 2

In [10]: tips["new_bill"] = tips["total_bill"] / 2

In [11]: tips
Out[11]: 
 total_bill   tip     sex smoker   day    time  size  new_bill
0         14.99  1.01  Female     No   Sun  Dinner     2     7.495
1          8.34  1.66    Male     No   Sun  Dinner     3     4.170
2         19.01  3.50    Male     No   Sun  Dinner     3     9.505
3         21.68  3.31    Male     No   Sun  Dinner     2    10.840
4         22.59  3.61  Female     No   Sun  Dinner     4    11.295
..          ...   ...     ...    ...   ...     ...   ...       ...
239       27.03  5.92    Male     No   Sat  Dinner     3    13.515
240       25.18  2.00  Female    Yes   Sat  Dinner     2    12.590
241       20.67  2.00    Male    Yes   Sat  Dinner     2    10.335
242       15.82  1.75    Male     No   Sat  Dinner     2     7.910
243       16.78  3.00  Female     No  Thur  Dinner     2     8.390

[244 rows x 8 columns]

In [12]: tips = tips.drop("new_bill", axis=1)

请注意，我们不需要逐个单元格地告诉它执行减法 - pandas 为我们处理了这个过程。请参阅如何根据现有列创建新列。

过滤

在 Excel 中，过滤是通过一个图形菜单完成的。

DataFrame 可以以多种方式进行过滤；其中最直观的是使用布尔索引。

In [13]: tips[tips["total_bill"] > 10]
Out[13]: 
 total_bill   tip     sex smoker   day    time  size
0         14.99  1.01  Female     No   Sun  Dinner     2
2         19.01  3.50    Male     No   Sun  Dinner     3
3         21.68  3.31    Male     No   Sun  Dinner     2
4         22.59  3.61  Female     No   Sun  Dinner     4
5         23.29  4.71    Male     No   Sun  Dinner     4
..          ...   ...     ...    ...   ...     ...   ...
239       27.03  5.92    Male     No   Sat  Dinner     3
240       25.18  2.00  Female    Yes   Sat  Dinner     2
241       20.67  2.00    Male    Yes   Sat  Dinner     2
242       15.82  1.75    Male     No   Sat  Dinner     2
243       16.78  3.00  Female     No  Thur  Dinner     2

[204 rows x 7 columns]

上述语句只是将一系列 True/False 对象传递给 DataFrame，返回所有具有 True 的行。

In [14]: is_dinner = tips["time"] == "Dinner"

In [15]: is_dinner
Out[15]: 
0      True
1      True
2      True
3      True
4      True
 ... 
239    True
240    True
241    True
242    True
243    True
Name: time, Length: 244, dtype: bool

In [16]: is_dinner.value_counts()
Out[16]: 
time
True     176
False     68
Name: count, dtype: int64

In [17]: tips[is_dinner]
Out[17]: 
 total_bill   tip     sex smoker   day    time  size
0         14.99  1.01  Female     No   Sun  Dinner     2
1          8.34  1.66    Male     No   Sun  Dinner     3
2         19.01  3.50    Male     No   Sun  Dinner     3
3         21.68  3.31    Male     No   Sun  Dinner     2
4         22.59  3.61  Female     No   Sun  Dinner     4
..          ...   ...     ...    ...   ...     ...   ...
239       27.03  5.92    Male     No   Sat  Dinner     3
240       25.18  2.00  Female    Yes   Sat  Dinner     2
241       20.67  2.00    Male    Yes   Sat  Dinner     2
242       15.82  1.75    Male     No   Sat  Dinner     2
243       16.78  3.00  Female     No  Thur  Dinner     2

[176 rows x 7 columns]

If/then 逻辑

假设我们想要根据 total_bill 是小于还是大于 10 美元来创建一个 bucket 列，其值分别为 low 和 high。

在电子表格中，可以使用条件公式进行逻辑比较。我们将一个 =IF(A2 < 10, "low", "high") 的公式拖动到一个新的 bucket 列的所有单元格中。

在 pandas 中，可以使用numpy中的where方法来完成相同的操作。

In [18]: tips["bucket"] = np.where(tips["total_bill"] < 10, "low", "high")

In [19]: tips
Out[19]: 
 total_bill   tip     sex smoker   day    time  size bucket
0         14.99  1.01  Female     No   Sun  Dinner     2   high
1          8.34  1.66    Male     No   Sun  Dinner     3    low
2         19.01  3.50    Male     No   Sun  Dinner     3   high
3         21.68  3.31    Male     No   Sun  Dinner     2   high
4         22.59  3.61  Female     No   Sun  Dinner     4   high
..          ...   ...     ...    ...   ...     ...   ...    ...
239       27.03  5.92    Male     No   Sat  Dinner     3   high
240       25.18  2.00  Female    Yes   Sat  Dinner     2   high
241       20.67  2.00    Male    Yes   Sat  Dinner     2   high
242       15.82  1.75    Male     No   Sat  Dinner     2   high
243       16.78  3.00  Female     No  Thur  Dinner     2   high

[244 rows x 8 columns]

日期功能

本节将提到“日期”，但时间戳处理方式类似。

我们可以将日期功能分为两部分：解析和输出。在电子表格中，日期值通常会自动解析，尽管如果需要，可以使用DATEVALUE函数。在 pandas 中，您需要显式地将纯文本转换为 datetime 对象，可以在从 CSV 读取时或在 DataFrame 中进行转换。

解析后，电子表格以默认格式显示日期，尽管格式可以更改。在 pandas 中，您通常希望在进行计算时将日期保留为datetime对象。在电子表格中，通过日期函数和在 pandas 中通过 datetime 属性来输出日期的部分（如年份）。

在电子表格的列A和B中给定date1和date2，您可能会有以下公式：

列名	公式
date1_year	=YEAR(A2)
date2_month	=MONTH(B2)
date1_next	=DATE(YEAR(A2),MONTH(A2)+1,1)
months_between	=DATEDIF(A2,B2,"M")

下面显示了等效的 pandas 操作。

In [20]: tips["date1"] = pd.Timestamp("2013-01-15")

In [21]: tips["date2"] = pd.Timestamp("2015-02-15")

In [22]: tips["date1_year"] = tips["date1"].dt.year

In [23]: tips["date2_month"] = tips["date2"].dt.month

In [24]: tips["date1_next"] = tips["date1"] + pd.offsets.MonthBegin()

In [25]: tips["months_between"] = tips["date2"].dt.to_period("M") - tips[
 ....:    "date1"
 ....: ].dt.to_period("M")
 ....: 

In [26]: tips[
 ....:    ["date1", "date2", "date1_year", "date2_month", "date1_next", "months_between"]
 ....: ]
 ....: 
Out[26]: 
 date1      date2  date1_year  date2_month date1_next    months_between
0   2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
1   2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
2   2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
3   2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
4   2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
..         ...        ...         ...          ...        ...               ...
239 2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
240 2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
241 2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
242 2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
243 2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>

[244 rows x 6 columns]

更多详细信息，请参阅时间序列/日期功能。

选择列

在电子表格中，您可以通过以下方式选择所需的列：

隐藏列
删除列
从一个工作表引用到另一个工作表的范围

由于电子表格列通常是在标题行中命名的，重命名列只需简单地更改该第一个单元格中的文本。

下面展示了 pandas 中相同的操作。

保留特定列

In [27]: tips[["sex", "total_bill", "tip"]]
Out[27]: 
 sex  total_bill   tip
0    Female       14.99  1.01
1      Male        8.34  1.66
2      Male       19.01  3.50
3      Male       21.68  3.31
4    Female       22.59  3.61
..      ...         ...   ...
239    Male       27.03  5.92
240  Female       25.18  2.00
241    Male       20.67  2.00
242    Male       15.82  1.75
243  Female       16.78  3.00

[244 rows x 3 columns]

删除一列

In [28]: tips.drop("sex", axis=1)
Out[28]: 
 total_bill   tip smoker   day    time  size
0         14.99  1.01     No   Sun  Dinner     2
1          8.34  1.66     No   Sun  Dinner     3
2         19.01  3.50     No   Sun  Dinner     3
3         21.68  3.31     No   Sun  Dinner     2
4         22.59  3.61     No   Sun  Dinner     4
..          ...   ...    ...   ...     ...   ...
239       27.03  5.92     No   Sat  Dinner     3
240       25.18  2.00    Yes   Sat  Dinner     2
241       20.67  2.00    Yes   Sat  Dinner     2
242       15.82  1.75     No   Sat  Dinner     2
243       16.78  3.00     No  Thur  Dinner     2

[244 rows x 6 columns]

重命名列

In [29]: tips.rename(columns={"total_bill": "total_bill_2"})
Out[29]: 
 total_bill_2   tip     sex smoker   day    time  size
0           14.99  1.01  Female     No   Sun  Dinner     2
1            8.34  1.66    Male     No   Sun  Dinner     3
2           19.01  3.50    Male     No   Sun  Dinner     3
3           21.68  3.31    Male     No   Sun  Dinner     2
4           22.59  3.61  Female     No   Sun  Dinner     4
..            ...   ...     ...    ...   ...     ...   ...
239         27.03  5.92    Male     No   Sat  Dinner     3
240         25.18  2.00  Female    Yes   Sat  Dinner     2
241         20.67  2.00    Male    Yes   Sat  Dinner     2
242         15.82  1.75    Male     No   Sat  Dinner     2
243         16.78  3.00  Female     No  Thur  Dinner     2

[244 rows x 7 columns]

按值排序

电子表格中的排序通过排序对话框完成。

pandas 有一个DataFrame.sort_values()方法，接受一个要排序的列列表。

In [30]: tips = tips.sort_values(["sex", "total_bill"])

In [31]: tips
Out[31]: 
 total_bill    tip     sex smoker   day    time  size
67         1.07   1.00  Female    Yes   Sat  Dinner     1
92         3.75   1.00  Female    Yes   Fri  Dinner     2
111        5.25   1.00  Female     No   Sat  Dinner     1
145        6.35   1.50  Female     No  Thur   Lunch     2
135        6.51   1.25  Female     No  Thur   Lunch     2
..          ...    ...     ...    ...   ...     ...   ...
182       43.35   3.50    Male    Yes   Sun  Dinner     3
156       46.17   5.00    Male     No   Sun  Dinner     6
59        46.27   6.73    Male     No   Sat  Dinner     4
212       46.33   9.00    Male     No   Sat  Dinner     4
170       48.81  10.00    Male    Yes   Sat  Dinner     3

[244 rows x 7 columns]

列操作

在电子表格中，公式通常在单独的单元格中创建，然后拖动到其他单元格中以计算其他列的值。在 pandas 中，您可以直接对整列进行操作。

pandas 通过在DataFrame中指定单独的Series提供矢量化操作。新列可以以相同的方式分配。DataFrame.drop()方法从DataFrame中删除列。

In [9]: tips["total_bill"] = tips["total_bill"] - 2

In [10]: tips["new_bill"] = tips["total_bill"] / 2

In [11]: tips
Out[11]: 
 total_bill   tip     sex smoker   day    time  size  new_bill
0         14.99  1.01  Female     No   Sun  Dinner     2     7.495
1          8.34  1.66    Male     No   Sun  Dinner     3     4.170
2         19.01  3.50    Male     No   Sun  Dinner     3     9.505
3         21.68  3.31    Male     No   Sun  Dinner     2    10.840
4         22.59  3.61  Female     No   Sun  Dinner     4    11.295
..          ...   ...     ...    ...   ...     ...   ...       ...
239       27.03  5.92    Male     No   Sat  Dinner     3    13.515
240       25.18  2.00  Female    Yes   Sat  Dinner     2    12.590
241       20.67  2.00    Male    Yes   Sat  Dinner     2    10.335
242       15.82  1.75    Male     No   Sat  Dinner     2     7.910
243       16.78  3.00  Female     No  Thur  Dinner     2     8.390

[244 rows x 8 columns]

In [12]: tips = tips.drop("new_bill", axis=1)

请注意，我们不需要逐个单元格地告诉它执行减法 - pandas 会为我们处理。参见如何从现有列派生新列。

过滤

在 Excel 中，过滤是通过图形菜单完成的。

DataFrames 可以以多种方式进行过滤；其中最直观的是使用布尔索引。

In [13]: tips[tips["total_bill"] > 10]
Out[13]: 
 total_bill   tip     sex smoker   day    time  size
0         14.99  1.01  Female     No   Sun  Dinner     2
2         19.01  3.50    Male     No   Sun  Dinner     3
3         21.68  3.31    Male     No   Sun  Dinner     2
4         22.59  3.61  Female     No   Sun  Dinner     4
5         23.29  4.71    Male     No   Sun  Dinner     4
..          ...   ...     ...    ...   ...     ...   ...
239       27.03  5.92    Male     No   Sat  Dinner     3
240       25.18  2.00  Female    Yes   Sat  Dinner     2
241       20.67  2.00    Male    Yes   Sat  Dinner     2
242       15.82  1.75    Male     No   Sat  Dinner     2
243       16.78  3.00  Female     No  Thur  Dinner     2

[204 rows x 7 columns]

上述语句只是简单地将True/False对象的Series传递给 DataFrame，返回所有具有True的行。

In [14]: is_dinner = tips["time"] == "Dinner"

In [15]: is_dinner
Out[15]: 
0      True
1      True
2      True
3      True
4      True
 ... 
239    True
240    True
241    True
242    True
243    True
Name: time, Length: 244, dtype: bool

In [16]: is_dinner.value_counts()
Out[16]: 
time
True     176
False     68
Name: count, dtype: int64

In [17]: tips[is_dinner]
Out[17]: 
 total_bill   tip     sex smoker   day    time  size
0         14.99  1.01  Female     No   Sun  Dinner     2
1          8.34  1.66    Male     No   Sun  Dinner     3
2         19.01  3.50    Male     No   Sun  Dinner     3
3         21.68  3.31    Male     No   Sun  Dinner     2
4         22.59  3.61  Female     No   Sun  Dinner     4
..          ...   ...     ...    ...   ...     ...   ...
239       27.03  5.92    Male     No   Sat  Dinner     3
240       25.18  2.00  Female    Yes   Sat  Dinner     2
241       20.67  2.00    Male    Yes   Sat  Dinner     2
242       15.82  1.75    Male     No   Sat  Dinner     2
243       16.78  3.00  Female     No  Thur  Dinner     2

[176 rows x 7 columns]

If/then 逻辑

假设我们想要根据total_bill是低于还是高于$10 来创建一个bucket列，值为low和high。

在电子表格中，可以使用条件公式进行逻辑比较。我们会使用一个公式=IF(A2 < 10, "low", "high")，拖动到新的bucket列中的所有单元格。

在 pandas 中，可以使用numpy的where方法来完成相同的操作。

In [18]: tips["bucket"] = np.where(tips["total_bill"] < 10, "low", "high")

In [19]: tips
Out[19]: 
 total_bill   tip     sex smoker   day    time  size bucket
0         14.99  1.01  Female     No   Sun  Dinner     2   high
1          8.34  1.66    Male     No   Sun  Dinner     3    low
2         19.01  3.50    Male     No   Sun  Dinner     3   high
3         21.68  3.31    Male     No   Sun  Dinner     2   high
4         22.59  3.61  Female     No   Sun  Dinner     4   high
..          ...   ...     ...    ...   ...     ...   ...    ...
239       27.03  5.92    Male     No   Sat  Dinner     3   high
240       25.18  2.00  Female    Yes   Sat  Dinner     2   high
241       20.67  2.00    Male    Yes   Sat  Dinner     2   high
242       15.82  1.75    Male     No   Sat  Dinner     2   high
243       16.78  3.00  Female     No  Thur  Dinner     2   high

[244 rows x 8 columns]

日期功能

本节将涉及“日期”，但时间戳处理方式类似。

我们可以将日期功能分为两部分：解析和输出。在电子表格中，日期值通常会自动解析，尽管如果需要的话可以使用 DATEVALUE 函数。在 pandas 中，您需要显式地将纯文本转换为日期时间对象，可以在读取 CSV 时或者在 DataFrame 中进行转换。

一旦解析，电子表格会以默认格式显示日期，尽管格式可以更改。在 pandas 中，通常在进行计算时希望将日期保留为 datetime 对象。在电子表格中，输出日期的部分（如年份）是通过日期函数实现的，在 pandas 中则通过 datetime 属性实现。

在电子表格的列 A 和 B 中给定 date1 和 date2，您可能会有以下公式：

列名	公式
date1_year	=YEAR(A2)
date2_month	=MONTH(B2)
date1_next	=DATE(YEAR(A2),MONTH(A2)+1,1)
months_between	=DATEDIF(A2,B2,"M")

等效的 pandas 操作如下所示。

In [20]: tips["date1"] = pd.Timestamp("2013-01-15")

In [21]: tips["date2"] = pd.Timestamp("2015-02-15")

In [22]: tips["date1_year"] = tips["date1"].dt.year

In [23]: tips["date2_month"] = tips["date2"].dt.month

In [24]: tips["date1_next"] = tips["date1"] + pd.offsets.MonthBegin()

In [25]: tips["months_between"] = tips["date2"].dt.to_period("M") - tips[
 ....:    "date1"
 ....: ].dt.to_period("M")
 ....: 

In [26]: tips[
 ....:    ["date1", "date2", "date1_year", "date2_month", "date1_next", "months_between"]
 ....: ]
 ....: 
Out[26]: 
 date1      date2  date1_year  date2_month date1_next    months_between
0   2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
1   2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
2   2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
3   2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
4   2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
..         ...        ...         ...          ...        ...               ...
239 2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
240 2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
241 2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
242 2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>
243 2013-01-15 2015-02-15        2013            2 2013-02-01  <25 * MonthEnds>

[244 rows x 6 columns]

更多详细信息，请��阅时间序列/日期功能。

选择列

在电子表格中，您可以通过以下方式选择所需的列：

由于电子表格列通常是在标题行中命名的，重命名列只需更改该首单元格中的文本。

pandas 中的相同操作如下所示。

保留特定列

In [27]: tips[["sex", "total_bill", "tip"]]
Out[27]: 
 sex  total_bill   tip
0    Female       14.99  1.01
1      Male        8.34  1.66
2      Male       19.01  3.50
3      Male       21.68  3.31
4    Female       22.59  3.61
..      ...         ...   ...
239    Male       27.03  5.92
240  Female       25.18  2.00
241    Male       20.67  2.00
242    Male       15.82  1.75
243  Female       16.78  3.00

[244 rows x 3 columns]

删除一列

In [28]: tips.drop("sex", axis=1)
Out[28]: 
 total_bill   tip smoker   day    time  size
0         14.99  1.01     No   Sun  Dinner     2
1          8.34  1.66     No   Sun  Dinner     3
2         19.01  3.50     No   Sun  Dinner     3
3         21.68  3.31     No   Sun  Dinner     2
4         22.59  3.61     No   Sun  Dinner     4
..          ...   ...    ...   ...     ...   ...
239       27.03  5.92     No   Sat  Dinner     3
240       25.18  2.00    Yes   Sat  Dinner     2
241       20.67  2.00    Yes   Sat  Dinner     2
242       15.82  1.75     No   Sat  Dinner     2
243       16.78  3.00     No  Thur  Dinner     2

[244 rows x 6 columns]

重命名列

In [29]: tips.rename(columns={"total_bill": "total_bill_2"})
Out[29]: 
 total_bill_2   tip     sex smoker   day    time  size
0           14.99  1.01  Female     No   Sun  Dinner     2
1            8.34  1.66    Male     No   Sun  Dinner     3
2           19.01  3.50    Male     No   Sun  Dinner     3
3           21.68  3.31    Male     No   Sun  Dinner     2
4           22.59  3.61  Female     No   Sun  Dinner     4
..            ...   ...     ...    ...   ...     ...   ...
239         27.03  5.92    Male     No   Sat  Dinner     3
240         25.18  2.00  Female    Yes   Sat  Dinner     2
241         20.67  2.00    Male    Yes   Sat  Dinner     2
242         15.82  1.75    Male     No   Sat  Dinner     2
243         16.78  3.00  Female     No  Thur  Dinner     2

[244 rows x 7 columns]

保留特定列

In [27]: tips[["sex", "total_bill", "tip"]]
Out[27]: 
 sex  total_bill   tip
0    Female       14.99  1.01
1      Male        8.34  1.66
2      Male       19.01  3.50
3      Male       21.68  3.31
4    Female       22.59  3.61
..      ...         ...   ...
239    Male       27.03  5.92
240  Female       25.18  2.00
241    Male       20.67  2.00
242    Male       15.82  1.75
243  Female       16.78  3.00

[244 rows x 3 columns]

删除一列

In [28]: tips.drop("sex", axis=1)
Out[28]: 
 total_bill   tip smoker   day    time  size
0         14.99  1.01     No   Sun  Dinner     2
1          8.34  1.66     No   Sun  Dinner     3
2         19.01  3.50     No   Sun  Dinner     3
3         21.68  3.31     No   Sun  Dinner     2
4         22.59  3.61     No   Sun  Dinner     4
..          ...   ...    ...   ...     ...   ...
239       27.03  5.92     No   Sat  Dinner     3
240       25.18  2.00    Yes   Sat  Dinner     2
241       20.67  2.00    Yes   Sat  Dinner     2
242       15.82  1.75     No   Sat  Dinner     2
243       16.78  3.00     No  Thur  Dinner     2

[244 rows x 6 columns]

重命名列

In [29]: tips.rename(columns={"total_bill": "total_bill_2"})
Out[29]: 
 total_bill_2   tip     sex smoker   day    time  size
0           14.99  1.01  Female     No   Sun  Dinner     2
1            8.34  1.66    Male     No   Sun  Dinner     3
2           19.01  3.50    Male     No   Sun  Dinner     3
3           21.68  3.31    Male     No   Sun  Dinner     2
4           22.59  3.61  Female     No   Sun  Dinner     4
..            ...   ...     ...    ...   ...     ...   ...
239         27.03  5.92    Male     No   Sat  Dinner     3
240         25.18  2.00  Female    Yes   Sat  Dinner     2
241         20.67  2.00    Male    Yes   Sat  Dinner     2
242         15.82  1.75    Male     No   Sat  Dinner     2
243         16.78  3.00  Female     No  Thur  Dinner     2

[244 rows x 7 columns]

按数值排序

在电子表格中，通过排序对话框实现排序。

pandas 有一个DataFrame.sort_values()方法，它接受要排序的列的列表。

In [30]: tips = tips.sort_values(["sex", "total_bill"])

In [31]: tips
Out[31]: 
 total_bill    tip     sex smoker   day    time  size
67         1.07   1.00  Female    Yes   Sat  Dinner     1
92         3.75   1.00  Female    Yes   Fri  Dinner     2
111        5.25   1.00  Female     No   Sat  Dinner     1
145        6.35   1.50  Female     No  Thur   Lunch     2
135        6.51   1.25  Female     No  Thur   Lunch     2
..          ...    ...     ...    ...   ...     ...   ...
182       43.35   3.50    Male    Yes   Sun  Dinner     3
156       46.17   5.00    Male     No   Sun  Dinner     6
59        46.27   6.73    Male     No   Sat  Dinner     4
212       46.33   9.00    Male     No   Sat  Dinner     4
170       48.81  10.00    Male    Yes   Sat  Dinner     3

[244 rows x 7 columns]

字符串处理

查找字符串的长度

在电子表格中，可以使用LEN函数找到文本中的字符数。这可以与TRIM函数一起使用，以去除额外的空格。

=LEN(TRIM(A2))

您可以使用Series.str.len()来查找字符字符串的长度。在 Python 3 中，所有字符串都是 Unicode 字符串。len包括尾随空格。使用len和rstrip来排除尾随空格。

In [32]: tips["time"].str.len()
Out[32]: 
67     6
92     6
111    6
145    5
135    5
 ..
182    6
156    6
59     6
212    6
170    6
Name: time, Length: 244, dtype: int64

In [33]: tips["time"].str.rstrip().str.len()
Out[33]: 
67     6
92     6
111    6
145    5
135    5
 ..
182    6
156    6
59     6
212    6
170    6
Name: time, Length: 244, dtype: int64

请注意，这仍然会包括字符串中的多个空格，因此并非完全等效。

查找子字符串的位置

FIND电子表格函数返回子字符串的位置，第一个字符为1。

In [34]: tips["sex"].str.find("ale")
Out[34]: 
67     3
92     3
111    3
145    3
135    3
 ..
182    1
156    1
59     1
212    1
170    1
Name: sex, Length: 244, dtype: int64

按位置提取子字符串

电子表格有一个MID公式，用于从给定位置提取子字符串。要获取第一个字符：

=MID(A2,1,1)

使用 pandas，您可以使用[]符号从字符串中提取位置位置的子字符串。请记住，Python 索引是从零开始的。

In [35]: tips["sex"].str[0:1]
Out[35]: 
67     F
92     F
111    F
145    F
135    F
 ..
182    M
156    M
59     M
212    M
170    M
Name: sex, Length: 244, dtype: object

提取第 n 个单词

在 Excel 中，您可以使用文本分列向导来拆分文本并检索特定列。（注意，也可以通过公式进行操作。）

在 pandas 中提取单词的最简单方法是通过空格拆分字符串，然后按索引引用单词。请注意，如果需要，还有更强大的方法。

In [36]: firstlast = pd.DataFrame({"String": ["John Smith", "Jane Cook"]})

In [37]: firstlast["First_Name"] = firstlast["String"].str.split(" ", expand=True)[0]

In [38]: firstlast["Last_Name"] = firstlast["String"].str.rsplit(" ", expand=True)[1]

In [39]: firstlast
Out[39]: 
 String First_Name Last_Name
0  John Smith       John     Smith
1   Jane Cook       Jane      Cook

更改大小写

电子表格提供了将文本转换为大写、小写和标题大小写的UPPER、LOWER 和 PROPER 函数。

等效的 pandas 方法是Series.str.upper()，Series.str.lower()和Series.str.title()。

In [40]: firstlast = pd.DataFrame({"string": ["John Smith", "Jane Cook"]})

In [41]: firstlast["upper"] = firstlast["string"].str.upper()

In [42]: firstlast["lower"] = firstlast["string"].str.lower()

In [43]: firstlast["title"] = firstlast["string"].str.title()

In [44]: firstlast
Out[44]: 
 string       upper       lower       title
0  John Smith  JOHN SMITH  john smith  John Smith
1   Jane Cook   JANE COOK   jane cook   Jane Cook

查找字符串长度

在电子表格中，可以使用LEN函数找到文本中的字符数。这可以与TRIM函数一起使用，以去除额外的空格。

=LEN(TRIM(A2))

您可以使用Series.str.len()找到字符串的长度。在 Python 3 中，所有字符串都是 Unicode 字符串。len包括尾随空格。使用len和rstrip来排除尾随空格。

In [32]: tips["time"].str.len()
Out[32]: 
67     6
92     6
111    6
145    5
135    5
 ..
182    6
156    6
59     6
212    6
170    6
Name: time, Length: 244, dtype: int64

In [33]: tips["time"].str.rstrip().str.len()
Out[33]: 
67     6
92     6
111    6
145    5
135    5
 ..
182    6
156    6
59     6
212    6
170    6
Name: time, Length: 244, dtype: int64

请注意，这仍然会包括字符串中的多个空格，因此不是 100%等效。

查找子字符串的位置

电子表格函数FIND返回子字符串的位置，第一个字符为1。

您可以使用Series.str.find()方法找到字符串列中字符的位置。find搜索子字符串的第一个位置。如果找到子字符串，则该方法返回其位置。如果未找到，则返回-1。请记住，Python 索引是从零开始的。

In [34]: tips["sex"].str.find("ale")
Out[34]: 
67     3
92     3
111    3
145    3
135    3
 ..
182    1
156    1
59     1
212    1
170    1
Name: sex, Length: 244, dtype: int64

按位置提取子字符串

电子表格有一个MID公式用于从给定位置提取子字符串。要获取第一个字符：

=MID(A2,1,1)

使用 pandas，您可以使用[]符号按位置位置提取字符串的子字符串。请记住，Python 索引是从零开始的。

In [35]: tips["sex"].str[0:1]
Out[35]: 
67     F
92     F
111    F
145    F
135    F
 ..
182    M
156    M
59     M
212    M
170    M
Name: sex, Length: 244, dtype: object

提取第`n`个单词

在 Excel 中，您可以使用文本分列向导来拆分文本并检索特定列。（注意，也可以通过公式实现。）

在 pandas 中提取单词的最简单方法是通过空格拆分字符串，然后按索引引用单词。请注意，如果需要，还有更强大的方法。

In [36]: firstlast = pd.DataFrame({"String": ["John Smith", "Jane Cook"]})

In [37]: firstlast["First_Name"] = firstlast["String"].str.split(" ", expand=True)[0]

In [38]: firstlast["Last_Name"] = firstlast["String"].str.rsplit(" ", expand=True)[1]

In [39]: firstlast
Out[39]: 
 String First_Name Last_Name
0  John Smith       John     Smith
1   Jane Cook       Jane      Cook

更改大小写

电子表格提供了将文本转换为大写、小写和标题大小写的UPPER, LOWER 和 PROPER 函数。

等效的 pandas 方法是 Series.str.upper()、Series.str.lower() 和 Series.str.title()。

In [40]: firstlast = pd.DataFrame({"string": ["John Smith", "Jane Cook"]})

In [41]: firstlast["upper"] = firstlast["string"].str.upper()

In [42]: firstlast["lower"] = firstlast["string"].str.lower()

In [43]: firstlast["title"] = firstlast["string"].str.title()

In [44]: firstlast
Out[44]: 
 string       upper       lower       title
0  John Smith  JOHN SMITH  john smith  John Smith
1   Jane Cook   JANE COOK   jane cook   Jane Cook

合并

下面的表将用于合并示例：

In [45]: df1 = pd.DataFrame({"key": ["A", "B", "C", "D"], "value": np.random.randn(4)})

In [46]: df1
Out[46]: 
 key     value
0   A  0.469112
1   B -0.282863
2   C -1.509059
3   D -1.135632

In [47]: df2 = pd.DataFrame({"key": ["B", "D", "D", "E"], "value": np.random.randn(4)})

In [48]: df2
Out[48]: 
 key     value
0   B  1.212112
1   D -0.173215
2   D  0.119209
3   E -1.044236

在 Excel 中，可以通过VLOOKUP 进行表格合并。

Excel 中两个表格之间的 VLOOKUP 公式的屏幕截图，一些值已填充，另一些显示为“#N/A”

pandas 的 DataFrame 具有 merge() 方法，提供类似的功能。数据不需要提前排序，不同的连接类型通过 how 关键字实现。

In [49]: inner_join = df1.merge(df2, on=["key"], how="inner")

In [50]: inner_join
Out[50]: 
 key   value_x   value_y
0   B -0.282863  1.212112
1   D -1.135632 -0.173215
2   D -1.135632  0.119209

In [51]: left_join = df1.merge(df2, on=["key"], how="left")

In [52]: left_join
Out[52]: 
 key   value_x   value_y
0   A  0.469112       NaN
1   B -0.282863  1.212112
2   C -1.509059       NaN
3   D -1.135632 -0.173215
4   D -1.135632  0.119209

In [53]: right_join = df1.merge(df2, on=["key"], how="right")

In [54]: right_join
Out[54]: 
 key   value_x   value_y
0   B -0.282863  1.212112
1   D -1.135632 -0.173215
2   D -1.135632  0.119209
3   E       NaN -1.044236

In [55]: outer_join = df1.merge(df2, on=["key"], how="outer")

In [56]: outer_join
Out[56]: 
 key   value_x   value_y
0   A  0.469112       NaN
1   B -0.282863  1.212112
2   C -1.509059       NaN
3   D -1.135632 -0.173215
4   D -1.135632  0.119209
5   E       NaN -1.044236

merge 相对于 VLOOKUP 有许多优势：

查找值不需要是查找表的第一列
如果匹配多行，则每个匹配将有一行，而不仅仅是第一个匹配
它将包括查找表中的所有列，而不仅仅是单个指定的列
它支持更复杂的连接操作

其他考虑事项

填充手柄

在一组特定的单元格中按照一定模式创建一系列数字。在电子表格中，这可以通过输入第一个数字后按住 Shift+拖动或输入前两个或三个值然后拖动来完成。

这可以通过创建一个系列并将其分配给所需的单元格来实现。

In [57]: df = pd.DataFrame({"AAA": [1] * 8, "BBB": list(range(0, 8))})

In [58]: df
Out[58]: 
 AAA  BBB
0    1    0
1    1    1
2    1    2
3    1    3
4    1    4
5    1    5
6    1    6
7    1    7

In [59]: series = list(range(1, 5))

In [60]: series
Out[60]: [1, 2, 3, 4]

In [61]: df.loc[2:5, "AAA"] = series

In [62]: df
Out[62]: 
 AAA  BBB
0    1    0
1    1    1
2    1    2
3    2    3
4    3    4
5    4    5
6    1    6
7    1    7

删除重复项

Excel 具有用于删除重复值的内置功能。在 pandas 中通过 drop_duplicates() 支持此功能。

In [63]: df = pd.DataFrame(
 ....:    {
 ....:        "class": ["A", "A", "A", "B", "C", "D"],
 ....:        "student_count": [42, 35, 42, 50, 47, 45],
 ....:        "all_pass": ["Yes", "Yes", "Yes", "No", "No", "Yes"],
 ....:    }
 ....: )
 ....: 

In [64]: df.drop_duplicates()
Out[64]: 
 class  student_count all_pass
0     A             42      Yes
1     A             35      Yes
3     B             50       No
4     C             47       No
5     D             45      Yes

In [65]: df.drop_duplicates(["class", "student_count"])
Out[65]: 
 class  student_count all_pass
0     A             42      Yes
1     A             35      Yes
3     B             50       No
4     C             47       No
5     D             45      Yes

透视表

通过重塑和透视表，可以在 pandas 中复制电子表格中的数据透视表。再次使用 tips 数据集，让我们按照聚会规模和服务员性别找到小费的平均值。

在 Excel 中，我们使用以下配置进行数据透视表：

在 pandas 中的等效操作：

In [66]: pd.pivot_table(
 ....:    tips, values="tip", index=["size"], columns=["sex"], aggfunc=np.average
 ....: )
 ....: 
Out[66]: 
sex     Female      Male
size 
1     1.276667  1.920000
2     2.528448  2.614184
3     3.250000  3.476667
4     4.021111  4.172143
5     5.140000  3.750000
6     4.600000  5.850000

添加一行

假设我们使用RangeIndex（编号为0，1等），我们可以使用concat()将一行添加到DataFrame的底部。

In [67]: df
Out[67]: 
 class  student_count all_pass
0     A             42      Yes
1     A             35      Yes
2     A             42      Yes
3     B             50       No
4     C             47       No
5     D             45      Yes

In [68]: new_row = pd.DataFrame([["E", 51, True]],
 ....:                       columns=["class", "student_count", "all_pass"])
 ....: 

In [69]: pd.concat([df, new_row])
Out[69]: 
 class  student_count all_pass
0     A             42      Yes
1     A             35      Yes
2     A             42      Yes
3     B             50       No
4     C             47       No
5     D             45      Yes
0     E             51     True

查找和替换

Excel 的查找对话框会逐个显示匹配的单元格。在 pandas 中，这个操作通常是针对整列或整个DataFrame通过条件表达式一次完成的。

In [70]: tips
Out[70]: 
 total_bill    tip     sex smoker   day    time  size
67         1.07   1.00  Female    Yes   Sat  Dinner     1
92         3.75   1.00  Female    Yes   Fri  Dinner     2
111        5.25   1.00  Female     No   Sat  Dinner     1
145        6.35   1.50  Female     No  Thur   Lunch     2
135        6.51   1.25  Female     No  Thur   Lunch     2
..          ...    ...     ...    ...   ...     ...   ...
182       43.35   3.50    Male    Yes   Sun  Dinner     3
156       46.17   5.00    Male     No   Sun  Dinner     6
59        46.27   6.73    Male     No   Sat  Dinner     4
212       46.33   9.00    Male     No   Sat  Dinner     4
170       48.81  10.00    Male    Yes   Sat  Dinner     3

[244 rows x 7 columns]

In [71]: tips == "Sun"
Out[71]: 
 total_bill    tip    sex  smoker    day   time   size
67        False  False  False   False  False  False  False
92        False  False  False   False  False  False  False
111       False  False  False   False  False  False  False
145       False  False  False   False  False  False  False
135       False  False  False   False  False  False  False
..          ...    ...    ...     ...    ...    ...    ...
182       False  False  False   False   True  False  False
156       False  False  False   False   True  False  False
59        False  False  False   False  False  False  False
212       False  False  False   False  False  False  False
170       False  False  False   False  False  False  False

[244 rows x 7 columns]

In [72]: tips["day"].str.contains("S")
Out[72]: 
67      True
92     False
111     True
145    False
135    False
 ... 
182     True
156     True
59      True
212     True
170     True
Name: day, Length: 244, dtype: bool

pandas 的replace()与 Excel 的Replace All类似。

In [73]: tips.replace("Thu", "Thursday")
Out[73]: 
 total_bill    tip     sex smoker   day    time  size
67         1.07   1.00  Female    Yes   Sat  Dinner     1
92         3.75   1.00  Female    Yes   Fri  Dinner     2
111        5.25   1.00  Female     No   Sat  Dinner     1
145        6.35   1.50  Female     No  Thur   Lunch     2
135        6.51   1.25  Female     No  Thur   Lunch     2
..          ...    ...     ...    ...   ...     ...   ...
182       43.35   3.50    Male    Yes   Sun  Dinner     3
156       46.17   5.00    Male     No   Sun  Dinner     6
59        46.27   6.73    Male     No   Sat  Dinner     4
212       46.33   9.00    Male     No   Sat  Dinner     4
170       48.81  10.00    Male    Yes   Sat  Dinner     3

[244 rows x 7 columns]

填充手柄

在一组特定的单元格中按照一定模式创建一系列数字。在电子表格中，可以在输入第一个数字后按住 Shift 并拖动，或者输入前两个或三个值然后拖动来完成。

这可以通过创建一个系列并将其分配给所需的单元格来实现。

In [57]: df = pd.DataFrame({"AAA": [1] * 8, "BBB": list(range(0, 8))})

In [58]: df
Out[58]: 
 AAA  BBB
0    1    0
1    1    1
2    1    2
3    1    3
4    1    4
5    1    5
6    1    6
7    1    7

In [59]: series = list(range(1, 5))

In [60]: series
Out[60]: [1, 2, 3, 4]

In [61]: df.loc[2:5, "AAA"] = series

In [62]: df
Out[62]: 
 AAA  BBB
0    1    0
1    1    1
2    1    2
3    2    3
4    3    4
5    4    5
6    1    6
7    1    7

删除重复项

Excel 具有内置功能，可用于删除重复值。在 pandas 中，通过drop_duplicates()来实现。

In [63]: df = pd.DataFrame(
 ....:    {
 ....:        "class": ["A", "A", "A", "B", "C", "D"],
 ....:        "student_count": [42, 35, 42, 50, 47, 45],
 ....:        "all_pass": ["Yes", "Yes", "Yes", "No", "No", "Yes"],
 ....:    }
 ....: )
 ....: 

In [64]: df.drop_duplicates()
Out[64]: 
 class  student_count all_pass
0     A             42      Yes
1     A             35      Yes
3     B             50       No
4     C             47       No
5     D             45      Yes

In [65]: df.drop_duplicates(["class", "student_count"])
Out[65]: 
 class  student_count all_pass
0     A             42      Yes
1     A             35      Yes
3     B             50       No
4     C             47       No
5     D             45      Yes

数据透视表

电子表格中的数据透视表可以通过 pandas 中的数据重塑和数据透视表来复制。再次使用tips数据集，让我们按照就餐人数和服务员性别找到小费的平均值。

在 Excel 中，我们使用以下配置来创建数据透视表：

在 pandas 中的等效操作：

In [66]: pd.pivot_table(
 ....:    tips, values="tip", index=["size"], columns=["sex"], aggfunc=np.average
 ....: )
 ....: 
Out[66]: 
sex     Female      Male
size 
1     1.276667  1.920000
2     2.528448  2.614184
3     3.250000  3.476667
4     4.021111  4.172143
5     5.140000  3.750000
6     4.600000  5.850000

添加一行

假设我们使用RangeIndex（编号为0，1等），我们可以使用concat()将一行添加到DataFrame的底部。

In [67]: df
Out[67]: 
 class  student_count all_pass
0     A             42      Yes
1     A             35      Yes
2     A             42      Yes
3     B             50       No
4     C             47       No
5     D             45      Yes

In [68]: new_row = pd.DataFrame([["E", 51, True]],
 ....:                       columns=["class", "student_count", "all_pass"])
 ....: 

In [69]: pd.concat([df, new_row])
Out[69]: 
 class  student_count all_pass
0     A             42      Yes
1     A             35      Yes
2     A             42      Yes
3     B             50       No
4     C             47       No
5     D             45      Yes
0     E             51     True

查找和替换

Excel 的查找对话框会逐个显示匹配的单元格。在 pandas 中，这个操作通常是针对整列或DataFrame一次性通过条件表达式完成的。

In [70]: tips
Out[70]: 
 total_bill    tip     sex smoker   day    time  size
67         1.07   1.00  Female    Yes   Sat  Dinner     1
92         3.75   1.00  Female    Yes   Fri  Dinner     2
111        5.25   1.00  Female     No   Sat  Dinner     1
145        6.35   1.50  Female     No  Thur   Lunch     2
135        6.51   1.25  Female     No  Thur   Lunch     2
..          ...    ...     ...    ...   ...     ...   ...
182       43.35   3.50    Male    Yes   Sun  Dinner     3
156       46.17   5.00    Male     No   Sun  Dinner     6
59        46.27   6.73    Male     No   Sat  Dinner     4
212       46.33   9.00    Male     No   Sat  Dinner     4
170       48.81  10.00    Male    Yes   Sat  Dinner     3

[244 rows x 7 columns]

In [71]: tips == "Sun"
Out[71]: 
 total_bill    tip    sex  smoker    day   time   size
67        False  False  False   False  False  False  False
92        False  False  False   False  False  False  False
111       False  False  False   False  False  False  False
145       False  False  False   False  False  False  False
135       False  False  False   False  False  False  False
..          ...    ...    ...     ...    ...    ...    ...
182       False  False  False   False   True  False  False
156       False  False  False   False   True  False  False
59        False  False  False   False  False  False  False
212       False  False  False   False  False  False  False
170       False  False  False   False  False  False  False

[244 rows x 7 columns]

In [72]: tips["day"].str.contains("S")
Out[72]: 
67      True
92     False
111     True
145    False
135    False
 ... 
182     True
156     True
59      True
212     True
170     True
Name: day, Length: 244, dtype: bool

pandas 的replace()与 Excel 的Replace All相当。

In [73]: tips.replace("Thu", "Thursday")
Out[73]: 
 total_bill    tip     sex smoker   day    time  size
67         1.07   1.00  Female    Yes   Sat  Dinner     1
92         3.75   1.00  Female    Yes   Fri  Dinner     2
111        5.25   1.00  Female     No   Sat  Dinner     1
145        6.35   1.50  Female     No  Thur   Lunch     2
135        6.51   1.25  Female     No  Thur   Lunch     2
..          ...    ...     ...    ...   ...     ...   ...
182       43.35   3.50    Male    Yes   Sun  Dinner     3
156       46.17   5.00    Male     No   Sun  Dinner     6
59        46.27   6.73    Male     No   Sat  Dinner     4
212       46.33   9.00    Male     No   Sat  Dinner     4
170       48.81  10.00    Male    Yes   Sat  Dinner     3

[244 rows x 7 columns]

本文参与腾讯云自媒体分享计划，分享自作者个人站点/博客。

原始发表：2024-04-25，如有侵权请联系 cloudcommunity@tencent.com 删除

教程