小编Pek*_*kka的帖子

和这个python pandas一样:如何在一个数据帧中找到行但在另一个数据帧中找不到？ 但有多列

这是设置:

import pandas as pd

df = pd.DataFrame(dict(
    col1=[0,1,1,2],
    col2=['a','b','c','b'],
    extra_col=['this','is','just','something']
))

other = pd.DataFrame(dict(
    col1=[1,2],
    col2=['b','c']
))

现在,我想选择其他行中df不存在的行.我想用col1和做选择col2

在SQL中我会这样做:

select * from df 
where not exists (
    select * from other o 
    where df.col1 = o.col1 and 
    df.col2 = o.col2
)

在熊猫我可以做这样的事情,但感觉非常难看.如果df具有id-column,则可以避免部分丑陋,但并不总是可用.

key_col = ['col1','col2']
df_with_idx = df.reset_index()
common = pd.merge(df_with_idx,other,on=key_col)['index']
mask = df_with_idx['index'].isin(common)

desired_result =  df_with_idx[~mask].drop('index',axis=1)

那么也许有一些更优雅的方式？

我有数据集,我有时需要选择没有列表中的变量丢失的观察.

即我必须这样做.

Where E1 NE . and E2 NE . and E3 NE .

或者我可以像这样轻松地做到这一点:

Where E1+E2+E3 NE .

但SAS有什么方法可以做以下事情:

Where not missing(E1 - E3)

如果我这样做,它就不起作用

where sum(of E1-E3) NE .

因为那相当于

Where E1 NE . or E2 NE . or E3 NE .

但我需要"和"而不是"或".

我还可以遍历数据集中的那些变量,并为选择构建变量,如:

array E E1-E3;
misind = 0;
do i=1 to dim(E);
    if E(i) = . then misind = 1;
end;

但这也不是那么简单!

我想启用按列搜索,但禁用特定列.

这几乎是我需要的 https://rstudio.github.io/DT/009-searchable.html, 但我想隐藏未使用的盒子.

有办法吗？

我试图运行一些简单的程序从html代码中提取表.但是,XML包中的readHTMLTable似乎存在一些内存问题.有什么方法可以轻松地解决这个问题.就像以某种方式为这个命令指定一些特殊的内存然后手动释放它.

我试图把它放在一个函数中并尝试使用gc()和不同版本的R和这个包,似乎什么都没有用.我开始绝望了.

示例代码.如何在不爆炸内存大小的情况下运行它？

library(XML)
a = readLines("http://en.wikipedia.org/wiki/2014_FIFA_World_Cup")
while(TRUE) {
    b = readHTMLTable(a)
    #do something with b
}

编辑:这样的事情仍然占据了我的所有记忆:

library(XML)
a = readLines("http://en.wikipedia.org/wiki/2014_FIFA_World_Cup")
f <- function(x) {
    b = readHTMLTable(x)
    rm(x)
    gc()
    return(b)
}

for(i in 1:100) {
    d = f(a)
    rm(d)
    gc()
}
rm(list=ls())
gc()

我正在使用win 7并尝试使用32位和64位.

如何在不计算sum和prod函数两次的情况下执行此操作？

require(data.table)

DT = data.table(x=rep(c("a","b","c"),each=4), y=1:6, V1 = 1000L, V2 = 2000, V3 = 1)

DT[x != "c",":="(
    V1 = sum(y),
    V2 = prod(y),
    V3 = sum(y) + prod(y)
),by=x]

当然我可以放弃V3计算然后像这样继续:

DT[x != "c",V3 := V1 + V2]

但它不是很干净,而且需要再次评估i-expression.

我想要的语法是这样的:

DT[x != "c",":="(
    V1 = sum(y),
    V2 = prod(y),
    V3 = V1 + V2
),by=x]

使用 Dataset-API 执行相同的任务似乎比使用队列慢 10-100 倍。

这就是我试图用数据集做的事情：

dataset = tf.data.TFRecordDataset(filenames).repeat()
dataset = dataset.batch(100)
dataset = dataset.map(_parse_function)
dataset = dataset.prefetch(1000)
d = dataset.make_one_shot_iterator()

%timeit -n 200 sess.run(d.get_next())

这与队列：

filename_queue = tf.train.string_input_producer(filenames, capacity=1)

