小编jef*_*ott的帖子

我在 2个月前第一次在PyPi上放了一个软件包,并且从那以后做了一些版本更新.本周我注意到了下载计数记录,并惊讶地看到它被下载了数百次.在接下来的几天里,我更惊讶的是,即使这是一个利基统计测试工具箱,下载次数有时会增加每天数百次.特别是,旧版本的软件包继续被下载,有时以比最新版本更高的速率下载.

这里发生了什么？

PyPi的下载计数中是否存在错误,或者是否存在大量抓取开源代码的爬虫(就像我的一样)？

我有一个Pandas数据帧,我想创建一个新列,其值是另一列的值,向下移动一行.最后一行应该显示NaN.

问题是我希望按组执行此操作,每组的最后一行显示NaN.没有组的最后一行"窃取"来自恰好在数据帧中相邻的组的值.

我试图实施是非常可耻的,所以我显然误解了一些基本的东西.

df['B_shifted'] = df.groupby(['A'])['B'].transform(lambda x:x.values[1:])

I am creating symmetric matrices/arrays in Python with NumPy, using a standard method:

x = rand(500,500)
x = (x+x.T)
all(x==x.T)
> True

Now let's be clever:

x = rand(500,500)
x += x.T
all(x==x.T)
> False

Wait, what?

