相关疑难解决方法(0)

我想知道list_1中包含哪些元素list_2。我需要输出作为布尔值的有序列表。但我想避免for循环，因为两个列表都有超过 200 万个元素。

这就是我所拥有的并且它有效，但它太慢了：

list_1 = [0,0,1,2,0,0]
list_2 = [1,2,3,4,5,6]

booleans = []
for i in list_1:
   booleans.append(i in list_2)

# booleans = [False, False, True, True, False, False]

我可以拆分列表并使用多线程，但如果可能的话，我更喜欢更简单的解决方案。我知道像 sum() 这样的一些函数使用向量运算。我正在寻找类似的东西。

如何让我的代码更加高效？

我不是来自软件/计算机科学背景,但我喜欢用Python编写代码,并且通常可以理解为什么事情变得更快.我真的很想知道为什么这个for循环比字典理解运行得更快.任何见解？

问题:给定a带有这些键和值的字典,返回一个字典,其值为键,键为值.(挑战:在一行中做到这一点)

和代码

a = {'a':'hi','b':'hey','c':'yo'}

b = {}
for i,j in a.items():
    b[j]=i

%% timeit 932 ns ± 37.2 ns per loop

b = {v: k for k, v in a.items()}

%% timeit 1.08 µs ± 16.4 ns per loop

假设我们有一个函数，它返回给定 dataframebar(df)的长度的 numpy 数组。len(df)df

现在考虑这个习语

def foo(df):\n    for i in range(N):\n        df['FOO_' + str(i)] = bar(df)\n    return df\n

最近的 pandas 更新开始导致以下警告

\n

性能警告：DataFrame 高度碎片化。这通常是\n多次调用的结果frame.insert，\n性能较差。考虑使用 pd.concat(axis=1) 一次连接所有列。要获取碎片整理的帧，请使用\nnewframe = frame.copy()

\n

据我了解，缓解这种情况的一种方法是将上面的代码更改为以下习惯用法

def foo2(df):\n    frames = [df]\n    for i in range(N):\n        frames += [pd.Series(bar(df), index=df.index)]\n    return pd.concat(frames, axis=1)\n

上面的代码修复了警告，但导致执行时间更差。

In [110]: %timeit foo()\n1.73 s \xc2\xb1 11 ms per loop (mean \xc2\xb1 std. dev. of 7 runs, 1 …

我试图找到列表理解的效率,但它看起来比正常的功能操作更昂贵.谁能解释一下？

def squares(values):
    lst = []
    for x in range(values):
        lst.append(x*x)
    return lst

def main():
    t = timeit.Timer(stmt="lst = [x*x for x in range(10)]")
    print t.timeit()
    t = timeit.Timer(stmt="squares",setup="from __main__ import squares")
    print t.timeit()

    lst = [x*x for x in range(10)]
    print lst
    print squares(10)



----Output:---
2.4147507644
0.0284455255965
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

对于相同的输出,与列表理解相比,正常函数在非常短的时间内计算.

我认为列表理解更有效.

有没有办法对需要几个numpy数组并将它们放入字典列表的操作进行矢量化？

这是一个简化的例子.真实场景可能涉及更多数组和更多字典键.

import numpy as np
x = np.arange(10)
y = np.arange(10, 20)
z = np.arange(100, 110)

print [dict(x=x[ii], y=y[ii], z=z[ii]) for ii in xrange(10)]

我可能在xrange通话中有数千或数十万次迭代.所有操作来创建x,y以及z被矢量(我的例子不是那么简单如上).因此,只有1个循环可以摆脱,我预计会导致巨大的加速.

我尝试使用map函数来创建字典和各种其他工作.似乎Python for循环是缓慢的部分(像往常一样).由于预先存在的API要求,我有点不习惯使用字典.但是,没有dicts和记录数组或其他东西的解决方案会很有趣,但最终我认为这不会适用于现有的API.

_{Stack Overflow 上有很多关于这个一般主题的问答，但它们要么质量很差（通常是初学者的调试问题暗示的），要么以其他方式错过了目标（通常是不够通用）。至少有两种极其常见的方法会使幼稚的代码出错，初学者从关于循环的规范中获益更多，而不是从将问题作为拼写错误或关于打印所需内容的规范中获益。所以这是我尝试将所有相关信息放在同一个地方。}

假设我有一些简单的代码，可以对一个值进行计算x并将其分配给y：

y = x + 1

# Or it could be in a function:
def calc_y(an_x):
    return an_x + 1

现在我想重复计算 的许多可能值x。我知道for如果我已经有要使用的值列表（或其他序列），我可以使用循环：

xs = [1, 3, 5]
for x in xs:
    y = x + 1

while或者，如果有其他逻辑来计算值序列，我可以使用循环x：

def next_collatz(value):
    if value % 2 == 0:
        return value // 2
    else:
        return 3 * value + 1

def collatz_from_19():
    x = 19
    while x != 1:
        x …

如何将空列添加到数据框？

这已经部分覆盖。

该dtype of df["D"] = np.nan在接受的答案是dtype=numpy.float64。

有没有办法在每个单元格中初始化一个空列表？

尝试过，df["D"] = [[]] * len(df)但是所有值都指向同一对象，将一个值设置为一个将全部设置。

df = pd.DataFrame({"A": [1,2,3], "B": [2,3,4]})
df

   A  B
0  1  2
1  2  3
2  3  4


df["D"] = [[]] * len(df)
df
   A  B   D
0  1  2  []
1  2  3  []
2  3  4  []


df['D'][1].append(['a','b','c','d'])
df
   A  B               D
0  1  2  [[a, b, c, d]]
1  2  3  [[a, b, c, d]]
2  3  4 …

我正在做一些字符串解析,如果字符是字母则要返回1,如果字符是数字则返回2,如果字符是其他字符则返回.

通常我会使用for循环并像这样附加到它

string = 'hello123...'
values = []
for char in string:
    if char.isalpha():
        values.append(1)
    elif char.isdigit():
        values.append(2)

返回

[1, 1, 1, 1, 1, 2, 2, 2]

正如所料.根据/sf/answers/2117182581/使用列表推导可以快得多.所以我尝试过:

values = [1 if char.isalpha else 2 if char.isdigit for char in string]

但是,这给了我一个语法错误,因为'else'是预期的.

File "C:/Users/test3.py", line 12
values = [1 if char.isalpha else 2 if char.isdigit for char in string]
                                                     ^
SyntaxError: invalid syntax

如果角色不是字母数字,我希望它不添加任何内容.我的代码出了什么问题？

我将不得不执行这个功能数十亿次,所以如果有更好的方法可以做到这一点,那么效率的提高是值得欢迎的.