reader = tf.TFRecordReader()
_, serialized_example = reader.read_up_to(filename_queue, 100)

features = _parse_function(serialized_example)

coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
tf.train.start_queue_runners()

%timeit -n 200 sess.run(features)

观察结果：

数据集： 23.6 ms ± 8.73 ms per loop (mean ± std. dev. of 7 runs, 200 loops each)

队列： 481 µs ± 91.7 µs per loop …

如何在不重新启动 python 的情况下再次看到警告。现在我只见到他们一次。

例如考虑以下代码：

import pandas as pd  
pd.Series([1]) / 0

我明白了

RuntimeWarning: divide by zero encountered in true_divide 

但当我再次运行它时，它会默默执行。

如何在不重新启动 python 的情况下再次看到警告？

我尝试过做

del __warningregistry__

但这没有帮助。

似乎只存储了某些类型的警告。例如，如果我这样做：

def f():   
    X = pd.DataFrame(dict(a=[1,2,3],b=[4,5,6]))
    Y = X.iloc[:2]
    Y['c'] = 8

那么这只会在第一次f()调用时发出警告。但是，现在什么时候del __warningregistry__我才能再次看到警告。

第一次警告和第二次警告有什么区别？为什么只有第二个存储在其中__warningregistry__？第一个存储在哪里？

Python itemgetter不返回长度为0或1的元组.例如:

from operator import itemgetter

def get_something(keys):
    d = {
        "a": 1,
        "b": 2,
        "c": 3
    }
    return itemgetter(*keys)(d)

print(type(get_something(["a", "b"])))
# <class 'tuple'>
print(type(get_something(["a"])))
# <class 'int'>
print(type(get_something([])))
# TypeError: itemgetter expected 1 arguments, got 0 

• 有这么好的理由itemgetter吗？而不是(1,)第二个()和最后一个？

• 如果我总是希望返回给定键的元组/列表,是否还有其他内置选项？

假设我有一个二维数组,例如:

val A1 = Array(Array(4,0,0,0),Array(3),Array(3,4,40,1),Array(50,2))

现在我希望每个位置都有最多的项目.

如果我以矩阵形式编写上面的数组,那么很明显我的意思是"列式"最大值:

4  0  0 0
3
3  4 40 1
50 2
----------
50 4 40 1 (result)

所以这种情况下的答案是Array(50,4,40,1)(空值将被忽略).

我可以这样做:

A1.foldLeft(A1.head)( (x1, x2) =>
  x1.padTo(x2.length, Int.MinValue).zip(x2.padTo(x1.length,Int.MinValue)).
    map { pair => pair._1 max pair._2 }
)

但不知何故,对于像这样的简单事情来说,这感觉非常硬.所以我希望有一个更简单的方法来做到这一点.

也许有

1)有些功能直接这样做吗？

2)有一些方法可以"用默认值压缩":x1.padTo(x2.length, Int.MinValue).zip(x2.padTo(x1.length,Int.MinValue))更好吗？

3)其他一些改进方法？

假设我有一个昂贵的功能f 和许多值v

def f(x: Int) = {
  x + 3
}

val v = 0 to 10e7.toInt

现在,我想申请f上v,选择基于一定条件下的一些结果.

我可以这样做

v.map(f).filter(_ > 10e7 - 5)

但这根本不可行,因为整体v.map(f)将首先存储在内存中.

那么其他选择是:

for(a <- v if f(a) > 10e7 - 5) yield f(a)

但是现在我需要为某些元素计算两次f,这是不可能的!

那么如何在不存储整个结果的情况下实现过滤,但仍能得到结果.逻辑看起来像这样(显然这不起作用):

for(a <- v) {
  val b = f(a)
  if(b > 10e7 - 5) yield b
}

为什么这是真的:

from collections import Iterable
import tensorflow as tf

v = tf.Variable(1.0)
print(isinstance(v, Iterable))

True

而这个

iter(v)

给

TypeError: 'Variable' object is not iterable.

使用旧的输入管道 API，我可以：

filename_queue = tf.train.string_input_producer(filenames, shuffle=True)

然后将文件名传递给其他队列，例如：

reader = tf.TFRecordReader()
_, serialized_example = reader.read_up_to(filename_queue, n)

如何使用 Dataset -API 实现类似的行为？

tf.data.TFRecordDataset()文件名的期望张量按固定顺序。