Pandas-2-2-中文文档-二-
Pandas 2.2 中文文档（二）
与 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;
让我们找到每个性别组中 (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
更新
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 会为我们处理。查看如何从现有列创建新列。
过滤
数据框可以通过多种方式进行过滤；其中最直观的是使用布尔索引。
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 合并表格。
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 中，我们使用以下配置进行数据透视表：
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，依此类推），类似于电子表格中的行标题/数字。
在 pandas 中，索引可以设置为一个（或多个）唯一值，这类似于在工作表中使用作为行标识符的列。与大多数电子表格不同，这些Index值实际上可以用于引用行。 （请注意，Excel 中可以使用结构化引用执行此操作。）例如，在电子表格中，您可以引用第一行为A1:Z1，而在 pandas 中，您可以使用populations.loc['Chicago']。
索引值也是持久的，因此如果重新排列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]
像 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 文件！
限制输出
电子表格程序一次只会显示一个屏幕的数据，然后允许您滚动，因此实际上不需要限制输出。在 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 会为我们处理。参见如何从现有列派生新列。
过滤
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。
您可以使用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
查找字符串长度
在电子表格中，可以使用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 进行表格合并。
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]
与 SAS 的比较
译文：
pandas.pydata.org/docs/getting_started/comparison/comparison_with_sas.html
对于来自SAS的潜在用户，本页面旨在演示如何在 pandas 中执行不同的 SAS 操作。
如果您是 pandas 的新手，您可能首先想通过阅读 10 分钟入门 pandas 来熟悉该库。
惯例上，我们导入 pandas 和 NumPy 如下：
In [1]: import pandas as pd
In [2]: import numpy as np
数据结构
一般术语翻译
| pandas | SAS |
|---|---|
DataFrame |
数据集 |
| 列 | 变量 |
| 行 | 观察 |
| groupby | BY-group |
NaN |
. |
DataFrame
pandas 中的DataFrame类似于 SAS 数据集 - 一个具有标记列的二维数据源，可以是不同类型。正如本文档所示，几乎可以使用 SAS 的DATA步骤对数据集应用的任何操作，也可以在 pandas 中完成。
Series
Series是表示DataFrame的一列的数据结构。SAS 没有单独的数据结构用于单列，但一般来说，使用Series类似于在DATA步骤中引用列。
Index
每个DataFrame和Series都有一个Index - 这些是数据的行上的标签。SAS 没有完全类似的概念。数据集的行基本上是无标签的，除了在DATA步骤中可以访问的隐式整数索引（_N_）。
在 pandas 中，如果没有指定索引，默认也会使用整数索引（第一行 = 0，第二行 = 1，依此类推）。使用标记的Index或MultiIndex可以实现复杂的分析，并最终是理解 pandas 的重要部分，但在这个比较中，我们将基本上忽略Index，只将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)
有关废弃和删除inplace和copy的活跃讨论，适用于大多数方法（例如dropna），除了一小部分方法（包括replace）。在写时复制的情况下，这两个关键字将不再必要。提案可以在这里找到。
数据输入/输出
从值构建 DataFrame
可以通过在datalines语句后放置数据并指定列名来从指定值构建 SAS 数据集。
data df;
input x y;
datalines;
1 2
3 4
5 6
;
run;
可以以多种不同的方式构建 pandasDataFrame，但对于少量值，通常将其指定为 Python 字典是方便的，其中键是列名，值是数据。
In [1]: df = pd.DataFrame({"x": [1, 3, 5], "y": [2, 4, 6]})
In [2]: df
Out[2]:
x y
0 1 2
1 3 4
2 5 6
读取外部数据
与 SAS 类似，pandas 提供了从多种格式读取数据的实用程序。在 pandas 测试中找到的tips数据集（csv）将在接下来的许多示例中使用。
SAS 提供PROC IMPORT来将 csv 数据读入数据集。
proc import datafile='tips.csv' dbms=csv out=tips replace;
getnames=yes;
run;
pandas 方法是read_csv()，工作方式类似。
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]
像PROC IMPORT一样，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)
除了文本/csv，pandas 还支持多种其他数据格式，如 Excel、HDF5 和 SQL 数据库。这些都可以通过pd.read_*函数读取。更多详情请参阅 IO 文档。
限制输出
默认情况下，pandas 会截断大型DataFrame的输出，以显示第一行和最后一行。可以通过更改 pandas 选项，或使用DataFrame.head()或DataFrame.tail()来覆盖此行为。
In [1]: tips.head(5)
Out[1]:
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
SAS 中的等效操作为：
proc print data=df(obs=5);
run;
导出数据
在 SAS 中，PROC IMPORT的反向操作是PROC EXPORT。
proc export data=tips outfile='tips2.csv' dbms=csv;
run;
类似地，在 pandas 中，read_csv的相反操作是to_csv()，其他数据格式遵循类似的 api。
tips.to_csv("tips2.csv")
数据操作
列操作
在DATA步骤中，可以对新列或现有列使用任意数学表达式。
data tips;
set tips;
total_bill = total_bill - 2;
new_bill = total_bill / 2;
run;
pandas 通过在DataFrame中指定各个Series来提供矢量化操作。新列可以以相同的方式分配。DataFrame.drop()方法从DataFrame中删除列。
In [1]: tips["total_bill"] = tips["total_bill"] - 2
In [2]: tips["new_bill"] = tips["total_bill"] / 2
In [3]: tips
Out[3]:
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 [4]: tips = tips.drop("new_bill", axis=1)
过滤
在 SAS 中，使用if或where语句对一个或多个列进行过滤。
data tips;
set tips;
if total_bill > 10;
run;
data tips;
set tips;
where total_bill > 10;
/* equivalent in this case - where happens before the
DATA step begins and can also be used in PROC statements */
run;
可以通过多种方式对数据框进行过滤；其中最直观的是使用布尔索引。
In [1]: tips[tips["total_bill"] > 10]
Out[1]:
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 [2]: is_dinner = tips["time"] == "Dinner"
In [3]: is_dinner
Out[3]:
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 [4]: is_dinner.value_counts()
Out[4]:
time
True 176
False 68
Name: count, dtype: int64
In [5]: tips[is_dinner]
Out[5]:
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 逻辑
在 SAS 中，可以使用 if/then 逻辑来创建新列。
data tips;
set tips;
format bucket $4.;
if total_bill < 10 then bucket = 'low';
else bucket = 'high';
run;
在 pandas 中，可以使用numpy的where方法来执行相同的操作。
In [1]: tips["bucket"] = np.where(tips["total_bill"] < 10, "low", "high")
In [2]: tips
Out[2]:
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]
日期功能
SAS 提供了多种函数来对日期/时间列进行操作。
data tips;
set tips;
format date1 date2 date1_plusmonth mmddyy10.;
date1 = mdy(1, 15, 2013);
date2 = mdy(2, 15, 2015);
date1_year = year(date1);
date2_month = month(date2);
* shift date to beginning of next interval;
date1_next = intnx('MONTH', date1, 1);
* count intervals between dates;
months_between = intck('MONTH', date1, date2);
run;
下面显示了等效的 pandas 操作。除了这些功能外，pandas 还支持 Base SAS 中不可用的其他时间序列功能（例如重新采样和自定义偏移）-有关更多详细信息，请参阅 timeseries 文档。
In [1]: tips["date1"] = pd.Timestamp("2013-01-15")
In [2]: tips["date2"] = pd.Timestamp("2015-02-15")
In [3]: tips["date1_year"] = tips["date1"].dt.year
In [4]: tips["date2_month"] = tips["date2"].dt.month
In [5]: tips["date1_next"] = tips["date1"] + pd.offsets.MonthBegin()
In [6]: tips["months_between"] = tips["date2"].dt.to_period("M") - tips[
...: "date1"
...: ].dt.to_period("M")
...:
In [7]: tips[
...: ["date1", "date2", "date1_year", "date2_month", "date1_next", "months_between"]
...: ]
...:
Out[7]:
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]
选择列
SAS 在DATA步骤中提供关键字来选择、删除和重命名列。
data tips;
set tips;
keep sex total_bill tip;
run;
data tips;
set tips;
drop sex;
run;
data tips;
set tips;
rename total_bill=total_bill_2;
run;
下面以 pandas 表达相同的操作。
保留某些列
In [1]: tips[["sex", "total_bill", "tip"]]
Out[1]:
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 [2]: tips.drop("sex", axis=1)
Out[2]:
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 [3]: tips.rename(columns={"total_bill": "total_bill_2"})
Out[3]:
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]
按值排序
在 SAS 中通过PROC SORT实现排序
proc sort data=tips;
by sex total_bill;
run;
pandas 有一个DataFrame.sort_values()方法，它接受要排序的列的列表。
In [1]: tips = tips.sort_values(["sex", "total_bill"])
In [2]: tips
Out[2]:
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]
字符串处理
查找字符串的长度
SAS 使用LENGTHN和LENGTHC函数确定字符字符串的长度。LENGTHN排除尾随空格，LENGTHC包括尾随空格。
data _null_;
set tips;
put(LENGTHN(time));
put(LENGTHC(time));
run;
您可以使用Series.str.len()找到字符字符串的长度。在 Python 3 中，所有字符串都是 Unicode 字符串。len包括尾随空格。使用len和rstrip来排除尾随空格。
In [1]: tips["time"].str.len()
Out[1]:
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 [2]: tips["time"].str.rstrip().str.len()
Out[2]:
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
查找子字符串的位置
SAS 使用FINDW函数确定字符串中字符的位置。FINDW接受由第一个参数定义的字符串，并搜索您提供的第二个参数作为子字符串的第一个位置。
data _null_;
set tips;
put(FINDW(sex,'ale'));
run;
您可以使用Series.str.find()方法在字符串列中找到字符的位置。find搜索子字符串的第一个位置。如果找到子字符串，则该方法返回其位置。如果未找到，则返回-1。请记住，Python 索引是从零开始的。
In [1]: tips["sex"].str.find("ale")
Out[1]:
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
根据位置提取子字符串
SAS 根据位置从字符串中提取子字符串，使用SUBSTR函数。
data _null_;
set tips;
put(substr(sex,1,1));
run;
使用 pandas，您可以使用[]符号通过位置位置从字符串中提取子字符串。请记住，Python 索引是从零开始的。
In [1]: tips["sex"].str[0:1]
Out[1]:
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 个单词
SAS 的SCAN函数从字符串中返回第 n 个单词。第一个参数是您要解析的字符串，第二个参数指定要提取的单词。
data firstlast;
input String $60.;
First_Name = scan(string, 1);
Last_Name = scan(string, -1);
datalines2;
John Smith;
Jane Cook;
;;;
run;
在 pandas 中提取单词的最简单方法是通过空格拆分字符串，然后通过索引引用单词。请注意，如果需要，还有更强大的方法。
In [1]: firstlast = pd.DataFrame({"String": ["John Smith", "Jane Cook"]})
In [2]: firstlast["First_Name"] = firstlast["String"].str.split(" ", expand=True)[0]
In [3]: firstlast["Last_Name"] = firstlast["String"].str.rsplit(" ", expand=True)[1]
In [4]: firstlast
Out[4]:
String First_Name Last_Name
0 John Smith John Smith
1 Jane Cook Jane Cook
更改大小写
SAS 的UPCASE LOWCASE和PROPCASE函数改变参数的大小写。
data firstlast;
input String $60.;
string_up = UPCASE(string);
string_low = LOWCASE(string);
string_prop = PROPCASE(string);
datalines2;
John Smith;
Jane Cook;
;;;
run;
等效的 pandas 方法是Series.str.upper()，Series.str.lower()和Series.str.title()。
In [1]: firstlast = pd.DataFrame({"string": ["John Smith", "Jane Cook"]})
In [2]: firstlast["upper"] = firstlast["string"].str.upper()
In [3]: firstlast["lower"] = firstlast["string"].str.lower()
In [4]: firstlast["title"] = firstlast["string"].str.title()
In [5]: firstlast
Out[5]:
string upper lower title
0 John Smith JOHN SMITH john smith John Smith
1 Jane Cook JANE COOK jane cook Jane Cook
合并
下表将用于合并示例：
In [1]: df1 = pd.DataFrame({"key": ["A", "B", "C", "D"], "value": np.random.randn(4)})
In [2]: df1
Out[2]:
key value
0 A 0.469112
1 B -0.282863
2 C -1.509059
3 D -1.135632
In [3]: df2 = pd.DataFrame({"key": ["B", "D", "D", "E"], "value": np.random.randn(4)})
In [4]: df2
Out[4]:
key value
0 B 1.212112
1 D -0.173215
2 D 0.119209
3 E -1.044236
在 SAS 中，数据必须在合并之前明确排序。使用in=虚拟变量来跟踪是否在一个或两个输入框架中找到匹配来实现不同类型的连接。
proc sort data=df1;
by key;
run;
proc sort data=df2;
by key;
run;
data left_join inner_join right_join outer_join;
merge df1(in=a) df2(in=b);
if a and b then output inner_join;
if a then output left_join;
if b then output right_join;
if a or b then output outer_join;
run;
pandas 的 DataFrame 有一个merge()方法，提供类似的功能。数据不必事先排序，不同的连接类型通过how关键字实现。
In [1]: inner_join = df1.merge(df2, on=["key"], how="inner")
In [2]: inner_join
Out[2]:
key value_x value_y
0 B -0.282863 1.212112
1 D -1.135632 -0.173215
2 D -1.135632 0.119209
In [3]: left_join = df1.merge(df2, on=["key"], how="left")
In [4]: left_join
Out[4]:
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 [5]: right_join = df1.merge(df2, on=["key"], how="right")
In [6]: right_join
Out[6]:
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 [7]: outer_join = df1.merge(df2, on=["key"], how="outer")
In [8]: outer_join
Out[8]:
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
缺失数据
pandas 和 SAS 都有处理缺失数据的表示方式。
pandas 用特殊的浮点值NaN（不是一个数字）表示缺失数据。许多语义是相同的；例如，缺失数据会在数值操作中传播，并且默认情况下会被聚合忽略。
In [1]: outer_join
Out[1]:
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
In [2]: outer_join["value_x"] + outer_join["value_y"]
Out[2]:
0 NaN
1 0.929249
2 NaN
3 -1.308847
4 -1.016424
5 NaN
dtype: float64
In [3]: outer_join["value_x"].sum()
Out[3]: -3.5940742896293765
一个区别是缺失数据不能与其标记值进行比较。例如，在 SAS 中，您可以这样做来过滤缺失值。
data outer_join_nulls;
set outer_join;
if value_x = .;
run;
data outer_join_no_nulls;
set outer_join;
if value_x ^= .;
run;
在 pandas 中，Series.isna()和Series.notna()可用于过滤行。
In [1]: outer_join[outer_join["value_x"].isna()]
Out[1]:
key value_x value_y
5 E NaN -1.044236
In [2]: outer_join[outer_join["value_x"].notna()]
Out[2]:
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
pandas 提供了处理缺失数据的各种方法。以下是一些示例：
删除具有缺失值的行
In [3]: outer_join.dropna()
Out[3]:
key value_x value_y
1 B -0.282863 1.212112
3 D -1.135632 -0.173215
4 D -1.135632 0.119209
从前面的行向前填充
In [4]: outer_join.ffill()
Out[4]:
key value_x value_y
0 A 0.469112 NaN
1 B -0.282863 1.212112
2 C -1.509059 1.212112
3 D -1.135632 -0.173215
4 D -1.135632 0.119209
5 E -1.135632 -1.044236
用指定值替换缺失值
使用均值：
In [5]: outer_join["value_x"].fillna(outer_join["value_x"].mean())
Out[5]:
0 0.469112
1 -0.282863
2 -1.509059
3 -1.135632
4 -1.135632
5 -0.718815
Name: value_x, dtype: float64
GroupBy
聚合
SAS 的PROC SUMMARY可以用于按一个或多个关键变量分组，并在数值列上计算聚合。
proc summary data=tips nway;
class sex smoker;
var total_bill tip;
output out=tips_summed sum=;
run;
pandas 提供了灵活的groupby机制，允许类似的聚合。有关更多详细信息和示例，请参阅 groupby 文档。
In [1]: tips_summed = tips.groupby(["sex", "smoker"])[["total_bill", "tip"]].sum()
In [2]: tips_summed
Out[2]:
total_bill tip
sex smoker
Female No 869.68 149.77
Yes 527.27 96.74
Male No 1725.75 302.00
Yes 1217.07 183.07
转换
在 SAS 中，如果需要将组聚合与原始框架一起使用，则必须将其合并在一起。例如，通过吸烟者组减去每个观察值的均值。
proc summary data=tips missing nway;
class smoker;
var total_bill;
output out=smoker_means mean(total_bill)=group_bill;
run;
proc sort data=tips;
by smoker;
run;
data tips;
merge tips(in=a) smoker_means(in=b);
by smoker;
adj_total_bill = total_bill - group_bill;
if a and b;
run;
pandas 提供了一个转换机制，允许这些类型的操作在一个操作中简洁地表达。
In [1]: gb = tips.groupby("smoker")["total_bill"]
In [2]: tips["adj_total_bill"] = tips["total_bill"] - gb.transform("mean")
In [3]: tips
Out[3]:
total_bill tip sex smoker day time size adj_total_bill
67 1.07 1.00 Female Yes Sat Dinner 1 -17.686344
92 3.75 1.00 Female Yes Fri Dinner 2 -15.006344
111 5.25 1.00 Female No Sat Dinner 1 -11.938278
145 6.35 1.50 Female No Thur Lunch 2 -10.838278
135 6.51 1.25 Female No Thur Lunch 2 -10.678278
.. ... ... ... ... ... ... ... ...
182 43.35 3.50 Male Yes Sun Dinner 3 24.593656
156 46.17 5.00 Male No Sun Dinner 6 28.981722
59 46.27 6.73 Male No Sat Dinner 4 29.081722
212 46.33 9.00 Male No Sat Dinner 4 29.141722
170 48.81 10.00 Male Yes Sat Dinner 3 30.053656
[244 rows x 8 columns]
按组处理
除了聚合，pandas 的groupby还可以用于复制 SAS 中的大多数按组处理。例如，这个DATA步骤按性别/吸烟者组读取数据，并过滤到每个组的第一个条目。
proc sort data=tips;
by sex smoker;
run;
data tips_first;
set tips;
by sex smoker;
if FIRST.sex or FIRST.smoker then output;
run;
在 pandas 中，这将被写为：
In [4]: tips.groupby(["sex", "smoker"]).first()
Out[4]:
total_bill tip day time size adj_total_bill
sex smoker
Female No 5.25 1.00 Sat Dinner 1 -11.938278
Yes 1.07 1.00 Sat Dinner 1 -17.686344
Male No 5.51 2.00 Thur Lunch 2 -11.678278
Yes 5.25 5.15 Sun Dinner 2 -13.506344
其他考虑因素
磁盘与内存
pandas 仅在内存中运行，而 SAS 数据集存在于磁盘上。这意味着 pandas 能够加载的数据大小受限于计算机的内存，但也意味着对该数据的操作可能更快。
如果需要进行外部处理，一种可能性是dask.dataframe库（目前正在开发中），它为磁盘上的DataFrame提供了一部分 pandas 功能。
数据互操作
pandas 提供了一个read_sas()方法，可以读取以 XPORT 或 SAS7BDAT 二进制格式保存的 SAS 数据。
libname xportout xport 'transport-file.xpt';
data xportout.tips;
set tips(rename=(total_bill=tbill));
* xport variable names limited to 6 characters;
run;
df = pd.read_sas("transport-file.xpt")
df = pd.read_sas("binary-file.sas7bdat")
你也可以直接指定文件格式。默认情况下，pandas 会根据文件扩展名来推断文件格式。
df = pd.read_sas("transport-file.xpt", format="xport")
df = pd.read_sas("binary-file.sas7bdat", format="sas7bdat")
XPORT 是一种相对有限的格式，其解析不像其他 pandas 读取器那样优化。在 SAS 和 pandas 之间交换数据的另一种方法是序列化为 csv。
# version 0.17, 10M rows
In [8]: %time df = pd.read_sas('big.xpt')
Wall time: 14.6 s
In [9]: %time df = pd.read_csv('big.csv')
Wall time: 4.86 s
数据结构
通用术语翻译
| pandas | SAS |
|---|---|
DataFrame |
数据集 |
| 列 | 变量 |
| 行 | 观察 |
| 分组 | BY 组 |
NaN |
. |
DataFrame
在 pandas 中，DataFrame类似于 SAS 数据集 - 一个具有标记列的二维数据源，可以是不同类型。正如本文档所示，几乎任何可以使用 SAS 的DATA步骤应用于数据集的操作，也可以在 pandas 中完成。
Series
Series是表示DataFrame的一列的数据结构。SAS 没有单独的数据结构用于单列，但通常，使用Series类似于在DATA步骤中引用列。
Index
每个DataFrame和Series都有一个Index - 这些是数据的行上的标签。SAS 没有完全类似的概念。数据集的行基本上是无标签的，除了在DATA步骤中可以访问的隐式整数索引（_N_）。
在 pandas 中，如果未指定索引，则默认情况下也使用整数索引（第一行=0，第二行=1，依此类推）。虽然使用带标签的Index或MultiIndex可以实现复杂的分析，并最终是理解 pandas 的重要部分，但在此比较中，我们将基本上忽略Index，只将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)
有关废弃和删除inplace和copy的讨论正在进行中，适用于大多数方法（例如dropna），除了一小部分方法（包括replace）。在写时复制的情况下，这两个关键字将不再必要。提案可以在这里找到。
通用术语翻译
| pandas | SAS |
|---|---|
DataFrame |
数据集 |
| column | 变量 |
| row | 观察 |
| groupby | BY-group |
NaN |
. |
DataFrame
在 pandas 中，DataFrame类似于 SAS 数据集 - 一个具有带标签列的二维数据源，可以是不同类型的数据。正如本文档所示，几乎可以使用 SAS 的DATA步骤对数据集应用的任何操作，也可以在 pandas 中完成。
Series
Series是表示DataFrame的一列的数据结构。SAS 没有单独的数据结构用于单列，但通常，使用Series类似于在DATA步骤中引用列。
Index
每个DataFrame和Series都有一个Index - 这些是数据的行上的标签。SAS 没有完全类似的概念。数据集的行基本上没有标签，除了在DATA步骤中可以访问的隐式整数索引（_N_）。
在 pandas 中，如果未指定索引，则默认情况下也使用整数索引（第一行=0，第二行=1，依此类推）。虽然使用带标签的Index或MultiIndex可以实现复杂的分析，并最终是理解 pandas 的重要部分，但在此比较中，我们将基本上忽略Index，只将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）。在写时复制的情况下，这两个关键字将不再需要。提案可以在这里找到。
数据输入 / 输出
从数值构建 DataFrame
可以通过在 datalines 语句后放置数据并指定列名来构建指定值的 SAS 数据集。
data df;
input x y;
datalines;
1 2
3 4
5 6
;
run;
可以用许多不同的方式构建 pandas 的 DataFrame，但对于少量的值，将其指定为 Python 字典通常很方便，其中键是列名，值是数据。
In [1]: df = pd.DataFrame({"x": [1, 3, 5], "y": [2, 4, 6]})
In [2]: df
Out[2]:
x y
0 1 2
1 3 4
2 5 6
读取外部数据
像 SAS 一样，pandas 提供了从多种格式中读取数据的工具。在 pandas 测试中找到的 tips 数据集（csv）将在接下来的许多示例中使用。
SAS 提供了 PROC IMPORT 以将 csv 数据读入数据集。
proc import datafile='tips.csv' dbms=csv out=tips replace;
getnames=yes;
run;
pandas 方法是 read_csv()，其工作方式类似。
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]
像 PROC IMPORT 一样，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)
除了 text/csv，pandas 还支持多种其他数据格式，如 Excel、HDF5 和 SQL 数据库。所有这些都是通过 pd.read_* 函数读取的。有关更多详细信息，请参阅 IO 文档。
限制输出
默认情况下，pandas 会截断大的 DataFrame 输出以显示第一行和最后一行。这可以通过更改 pandas 选项或使用 DataFrame.head() 或 DataFrame.tail() 来覆盖。
In [1]: tips.head(5)
Out[1]:
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
在 SAS 中等效的是：
proc print data=df(obs=5);
run;
导出数据
SAS 中 PROC IMPORT 的反操作是 PROC EXPORT
proc export data=tips outfile='tips2.csv' dbms=csv;
run;
同样地，在 pandas 中，read_csv 的相反操作是 to_csv()，其他数据格式也遵循类似的 API。
tips.to_csv("tips2.csv")
从数值构建 DataFrame
可以通过在 datalines 语句后放置数据并指定列名来构建指定值的 SAS 数据集。
data df;
input x y;
datalines;
1 2
3 4
5 6
;
run;
可以用许多不同的方式构建 pandas 的 DataFrame，但对于少量的值，将其指定为 Python 字典通常很方便，其中键是列名，值是数据。
In [1]: df = pd.DataFrame({"x": [1, 3, 5], "y": [2, 4, 6]})
In [2]: df
Out[2]:
x y
0 1 2
1 3 4
2 5 6
读取外部数据
与 SAS 类似，pandas 提供了从许多格式中读取数据的实用程序。在 pandas 测试中找到的tips数据集（csv）将在接下来的许多示例中使用。
SAS 提供了PROC IMPORT来将 csv 数据读入数据集。
proc import datafile='tips.csv' dbms=csv out=tips replace;
getnames=yes;
run;
pandas 方法是read_csv()，工作方式类似。
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]
与PROC IMPORT类似，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)
除了文本/csv，pandas 还支持多种其他数据格式，如 Excel、HDF5 和 SQL 数据库。这些都是通过pd.read_*函数读取的。更多详情请参阅 IO 文档。
限制输出
默认情况下，pandas 会截断大型DataFrame的输出以显示第一行和最后一行。这可以通过更改 pandas 选项，或使用DataFrame.head()或DataFrame.tail()来覆盖。
In [1]: tips.head(5)
Out[1]:
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
在 SAS 中的等效操作是：
proc print data=df(obs=5);
run;
导出数据
在 SAS 中，PROC IMPORT的反向操作是PROC EXPORT
proc export data=tips outfile='tips2.csv' dbms=csv;
run;
类似于 pandas，read_csv的相反操作是to_csv()，其他数据格式遵循类似的 api。
tips.to_csv("tips2.csv")
数据操作
列操作
在DATA步骤中，可以对新列或现有列使用任意数学表达式。
data tips;
set tips;
total_bill = total_bill - 2;
new_bill = total_bill / 2;
run;
pandas 通过在DataFrame中指定各个Series来提供矢量化操作。新列可以以相同方式分配。DataFrame.drop()方法从DataFrame中删除列。
In [1]: tips["total_bill"] = tips["total_bill"] - 2
In [2]: tips["new_bill"] = tips["total_bill"] / 2
In [3]: tips
Out[3]:
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 [4]: tips = tips.drop("new_bill", axis=1)
过滤
在 SAS 中，使用if或where语句对一个或多个列进行过滤。
data tips;
set tips;
if total_bill > 10;
run;
data tips;
set tips;
where total_bill > 10;
/* equivalent in this case - where happens before the
DATA step begins and can also be used in PROC statements */
run;
数据框可以以多种方式进行过滤；其中最直观的是使用布尔索引。
In [1]: tips[tips["total_bill"] > 10]
Out[1]:
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 [2]: is_dinner = tips["time"] == "Dinner"
In [3]: is_dinner
Out[3]:
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 [4]: is_dinner.value_counts()
Out[4]:
time
True 176
False 68
Name: count, dtype: int64
In [5]: tips[is_dinner]
Out[5]:
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 逻辑
在 SAS 中，可以使用 if/then 逻辑来创建新列。
data tips;
set tips;
format bucket $4.;
if total_bill < 10 then bucket = 'low';
else bucket = 'high';
run;
在 pandas 中，可以使用numpy中的where方法来完成相同的操作。
In [1]: tips["bucket"] = np.where(tips["total_bill"] < 10, "low", "high")
In [2]: tips
Out[2]:
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]
日期功能
SAS 提供了多种函数来对日期/时间列进行操作。
data tips;
set tips;
format date1 date2 date1_plusmonth mmddyy10.;
date1 = mdy(1, 15, 2013);
date2 = mdy(2, 15, 2015);
date1_year = year(date1);
date2_month = month(date2);
* shift date to beginning of next interval;
date1_next = intnx('MONTH', date1, 1);
* count intervals between dates;
months_between = intck('MONTH', date1, date2);
run;
下面显示了等效的 pandas 操作。除了这些功能外，pandas 还支持 Base SAS 中不可用的其他时间序列功能（例如重新采样和自定义偏移）-请参阅 timeseries 文档了解更多详情。
In [1]: tips["date1"] = pd.Timestamp("2013-01-15")
In [2]: tips["date2"] = pd.Timestamp("2015-02-15")
In [3]: tips["date1_year"] = tips["date1"].dt.year
In [4]: tips["date2_month"] = tips["date2"].dt.month
In [5]: tips["date1_next"] = tips["date1"] + pd.offsets.MonthBegin()
In [6]: tips["months_between"] = tips["date2"].dt.to_period("M") - tips[
...: "date1"
...: ].dt.to_period("M")
...:
In [7]: tips[
...: ["date1", "date2", "date1_year", "date2_month", "date1_next", "months_between"]
...: ]
...:
Out[7]:
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]
选择列
SAS 提供了在DATA步骤中选择、删除和重命名列的关键字。
data tips;
set tips;
keep sex total_bill tip;
run;
data tips;
set tips;
drop sex;
run;
data tips;
set tips;
rename total_bill=total_bill_2;
run;
下面以 pandas 表达了相同的操作。
保留特定列
In [1]: tips[["sex", "total_bill", "tip"]]
Out[1]:
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 [2]: tips.drop("sex", axis=1)
Out[2]:
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 [3]: tips.rename(columns={"total_bill": "total_bill_2"})
Out[3]:
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]
按值排序
在 SAS 中，通过PROC SORT来实现排序
proc sort data=tips;
by sex total_bill;
run;
pandas 有一个DataFrame.sort_values()方法，可以按列排序。
In [1]: tips = tips.sort_values(["sex", "total_bill"])
In [2]: tips
Out[2]:
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]
列上的操作
在DATA步骤中，可以对新列或现有列使用任意数学表达式。
data tips;
set tips;
total_bill = total_bill - 2;
new_bill = total_bill / 2;
run;
pandas 通过在DataFrame中指定单独的Series来提供矢量化操作。新列可以以相同的方式分配。DataFrame.drop()方法从DataFrame中删除一列。
In [1]: tips["total_bill"] = tips["total_bill"] - 2
In [2]: tips["new_bill"] = tips["total_bill"] / 2
In [3]: tips
Out[3]:
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 [4]: tips = tips.drop("new_bill", axis=1)
过滤
在 SAS 中，使用if或where语句在一个或多个列上进行过滤。
data tips;
set tips;
if total_bill > 10;
run;
data tips;
set tips;
where total_bill > 10;
/* equivalent in this case - where happens before the
DATA step begins and can also be used in PROC statements */
run;
DataFrames 可以以多种方式进行过滤；其中最直观的是使用布尔索引。
In [1]: tips[tips["total_bill"] > 10]
Out[1]:
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 [2]: is_dinner = tips["time"] == "Dinner"
In [3]: is_dinner
Out[3]:
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 [4]: is_dinner.value_counts()
Out[4]:
time
True 176
False 68
Name: count, dtype: int64
In [5]: tips[is_dinner]
Out[5]:
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]
如果/那么逻辑
在 SAS 中，可以使用如果/那么逻辑来创建新列。
data tips;
set tips;
format bucket $4.;
if total_bill < 10 then bucket = 'low';
else bucket = 'high';
run;
在 pandas 中，可以使用numpy的where方法来实现相同的操作。
In [1]: tips["bucket"] = np.where(tips["total_bill"] < 10, "low", "high")
In [2]: tips
Out[2]:
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]
日期功能
SAS 提供了各种函数来对日期/时间列进行操作。
data tips;
set tips;
format date1 date2 date1_plusmonth mmddyy10.;
date1 = mdy(1, 15, 2013);
date2 = mdy(2, 15, 2015);
date1_year = year(date1);
date2_month = month(date2);
* shift date to beginning of next interval;
date1_next = intnx('MONTH', date1, 1);
* count intervals between dates;
months_between = intck('MONTH', date1, date2);
run;
下面显示了等效的 pandas 操作。除了这些功能外，pandas 还支持 Base SAS 中不可用的其他时间序列功能（例如重新采样和自定义偏移）-请参阅 timeseries 文档了解更多详情。
In [1]: tips["date1"] = pd.Timestamp("2013-01-15")
In [2]: tips["date2"] = pd.Timestamp("2015-02-15")
In [3]: tips["date1_year"] = tips["date1"].dt.year
In [4]: tips["date2_month"] = tips["date2"].dt.month
In [5]: tips["date1_next"] = tips["date1"] + pd.offsets.MonthBegin()
In [6]: tips["months_between"] = tips["date2"].dt.to_period("M") - tips[
...: "date1"
...: ].dt.to_period("M")
...:
In [7]: tips[
...: ["date1", "date2", "date1_year", "date2_month", "date1_next", "months_between"]
...: ]
...:
Out[7]:
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]
选择列
SAS 提供了在DATA步骤中选择、删除和重命名列的关键字。
data tips;
set tips;
keep sex total_bill tip;
run;
data tips;
set tips;
drop sex;
run;
data tips;
set tips;
rename total_bill=total_bill_2;
run;
下面以 pandas 表达了相同的操作。
保留特定列
In [1]: tips[["sex", "total_bill", "tip"]]
Out[1]:
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 [2]: tips.drop("sex", axis=1)
Out[2]:
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 [3]: tips.rename(columns={"total_bill": "total_bill_2"})
Out[3]:
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 [1]: tips[["sex", "total_bill", "tip"]]
Out[1]:
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 [2]: tips.drop("sex", axis=1)
Out[2]:
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 [3]: tips.rename(columns={"total_bill": "total_bill_2"})
Out[3]:
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]
按值排序
在 SAS 中，通过PROC SORT来实现排序
proc sort data=tips;
by sex total_bill;
run;
pandas 有一个DataFrame.sort_values()方法，可以按列排序。
In [1]: tips = tips.sort_values(["sex", "total_bill"])
In [2]: tips
Out[2]:
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]
字符串处理
查找字符串的长度
SAS 使用 LENGTHN 和 LENGTHC 函数确定字符字符串的长度。LENGTHN 排除尾随空格，LENGTHC 包括尾随空格。
data _null_;
set tips;
put(LENGTHN(time));
put(LENGTHC(time));
run;
你可以使用 Series.str.len() 找到字符串的长度。在 Python 3 中，所有字符串都是 Unicode 字符串。len 包括尾随空格。使用 len 和 rstrip 排除尾随空格。
In [1]: tips["time"].str.len()
Out[1]:
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 [2]: tips["time"].str.rstrip().str.len()
Out[2]:
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
查找子串的位置
SAS 使用 FINDW 函数确定字符串中字符的位置。FINDW 使用第一个参数定义的字符串，并搜索你提供的第二个参数作为子串的第一个位置。
data _null_;
set tips;
put(FINDW(sex,'ale'));
run;
你可以使用 Series.str.find() 方法在字符串列中找到字符的位置。find 搜索子串的第一个位置。如果找到子串，则该方法返回其位置。如果未找到，则返回-1。请记住，Python 的索引是从零开始的。
In [1]: tips["sex"].str.find("ale")
Out[1]:
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
根据位置提取子串
SAS 使用 SUBSTR 函数根据位置从字符串中提取子串。
data _null_;
set tips;
put(substr(sex,1,1));
run;
使用 pandas，你可以使用[]符号通过位置来提取字符串中的子串。请记住，Python 的索引是从零开始的。
In [1]: tips["sex"].str[0:1]
Out[1]:
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 个单词
SAS 的 SCAN 函数从字符串中返回第 n 个单词。第一个参数是要解析的字符串，第二个参数指定要提取的单词。
data firstlast;
input String $60.;
First_Name = scan(string, 1);
Last_Name = scan(string, -1);
datalines2;
John Smith;
Jane Cook;
;;;
run;
在 pandas 中提取单词的最简单方法是通过空格将字符串分割，然后按索引引用单词。请注意，如果需要，还有更强大的方法。
In [1]: firstlast = pd.DataFrame({"String": ["John Smith", "Jane Cook"]})
In [2]: firstlast["First_Name"] = firstlast["String"].str.split(" ", expand=True)[0]
In [3]: firstlast["Last_Name"] = firstlast["String"].str.rsplit(" ", expand=True)[1]
In [4]: firstlast
Out[4]:
String First_Name Last_Name
0 John Smith John Smith
1 Jane Cook Jane Cook
更改大小写
SAS 的 UPCASE、LOWCASE 和 PROPCASE 函数更改参数的大小写。
data firstlast;
input String $60.;
string_up = UPCASE(string);
string_low = LOWCASE(string);
string_prop = PROPCASE(string);
datalines2;
John Smith;
Jane Cook;
;;;
run;
等效的 pandas 方法是Series.str.upper()、Series.str.lower()和Series.str.title()。
In [1]: firstlast = pd.DataFrame({"string": ["John Smith", "Jane Cook"]})
In [2]: firstlast["upper"] = firstlast["string"].str.upper()
In [3]: firstlast["lower"] = firstlast["string"].str.lower()
In [4]: firstlast["title"] = firstlast["string"].str.title()
In [5]: firstlast
Out[5]:
string upper lower title
0 John Smith JOHN SMITH john smith John Smith
1 Jane Cook JANE COOK jane cook Jane Cook
查找字符串的长度
SAS 使用LENGTHN和LENGTHC函数确定字符字符串的长度。LENGTHN排除尾随空格，LENGTHC包括尾随空格。
data _null_;
set tips;
put(LENGTHN(time));
put(LENGTHC(time));
run;
您可以使用Series.str.len()找到字符字符串的长度。在 Python 3 中，所有字符串都是 Unicode 字符串。len包括尾随空格。使用len和rstrip来排除尾随空格。
In [1]: tips["time"].str.len()
Out[1]:
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 [2]: tips["time"].str.rstrip().str.len()
Out[2]:
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
查找子字符串的位置
SAS 使用FINDW函数确定字符串中字符的位置。FINDW接受由第一个参数定义的字符串，并搜索你提供的第二个参数作为子字符串的第一个位置。
data _null_;
set tips;
put(FINDW(sex,'ale'));
run;
您可以使用Series.str.find()方法在字符串列中找到字符的位置。find搜索子字符串的第一个位置。如果找到子字符串，则该方法返回其位置。如果未找到，则返回-1。请记住，Python 索引是从零开始的。
In [1]: tips["sex"].str.find("ale")
Out[1]:
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
按位置提取子字符串
SAS 使用SUBSTR函数根据其位置从字符串中提取子字符串。
data _null_;
set tips;
put(substr(sex,1,1));
run;
使用 pandas，您可以使用[]符号按位置位置从字符串中提取子字符串。请记住，Python 索引是从零开始的。
In [1]: tips["sex"].str[0:1]
Out[1]:
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 个单词
SAS 的SCAN函数从字符串中返回第 n 个单词。第一个参数是要解析的字符串，第二个参数指定要提取的单词。
data firstlast;
input String $60.;
First_Name = scan(string, 1);
Last_Name = scan(string, -1);
datalines2;
John Smith;
Jane Cook;
;;;
run;
用 pandas 提取单词的最简单方法是通过空格分割字符串，然后通过索引引用单词。请注意，如果需要，还有更强大的方法。
In [1]: firstlast = pd.DataFrame({"String": ["John Smith", "Jane Cook"]})
In [2]: firstlast["First_Name"] = firstlast["String"].str.split(" ", expand=True)[0]
In [3]: firstlast["Last_Name"] = firstlast["String"].str.rsplit(" ", expand=True)[1]
In [4]: firstlast
Out[4]:
String First_Name Last_Name
0 John Smith John Smith
1 Jane Cook Jane Cook
更改大小写
SAS 的 UPCASE、LOWCASE 和 PROPCASE 函数改变参数的大小写。
data firstlast;
input String $60.;
string_up = UPCASE(string);
string_low = LOWCASE(string);
string_prop = PROPCASE(string);
datalines2;
John Smith;
Jane Cook;
;;;
run;
pandas 相应的方法为Series.str.upper()、Series.str.lower()和Series.str.title()。
In [1]: firstlast = pd.DataFrame({"string": ["John Smith", "Jane Cook"]})
In [2]: firstlast["upper"] = firstlast["string"].str.upper()
In [3]: firstlast["lower"] = firstlast["string"].str.lower()
In [4]: firstlast["title"] = firstlast["string"].str.title()
In [5]: firstlast
Out[5]:
string upper lower title
0 John Smith JOHN SMITH john smith John Smith
1 Jane Cook JANE COOK jane cook Jane Cook
合并
合并示例中将使用以下表格：
In [1]: df1 = pd.DataFrame({"key": ["A", "B", "C", "D"], "value": np.random.randn(4)})
In [2]: df1
Out[2]:
key value
0 A 0.469112
1 B -0.282863
2 C -1.509059
3 D -1.135632
In [3]: df2 = pd.DataFrame({"key": ["B", "D", "D", "E"], "value": np.random.randn(4)})
In [4]: df2
Out[4]:
key value
0 B 1.212112
1 D -0.173215
2 D 0.119209
3 E -1.044236
在 SAS 中，数据必须在合并之前明确排序。使用 in= 虚拟变量来实现不同类型的连接，以跟踪在一个或两个输入框架中是否找到了匹配项。
proc sort data=df1;
by key;
run;
proc sort data=df2;
by key;
run;
data left_join inner_join right_join outer_join;
merge df1(in=a) df2(in=b);
if a and b then output inner_join;
if a then output left_join;
if b then output right_join;
if a or b then output outer_join;
run;
pandas DataFrame 有一个merge()方法，提供了类似的功能。数据不必提前排序，并且不同的连接类型通过 how 关键字实现。
In [1]: inner_join = df1.merge(df2, on=["key"], how="inner")
In [2]: inner_join
Out[2]:
key value_x value_y
0 B -0.282863 1.212112
1 D -1.135632 -0.173215
2 D -1.135632 0.119209
In [3]: left_join = df1.merge(df2, on=["key"], how="left")
In [4]: left_join
Out[4]:
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 [5]: right_join = df1.merge(df2, on=["key"], how="right")
In [6]: right_join
Out[6]:
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 [7]: outer_join = df1.merge(df2, on=["key"], how="outer")
In [8]: outer_join
Out[8]:
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
缺失数据
pandas 和 SAS 都有一个表示缺失数据的表示形式。
pandas 用特殊的浮点值 NaN（不是一个数字）表示缺失数据。许多语义是相同的；例如，缺失数据在数值运算中传播，并且默认情况下在聚合中被忽略。
In [1]: outer_join
Out[1]:
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
In [2]: outer_join["value_x"] + outer_join["value_y"]
Out[2]:
0 NaN
1 0.929249
2 NaN
3 -1.308847
4 -1.016424
5 NaN
dtype: float64
In [3]: outer_join["value_x"].sum()
Out[3]: -3.5940742896293765
一个区别是缺失数据不能与其标志值进行比较。例如，在 SAS 中，您可以这样做来过滤缺失值。
data outer_join_nulls;
set outer_join;
if value_x = .;
run;
data outer_join_no_nulls;
set outer_join;
if value_x ^= .;
run;
在 pandas 中，可以使用Series.isna()和Series.notna()来过滤行。
In [1]: outer_join[outer_join["value_x"].isna()]
Out[1]:
key value_x value_y
5 E NaN -1.044236
In [2]: outer_join[outer_join["value_x"].notna()]
Out[2]:
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
pandas 提供了多种处理缺失数据的方法。以下是一些示例：
删除含有缺失值的行
In [3]: outer_join.dropna()
Out[3]:
key value_x value_y
1 B -0.282863 1.212112
3 D -1.135632 -0.173215
4 D -1.135632 0.119209
从前面的行向前填充
In [4]: outer_join.ffill()
Out[4]:
key value_x value_y
0 A 0.469112 NaN
1 B -0.282863 1.212112
2 C -1.509059 1.212112
3 D -1.135632 -0.173215
4 D -1.135632 0.119209
5 E -1.135632 -1.044236
用指定值替换缺失值
使用均值：
In [5]: outer_join["value_x"].fillna(outer_join["value_x"].mean())
Out[5]:
0 0.469112
1 -0.282863
2 -1.509059
3 -1.135632
4 -1.135632
5 -0.718815
Name: value_x, dtype: float64
删除含有缺失值的行
In [3]: outer_join.dropna()
Out[3]:
key value_x value_y
1 B -0.282863 1.212112
3 D -1.135632 -0.173215
4 D -1.135632 0.119209
从前面的行向前填充
In [4]: outer_join.ffill()
Out[4]:
key value_x value_y
0 A 0.469112 NaN
1 B -0.282863 1.212112
2 C -1.509059 1.212112
3 D -1.135632 -0.173215
4 D -1.135632 0.119209
5 E -1.135632 -1.044236
用指定值替换缺失值
使用均值：
In [5]: outer_join["value_x"].fillna(outer_join["value_x"].mean())
Out[5]:
0 0.469112
1 -0.282863
2 -1.509059
3 -1.135632
4 -1.135632
5 -0.718815
Name: value_x, dtype: float64
分组
聚合
SAS 的 PROC SUMMARY 可以用于按一个或多个关键变量分组，并对数值列进行聚合计算。
proc summary data=tips nway;
class sex smoker;
var total_bill tip;
output out=tips_summed sum=;
run;
pandas 提供了灵活的 groupby 机制，允许进行类似的聚合。详细内容和示例请参阅 groupby 文档。
In [1]: tips_summed = tips.groupby(["sex", "smoker"])[["total_bill", "tip"]].sum()
In [2]: tips_summed
Out[2]:
total_bill tip
sex smoker
Female No 869.68 149.77
Yes 527.27 96.74
Male No 1725.75 302.00
Yes 1217.07 183.07
转换
在 SAS 中，如果需要将组聚合与原始框架一起使用，则必须将其合并回来。例如，通过吸烟者组逐个观察减去均值。
proc summary data=tips missing nway;
class smoker;
var total_bill;
output out=smoker_means mean(total_bill)=group_bill;
run;
proc sort data=tips;
by smoker;
run;
data tips;
merge tips(in=a) smoker_means(in=b);
by smoker;
adj_total_bill = total_bill - group_bill;
if a and b;
run;
pandas 提供了一个 Transformation 机制，允许这些类型的操作在一个操作中简洁地表达。
In [1]: gb = tips.groupby("smoker")["total_bill"]
In [2]: tips["adj_total_bill"] = tips["total_bill"] - gb.transform("mean")
In [3]: tips
Out[3]:
total_bill tip sex smoker day time size adj_total_bill
67 1.07 1.00 Female Yes Sat Dinner 1 -17.686344
92 3.75 1.00 Female Yes Fri Dinner 2 -15.006344
111 5.25 1.00 Female No Sat Dinner 1 -11.938278
145 6.35 1.50 Female No Thur Lunch 2 -10.838278
135 6.51 1.25 Female No Thur Lunch 2 -10.678278
.. ... ... ... ... ... ... ... ...
182 43.35 3.50 Male Yes Sun Dinner 3 24.593656
156 46.17 5.00 Male No Sun Dinner 6 28.981722
59 46.27 6.73 Male No Sat Dinner 4 29.081722
212 46.33 9.00 Male No Sat Dinner 4 29.141722
170 48.81 10.00 Male Yes Sat Dinner 3 30.053656
[244 rows x 8 columns]
按组处理
除了聚合，pandas 的groupby还可以用于复制 SAS 中的大多数其他按组处理。例如，这个DATA步骤按性别/吸烟者组读取数据，并过滤到每个组的第一个条目。
proc sort data=tips;
by sex smoker;
run;
data tips_first;
set tips;
by sex smoker;
if FIRST.sex or FIRST.smoker then output;
run;
在 pandas 中，这样写：
In [4]: tips.groupby(["sex", "smoker"]).first()
Out[4]:
total_bill tip day time size adj_total_bill
sex smoker
Female No 5.25 1.00 Sat Dinner 1 -11.938278
Yes 1.07 1.00 Sat Dinner 1 -17.686344
Male No 5.51 2.00 Thur Lunch 2 -11.678278
Yes 5.25 5.15 Sun Dinner 2 -13.506344
聚合
SAS 的PROC SUMMARY可以用于按一个或多个关键变量分组，并在数值列上计算聚合。
proc summary data=tips nway;
class sex smoker;
var total_bill tip;
output out=tips_summed sum=;
run;
pandas 提供了灵活的groupby机制，允许进行类似的聚合。查看 groupby 文档获取更多详细信息和示例。
In [1]: tips_summed = tips.groupby(["sex", "smoker"])[["total_bill", "tip"]].sum()
In [2]: tips_summed
Out[2]:
total_bill tip
sex smoker
Female No 869.68 149.77
Yes 527.27 96.74
Male No 1725.75 302.00
Yes 1217.07 183.07
转换
在 SAS 中，如果需要将组聚合与原始框架一起使用，则必须将其合并在一起。例如，通过吸烟者组减去每个观察值的平均值。
proc summary data=tips missing nway;
class smoker;
var total_bill;
output out=smoker_means mean(total_bill)=group_bill;
run;
proc sort data=tips;
by smoker;
run;
data tips;
merge tips(in=a) smoker_means(in=b);
by smoker;
adj_total_bill = total_bill - group_bill;
if a and b;
run;
pandas 提供了一个 Transformation 机制，允许这些类型的操作在一个操作中简洁地表达。
In [1]: gb = tips.groupby("smoker")["total_bill"]
In [2]: tips["adj_total_bill"] = tips["total_bill"] - gb.transform("mean")
In [3]: tips
Out[3]:
total_bill tip sex smoker day time size adj_total_bill
67 1.07 1.00 Female Yes Sat Dinner 1 -17.686344
92 3.75 1.00 Female Yes Fri Dinner 2 -15.006344
111 5.25 1.00 Female No Sat Dinner 1 -11.938278
145 6.35 1.50 Female No Thur Lunch 2 -10.838278
135 6.51 1.25 Female No Thur Lunch 2 -10.678278
.. ... ... ... ... ... ... ... ...
182 43.35 3.50 Male Yes Sun Dinner 3 24.593656
156 46.17 5.00 Male No Sun Dinner 6 28.981722
59 46.27 6.73 Male No Sat Dinner 4 29.081722
212 46.33 9.00 Male No Sat Dinner 4 29.141722
170 48.81 10.00 Male Yes Sat Dinner 3 30.053656
[244 rows x 8 columns]
按组处理
除了聚合，pandas 的groupby还可以用于复制 SAS 中的大多数其他按组处理。例如，这个DATA步骤按性别/吸烟者组读取数据，并过滤到每个组的第一个条目。
proc sort data=tips;
by sex smoker;
run;
data tips_first;
set tips;
by sex smoker;
if FIRST.sex or FIRST.smoker then output;
run;
在 pandas 中，这样写：
In [4]: tips.groupby(["sex", "smoker"]).first()
Out[4]:
total_bill tip day time size adj_total_bill
sex smoker
Female No 5.25 1.00 Sat Dinner 1 -11.938278
Yes 1.07 1.00 Sat Dinner 1 -17.686344
Male No 5.51 2.00 Thur Lunch 2 -11.678278
Yes 5.25 5.15 Sun Dinner 2 -13.506344
其他考虑
磁盘 vs 内存
pandas 仅在内存中运行，而 SAS 数据集存在于磁盘上。这意味着 pandas���够加载的数据大小受限于计算机的内存，但也意味着对该数据的操作可能更快。
如果需要进行核心外处理，一种可能性是dask.dataframe库（目前正在开发中），它为磁盘上的DataFrame提供了一部分 pandas 功能。
数据互操作
pandas 提供了一个read_sas()方法，可以读取以 XPORT 或 SAS7BDAT 二进制格式保存的 SAS 数据。
libname xportout xport 'transport-file.xpt';
data xportout.tips;
set tips(rename=(total_bill=tbill));
* xport variable names limited to 6 characters;
run;
df = pd.read_sas("transport-file.xpt")
df = pd.read_sas("binary-file.sas7bdat")
您还可以直接指定文件格式。默认情况下，pandas 将尝试根据其扩展名推断文件格式。
df = pd.read_sas("transport-file.xpt", format="xport")
df = pd.read_sas("binary-file.sas7bdat", format="sas7bdat")
XPORT 是一个相对有限的格式，其解析不像其他 pandas 读取器那样经过优化。在 SAS 和 pandas 之间交换数据的另一种方法是序列化为 csv。
# version 0.17, 10M rows
In [8]: %time df = pd.read_sas('big.xpt')
Wall time: 14.6 s
In [9]: %time df = pd.read_csv('big.csv')
Wall time: 4.86 s
磁盘 vs 内存
pandas 仅在内存中运行，而 SAS 数据集存在于磁盘上。这意味着 pandas 能够加载的数据大小受限于计算机的内存，但也意味着对该数据的操作可能更快。
如果需要进行核心外处理，一种可能性是dask.dataframe库（目前正在开发中），它为磁盘上的DataFrame提供了一部分 pandas 功能。
数据互操作
pandas 提供了一个 read_sas() 方法，可以读取以 XPORT 或 SAS7BDAT 二进制格式保存的 SAS 数据。
libname xportout xport 'transport-file.xpt';
data xportout.tips;
set tips(rename=(total_bill=tbill));
* xport variable names limited to 6 characters;
run;
df = pd.read_sas("transport-file.xpt")
df = pd.read_sas("binary-file.sas7bdat")
您也可以直接指定文件格式。默认情况下，pandas 将尝试根据文件扩展名推断文件格式。
df = pd.read_sas("transport-file.xpt", format="xport")
df = pd.read_sas("binary-file.sas7bdat", format="sas7bdat")
XPORT 是一个相对有限的格式，其解析并不像其他 pandas 读取器那样优化。在 SAS 和 pandas 之间进行数据交互的另一种方式是序列化为 csv。
# version 0.17, 10M rows
In [8]: %time df = pd.read_sas('big.xpt')
Wall time: 14.6 s
In [9]: %time df = pd.read_csv('big.csv')
Wall time: 4.86 s
