R 如何制作好可复制的熊猫示例

在花了相当长的时间观看和标签之后，我得到的印象是

熊猫

问题不太可能包含可复制的数据。这是R社区非常乐于鼓励的事情，多亏了像这样的指南，新来者能够获得一些帮助来组合这些例子。能够阅读这些指南并带回可复制数据的人通常会更幸运地得到问题的答案

我们如何才能为

pandas

问题创建良好的重复性示例？可以将简单的数据帧放在一起，例如：

import pandas as pd
df = pd.DataFrame({'user': ['Bob', 'Jane', 'Alice'], 
                   'income': [40000, 50000, 42000]})

但许多示例数据集需要更复杂的结构，例如：

• datetime

  索引或数据
• 多个分类变量（是否有一个等价于R的

  expand.grid（）

  函数，它生成某些给定变量的所有可能组合？）
• 多索引或面板数据

对于很难用几行代码来模拟的数据集，是否有一个与R的

dput（）

等效的方法，允许您生成可复制粘贴的代码来重新生成数据结构？

注意：这里的思想对于堆栈溢出来说确实非常通用

免责声明：写一个好问题很难。 好人：

• 包括小*示例数据帧，作为可运行代码：

  In [1]: df = pd.DataFrame([[1, 2], [1, 3], [4, 6]], columns=['A', 'B'])
  

  或者使用

  pd.read_clipboard（sep='\s\s+'）

  将其设置为“可复制并可粘贴”。您可以为堆栈溢出高亮显示设置文本格式，并使用Ctrl+K（或在每行前面加四个空格），或者在代码上方和下方放置三个平铺，使代码不凹陷：

  In [2]: df
  Out[2]: 
     A  B
  0  1  2
  1  1  3
  2  4  6
  

  测试

  pd.自己阅读剪贴板（sep='\s\s+）

  *我的意思是small，绝大多数示例数据帧所需的行数可能少于6行，而且我打赌我可以在5行中完成。你能用

  df=df.head（）重现错误吗，如果没有，那就四处摆弄，看看你是否能编一个小数据框来展示你所面临的问题
  
  *每个规则都有一个例外，最明显的一个例外是针对性能问题（），您应该在这里生成（考虑使用np.random.seed，这样我们就有了完全相同的框架）：
  df=pd.DataFrame（np.random.randn（100000000，10））
  。说“让这段代码对我来说很快”并不是严格意义上的网站主题
  

• 写出你想要的结果（类似于上面）
  解释数字的来源：5是A为1的行的B列的总和

• 请显示您尝试过的代码：

  In [4]: df.groupby('A').sum()
  Out[4]: 
     B
  A   
  1  5
  4  6
  

  但请说出错误的地方：A列在索引中，而不是列中

• 一定要展示你做过一些研究（，），总结一下：
  sum的docstring仅表示“计算组值之和”
  政府没有给出这方面的任何例子
  旁白：这里的答案是使用

  df.groupby（'A'，as_index=False）.sum（）

• 如果您有时间戳列（例如，您正在重新采样或做其他事情）是相关的，那么请明确地对它们应用

  pd.\u datetime

  ，以便更好地测量**

  df['date'] = pd.to_datetime(df['date']) # this column ought to be date..
  

  **有时这就是问题本身：它们是字符串

坏消息：

• 不要包含多索引，因为我们无法复制和粘贴多索引（见上文），这是一种对熊猫默认显示的不满，但仍然很烦人：

  In [11]: df
  Out[11]:
       C
  A B   
  1 2  3
    2  6
  

  正确的方法是在调用中包含普通数据帧：

• 在给出您想要的结果时，一定要深入了解它是什么：

     B
  A   
  1  1
  5  0
  

  具体说明你是如何得到这些数字的（它们是什么）。。。仔细检查他们是否正确

• 如果您的代码抛出错误，一定要包含整个堆栈跟踪（如果太嘈杂，可以稍后编辑）。显示行号（以及与之相对应的代码行）

丑八怪：

• 不要链接到我们无法访问的csv（最好不要链接到外部源…）
  大多数数据都是专有的我们得到了这样一个结论：编造类似的数据，看看是否可以重现问题（一些小问题）

• 不要含糊其辞地解释这种情况，比如你有一个“大”的数据框，顺便提到一些列名（确保不要提到它们的数据类型）。试着去了解一些完全没有意义的细节，而不去了解实际的情况。想必没有人会读到这一段的结尾
  文章不好，用小例子比较容易

• 在开始实际问题之前，不要包含10+（100+？）行数据
  拜托，我们在日常工作中看到的已经够多了。我们想帮忙，但是。
  剪掉简介，在这一步中只显示给您带来麻烦的相关数据帧（或它们的小版本）

