小编Jiv*_*van的帖子

是否有一个运算符可以List根据 a 的内容从 a中删除元素Set？

我想做的事情已经可以通过这样做：

words = ["hello", "you", "how", "are", "you", "today", "hello"]
my_set = {"you", "are"}

new_list = [w for w in words if w not in my_set]
# ["hello", "how", "today", "hello"]

这种列表理解让我困扰的是，对于巨大的集合，它看起来不如可-在两个集合之间使用的运算符有效。因为在列表推导式中，迭代发生在 Python 中，而使用运算符时，迭代发生在C和 中，并且级别更低，因此速度更快。

那么，是否有某种方法可以比使用列表理解更短/更干净/更有效地计算列表和集合之间的差异，例如：

# I know this is not possible, but does something approaching exist?
new_list = words - my_set

长话短说

我正在寻找一种方法来Set从 a中删除 a 中存在的所有元素List，即：

• 清洁器（也许是内置的）
• 和/或更高效

比我所知道的可以通过列表理解来完成。

从这样一个表:

id   name      alias
0    John      Null
1    Null      Paul
2    Null      George
3    Ringo     Null
4    Pete      Pete

如何在列name和alias列之间选择第一个非Null值,并将其放入自己的results字段中,以便输出为:

id   result
0    John
1    Paul
2    George
3    Ringo
4    Pete

使用给定的Spark DataFrame:

> df.show()

+---+-----+---+---+---+---+
| id|delay| p1| p2| p3| p4|
+---+-----+---+---+---+---+
|  1|    3|  a|  b|  c|  d|
|  2|    1|  m|  n|  o|  p|
|  3|    2|  q|  r|  s|  t|
+---+-----+---+---+---+---+

如何动态选择列,以便新col列是p{delay}现有列的结果？

> df.withColumn("col", /* ??? */).show()

+---+-----+---+---+---+---+----+
| id|delay| p1| p2| p3| p4| col|
+---+-----+---+---+---+---+----+
|  1|    3|  a|  b|  c|  d|   c|   // col = p3
|  2|    1|  m|  n|  o|  p|   m|   // col = p1
|  3|    2| …

我想dict y1~y10[name]用给定的列表来评估以下内容.

我知道使用eval(self.y$i[name]) = value是错误的,但我应该如何在python中执行此操作？

class excel:
    def __init__(self):
        self.base_year = 2004
        self.y1 = {'year':self.base_year}
        self.y2 = {'year':self.base_year + 1}
        self.y3 = {'year':self.base_year + 2}
        self.y4 = {'year':self.base_year + 3}
        self.y5 = {'year':self.base_year + 4}
        self.y6 = {'year':self.base_year + 5}
        self.y7 = {'year':self.base_year + 6}
        self.y8 = {'year':self.base_year + 7}
        self.y9 = {'year':self.base_year + 8}
        self.y10 = {'year':self.base_year + 9}
    def value(self, name, value_list):
        for value, i in value_list, range(1, 10):
            eval(self.y$i[name]) = value

list = …

我知道在 python 中创建动态 for 循环、递归或 itertools 模块是要走的路。可以说我是递归的。

我想要的是

for var1 in range(var1_lowerlimit, var1_upperlimit, var1_stepsize):
    for var2 in range(var2_lowerlimit, var2_upperlimit, var2_stepsize):
    :
    :
        # do_whatever()

重复 n 次循环，其中 n 是变量数

我现在拥有的是我有 2 个列表

variable_list = [ var1, var2, var3, ... ]
boundaries_list = [ [var1_lowerlimit, var1_upperlimit, var1_stepsize], 
                    [var2_lowerlimit, var2_upperlimit, var2_stepsize], ...]

def dynamic_for_loop(variable_list , boundaries_list, no_of_loops, list_index = 0):
    if no_of_loops <= 0:
        # do_whatever()
    else:
        lower_bound = boundaries_list[list_index][0]
        upper_bound = boundaries_list[list_index][1]
        step_size = boundaries_list[list_index][2]
        for index in range(lower_bound, upper_bound, step_size): …

在n = range(1, n+1)我有随机生成的列表n * p唯一整数.

例如,如果n = 10和p = 0.3随后可能的结果可能是:

[2, 6, 9]
[1, 5, 7]
[3, 4, 8]
[3, 5, 6]
etc

以下Python代码完美地完成了这项工作:

import random

n = 250000
p = 0.8
np = int(n * p)

result = []
for i in range(np):
    attempt = random.randint(1, n)
    if attempt not in result:
        result.append(attempt)

但是,因为它是Python,它可能需要很长时间(比如超过一分钟)np > 200000.

你能看到更有效的上述解决方案NumPy吗？

我有以下 ADT 实现：

data FeatureValue =
    FvInt Int
  | FvFloat Float
  | FvText Text
  | FvBool Bool
  deriving Show

data ApiResponse =
    Online [[Maybe FeatureValue]]
  | Offline [[[Maybe FeatureValue]]]
  deriving Show

要编码的示例值可能是：

example :: ApiResponse
example =
    Online [
        [Just (FvInt 10), Nothing, Just (FvText "foo"), Just (FvFloat 1.42)],
        [Nothing, Just (FvBool False), Just (FvText "bar"), Nothing]
    ]

这将导致以下 JSON：

[
    [10, null, "foo", 1.42],
    [null, false, "bar", null]
]

我正在努力研究如何特别地派生ToJSON实例FeatureValue。使用 Aeson 进行 ADT 编码的文档特别稀少（例如，其他很棒的 Aelve …

我想newtype通过Show以下方式派生来打印 a 的内部值，这样我就不必在Value val每次需要打印时打开它。

{-# LANGUAGE OverloadedStrings          #-}

import Data.Text

newtype Value = Value Text
instance Show Value where show (Value val) = show val


main :: IO ()
main = do
    let hello = Value "hello"
        world = Value "world"
    print $ show hello <> ", " <> show world
    pure ()

这个想法是我可以简单地show hello而不是做let Value helloVal = hello in show helloVal（一个人为的例子，但主要的一点是避免展开）。

问题是这会打印以下内容：

"\"hello\", \"world\""

而期望的结果是：

hello, world

如何获得所需的输出？