首页 > 其他分享 >Pandas 2.2 中文官方教程和指南（三）

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

时间：2024-04-24 11:55:35浏览次数：22  
标签：... 教程 df .... col1 np 2.2 Pandas Out

原文：pandas.pydata.org/docs/

如何操作文本数据

原文：pandas.pydata.org/docs/getting_started/intro_tutorials/10_text_data.html

  • 将所有名称字符改为小写。

    In [4]: titanic["Name"].str.lower()
Out[4]: 
0                                braund, mr. owen harris
1      cumings, mrs. john bradley (florence briggs th...
2                                 heikkinen, miss. laina
3           futrelle, mrs. jacques heath (lily may peel)
4                               allen, mr. william henry
 ... 
886                                montvila, rev. juozas
887                         graham, miss. margaret edith
888             johnston, miss. catherine helen "carrie"
889                                behr, mr. karl howell
890                                  dooley, mr. patrick
Name: Name, Length: 891, dtype: object

    要使Name列中的每个字符串都变为小写，选择Name列（参见数据选择教程），添加str访问器并应用lower方法。因此，每个字符串都被逐个转换。

与时间序列教程中具有dt访问器的日期时间对象类似，在使用str访问器时可以使用许多专门的字符串方法。这些方法通常与单个元素的内置字符串方法具有匹配的名称，但是在每个值的列上逐个应用（记得逐元素计算吗？）。

  • 创建一个新列Surname，其中包含乘客的姓氏，通过提取逗号前的部分。

    In [5]: titanic["Name"].str.split(",")
Out[5]: 
0                             [Braund,  Mr. Owen Harris]
1      [Cumings,  Mrs. John Bradley (Florence Briggs ...
2                              [Heikkinen,  Miss. Laina]
3        [Futrelle,  Mrs. Jacques Heath (Lily May Peel)]
4                            [Allen,  Mr. William Henry]
 ... 
886                             [Montvila,  Rev. Juozas]
887                      [Graham,  Miss. Margaret Edith]
888          [Johnston,  Miss. Catherine Helen "Carrie"]
889                             [Behr,  Mr. Karl Howell]
890                               [Dooley,  Mr. Patrick]
Name: Name, Length: 891, dtype: object

    使用Series.str.split()方法，每个值都返回一个包含 2 个元素的列表。第一个元素是逗号前的部分，第二个元素是逗号后的部分。

    In [6]: titanic["Surname"] = titanic["Name"].str.split(",").str.get(0)

In [7]: titanic["Surname"]
Out[7]: 
0         Braund
1        Cumings
2      Heikkinen
3       Futrelle
4          Allen
 ... 
886     Montvila
887       Graham
888     Johnston
889         Behr
890       Dooley
Name: Surname, Length: 891, dtype: object

    由于我们只对代表姓氏的第一部分感兴趣（元素 0），我们可以再次使用str访问器，并应用Series.str.get()来提取相关部分。事实上，这些字符串函数可以连接起来组合多个函数！

到用户指南

有关提取字符串部分的更多信息，请参阅用户指南中关于拆分和替换字符串的部分。

  • 提取关于泰坦尼克号上女伯爵的乘客数据。

    In [8]: titanic["Name"].str.contains("Countess")
Out[8]: 
0      False
1      False
2      False
3      False
4      False
 ... 
886    False
887    False
888    False
889    False
890    False
Name: Name, Length: 891, dtype: bool 

    In [9]: titanic[titanic["Name"].str.contains("Countess")]
Out[9]: 
 PassengerId  Survived  Pclass  ... Cabin Embarked  Surname
759          760         1       1  ...   B77        S   Rothes

[1 rows x 13 columns]

    (对她的故事感兴趣吗？请参阅 维基百科！)

    字符串方法Series.str.contains()检查列Name中的每个值是否包含单词Countess，并对每个值返回True（Countess是名称的一部分）或False（Countess不是名称的一部分）。此输出可用于使用在数据子集教程中介绍的条件（布尔）索引来对数据进行子选择。由于泰坦尼克号上只有一位女伯爵，我们得到一行作为结果。

注意

字符串的更强大的提取操作是支持的，因为Series.str.contains() 和 Series.str.extract() 方法接受正则表达式，但不在本教程的范围内。

到用户指南

更多有关提取字符串部分的信息，请参阅用户指南中有关字符串匹配和提取的部分。

  • 泰坦尼克号的乘客中，哪位乘客的名字最长？

    In [10]: titanic["Name"].str.len()
Out[10]: 
0      23
1      51
2      22
3      44
4      24
 ..
886    21
887    28
888    40
889    21
890    19
Name: Name, Length: 891, dtype: int64

    要获得最长的名称，我们首先必须获取Name列中每个名称的长度。通过使用 pandas 字符串方法，对每个名称单独应用Series.str.len()函数（逐元素）。

    In [11]: titanic["Name"].str.len().idxmax()
Out[11]: 307

    接下来，我们需要获取对应位置，最好是表格中名字长度最大的索引标签。 idxmax() 方法正是这样做的。它不是字符串方法，适用于整数，因此不使用str。

    In [12]: titanic.loc[titanic["Name"].str.len().idxmax(), "Name"]
Out[12]: 'Penasco y Castellana, Mrs. Victor de Satode (Maria Josefa Perez de Soto y Vallejo)'

    基于行的索引名称（307）和列的名称（Name），我们可以使用loc运算符进行选择，该运算符在子集切片教程中介绍过。

  • 在“性别”列中，将“male”的值替换为“M”，将“female”的值替换为“F”。

    In [13]: titanic["Sex_short"] = titanic["Sex"].replace({"male": "M", "female": "F"})

In [14]: titanic["Sex_short"]
Out[14]: 
0      M
1      F
2      F
3      F
4      M
 ..
886    M
887    F
888    F
889    M
890    M
Name: Sex_short, Length: 891, dtype: object

    而replace() 不是一个字符串方法，它提供了一种方便的方式来使用映射或词汇表来转换某些值。它需要一个dictionary来定义映射 {from : to}。

警告

还有一个可用的replace()方法，可以替换特定的字符集。但是，当有多个值的映射时，这将变得：

titanic["Sex_short"] = titanic["Sex"].str.replace("female", "F")
titanic["Sex_short"] = titanic["Sex_short"].str.replace("male", "M")

这将变得繁琐，并且很容易出错。想想（或者试试）如果这两个语句以相反的顺序应用会发生什么…

记住

  • 可以使用str访问器使用字符串方法。

  • 字符串方法是逐元素进行的，可以用于条件索引。

  • replace方法是根据给定字典转换值的便捷方法。

到用户指南

用户指南页面提供了处理文本数据的全面概述。

与其他工具的比较

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

  • 与 R / R 库的比较

    • 快速参考

    • 基本 R

    • plyr

    • reshape / reshape2

  • 与 SQL 的比较

    • 复制 vs. 原地操作

    • 选择

    • WHERE

    • GROUP BY

    • 连接

    • UNION

    • 限制

    • pandas 对一些 SQL 分析和聚合函数的等效操作

    • 更新

    • 删除

  • 与电子表格的比较

    • 数据结构

    • 数据输入/输出

    • 数据操作

    • 字符串处理

    • 合并

    • 其他考虑因素

  • 与 SAS 的比较

    • 数据结构

    • 数据输入/输出

    • 数据操作

    • 字符串处理

    • 合并

    • 缺失数据

    • GroupBy

    • 其他考虑因素

  • 与 Stata 的比较

    • 数据结构

    • 数据输入/输出

    • 数据操作

    • 字符串处理

    • 合并

    • 缺失数据

    • GroupBy

    • 其他考虑因素

与 R/R 库的比较

译文：pandas.pydata.org/docs/getting_started/comparison/comparison_with_r.html

由于 pandas 旨在提供许多人们使用R的数据操作和分析功能，因此本页面旨在更详细地查看R 语言及其许多第三方库与 pandas 的关系。在与 R 和 CRAN 库的比较中，我们关心以下几点：

  • 功能性/灵活性：每个工具可以/不可以做什么

  • 性能：操作有多快。最好提供硬性数据/基准

  • 易用性：一个工具更容易/更难使用（您可能需要通过并排代码比较来判断）

本页面还提供了一个为这些 R 包的用户提供一点翻译指南的页面。

快速参考

我们将从一个快速参考指南开始，将一些常见的 R 操作（使用dplyr）与 pandas 的等效操作进行配对。

查询、过滤、抽样

R pandas
dim(df) df.shape
head(df) df.head()
slice(df, 1:10) df.iloc[:9]
filter(df, col1 == 1, col2 == 1) df.query('col1 == 1 & col2 == 1')
df[df$col1 == 1 & df$col2 == 1,] df[(df.col1 == 1) & (df.col2 == 1)]
select(df, col1, col2) df[['col1', 'col2']]
select(df, col1:col3) df.loc[:, 'col1':'col3']
select(df, -(col1:col3)) df.drop(cols_to_drop, axis=1) 但请参见[1]
distinct(select(df, col1)) df[['col1']].drop_duplicates()
distinct(select(df, col1, col2)) df[['col1', 'col2']].drop_duplicates()
sample_n(df, 10) df.sample(n=10)
sample_frac(df, 0.01) df.sample(frac=0.01)

排序

R pandas
arrange(df, col1, col2) df.sort_values(['col1', 'col2'])
arrange(df, desc(col1)) df.sort_values('col1', ascending=False)

转换

R pandas
select(df, col_one = col1) df.rename(columns={'col1': 'col_one'})['col_one']
rename(df, col_one = col1) df.rename(columns={'col1': 'col_one'})
mutate(df, c=a-b) df.assign(c=df['a']-df['b'])

分组和汇总

R pandas
summary(df) df.describe()
gdf <- group_by(df, col1) gdf = df.groupby('col1')
summarise(gdf, avg=mean(col1, na.rm=TRUE)) df.groupby('col1').agg({'col1': 'mean'})
summarise(gdf, total=sum(col1)) df.groupby('col1').sum()

基础 R

使用 R 的c进行切片

R 使得通过名称轻松访问 data.frame 列成为可能

df  <-  data.frame(a=rnorm(5),  b=rnorm(5),  c=rnorm(5),  d=rnorm(5),  e=rnorm(5))
df[,  c("a",  "c",  "e")]

或按整数位置

df  <-  data.frame(matrix(rnorm(1000),  ncol=100))
df[,  c(1:10,  25:30,  40,  50:100)]

在 pandas 中按名称选择多列很简单

In [1]: df = pd.DataFrame(np.random.randn(10, 3), columns=list("abc"))

In [2]: df[["a", "c"]]
Out[2]: 
 a         c
0  0.469112 -1.509059
1 -1.135632 -0.173215
2  0.119209 -0.861849
3 -2.104569  1.071804
4  0.721555 -1.039575
5  0.271860  0.567020
6  0.276232 -0.673690
7  0.113648  0.524988
8  0.404705 -1.715002
9 -1.039268 -1.157892

In [3]: df.loc[:, ["a", "c"]]
Out[3]: 
 a         c
0  0.469112 -1.509059
1 -1.135632 -0.173215
2  0.119209 -0.861849
3 -2.104569  1.071804
4  0.721555 -1.039575
5  0.271860  0.567020
6  0.276232 -0.673690
7  0.113648  0.524988
8  0.404705 -1.715002
9 -1.039268 -1.157892

通过整数位置选择多个不连续列可以通过iloc索引器属性和numpy.r_的组合实现。

In [4]: named = list("abcdefg")

In [5]: n = 30

In [6]: columns = named + np.arange(len(named), n).tolist()

In [7]: df = pd.DataFrame(np.random.randn(n, n), columns=columns)

In [8]: df.iloc[:, np.r_[:10, 24:30]]
Out[8]: 
 a         b         c  ...        27        28        29
0  -1.344312  0.844885  1.075770  ...  0.813850  0.132003 -0.827317
1  -0.076467 -1.187678  1.130127  ...  0.149748 -0.732339  0.687738
2   0.176444  0.403310 -0.154951  ... -0.493662  0.600178  0.274230
3   0.132885 -0.023688  2.410179  ...  0.109121  1.126203 -0.977349
4   1.474071 -0.064034 -1.282782  ... -0.858447  0.306996 -0.028665
..       ...       ...       ...  ...       ...       ...       ...
25  1.492125 -0.068190  0.681456  ...  0.428572  0.880609  0.487645
26  0.725238  0.624607 -0.141185  ...  1.008500  1.424017  0.717110
27  1.262419  1.950057  0.301038  ...  1.007824  2.826008  1.458383
28 -1.585746 -0.899734  0.921494  ...  0.577223 -1.088417  0.326687
29 -0.986248  0.169729 -1.158091  ... -2.013086 -1.602549  0.333109

[30 rows x 16 columns]

aggregate

在 R 中，您可能希望将数据拆分为子集并为每个子集计算平均值。使用名为df的数据框，并将其拆分为by1和by2组：

df  <-  data.frame(
  v1  =  c(1,3,5,7,8,3,5,NA,4,5,7,9),
  v2  =  c(11,33,55,77,88,33,55,NA,44,55,77,99),
  by1  =  c("red",  "blue",  1,  2,  NA,  "big",  1,  2,  "red",  1,  NA,  12),
  by2  =  c("wet",  "dry",  99,  95,  NA,  "damp",  95,  99,  "red",  99,  NA,  NA))
aggregate(x=df[,  c("v1",  "v2")],  by=list(mydf2$by1,  mydf2$by2),  FUN  =  mean)

groupby()方法类似于基本的 R aggregate函数。

In [9]: df = pd.DataFrame(
 ...:    {
 ...:        "v1": [1, 3, 5, 7, 8, 3, 5, np.nan, 4, 5, 7, 9],
 ...:        "v2": [11, 33, 55, 77, 88, 33, 55, np.nan, 44, 55, 77, 99],
 ...:        "by1": ["red", "blue", 1, 2, np.nan, "big", 1, 2, "red", 1, np.nan, 12],
 ...:        "by2": [
 ...:            "wet",
 ...:            "dry",
 ...:            99,
 ...:            95,
 ...:            np.nan,
 ...:            "damp",
 ...:            95,
 ...:            99,
 ...:            "red",
 ...:            99,
 ...:            np.nan,
 ...:            np.nan,
 ...:        ],
 ...:    }
 ...: )
 ...: 

In [10]: g = df.groupby(["by1", "by2"])

In [11]: g[["v1", "v2"]].mean()
Out[11]: 
 v1    v2
by1  by2 
1    95    5.0  55.0
 99    5.0  55.0
2    95    7.0  77.0
 99    NaN   NaN
big  damp  3.0  33.0
blue dry   3.0  33.0
red  red   4.0  44.0
 wet   1.0  11.0

有关更多详细信息和示例，请参阅分组文档。

match / %in%

在 R 中选择数据的常见方法是使用%in%，该运算符使用函数match定义。运算符%in%用于返回指示是否存在匹配项的逻辑向量：

s  <-  0:4
s  %in%  c(2,4)

isin()方法类似于 R 的%in%运算符：

In [12]: s = pd.Series(np.arange(5), dtype=np.float32)

In [13]: s.isin([2, 4])
Out[13]: 
0    False
1    False
2     True
3    False
4     True
dtype: bool

match函数返回其第一个参数在第二个参数中匹配位置的向量：

s  <-  0:4
match(s,  c(2,4))

有关更多详细信息和示例，请参阅重塑文档。

tapply

tapply类似于aggregate，但数据可以是不规则的数组，因为子类大小可能不规则。使用名为baseball的数据框，并根据数组team检索信息：

baseball  <-
  data.frame(team  =  gl(5,  5,
  labels  =  paste("Team",  LETTERS[1:5])),
  player  =  sample(letters,  25),
  batting.average  =  runif(25,  .200,  .400))

tapply(baseball$batting.average,  baseball.example$team,
  max)

在 pandas 中，我们可以使用pivot_table()方法来处理这个问题：

In [14]: import random

In [15]: import string

In [16]: baseball = pd.DataFrame(
 ....:    {
 ....:        "team": ["team %d" % (x + 1) for x in range(5)] * 5,
 ....:        "player": random.sample(list(string.ascii_lowercase), 25),
 ....:        "batting avg": np.random.uniform(0.200, 0.400, 25),
 ....:    }
 ....: )
 ....: 

In [17]: baseball.pivot_table(values="batting avg", columns="team", aggfunc="max")
Out[17]: 
team           team 1    team 2    team 3    team 4    team 5
batting avg  0.352134  0.295327  0.397191  0.394457  0.396194

有关更多详细信息和示例，请参阅重塑文档。

subset

query()方法类似于基本的 R subset函数。在 R 中，您可能希望获取data.frame的行，其中一列的值小于另一列的值：

df  <-  data.frame(a=rnorm(10),  b=rnorm(10))
subset(df,  a  <=  b)
df[df$a  <=  df$b,]  # note the comma

在 pandas 中，有几种方法可以执行子集。您可以使用query()或将表达式传递为索引/切片，以及标准布尔索引：

In [18]: df = pd.DataFrame({"a": np.random.randn(10), "b": np.random.randn(10)})

In [19]: df.query("a <= b")
Out[19]: 
 a         b
1  0.174950  0.552887
2 -0.023167  0.148084
3 -0.495291 -0.300218
4 -0.860736  0.197378
5 -1.134146  1.720780
7 -0.290098  0.083515
8  0.238636  0.946550

In [20]: df[df["a"] <= df["b"]]
Out[20]: 
 a         b
1  0.174950  0.552887
2 -0.023167  0.148084
3 -0.495291 -0.300218
4 -0.860736  0.197378
5 -1.134146  1.720780
7 -0.290098  0.083515
8  0.238636  0.946550

In [21]: df.loc[df["a"] <= df["b"]]
Out[21]: 
 a         b
1  0.174950  0.552887
2 -0.023167  0.148084
3 -0.495291 -0.300218
4 -0.860736  0.197378
5 -1.134146  1.720780
7 -0.290098  0.083515
8  0.238636  0.946550

有关更多详细信息和示例，请参阅查询文档。

with

在 R 中使用名为df的数据框，其中包含a和b列的表达式将使用with进行评估：

df  <-  data.frame(a=rnorm(10),  b=rnorm(10))
with(df,  a  +  b)
df$a  +  df$b  # same as the previous expression

在 pandas 中，使用eval()方法的等效表达式将是：

In [22]: df = pd.DataFrame({"a": np.random.randn(10), "b": np.random.randn(10)})

In [23]: df.eval("a + b")
Out[23]: 
0   -0.091430
1   -2.483890
2   -0.252728
3   -0.626444
4   -0.261740
5    2.149503
6   -0.332214
7    0.799331
8   -2.377245
9    2.104677
dtype: float64

In [24]: df["a"] + df["b"]  # same as the previous expression
Out[24]: 
0   -0.091430
1   -2.483890
2   -0.252728
3   -0.626444
4   -0.261740
5    2.149503
6   -0.332214
7    0.799331
8   -2.377245
9    2.104677
dtype: float64

在某些情况下，eval() 比纯 Python 中的评估要快得多。更多详细信息和示例请参见 eval 文档。

plyr

plyr 是一个用于数据分析的 R 库，围绕着 R 中的三种数据结构 a（数组）、l（列表）和 d（数据框）展开。下表显示了这些数据结构在 Python 中的映射方式。

R Python
数组 列表
列表 字典或对象列表
data.frame 数据框

ddply

在 R 中使用名为 df 的 data.frame 来按 month 汇总 x 的表达式：

require(plyr)
df  <-  data.frame(
  x  =  runif(120,  1,  168),
  y  =  runif(120,  7,  334),
  z  =  runif(120,  1.7,  20.7),
  month  =  rep(c(5,6,7,8),30),
  week  =  sample(1:4,  120,  TRUE)
)

ddply(df,  .(month,  week),  summarize,
  mean  =  round(mean(x),  2),
  sd  =  round(sd(x),  2))

在 pandas 中，等效的表达式，使用 groupby() 方法，将是：

In [25]: df = pd.DataFrame(
 ....:    {
 ....:        "x": np.random.uniform(1.0, 168.0, 120),
 ....:        "y": np.random.uniform(7.0, 334.0, 120),
 ....:        "z": np.random.uniform(1.7, 20.7, 120),
 ....:        "month": [5, 6, 7, 8] * 30,
 ....:        "week": np.random.randint(1, 4, 120),
 ....:    }
 ....: )
 ....: 

In [26]: grouped = df.groupby(["month", "week"])

In [27]: grouped["x"].agg(["mean", "std"])
Out[27]: 
 mean        std
month week 
5     1      63.653367  40.601965
 2      78.126605  53.342400
 3      92.091886  57.630110
6     1      81.747070  54.339218
 2      70.971205  54.687287
 3     100.968344  54.010081
7     1      61.576332  38.844274
 2      61.733510  48.209013
 3      71.688795  37.595638
8     1      62.741922  34.618153
 2      91.774627  49.790202
 3      73.936856  60.773900

更多详细信息和示例请参见 分组文档。

reshape / reshape2

meltarray

在 R 中使用名为 a 的 3 维数组来将其融合成一个 data.frame 的表达式：

a  <-  array(c(1:23,  NA),  c(2,3,4))
data.frame(melt(a))

在 Python 中，由于 a 是一个列表，你可以简单地使用列表推导式。

In [28]: a = np.array(list(range(1, 24)) + [np.NAN]).reshape(2, 3, 4)

In [29]: pd.DataFrame([tuple(list(x) + [val]) for x, val in np.ndenumerate(a)])
Out[29]: 
 0  1  2     3
0   0  0  0   1.0
1   0  0  1   2.0
2   0  0  2   3.0
3   0  0  3   4.0
4   0  1  0   5.0
.. .. .. ..   ...
19  1  1  3  20.0
20  1  2  0  21.0
21  1  2  1  22.0
22  1  2  2  23.0
23  1  2  3   NaN

[24 rows x 4 columns]

meltlist

在 R 中使用名为 a 的列表来将其融合成一个 data.frame 的表达式：

a  <-  as.list(c(1:4,  NA))
data.frame(melt(a))

在 Python 中，这个列表将是一个元组的列表，因此 DataFrame() 方法将其转换为所需的数据框。

In [30]: a = list(enumerate(list(range(1, 5)) + [np.NAN]))

In [31]: pd.DataFrame(a)
Out[31]: 
 0    1
0  0  1.0
1  1  2.0
2  2  3.0
3  3  4.0
4  4  NaN

更多详细信息和示例请参见 数据结构入门文档。

meltdf

在 R 中使用名为 cheese 的 data.frame 来重新塑造数据框的表达式：

cheese  <-  data.frame(
  first  =  c('John',  'Mary'),
  last  =  c('Doe',  'Bo'),
  height  =  c(5.5,  6.0),
  weight  =  c(130,  150)
)
melt(cheese,  id=c("first",  "last"))

在 Python 中，melt() 方法是 R 中的等效方法：

In [32]: cheese = pd.DataFrame(
 ....:    {
 ....:        "first": ["John", "Mary"],
 ....:        "last": ["Doe", "Bo"],
 ....:        "height": [5.5, 6.0],
 ....:        "weight": [130, 150],
 ....:    }
 ....: )
 ....: 

In [33]: pd.melt(cheese, id_vars=["first", "last"])
Out[33]: 
 first last variable  value
0  John  Doe   height    5.5
1  Mary   Bo   height    6.0
2  John  Doe   weight  130.0
3  Mary   Bo   weight  150.0

In [34]: cheese.set_index(["first", "last"]).stack(future_stack=True)  # alternative way
Out[34]: 
first  last 
John   Doe   height      5.5
 weight    130.0
Mary   Bo    height      6.0
 weight    150.0
dtype: float64

更多详细信息和示例请参见 重塑文档。

cast

在 R 中，acast 是使用名为 df 的 data.frame 来转换为更高维数组的表达式：

df  <-  data.frame(
  x  =  runif(12,  1,  168),
  y  =  runif(12,  7,  334),
  z  =  runif(12,  1.7,  20.7),
  month  =  rep(c(5,6,7),4),
  week  =  rep(c(1,2),  6)
)

mdf  <-  melt(df,  id=c("month",  "week"))
acast(mdf,  week  ~  month  ~  variable,  mean)

在 Python 中，最好的方法是利用 pivot_table()：

In [35]: df = pd.DataFrame(
 ....:    {
 ....:        "x": np.random.uniform(1.0, 168.0, 12),
 ....:        "y": np.random.uniform(7.0, 334.0, 12),
 ....:        "z": np.random.uniform(1.7, 20.7, 12),
 ....:        "month": [5, 6, 7] * 4,
 ....:        "week": [1, 2] * 6,
 ....:    }
 ....: )
 ....: 

In [36]: mdf = pd.melt(df, id_vars=["month", "week"])

In [37]: pd.pivot_table(
 ....:    mdf,
 ....:    values="value",
 ....:    index=["variable", "week"],
 ....:    columns=["month"],
 ....:    aggfunc="mean",
 ....: )
 ....: 
Out[37]: 
month                  5           6           7
variable week 
x        1     93.888747   98.762034   55.219673
 2     94.391427   38.112932   83.942781
y        1     94.306912  279.454811  227.840449
 2     87.392662  193.028166  173.899260
z        1     11.016009   10.079307   16.170549
 2      8.476111   17.638509   19.003494

类似于在 R 中使用名为 df 的 data.frame 来基于 Animal 和 FeedType 聚合信息的 dcast：

df  <-  data.frame(
  Animal  =  c('Animal1',  'Animal2',  'Animal3',  'Animal2',  'Animal1',
  'Animal2',  'Animal3'),
  FeedType  =  c('A',  'B',  'A',  'A',  'B',  'B',  'A'),
  Amount  =  c(10,  7,  4,  2,  5,  6,  2)
)

dcast(df,  Animal  ~  FeedType,  sum,  fill=NaN)
# Alternative method using base R
with(df,  tapply(Amount,  list(Animal,  FeedType),  sum))

Python 可以通过两种不同的方式来处理这个问题。首先，类似于上面使用 pivot_table()：

In [38]: df = pd.DataFrame(
 ....:    {
 ....:        "Animal": [
 ....:            "Animal1",
 ....:            "Animal2",
 ....:            "Animal3",
 ....:            "Animal2",
 ....:            "Animal1",
 ....:            "Animal2",
 ....:            "Animal3",
 ....:        ],
 ....:        "FeedType": ["A", "B", "A", "A", "B", "B", "A"],
 ....:        "Amount": [10, 7, 4, 2, 5, 6, 2],
 ....:    }
 ....: )
 ....: 

In [39]: df.pivot_table(values="Amount", index="Animal", columns="FeedType", aggfunc="sum")
Out[39]: 
FeedType     A     B
Animal 
Animal1   10.0   5.0
Animal2    2.0  13.0
Animal3    6.0   NaN

第二种方法是使用 groupby() 方法：

In [40]: df.groupby(["Animal", "FeedType"])["Amount"].sum()
Out[40]: 
Animal   FeedType
Animal1  A           10
 B            5
Animal2  A            2
 B           13
Animal3  A            6
Name: Amount, dtype: int64

更多详细信息和示例请参见 重塑文档 或 分组文档。

factor

pandas 有一种用于分类数据的数据类型。

cut(c(1,2,3,4,5,6),  3)
factor(c(1,2,3,2,2,3))

在 pandas 中可以用 pd.cut 和 astype("category") 实现：

In [41]: pd.cut(pd.Series([1, 2, 3, 4, 5, 6]), 3)
Out[41]: 
0    (0.995, 2.667]
1    (0.995, 2.667]
2    (2.667, 4.333]
3    (2.667, 4.333]
4      (4.333, 6.0]
5      (4.333, 6.0]
dtype: category
Categories (3, interval[float64, right]): [(0.995, 2.667] < (2.667, 4.333] < (4.333, 6.0]]

In [42]: pd.Series([1, 2, 3, 2, 2, 3]).astype("category")
Out[42]: 
0    1
1    2
2    3
3    2
4    2
5    3
dtype: category
Categories (3, int64): [1, 2, 3]

更多详情和示例请参阅 分类简介 和 API 文档。还有关于 与 R 的因子的区别 的文档。

快速参考

我们将从一个快速参考指南开始，将一些常见的 R 操作（使用 dplyr）与 pandas 的等价操作进行对比。

查询、过滤、抽样

R pandas
dim(df) df.shape
head(df) df.head()
slice(df, 1:10) df.iloc[:9]
filter(df, col1 == 1, col2 == 1) df.query('col1 == 1 & col2 == 1')
df[df$col1 == 1 & df$col2 == 1,] df[(df.col1 == 1) & (df.col2 == 1)]
select(df, col1, col2) df[['col1', 'col2']]
select(df, col1:col3) df.loc[:, 'col1':'col3']
select(df, -(col1:col3)) df.drop(cols_to_drop, axis=1) 但见 [1]
distinct(select(df, col1)) df[['col1']].drop_duplicates()
distinct(select(df, col1, col2)) df[['col1', 'col2']].drop_duplicates()
sample_n(df, 10) df.sample(n=10)
sample_frac(df, 0.01) df.sample(frac=0.01)

排序

R pandas
arrange(df, col1, col2) df.sort_values(['col1', 'col2'])
arrange(df, desc(col1)) df.sort_values('col1', ascending=False)

转换

R pandas
select(df, col_one = col1) df.rename(columns={'col1': 'col_one'})['col_one']
rename(df, col_one = col1) df.rename(columns={'col1': 'col_one'})
mutate(df, c=a-b) df.assign(c=df['a']-df['b'])

分组和汇总

R pandas
summary(df) df.describe()
gdf <- group_by(df, col1) gdf = df.groupby('col1')
summarise(gdf, avg=mean(col1, na.rm=TRUE)) df.groupby('col1').agg({'col1': 'mean'})
summarise(gdf, total=sum(col1)) df.groupby('col1').sum()

查询、过滤、抽样

R pandas
dim(df) df.shape
head(df) df.head()
slice(df, 1:10) df.iloc[:9]
filter(df, col1 == 1, col2 == 1) df.query('col1 == 1 & col2 == 1')
df[df$col1 == 1 & df$col2 == 1,] df[(df.col1 == 1) & (df.col2 == 1)]
select(df, col1, col2) df[['col1', 'col2']]
select(df, col1:col3) df.loc[:, 'col1':'col3']
select(df, -(col1:col3)) df.drop(cols_to_drop, axis=1) 但见 [1]
distinct(select(df, col1)) df[['col1']].drop_duplicates()
distinct(select(df, col1, col2)) df[['col1', 'col2']].drop_duplicates()
sample_n(df, 10) df.sample(n=10)
sample_frac(df, 0.01) df.sample(frac=0.01)

排序

R pandas
arrange(df, col1, col2) df.sort_values(['col1', 'col2'])
arrange(df, desc(col1)) df.sort_values('col1', ascending=False)

转换

R pandas
select(df, col_one = col1) df.rename(columns={'col1': 'col_one'})['col_one']
rename(df, col_one = col1) df.rename(columns={'col1': 'col_one'})
mutate(df, c=a-b) df.assign(c=df['a']-df['b'])

分组和汇总

R pandas
summary(df) df.describe()
gdf <- group_by(df, col1) gdf = df.groupby('col1')
summarise(gdf, avg=mean(col1, na.rm=TRUE)) df.groupby('col1').agg({'col1': 'mean'})
summarise(gdf, total=sum(col1)) df.groupby('col1').sum()

基本 R

使用 R 的 c 进行切片

R 使得通过名称轻松访问 data.frame 列

df  <-  data.frame(a=rnorm(5),  b=rnorm(5),  c=rnorm(5),  d=rnorm(5),  e=rnorm(5))
df[,  c("a",  "c",  "e")]

或通过整数位置

df  <-  data.frame(matrix(rnorm(1000),  ncol=100))
df[,  c(1:10,  25:30,  40,  50:100)]

在 pandas 中通过名称选择多列很简单

In [1]: df = pd.DataFrame(np.random.randn(10, 3), columns=list("abc"))

In [2]: df[["a", "c"]]
Out[2]: 
 a         c
0  0.469112 -1.509059
1 -1.135632 -0.173215
2  0.119209 -0.861849
3 -2.104569  1.071804
4  0.721555 -1.039575
5  0.271860  0.567020
6  0.276232 -0.673690
7  0.113648  0.524988
8  0.404705 -1.715002
9 -1.039268 -1.157892

In [3]: df.loc[:, ["a", "c"]]
Out[3]: 
 a         c
0  0.469112 -1.509059
1 -1.135632 -0.173215
2  0.119209 -0.861849
3 -2.104569  1.071804
4  0.721555 -1.039575
5  0.271860  0.567020
6  0.276232 -0.673690
7  0.113648  0.524988
8  0.404705 -1.715002
9 -1.039268 -1.157892

通过整数位置选择多个不连续的列可以通过 iloc 索引器属性和 numpy.r_ 的组合实现。

In [4]: named = list("abcdefg")

In [5]: n = 30

In [6]: columns = named + np.arange(len(named), n).tolist()

In [7]: df = pd.DataFrame(np.random.randn(n, n), columns=columns)

In [8]: df.iloc[:, np.r_[:10, 24:30]]
Out[8]: 
 a         b         c  ...        27        28        29
0  -1.344312  0.844885  1.075770  ...  0.813850  0.132003 -0.827317
1  -0.076467 -1.187678  1.130127  ...  0.149748 -0.732339  0.687738
2   0.176444  0.403310 -0.154951  ... -0.493662  0.600178  0.274230
3   0.132885 -0.023688  2.410179  ...  0.109121  1.126203 -0.977349
4   1.474071 -0.064034 -1.282782  ... -0.858447  0.306996 -0.028665
..       ...       ...       ...  ...       ...       ...       ...
25  1.492125 -0.068190  0.681456  ...  0.428572  0.880609  0.487645
26  0.725238  0.624607 -0.141185  ...  1.008500  1.424017  0.717110
27  1.262419  1.950057  0.301038  ...  1.007824  2.826008  1.458383
28 -1.585746 -0.899734  0.921494  ...  0.577223 -1.088417  0.326687
29 -0.986248  0.169729 -1.158091  ... -2.013086 -1.602549  0.333109

[30 rows x 16 columns]

aggregate

在 R 中，您可能希望将数据拆分为子集，并为每个子集计算平均值。使用名为 df 的数据框，并将其拆分为 by1 和 by2 组：

df  <-  data.frame(
  v1  =  c(1,3,5,7,8,3,5,NA,4,5,7,9),
  v2  =  c(11,33,55,77,88,33,55,NA,44,55,77,99),
  by1  =  c("red",  "blue",  1,  2,  NA,  "big",  1,  2,  "red",  1,  NA,  12),
  by2  =  c("wet",  "dry",  99,  95,  NA,  "damp",  95,  99,  "red",  99,  NA,  NA))
aggregate(x=df[,  c("v1",  "v2")],  by=list(mydf2$by1,  mydf2$by2),  FUN  =  mean)

groupby() 方法类似于基本的 R aggregate 函数。

In [9]: df = pd.DataFrame(
 ...:    {
 ...:        "v1": [1, 3, 5, 7, 8, 3, 5, np.nan, 4, 5, 7, 9],
 ...:        "v2": [11, 33, 55, 77, 88, 33, 55, np.nan, 44, 55, 77, 99],
 ...:        "by1": ["red", "blue", 1, 2, np.nan, "big", 1, 2, "red", 1, np.nan, 12],
 ...:        "by2": [
 ...:            "wet",
 ...:            "dry",
 ...:            99,
 ...:            95,
 ...:            np.nan,
 ...:            "damp",
 ...:            95,
 ...:            99,
 ...:            "red",
 ...:            99,
 ...:            np.nan,
 ...:            np.nan,
 ...:        ],
 ...:    }
 ...: )
 ...: 

In [10]: g = df.groupby(["by1", "by2"])

In [11]: g[["v1", "v2"]].mean()
Out[11]: 
 v1    v2
by1  by2 
1    95    5.0  55.0
 99    5.0  55.0
2    95    7.0  77.0
 99    NaN   NaN
big  damp  3.0  33.0
blue dry   3.0  33.0
red  red   4.0  44.0
 wet   1.0  11.0

有关更多详细信息和示例，请参阅分组文档。

match / %in%

用 %in% 在 R 中选择数据的常见方法是使用 match 函数定义的。操作符 %in% 用于返回一个逻辑向量，指示是否有匹配项：

s  <-  0:4
s  %in%  c(2,4)

isin() 方法类似于 R 的 %in% 操作符：

In [12]: s = pd.Series(np.arange(5), dtype=np.float32)

In [13]: s.isin([2, 4])
Out[13]: 
0    False
1    False
2     True
3    False
4     True
dtype: bool

match 函数返回其第一个参数在第二个参数中的匹配位置的向量：

s  <-  0:4
match(s,  c(2,4))

有关更多详细信息和示例，请参阅重塑文档。

tapply

tapply 类似于 aggregate，但数据可以是不规则的，因为子类大小可能不规则。使用名为 baseball 的数据框，并根据数组 team 检索信息：

baseball  <-
  data.frame(team  =  gl(5,  5,
  labels  =  paste("Team",  LETTERS[1:5])),
  player  =  sample(letters,  25),
  batting.average  =  runif(25,  .200,  .400))

tapply(baseball$batting.average,  baseball.example$team,
  max)

在 pandas 中，我们可以使用 pivot_table() 方法来处理这个问题：

In [14]: import random

In [15]: import string

In [16]: baseball = pd.DataFrame(
 ....:    {
 ....:        "team": ["team %d" % (x + 1) for x in range(5)] * 5,
 ....:        "player": random.sample(list(string.ascii_lowercase), 25),
 ....:        "batting avg": np.random.uniform(0.200, 0.400, 25),
 ....:    }
 ....: )
 ....: 

In [17]: baseball.pivot_table(values="batting avg", columns="team", aggfunc="max")
Out[17]: 
team           team 1    team 2    team 3    team 4    team 5
batting avg  0.352134  0.295327  0.397191  0.394457  0.396194

有关更多详细信息和示例，请参阅重塑文档。

subset

query()方法类似于基本的 R subset 函数。在 R 中，您可能希望获取data.frame的行，其中一列的值小于另一列的值：

df  <-  data.frame(a=rnorm(10),  b=rnorm(10))
subset(df,  a  <=  b)
df[df$a  <=  df$b,]  # note the comma

在 pandas 中，有几种执行子集的方法。您可以使用query()或将表达式传递为索引/切片，以及标准布尔索引：

In [18]: df = pd.DataFrame({"a": np.random.randn(10), "b": np.random.randn(10)})

In [19]: df.query("a <= b")
Out[19]: 
 a         b
1  0.174950  0.552887
2 -0.023167  0.148084
3 -0.495291 -0.300218
4 -0.860736  0.197378
5 -1.134146  1.720780
7 -0.290098  0.083515
8  0.238636  0.946550

In [20]: df[df["a"] <= df["b"]]
Out[20]: 
 a         b
1  0.174950  0.552887
2 -0.023167  0.148084
3 -0.495291 -0.300218
4 -0.860736  0.197378
5 -1.134146  1.720780
7 -0.290098  0.083515
8  0.238636  0.946550

In [21]: df.loc[df["a"] <= df["b"]]
Out[21]: 
 a         b
1  0.174950  0.552887
2 -0.023167  0.148084
3 -0.495291 -0.300218
4 -0.860736  0.197378
5 -1.134146  1.720780
7 -0.290098  0.083515
8  0.238636  0.946550

更多详细信息和示例请参见查询文档。

with

在 R 中使用名为df的数据框（data.frame）和列a和b的表达式将使用with进行评估，如下所示：

df  <-  data.frame(a=rnorm(10),  b=rnorm(10))
with(df,  a  +  b)
df$a  +  df$b  # same as the previous expression

在 pandas 中，使用eval()方法的等价表达式将是：

In [22]: df = pd.DataFrame({"a": np.random.randn(10), "b": np.random.randn(10)})

In [23]: df.eval("a + b")
Out[23]: 
0   -0.091430
1   -2.483890
2   -0.252728
3   -0.626444
4   -0.261740
5    2.149503
6   -0.332214
7    0.799331
8   -2.377245
9    2.104677
dtype: float64

In [24]: df["a"] + df["b"]  # same as the previous expression
Out[24]: 
0   -0.091430
1   -2.483890
2   -0.252728
3   -0.626444
4   -0.261740
5    2.149503
6   -0.332214
7    0.799331
8   -2.377245
9    2.104677
dtype: float64

在某些情况下，eval()比纯 Python 中的评估要快得多。更多详细信息和示例请参见评估文档。

使用 R 的c进行切片

R 可以轻松通过名称访问data.frame列

df  <-  data.frame(a=rnorm(5),  b=rnorm(5),  c=rnorm(5),  d=rnorm(5),  e=rnorm(5))
df[,  c("a",  "c",  "e")]

或通过整数位置

df  <-  data.frame(matrix(rnorm(1000),  ncol=100))
df[,  c(1:10,  25:30,  40,  50:100)]

在 pandas 中按名称选择多个列非常简单

In [1]: df = pd.DataFrame(np.random.randn(10, 3), columns=list("abc"))

In [2]: df[["a", "c"]]
Out[2]: 
 a         c
0  0.469112 -1.509059
1 -1.135632 -0.173215
2  0.119209 -0.861849
3 -2.104569  1.071804
4  0.721555 -1.039575
5  0.271860  0.567020
6  0.276232 -0.673690
7  0.113648  0.524988
8  0.404705 -1.715002
9 -1.039268 -1.157892

In [3]: df.loc[:, ["a", "c"]]
Out[3]: 
 a         c
0  0.469112 -1.509059
1 -1.135632 -0.173215
2  0.119209 -0.861849
3 -2.104569  1.071804
4  0.721555 -1.039575
5  0.271860  0.567020
6  0.276232 -0.673690
7  0.113648  0.524988
8  0.404705 -1.715002
9 -1.039268 -1.157892

通过iloc索引器属性和numpy.r_的组合可以实现通过整数位置选择多个非连续列。

In [4]: named = list("abcdefg")

In [5]: n = 30

In [6]: columns = named + np.arange(len(named), n).tolist()

In [7]: df = pd.DataFrame(np.random.randn(n, n), columns=columns)

In [8]: df.iloc[:, np.r_[:10, 24:30]]
Out[8]: 
 a         b         c  ...        27        28        29
0  -1.344312  0.844885  1.075770  ...  0.813850  0.132003 -0.827317
1  -0.076467 -1.187678  1.130127  ...  0.149748 -0.732339  0.687738
2   0.176444  0.403310 -0.154951  ... -0.493662  0.600178  0.274230
3   0.132885 -0.023688  2.410179  ...  0.109121  1.126203 -0.977349
4   1.474071 -0.064034 -1.282782  ... -0.858447  0.306996 -0.028665
..       ...       ...       ...  ...       ...       ...       ...
25  1.492125 -0.068190  0.681456  ...  0.428572  0.880609  0.487645
26  0.725238  0.624607 -0.141185  ...  1.008500  1.424017  0.717110
27  1.262419  1.950057  0.301038  ...  1.007824  2.826008  1.458383
28 -1.585746 -0.899734  0.921494  ...  0.577223 -1.088417  0.326687
29 -0.986248  0.169729 -1.158091  ... -2.013086 -1.602549  0.333109

[30 rows x 16 columns]

aggregate

在 R 中，您可能希望将数据拆分为子集并为每个子集计算平均值。使用名为df的数据框，并将其拆分为组by1和by2：

df  <-  data.frame(
  v1  =  c(1,3,5,7,8,3,5,NA,4,5,7,9),
  v2  =  c(11,33,55,77,88,33,55,NA,44,55,77,99),
  by1  =  c("red",  "blue",  1,  2,  NA,  "big",  1,  2,  "red",  1,  NA,  12),
  by2  =  c("wet",  "dry",  99,  95,  NA,  "damp",  95,  99,  "red",  99,  NA,  NA))
aggregate(x=df[,  c("v1",  "v2")],  by=list(mydf2$by1,  mydf2$by2),  FUN  =  mean)

groupby()方法类似于基本的 R aggregate 函数。

In [9]: df = pd.DataFrame(
 ...:    {
 ...:        "v1": [1, 3, 5, 7, 8, 3, 5, np.nan, 4, 5, 7, 9],
 ...:        "v2": [11, 33, 55, 77, 88, 33, 55, np.nan, 44, 55, 77, 99],
 ...:        "by1": ["red", "blue", 1, 2, np.nan, "big", 1, 2, "red", 1, np.nan, 12],
 ...:        "by2": [
 ...:            "wet",
 ...:            "dry",
 ...:            99,
 ...:            95,
 ...:            np.nan,
 ...:            "damp",
 ...:            95,
 ...:            99,
 ...:            "red",
 ...:            99,
 ...:            np.nan,
 ...:            np.nan,
 ...:        ],
 ...:    }
 ...: )
 ...: 

In [10]: g = df.groupby(["by1", "by2"])

In [11]: g[["v1", "v2"]].mean()
Out[11]: 
 v1    v2
by1  by2 
1    95    5.0  55.0
 99    5.0  55.0
2    95    7.0  77.0
 99    NaN   NaN
big  damp  3.0  33.0
blue dry   3.0  33.0
red  red   4.0  44.0
 wet   1.0  11.0

更多详细信息和示例请参见分组文档。

match / %in%

在 R 中选择数据的常见方式是使用%in%，该运算符使用match函数定义。运算符%in%用于返回一个逻辑向量，指示是否存在匹配项：

s  <-  0:4
s  %in%  c(2,4)

isin()方法类似于 R 的%in%运算符：

In [12]: s = pd.Series(np.arange(5), dtype=np.float32)

In [13]: s.isin([2, 4])
Out[13]: 
0    False
1    False
2     True
3    False
4     True
dtype: bool

match函数返回其第一个参数在第二个参数中匹配位置的向量：

s  <-  0:4
match(s,  c(2,4))

更多详细信息和示例请参见重塑文档。

tapply

tapply 类似于 aggregate，但数据可以是不规则的数组，因为子类大小可能不规则。使用名为 baseball 的 data.frame，并根据数组 team 检索信息：

baseball  <-
  data.frame(team  =  gl(5,  5,
  labels  =  paste("Team",  LETTERS[1:5])),
  player  =  sample(letters,  25),
  batting.average  =  runif(25,  .200,  .400))

tapply(baseball$batting.average,  baseball.example$team,
  max)

在 pandas 中，我们可以使用pivot_table()方法来处理这个问题：

In [14]: import random

In [15]: import string

In [16]: baseball = pd.DataFrame(
 ....:    {
 ....:        "team": ["team %d" % (x + 1) for x in range(5)] * 5,
 ....:        "player": random.sample(list(string.ascii_lowercase), 25),
 ....:        "batting avg": np.random.uniform(0.200, 0.400, 25),
 ....:    }
 ....: )
 ....: 

In [17]: baseball.pivot_table(values="batting avg", columns="team", aggfunc="max")
Out[17]: 
team           team 1    team 2    team 3    team 4    team 5
batting avg  0.352134  0.295327  0.397191  0.394457  0.396194

更多详细信息和示例请参见重塑文档。

subset

query()方法类似于基本的 R subset 函数。在 R 中，您可能希望获取 data.frame 的行，其中一个列的值小于另一个列的值：

df  <-  data.frame(a=rnorm(10),  b=rnorm(10))
subset(df,  a  <=  b)
df[df$a  <=  df$b,]  # note the comma

在 pandas 中，有几种方法可以执行子集。您可以使用query()或将表达式传递为索引/切片，以及标准布尔索引：

In [18]: df = pd.DataFrame({"a": np.random.randn(10), "b": np.random.randn(10)})

In [19]: df.query("a <= b")
Out[19]: 
 a         b
1  0.174950  0.552887
2 -0.023167  0.148084
3 -0.495291 -0.300218
4 -0.860736  0.197378
5 -1.134146  1.720780
7 -0.290098  0.083515
8  0.238636  0.946550

In [20]: df[df["a"] <= df["b"]]
Out[20]: 
 a         b
1  0.174950  0.552887
2 -0.023167  0.148084
3 -0.495291 -0.300218
4 -0.860736  0.197378
5 -1.134146  1.720780
7 -0.290098  0.083515
8  0.238636  0.946550

In [21]: df.loc[df["a"] <= df["b"]]
Out[21]: 
 a         b
1  0.174950  0.552887
2 -0.023167  0.148084
3 -0.495291 -0.300218
4 -0.860736  0.197378
5 -1.134146  1.720780
7 -0.290098  0.083515
8  0.238636  0.946550

更多详细信息和示例请参见查询文档。

with

在 R 中使用名为 df 的 data.frame，具有列 a 和 b，将使用 with 进行评估，如下所示：

df  <-  data.frame(a=rnorm(10),  b=rnorm(10))
with(df,  a  +  b)
df$a  +  df$b  # same as the previous expression

在 pandas 中，等效的��达式，使用eval()方法，将是：

In [22]: df = pd.DataFrame({"a": np.random.randn(10), "b": np.random.randn(10)})

In [23]: df.eval("a + b")
Out[23]: 
0   -0.091430
1   -2.483890
2   -0.252728
3   -0.626444
4   -0.261740
5    2.149503
6   -0.332214
7    0.799331
8   -2.377245
9    2.104677
dtype: float64

In [24]: df["a"] + df["b"]  # same as the previous expression
Out[24]: 
0   -0.091430
1   -2.483890
2   -0.252728
3   -0.626444
4   -0.261740
5    2.149503
6   -0.332214
7    0.799331
8   -2.377245
9    2.104677
dtype: float64

在某些情况下，eval()比纯 Python 中的评估要快得多。更多详细信息和示例请参见 eval 文档。

plyr

plyr 是用于数据分析的分割-应用-组合策略的 R 库。这些函数围绕 R 中的三种数据结构展开，a 代表 arrays，l 代表 lists，d 代表 data.frame。下表显示了这些数据结构在 Python 中的映射方式。

R Python
array list
lists 字典或对象列表
data.frame dataframe

ddply

在 R 中使用名为 df 的 data.frame 表达式，您想要按 month 汇总 x：

require(plyr)
df  <-  data.frame(
  x  =  runif(120,  1,  168),
  y  =  runif(120,  7,  334),
  z  =  runif(120,  1.7,  20.7),
  month  =  rep(c(5,6,7,8),30),
  week  =  sample(1:4,  120,  TRUE)
)

ddply(df,  .(month,  week),  summarize,
  mean  =  round(mean(x),  2),
  sd  =  round(sd(x),  2))

在 pandas 中，等效的表达式，使用groupby()方法，将是：

In [25]: df = pd.DataFrame(
 ....:    {
 ....:        "x": np.random.uniform(1.0, 168.0, 120),
 ....:        "y": np.random.uniform(7.0, 334.0, 120),
 ....:        "z": np.random.uniform(1.7, 20.7, 120),
 ....:        "month": [5, 6, 7, 8] * 30,
 ....:        "week": np.random.randint(1, 4, 120),
 ....:    }
 ....: )
 ....: 

In [26]: grouped = df.groupby(["month", "week"])

In [27]: grouped["x"].agg(["mean", "std"])
Out[27]: 
 mean        std
month week 
5     1      63.653367  40.601965
 2      78.126605  53.342400
 3      92.091886  57.630110
6     1      81.747070  54.339218
 2      70.971205  54.687287
 3     100.968344  54.010081
7     1      61.576332  38.844274
 2      61.733510  48.209013
 3      71.688795  37.595638
8     1      62.741922  34.618153
 2      91.774627  49.790202
 3      73.936856  60.773900

更多详细信息和示例请参见分组文档。

ddply

在 R 中使用名为 df 的 data.frame 表达式，您想要按 month 汇总 x：

require(plyr)
df  <-  data.frame(
  x  =  runif(120,  1,  168),
  y  =  runif(120,  7,  334),
  z  =  runif(120,  1.7,  20.7),
  month  =  rep(c(5,6,7,8),30),
  week  =  sample(1:4,  120,  TRUE)
)

ddply(df,  .(month,  week),  summarize,
  mean  =  round(mean(x),  2),
  sd  =  round(sd(x),  2))

在 pandas 中，等效的表达式，使用groupby()方法，将是：

In [25]: df = pd.DataFrame(
 ....:    {
 ....:        "x": np.random.uniform(1.0, 168.0, 120),
 ....:        "y": np.random.uniform(7.0, 334.0, 120),
 ....:        "z": np.random.uniform(1.7, 20.7, 120),
 ....:        "month": [5, 6, 7, 8] * 30,
 ....:        "week": np.random.randint(1, 4, 120),
 ....:    }
 ....: )
 ....: 

In [26]: grouped = df.groupby(["month", "week"])

In [27]: grouped["x"].agg(["mean", "std"])
Out[27]: 
 mean        std
month week 
5     1      63.653367  40.601965
 2      78.126605  53.342400
 3      92.091886  57.630110
6     1      81.747070  54.339218
 2      70.971205  54.687287
 3     100.968344  54.010081
7     1      61.576332  38.844274
 2      61.733510  48.209013
 3      71.688795  37.595638
8     1      62.741922  34.618153
 2      91.774627  49.790202
 3      73.936856  60.773900

更多细节和示例请参见分组文档。

reshape / reshape2

meltarray

在 R 中使用名为a的三维数组的表达式，你想要将其融化成数据框：

a  <-  array(c(1:23,  NA),  c(2,3,4))
data.frame(melt(a))

在 Python 中，由于a是一个列表，你可以简单地使用列表推导式。

In [28]: a = np.array(list(range(1, 24)) + [np.NAN]).reshape(2, 3, 4)

In [29]: pd.DataFrame([tuple(list(x) + [val]) for x, val in np.ndenumerate(a)])
Out[29]: 
 0  1  2     3
0   0  0  0   1.0
1   0  0  1   2.0
2   0  0  2   3.0
3   0  0  3   4.0
4   0  1  0   5.0
.. .. .. ..   ...
19  1  1  3  20.0
20  1  2  0  21.0
21  1  2  1  22.0
22  1  2  2  23.0
23  1  2  3   NaN

[24 rows x 4 columns]

meltlist

在 R 中使用名为a的列表的表达式，你想要将其融化成数据框：

a  <-  as.list(c(1:4,  NA))
data.frame(melt(a))

在 Python 中，这个列表将是一个元组的列表，所以DataFrame()方法会将其转换为所需的数据框。

In [30]: a = list(enumerate(list(range(1, 5)) + [np.NAN]))

In [31]: pd.DataFrame(a)
Out[31]: 
 0    1
0  0  1.0
1  1  2.0
2  2  3.0
3  3  4.0
4  4  NaN

更多细节和示例请参见数据结构介绍文档。

meltdf

在 R 中使用名为cheese的数据框的表达式，你想要重塑数据框：

cheese  <-  data.frame(
  first  =  c('John',  'Mary'),
  last  =  c('Doe',  'Bo'),
  height  =  c(5.5,  6.0),
  weight  =  c(130,  150)
)
melt(cheese,  id=c("first",  "last"))

在 Python 中，melt()方法是 R 的等价物：

In [32]: cheese = pd.DataFrame(
 ....:    {
 ....:        "first": ["John", "Mary"],
 ....:        "last": ["Doe", "Bo"],
 ....:        "height": [5.5, 6.0],
 ....:        "weight": [130, 150],
 ....:    }
 ....: )
 ....: 

In [33]: pd.melt(cheese, id_vars=["first", "last"])
Out[33]: 
 first last variable  value
0  John  Doe   height    5.5
1  Mary   Bo   height    6.0
2  John  Doe   weight  130.0
3  Mary   Bo   weight  150.0

In [34]: cheese.set_index(["first", "last"]).stack(future_stack=True)  # alternative way
Out[34]: 
first  last 
John   Doe   height      5.5
 weight    130.0
Mary   Bo    height      6.0
 weight    150.0
dtype: float64

更多细节和示��请参见重塑文档。

转换

在 R 中，acast是一个使用名为df的数据框来转换为更高维数组的表达式：

df  <-  data.frame(
  x  =  runif(12,  1,  168),
  y  =  runif(12,  7,  334),
  z  =  runif(12,  1.7,  20.7),
  month  =  rep(c(5,6,7),4),
  week  =  rep(c(1,2),  6)
)

mdf  <-  melt(df,  id=c("month",  "week"))
acast(mdf,  week  ~  month  ~  variable,  mean)

在 Python 中，最好的方法是利用pivot_table()：

In [35]: df = pd.DataFrame(
 ....:    {
 ....:        "x": np.random.uniform(1.0, 168.0, 12),
 ....:        "y": np.random.uniform(7.0, 334.0, 12),
 ....:        "z": np.random.uniform(1.7, 20.7, 12),
 ....:        "month": [5, 6, 7] * 4,
 ....:        "week": [1, 2] * 6,
 ....:    }
 ....: )
 ....: 

In [36]: mdf = pd.melt(df, id_vars=["month", "week"])

In [37]: pd.pivot_table(
 ....:    mdf,
 ....:    values="value",
 ....:    index=["variable", "week"],
 ....:    columns=["month"],
 ....:    aggfunc="mean",
 ....: )
 ....: 
Out[37]: 
month                  5           6           7
variable week 
x        1     93.888747   98.762034   55.219673
 2     94.391427   38.112932   83.942781
y        1     94.306912  279.454811  227.840449
 2     87.392662  193.028166  173.899260
z        1     11.016009   10.079307   16.170549
 2      8.476111   17.638509   19.003494

类似于dcast，它使用在 R 中名为df的数据框来根据Animal和FeedType聚合信息的表达式：

df  <-  data.frame(
  Animal  =  c('Animal1',  'Animal2',  'Animal3',  'Animal2',  'Animal1',
  'Animal2',  'Animal3'),
  FeedType  =  c('A',  'B',  'A',  'A',  'B',  'B',  'A'),
  Amount  =  c(10,  7,  4,  2,  5,  6,  2)
)

dcast(df,  Animal  ~  FeedType,  sum,  fill=NaN)
# Alternative method using base R
with(df,  tapply(Amount,  list(Animal,  FeedType),  sum))

Python 可以用两种不同的方式来处理这个问题。首先，类似于上面使用pivot_table()：

In [38]: df = pd.DataFrame(
 ....:    {
 ....:        "Animal": [
 ....:            "Animal1",
 ....:            "Animal2",
 ....:            "Animal3",
 ....:            "Animal2",
 ....:            "Animal1",
 ....:            "Animal2",
 ....:            "Animal3",
 ....:        ],
 ....:        "FeedType": ["A", "B", "A", "A", "B", "B", "A"],
 ....:        "Amount": [10, 7, 4, 2, 5, 6, 2],
 ....:    }
 ....: )
 ....: 

In [39]: df.pivot_table(values="Amount", index="Animal", columns="FeedType", aggfunc="sum")
Out[39]: 
FeedType     A     B
Animal 
Animal1   10.0   5.0
Animal2    2.0  13.0
Animal3    6.0   NaN

第二种方法是使用groupby()方法：

In [40]: df.groupby(["Animal", "FeedType"])["Amount"].sum()
Out[40]: 
Animal   FeedType
Animal1  A           10
 B            5
Animal2  A            2
 B           13
Animal3  A            6
Name: Amount, dtype: int64

更多细节和示例请参见重塑文档或分组文档。

factor

pandas 有一个用于分类数据的数据类型。

cut(c(1,2,3,4,5,6),  3)
factor(c(1,2,3,2,2,3))

在 pandas 中，可以通过pd.cut和astype("category")来实现：

In [41]: pd.cut(pd.Series([1, 2, 3, 4, 5, 6]), 3)
Out[41]: 
0    (0.995, 2.667]
1    (0.995, 2.667]
2    (2.667, 4.333]
3    (2.667, 4.333]
4      (4.333, 6.0]
5      (4.333, 6.0]
dtype: category
Categories (3, interval[float64, right]): [(0.995, 2.667] < (2.667, 4.333] < (4.333, 6.0]]

In [42]: pd.Series([1, 2, 3, 2, 2, 3]).astype("category")
Out[42]: 
0    1
1    2
2    3
3    2
4    2
5    3
dtype: category
Categories (3, int64): [1, 2, 3]

更多细节和示例请参见分类介绍和 API 文档。还有关于 R 的因子的差异的文档。

meltarray

在 R 中使用名为a的三维数组的表达式，你想要将其融化成数据框：

a  <-  array(c(1:23,  NA),  c(2,3,4))
data.frame(melt(a))

在 Python 中，由于a是一个列表，你可以简单地使用列表推导式。

In [28]: a = np.array(list(range(1, 24)) + [np.NAN]).reshape(2, 3, 4)

In [29]: pd.DataFrame([tuple(list(x) + [val]) for x, val in np.ndenumerate(a)])
Out[29]: 
 0  1  2     3
0   0  0  0   1.0
1   0  0  1   2.0
2   0  0  2   3.0
3   0  0  3   4.0
4   0  1  0   5.0
.. .. .. ..   ...
19  1  1  3  20.0
20  1  2  0  21.0
21  1  2  1  22.0
22  1  2  2  23.0
23  1  2  3   NaN

[24 rows x 4 columns]

meltlist

在 R 中使用名为a的列表的表达式，你想要将其融化成数据框：

a  <-  as.list(c(1:4,  NA))
data.frame(melt(a))

在 Python 中，这个列表将是一个元组的列表，所以DataFrame()方法会将其转换为所需的数据框。

In [30]: a = list(enumerate(list(range(1, 5)) + [np.NAN]))

In [31]: pd.DataFrame(a)
Out[31]: 
 0    1
0  0  1.0
1  1  2.0
2  2  3.0
3  3  4.0
4  4  NaN

更多详细信息和示例请参见数据结构介绍文档。

meltdf

在 R 中使用名为cheese的数据框进行数据重塑的表达式：

cheese  <-  data.frame(
  first  =  c('John',  'Mary'),
  last  =  c('Doe',  'Bo'),
  height  =  c(5.5,  6.0),
  weight  =  c(130,  150)
)
melt(cheese,  id=c("first",  "last"))

在 Python 中，melt()方法相当于 R 中的：

In [32]: cheese = pd.DataFrame(
 ....:    {
 ....:        "first": ["John", "Mary"],
 ....:        "last": ["Doe", "Bo"],
 ....:        "height": [5.5, 6.0],
 ....:        "weight": [130, 150],
 ....:    }
 ....: )
 ....: 

In [33]: pd.melt(cheese, id_vars=["first", "last"])
Out[33]: 
 first last variable  value
0  John  Doe   height    5.5
1  Mary   Bo   height    6.0
2  John  Doe   weight  130.0
3  Mary   Bo   weight  150.0

In [34]: cheese.set_index(["first", "last"]).stack(future_stack=True)  # alternative way
Out[34]: 
first  last 
John   Doe   height      5.5
 weight    130.0
Mary   Bo    height      6.0
 weight    150.0
dtype: float64

更多详细信息和示例请参见重塑文档。

cast

在 R 中，acast是使用名为df的数据框进行高维数组转换的表达式：

df  <-  data.frame(
  x  =  runif(12,  1,  168),
  y  =  runif(12,  7,  334),
  z  =  runif(12,  1.7,  20.7),
  month  =  rep(c(5,6,7),4),
  week  =  rep(c(1,2),  6)
)

mdf  <-  melt(df,  id=c("month",  "week"))
acast(mdf,  week  ~  month  ~  variable,  mean)

在 Python 中，最佳方式是利用pivot_table()：

In [35]: df = pd.DataFrame(
 ....:    {
 ....:        "x": np.random.uniform(1.0, 168.0, 12),
 ....:        "y": np.random.uniform(7.0, 334.0, 12),
 ....:        "z": np.random.uniform(1.7, 20.7, 12),
 ....:        "month": [5, 6, 7] * 4,
 ....:        "week": [1, 2] * 6,
 ....:    }
 ....: )
 ....: 

In [36]: mdf = pd.melt(df, id_vars=["month", "week"])

In [37]: pd.pivot_table(
 ....:    mdf,
 ....:    values="value",
 ....:    index=["variable", "week"],
 ....:    columns=["month"],
 ....:    aggfunc="mean",
 ....: )
 ....: 
Out[37]: 
month                  5           6           7
variable week 
x        1     93.888747   98.762034   55.219673
 2     94.391427   38.112932   83.942781
y        1     94.306912  279.454811  227.840449
 2     87.392662  193.028166  173.899260
z        1     11.016009   10.079307   16.170549
 2      8.476111   17.638509   19.003494

类似于dcast，它使用 R 中名为df的数据框根据Animal和FeedType聚合信息：

df  <-  data.frame(
  Animal  =  c('Animal1',  'Animal2',  'Animal3',  'Animal2',  'Animal1',
  'Animal2',  'Animal3'),
  FeedType  =  c('A',  'B',  'A',  'A',  'B',  'B',  'A'),
  Amount  =  c(10,  7,  4,  2,  5,  6,  2)
)

dcast(df,  Animal  ~  FeedType,  sum,  fill=NaN)
# Alternative method using base R
with(df,  tapply(Amount,  list(Animal,  FeedType),  sum))

Python 可以通过两种不同的方式来实现。首先，类似于上面使用pivot_table()：

In [38]: df = pd.DataFrame(
 ....:    {
 ....:        "Animal": [
 ....:            "Animal1",
 ....:            "Animal2",
 ....:            "Animal3",
 ....:            "Animal2",
 ....:            "Animal1",
 ....:            "Animal2",
 ....:            "Animal3",
 ....:        ],
 ....:        "FeedType": ["A", "B", "A", "A", "B", "B", "A"],
 ....:        "Amount": [10, 7, 4, 2, 5, 6, 2],
 ....:    }
 ....: )
 ....: 

In [39]: df.pivot_table(values="Amount", index="Animal", columns="FeedType", aggfunc="sum")
Out[39]: 
FeedType     A     B
Animal 
Animal1   10.0   5.0
Animal2    2.0  13.0
Animal3    6.0   NaN

第二种方法是使用groupby()方法：

In [40]: df.groupby(["Animal", "FeedType"])["Amount"].sum()
Out[40]: 
Animal   FeedType
Animal1  A           10
 B            5
Animal2  A            2
 B           13
Animal3  A            6
Name: Amount, dtype: int64

更多详细信息和示例请参见重塑文档或分组文档。

factor

pandas 有一种用于分类数据的数据类型。

cut(c(1,2,3,4,5,6),  3)
factor(c(1,2,3,2,2,3))

在 pandas 中，可以通过pd.cut和astype("category")来实现：

In [41]: pd.cut(pd.Series([1, 2, 3, 4, 5, 6]), 3)
Out[41]: 
0    (0.995, 2.667]
1    (0.995, 2.667]
2    (2.667, 4.333]
3    (2.667, 4.333]
4      (4.333, 6.0]
5      (4.333, 6.0]
dtype: category
Categories (3, interval[float64, right]): [(0.995, 2.667] < (2.667, 4.333] < (4.333, 6.0]]

In [42]: pd.Series([1, 2, 3, 2, 2, 3]).astype("category")
Out[42]: 
0    1
1    2
2    3
3    2
4    2
5    3
dtype: category
Categories (3, int64): [1, 2, 3]

更多详细信息和示例请参见分类介绍和 API 文档。还有一份关于 R 中因子的差异的文档。

标签：...,教程,df,....,col1,np,2.2,Pandas,Out
From： https://www.cnblogs.com/apachecn/p/18154743

相关文章

  • Pandas 2.2 中文官方教程和指南（十八）
    原文：pandas.pydata.org/docs/可空整数数据类型原文：pandas.pydata.org/docs/user_guide/integer_na.html注意IntegerArray目前处于实验阶段。其API或实现可能会在没有警告的情况下发生变化。使用pandas.NA作为缺失值。在处理缺失数据中，我们看到pandas主要使用NaN来表......
  • Pandas 2.2 中文官方教程和指南（二十四）
    原文：pandas.pydata.org/docs/扩展到大型数据集原文：pandas.pydata.org/docs/user_guide/scale.htmlpandas提供了用于内存分析的数据结构，这使得使用pandas分析大于内存数据集的数据集有些棘手。即使是占用相当大内存的数据集也变得难以处理，因为一些pandas操作需要进行中......
  • Pandas 2.2 中文官方教程和指南（二十三）
    原文：pandas.pydata.org/docs/提高性能原文：pandas.pydata.org/docs/user_guide/enhancingperf.html在本教程的这一部分中，我们将研究如何加速在pandas的DataFrame上操作的某些函数，使用Cython、Numba和pandas.eval()。通常，使用Cython和Numba可以比使用pandas.eval()提......
  • Pandas 2.2 中文官方教程和指南（二）
    原文：pandas.pydata.org/docs/如何在pandas中创建图表？原文：pandas.pydata.org/docs/getting_started/intro_tutorials/04_plotting.htmlIn[1]:importpandasaspdIn[2]:importmatplotlib.pyplotasplt本教程使用的数据：空气质量数据本教程使用关于(NO_2)的......
  • Pandas 2.2 中文官方教程和指南（二十）
    原文：pandas.pydata.org/docs/按组分组：分割-应用-合并原文：pandas.pydata.org/docs/user_guide/groupby.html通过“按组”我们指的是涉及以下一个或多个步骤的过程：根据某些标准将数据分成组。应用一个函数到每个组独立地。合并结果到数据结构中。在这些中，分割步......
  • Pandas 2.2 中文官方教程和指南（二十二）
    原文：pandas.pydata.org/docs/时间增量原文：pandas.pydata.org/docs/user_guide/timedeltas.html时间增量是时间之间的差异，以不同的单位表示，例如天、小时、分钟、秒。它们可以是正数也可以是负数。Timedelta是datetime.timedelta的子类，并且行为类似，但也允许与np.timedelta64......
  • Java 断言 Assert 使用教程与最佳实践
    本文收录于Github.com/niumoo/JavaNotes，Java系列文档，数据结构与算法！本文收录于网站：https://www.wdbyte.com/，我的公众号：程序猿阿朗作为一个Java开发者，如果要问你Java中有哪些关键字，你可能会随口说出一串，如果问你Java有哪些最不常使用的关键字，或许你还能说出几个。但是......
  • windows server 2012 standard搭建onlyoffice服务所用软件和安装教程（亲测有效）
    链接内容：postgresql请使用12版本的，否则会报错！百度链接：https://pan.baidu.com/s/14PZJsjH-kqvKNZHjyBCWcA提取码：89zb效果：excel(xls)word(doc)......
  • [987] geopandas.sjoin
    geopandas.sjoin:SpatialjoinoftwoGeoDataFrames.geopandas.sjoin(left_df, right_df, how='inner', predicate='intersects', lsuffix='left', rsuffix='right', **kwargs)Parameters:left_df,right_df:GeoDataFram......
  • [986] Filter rows by containing a particular word in Pandas
    In Pandas,youcanfilterrowsbasedonwhetheraspecificcolumncontainsaparticularwordorsubstring.Hereareafewwaystoachievethis:Using str.contains():Tofilterrowswhereaspecificcolumn(let’ssay‘ids’)containstheword“ball,”......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99