无论如何，学习Python、NumPy和Pandas都很有趣！如何创建示例数据集 这主要是为了通过提供如何创建示例数据帧的示例来扩展@AndyHayden的答案。Pandas和（特别是）numpy为此提供了各种工具，这样您通常只需几行代码就可以创建任何真实数据集的合理副本

导入numpy和pandas后，如果您希望人们能够准确地复制您的数据和结果，请确保提供随机种子

import numpy as np
import pandas as pd

np.random.seed(123)

厨房水槽示例 下面是一个例子，展示了您可以做的各种事情。所有类型的有用示例数据帧都可以从以下数据帧的子集创建：

df = pd.DataFrame({ 

    # some ways to create random data
    'a':np.random.randn(6),
    'b':np.random.choice( [5,7,np.nan], 6),
    'c':np.random.choice( ['panda','python','shark'], 6),

    # some ways to create systematic groups for indexing or groupby
    # this is similar to r's expand.grid(), see note 2 below
    'd':np.repeat( range(3), 2 ),
    'e':np.tile(   range(2), 3 ),

    # a date range and set of random dates
    'f':pd.date_range('1/1/2011', periods=6, freq='D'),
    'g':np.random.choice( pd.date_range('1/1/2011', periods=365, 
                          freq='D'), 6, replace=False) 
    })

这将产生：

          a   b       c  d  e          f          g
0 -1.085631 NaN   panda  0  0 2011-01-01 2011-08-12
1  0.997345   7   shark  0  1 2011-01-02 2011-11-10
2  0.282978   5   panda  1  0 2011-01-03 2011-10-30
3 -1.506295   7  python  1  1 2011-01-04 2011-09-07
4 -0.578600 NaN   shark  2  0 2011-01-05 2011-02-27
5  1.651437   7  python  2  1 2011-01-06 2011-02-03

一些注意事项：

np.repeat

和

np.tile

（列

d

和

e

）对于以非常常规的方式创建组和索引非常有用。对于2列，这可以用来轻松地复制r的

expand.grid（）

，但是

import numpy as np
import pandas as pd

np.random.seed(123)

df = pd.DataFrame({ 

    # some ways to create random data
    'a':np.random.randn(6),
    'b':np.random.choice( [5,7,np.nan], 6),
    'c':np.random.choice( ['panda','python','shark'], 6),

    # some ways to create systematic groups for indexing or groupby
    # this is similar to r's expand.grid(), see note 2 below
    'd':np.repeat( range(3), 2 ),
    'e':np.tile(   range(2), 3 ),

    # a date range and set of random dates
    'f':pd.date_range('1/1/2011', periods=6, freq='D'),
    'g':np.random.choice( pd.date_range('1/1/2011', periods=365, 
                          freq='D'), 6, replace=False) 
    })

          a   b       c  d  e          f          g
0 -1.085631 NaN   panda  0  0 2011-01-01 2011-08-12
1  0.997345   7   shark  0  1 2011-01-02 2011-11-10
2  0.282978   5   panda  1  0 2011-01-03 2011-10-30
3 -1.506295   7  python  1  1 2011-01-04 2011-09-07
4 -0.578600 NaN   shark  2  0 2011-01-05 2011-02-27
5  1.651437   7  python  2  1 2011-01-06 2011-02-03

stocks = pd.DataFrame({ 
    'ticker':np.repeat( ['aapl','goog','yhoo','msft'], 25 ),
    'date':np.tile( pd.date_range('1/1/2011', periods=25, freq='D'), 4 ),
    'price':(np.random.randn(100).cumsum() + 10) })

>>> stocks.head(5)

        date      price ticker
0 2011-01-01   9.497412   aapl
1 2011-01-02  10.261908   aapl
2 2011-01-03   9.438538   aapl
3 2011-01-04   9.515958   aapl
4 2011-01-05   7.554070   aapl

>>> stocks.groupby('ticker').head(2)

         date      price ticker
0  2011-01-01   9.497412   aapl
1  2011-01-02  10.261908   aapl
25 2011-01-01   8.277772   goog
26 2011-01-02   7.714916   goog
50 2011-01-01   5.613023   yhoo
51 2011-01-02   6.397686   yhoo
75 2011-01-01  11.736584   msft
76 2011-01-02  11.944519   msft

stocks = pd.DataFrame({ 
    'ticker':np.repeat( ['aapl','goog','yhoo','msft'], 25 ),
    'date':np.tile( pd.date_range('1/1/2011', periods=25, freq='D'), 4 ),
    'price':(np.random.randn(100).cumsum() + 10) })

>>> stocks.head(5).to_dict()
{'date': {0: Timestamp('2011-01-01 00:00:00'),
  1: Timestamp('2011-01-01 00:00:00'),
  2: Timestamp('2011-01-01 00:00:00'),
  3: Timestamp('2011-01-01 00:00:00'),
  4: Timestamp('2011-01-02 00:00:00')},
 'price': {0: 10.284260107718254,
  1: 11.930300761831457,
  2: 10.93741046217319,
  3: 10.884574289565609,
  4: 11.78005850418319},
 'ticker': {0: 'aapl', 1: 'aapl', 2: 'aapl', 3: 'aapl', 4: 'aapl'}}

