小编use*_*167的帖子

我尝试做一些自举和计算colMeans,当然我选择矩阵来存储数据,但是,采样速度非常慢:

m[sample(n,replace=TRUE),]

事实证明data.table是最快的.

require(microbenchmark)
require(data.table)
n = 2000
nc = 8000
m = matrix(1:(n*nc) ,nrow = n)
DF = as.data.frame(m)
DT = as.data.table(m)

s=sample(n, replace=TRUE)
microbenchmark(m[s,], DF[s,],DT[s,])

# Unit: milliseconds
    # expr      min       lq     mean   median       uq      max neval
  # m[s, ] 371.9271 402.3542 421.7907 420.8446 437.8251 506.1788   100
 # DF[s, ] 182.3189 199.0865 218.0746 213.9451 231.1518 409.8625   100
 # DT[s, ] 129.8225 139.1977 156.9506 150.4321 164.3104 254.2048   100

为什么采样矩阵比其他两个矩阵慢得多？

shift将我的列从整数转换为浮点数.事实证明这np.nan只是浮动.有没有办法将移位列保持为整数？

df = pd.DataFrame({"a":range(5)})
df['b'] = df['a'].shift(1)

df['a']
# 0    0
# 1    1
# 2    2
# 3    3
# 4    4
# Name: a, dtype: int64

df['b']

# 0   NaN
# 1     0
# 2     1
# 3     2
# 4     3
# Name: b, dtype: float64

我想问和Python 3一样的问题 ：Pool 是否保持传递给 map 的数据的原始顺序？对于joblib。例如：

Parallel(n_jobs=2)(delayed(sqrt)(i ** 2) for i in x)

语法有点暗示它，但我总是担心并行处理的输出顺序，我不想根据未记录的行为进行编码。

我想在内存中创建一个包含 10 个最大对象的表，并且具有大小。

R 中的等效函数： 在 R 会话中管理可用内存的技巧

lsos()
#                          Type Size(MB)   Rows Columns
#d2                  data.table 157.8364 281444      74
#d                   data.table  62.2658 816078      11

编辑：@ 9.0 这是我的尝试。

我必须使用globals()，使用gc.get_objects()使我的电脑很慢。我不确定globals()给了我我想要的。 如何在python中获取所有已初始化对象和函数定义的列表？

def lsos(n=10):

    import pandas as pd
    import sys

    all_obj =globals()

    object_name = list(all_obj).copy()
    object_size = [sys.getsizeof(all_obj[x]) for x in object_name]

    d = pd.DataFrame(dict(name = object_name, size = object_size))
    d.sort_values(['size'], ascending=[0],inplace=True)

    return(d.head(n))


v  = list(range(1000))
v2 = list(range(10000))
v3 = list(range(100000))
v4 = v3
lsos()

    # …

我有一个大数据框df和一个小数据框，df_right有 2 列a和b. 我想在a不复制的情况下进行简单的左连接/查找df。

我想出了这段代码，但我不确定它有多健壮：

dtmp = pd.merge(df[['a']], df_right, on = 'a', how = "left")  #one col left join
df['b'] = dtmp['b'].values

我知道当有重复的键时它肯定会失败：pandas left join - 为什么会有更多的结果？

有没有更好的方法来做到这一点？

有关的：

外部合并熊猫中的两个数据框

DataFrame.merge() 中 copy=False 的确切缺点是什么？

我尝试使用!运算符选择行

d = data.table(a = 1:3, b = c(TRUE, FALSE,FALSE))

d [b==FALSE]
#    a     b
# 1: 2 FALSE
# 2: 3 FALSE


d [!b]
# Error in eval(expr, envir, enclos) : object 'b' not found

如果它是表达式,是否应该进行评估？

在许多data.tables中我需要一些列(~20),如何在函数中封装操作？

例如,我想要列a1和a2每个data.table,最快的方法是复制和粘贴代码:

n= 10
m = 2
d = data.table( p = c(1:n)*1.0, q = 1:m)
dnew = d[, list(a1 = mean(p),a2 = max(p), b = 2) , by = q] #copy and paste

我想写这样的可重用函数,

f <- function(d) with(d, list( a1 = mean(p), a2 = max(p))) #return list
dnew = d[, c(f(.SD), list( b = 2)) , by = q]

或这个,

g <- function(d)d[, list(a1 = mean(p), a2 = max(p)), by = q] #return data.table
dnew1 …