x==x.T
> array([[ True,  True,  True, ..., False, False, False],
       [ True,  True,  True, ..., False, False, False],
       [ True,  True,  True, ..., False, False, False],
       ..., 
       [False, False, False, ...,  True,  True,  True],
       [False, False, False, ...,  True,  True,  True],
       [False, False, …

使用Pandas,使用Panel与MultiIndex DataFrame的原因是什么？

我个人发现两者在访问不同维度/级别的难易程度方面存在显着差异,但这可能只是我对一个界面与另一个界面的界面更为熟悉.不过,我认为存在更多实质性差异.

我在Pandas中有一个数据帧,我想用R函数对它做一些统计.没问题!RPy可以轻松地将数据帧从Pandas发送到R:

import pandas as pd
df = pd.DataFrame(index=range(100000),columns=range(100))
from rpy2 import robjects as ro
ro.globalenv['df'] = df

如果我们在IPython:

%load_ext rmagic
%R -i df

由于某种原因,ro.globalenv路线比rmagic路线稍慢,但无论如何.重要的是:我最终将使用的数据帧是~100GB.这提出了一些问题:

1. 即使只有1GB的数据,传输速度也相当慢.
2. 如果我理解正确,这会在内存中创建两个数据帧副本:一个在Python中,一个在R中.这意味着我只需要将内存需求增加一倍,而且我甚至都没有运行统计测试!

有没有办法:

1. 在Python和R之间更快地传输大型数据帧？
2. 访问内存中的同一个对象？我怀疑这要求登月.

我们有一个如下所示的DataFrame:

> df.ix[:2,:10]
    0   1   2   3   4   5   6   7   8   9   10
0   NaN NaN NaN NaN  6   5  NaN NaN  4  NaN  5
1   NaN NaN NaN NaN  8  NaN NaN  7  NaN NaN  5
2   NaN NaN NaN NaN NaN  1  NaN NaN NaN NaN NaN

我们只想要DataFrame中所有唯一值的计数.一个简单的解决方案是

df.stack().value_counts() 

但是:1.看起来像是stack返回副本,而不是视图,在这种情况下,内存禁止.它是否正确？2.我想按行对DataFrame进行分组,然后为每个分组获取不同的直方图.如果我们忽略了内存问题stack并暂时使用它,那么如何正确地进行分组呢？

d = pd.DataFrame([[nan, 1, nan, 2, 3],
              [nan, 1, 1, 1, 3],
              [nan, 1, nan, 2, 3],
              [nan,2,2,2, 3]])

len(d.stack()) #14
d.stack().groupby(arange(4))
AssertionError: …

在Pandas中,在多索引中选择任意行集的好方法是什么？

df = pd.DataFrame(columns=['A', 'B', 'C'])
df['A'] = ['a', 'a', 'b', 'b']
df['B'] = [1,2,3,4]
df['C'] = [1,2,3,4]

the_indices_we_want = df.ix[[0,3],['A','B']]
df = df.set_index(['A', 'B']) #Create a multiindex

df.ix[the_indices_we_want] #ValueError: Cannot index with multidimensional key

df.ix[[tuple(x) for x in the_indices_we_want.values]]

这最后一行是答案,但感觉笨拙的回答; 他们甚至不能成为名单,他们必须是元组.它还涉及生成一个新对象来进行索引.我正处于这样一种情况:我正在尝试使用另一个数据帧的索引对多索引数据帧进行查找:

data_we_want = dataframe_with_the_data.ix[dataframe_with_the_indices[['Index1','Index2']]]

现在看起来我需要像这样写:

data_we_want = dataframe_with_the_data.ix[[tuple(x) for x in dataframe_with_the_indices[['Index1','Index2']].values]]

这是可行的,但如果有很多行(即数亿个所需的索引),那么生成这个元组列表就变成了负担.有解决方案吗

编辑:@joris的解决方案有效,但如果索引都是数字则不行.索引全部为整数的示例:

df = pd.DataFrame(columns=['A', 'B', 'C'])
df['A'] = ['a', 'a', 'b', 'b']
df['B'] = [1,2,3,4]
df['C'] = [1,2,3,4]

the_indices_we_want = df.ix[[0,3],['B','C']]
df = df.set_index(['B', 'C'])

df.ix[pd.Index(the_indices_we_want)] …

我希望快速（希望没有 for 循环）生成以下形式的 Numpy 数组：

array([a,a,a,a,0,0,0,0,0,b,b,b,0,0,0, c,c,0,0....])

其中a、b、c和其他值在不同的点重复不同的范围。我真的在想这样的事情：

import numpy as np
a = np.zeros(100)
a[0:3,9:11,15:16] = np.array([a,b,c])

这显然是行不通的。有什么建议么？

编辑（jterrace 回答了原来的问题）：数据以 N*M Numpy 数组的形式出现。每行大部分都是零，偶尔散布着非零数字序列。我想用序列的最后一个值替换每个此类序列的所有元素。我会采取任何快速的方法来做到这一点！使用 where 和 diff 几次，我们可以获得每次运行的开始和停止索引。

raw_data = array([.....][....])
starts = array([0,0,0,1,1,1,1...][3, 9, 32, 7, 22, 45, 57,....])
stops = array([0,0,0,1,1,1,1...][5, 12, 50, 10, 30, 51, 65,....])
last_values = raw_data[stops]
length_to_repeat = stops[1]-starts[1]

请注意，starts[0] 和stops[0] 是相同的信息（运行发生在哪一行）。此时，由于我知道的唯一路线是 jterrace 建议的路线，因此我们需要进行一些扭曲以获得类似的零开始/停止位置，然后将零开始/停止与值开始/停止交错，并将数字 0 与 last_values 数组交错。然后我们循环每一行，执行如下操作：

for i in range(N)
    values_in_this_row = where(starts[0]==i)[0]
    output[i] = numpy.repeat(last_values[values_in_this_row], length_to_repeat[values_in_this_row])

这有道理吗，还是我应该解释更多？

我有几个函数可能会返回多个计算inf,如下所示:

In [10]: numpy.exp(5000)
Out[10]: inf

我宁愿它返回最大浮点值:

In [11]: sys.float_info.max
Out[11]: 1.7976931348623157e+308

我可以在每次inf弹出时检查,或者将每个计算包装在一个inf向下舍入到所需浮点数的函数中.但是,我真的很喜欢每个函数开头的简单hack,例如:

inf = sys.float_info.max

这显然不起作用.有一种聪明的方法吗？谢谢!

我发现数据帧的稀疏版本在保存到磁盘时实际上比密集版本大得多.我究竟做错了什么？

test = pd.DataFrame(ones((4,4000)))
test.ix[:,:] = nan
test.ix[0,0] = 47

test.to_hdf('test3', 'df')
test.to_sparse(fill_value=nan).to_hdf('test4', 'df')

test.to_pickle('test5')
test.to_sparse(fill_value=nan).to_pickle('test6')

....
ls -sh test*
200K test3   16M test4  164K test5  516K test6

使用版本0.12.0

我最终希望有效地存储10 ^ 7个60个阵列,密度大约为10%,然后将它们拉入Pandas数据帧并使用它们.

编辑:感谢Jeff回答原始问题.后续问题:这似乎只能节省酸洗费用,而不是使用其他格式如HDF5.酸洗我最好的路线？

print shape(array_activity) #This is just 0s and 1s
(1020000, 60)

test = pd.DataFrame(array_activity)
test_sparse = test.to_sparse()
print test_sparse.density
0.0832333496732

test.to_hdf('1', 'df')
test_sparse.to_hdf('2', 'df')
test.to_pickle('3')
test_sparse.to_pickle('4')
!ls -sh 1 2 3 4
477M 1  544M 2  477M 3   83M 4

这是一个数据,作为Matlab .mat文件中的索引列表,小于12M.我很想把它变成HDF5/Pytables格式,这样我就可以抓住特定的索引(其他文件要大得多,加载到内存中需要更长的时间),然后随便做一些Pandasy的事情.也许我不会以正确的方式解决这个问题？