>>> pd.concat([stocks.head(), stocks.tail()], ignore_index=True).to_dict()
{'date': {0: Timestamp('2011-01-01 00:00:00'),
  1: Timestamp('2011-01-01 00:00:00'),
  2: Timestamp('2011-01-01 00:00:00'),
  3: Timestamp('2011-01-01 00:00:00'),
  4: Timestamp('2011-01-02 00:00:00'),
  5: Timestamp('2011-01-24 00:00:00'),
  6: Timestamp('2011-01-25 00:00:00'),
  7: Timestamp('2011-01-25 00:00:00'),
  8: Timestamp('2011-01-25 00:00:00'),
  9: Timestamp('2011-01-25 00:00:00')},
 'price': {0: 10.284260107718254,
  1: 11.930300761831457,
  2: 10.93741046217319,
  3: 10.884574289565609,
  4: 11.78005850418319,
  5: 10.017209045035006,
  6: 10.57090128181566,
  7: 11.442792747870204,
  8: 11.592953372130493,
  9: 12.864146419530938},
 'ticker': {0: 'aapl',
  1: 'aapl',
  2: 'aapl',
  3: 'aapl',
  4: 'aapl',
  5: 'msft',
  6: 'msft',
  7: 'msft',
  8: 'msft',
  9: 'msft'}}

stocks.info()
<class 'pandas.core.frame.DataFrame'>
Int64Index: 100 entries, 0 to 99
Data columns (total 3 columns):
date      100 non-null datetime64[ns]
price     100 non-null float64
ticker    100 non-null object
dtypes: datetime64[ns](1), float64(1), object(1)

# MultiIndex example.  First create a MultiIndex DataFrame.
df = stocks.set_index(['date', 'ticker'])
>>> df
                       price
date       ticker           
2011-01-01 aapl    10.284260
           aapl    11.930301
           aapl    10.937410
           aapl    10.884574
2011-01-02 aapl    11.780059
...

# After resetting the index and passing the DataFrame to `to_dict`, make sure to use 
# `set_index` to restore the original MultiIndex.  This DataFrame can then be restored.

d = df.reset_index().to_dict()
df_new = pd.DataFrame(d).set_index(['date', 'ticker'])
>>> df_new.head()
                       price
date       ticker           
2011-01-01 aapl    10.284260
           aapl    11.930301
           aapl    10.937410
           aapl    10.884574
2011-01-02 aapl    11.780059

import pandas as pd
def dput(x):
    if isinstance(x,pd.Series):
        return "pd.Series(%s,dtype='%s',index=pd.%s)" % (list(x),x.dtype,x.index)
    if isinstance(x,pd.DataFrame):
        return "pd.DataFrame({" + ", ".join([
            "'%s': %s" % (c,dput(x[c])) for c in x.columns]) + (
                "}, index=pd.%s)" % (x.index))
    raise NotImplementedError("dput",type(x),x)

df = pd.DataFrame({'a':[1,2,3,4,2,1,3,1]})
assert df.equals(eval(dput(df)))
du = pd.get_dummies(df.a,"foo")
assert du.equals(eval(dput(du)))
di = df
di.index = list('abcdefgh')
assert di.equals(eval(dput(di)))

pd.DataFrame({
  'foo_1':pd.Series([1, 0, 0, 0, 0, 1, 0, 1],dtype='uint8',index=pd.RangeIndex(start=0, stop=8, step=1)),
  'foo_2':pd.Series([0, 1, 0, 0, 1, 0, 0, 0],dtype='uint8',index=pd.RangeIndex(start=0, stop=8, step=1)),
  'foo_3':pd.Series([0, 0, 1, 0, 0, 0, 1, 0],dtype='uint8',index=pd.RangeIndex(start=0, stop=8, step=1)),
  'foo_4':pd.Series([0, 0, 0, 1, 0, 0, 0, 0],dtype='uint8',index=pd.RangeIndex(start=0, stop=8, step=1))},
  index=pd.RangeIndex(start=0, stop=8, step=1))

{'foo_1': {0: 1, 1: 0, 2: 0, 3: 0, 4: 0, 5: 1, 6: 0, 7: 1}, 
 'foo_2': {0: 0, 1: 1, 2: 0, 3: 0, 4: 1, 5: 0, 6: 0, 7: 0}, 
 'foo_3': {0: 0, 1: 0, 2: 1, 3: 0, 4: 0, 5: 0, 6: 1, 7: 0}, 
 'foo_4': {0: 0, 1: 0, 2: 0, 3: 1, 4: 0, 5: 0, 6: 0, 7: 0}}

du.equals(pd.DataFrame(du.to_dict()))
==> False