小编Tom*_*ski的帖子

我创建一个列表如下:

['v0' if x%4==0 else 'v1' if x%4==1 else 'v2' if x%4==2 else 'v3' for x in list_1]

如何推广这样一个列表的创建,以便它可以通过更多的变量和后续条件轻松扩展？

我有一个算法,创建一个图形,其中包含以最短图形路径的形式编码的3位二进制字符串的所有表示,其中路径中的偶数表示0,而奇数表示1:

from itertools import permutations, product
import networkx as nx
import progressbar
import itertools

def groups(sources, template):
    func = permutations
    keys = sources.keys()
    combos = [func(sources[k], template.count(k)) for k in keys]
    for t in product(*combos):
        d = {k: iter(n) for k, n in zip(keys, t)}
        yield [next(d[k]) for k in template]                                      

g = nx.Graph()

added = []   
good = []
index = []
# I create list with 3-bit binary strings
# I do not include one of the pairs …

我扩展并添加了一个新问题.

我有一个清单:

li = [2, 3, 1, 4, 2, 2, 2, 3, 1, 3, 2] 

然后我认识到哪个值最常出现,我保留在变量中的值i2:

f = {}
for item in li:
    f[item] = f.get(item, 0) + 1   

for i in f:
    if f[i]==int(max(f.values())):
       i2 = i

之后,重复的所有值都会增加10,但除了最大值之外.这是我使用的代码:

for i in range(len(li)):
    for x in range(i + 1, len(li)):
        if li[i] == li[x] and li[i] != i2:
           li[x] = li[x] + 10

完成此操作后,我得到:

li = [2, 3, 1, 4, 2, 2, 2, 13, 11, 23, 2]

如您所见,最常见的值是2,因此它保持不变.例如,3发生三次,并且从所有三个新值创建3,3 …

我使用以下itertools.product函数创建笛卡尔积：

from itertools import product

a = list(map(list, itertools.product(list(range(2)), repeat=3)))

输出：

[[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1]]

然后我通过以下方式摆脱镜子反射：

b = [] 
for k, v in enumerate(a):
    if v[::-1] not in a[:k]:
       b.append(v[::-1])

输出：

[[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0], [1, 0, 1], [1, 1, 1]]

但是我可以在不保存itertools.product列表中的所有结果的情况下逐步获得相同的效果吗？例如，使用 for 循环的常用方法：

for i in list(map(list, …

提供数据框：

a = pd.DataFrame({'A':[1, 2]})
b = pd.DataFrame({'B':[2, 3]})
C = pd.DataFrame({'C':[4, 5]})

并列出 d = [A, C, B, B]

如何(((A + C) * B) - B)对帧值编写数学运算以创建新的数据帧？

例如，结果是以下形式的框架：

e = pd.DataFrame({'E':[8, 18]})

我使用以下方法创建所有三元素排列而不进行镜像itertools.product():

import itertools

list_1 = [list(i) for i in itertools.product(tuple(range(4)), repeat=3) if tuple(reversed(i)) >= tuple(i)]

输出:

[[0, 0, 0], [0, 0, 1], [0, 0, 2], [0, 0, 3], [0, 1, 0], [0, 1, 1], [0, 1, 2], [0, 1, 3], [0, 2, 0], [0, 2, 1], [0, 2, 2], [0, 2, 3], [0, 3, 0], [0, 3, 1], [0, 3, 2], [0, 3, 3], [1, 0, 1], [1, 0, 2], [1, 0, 3], [1, 1, 1], [1, 1, …

我在csv中有一个数组:

    date        group
0   2015-01-02  WODKA
1   2015-01-02  PIWO
2   2015-01-02  2015-01-02
3   2015-01-03  WODKA
4   2015-01-03  PIWO
5   2015-01-03  2015-01-03
6   2015-01-03  WODKA
7   2015-01-03  PIWO

我想将所有日期从"group"列转换为"sum".但我的代码不起作用......

import pandas as pd
import numpy as np
from datetime import datetime as dt

x = pd.read_csv("C:\\Users\dell\\Desktop\\list_1.csv", sep=';')
x.group = x.group.replace(dt, 'sum')

我有一个简单的递归函数及其值的生成器：

def rec(n):
    if n == 1:
        return 1
    else:
        return n + rec(n-1)

lis=[]    
for i in range(1,1000):
    lis.append(rec(i))

输出：

[1, 3, 6, 10, 15, 21, 28, 36,...]

可以在这样的结构中使用多处理吗？

我有这段代码:

for aaa_binary in groups(sources, a):

    if len(dodane_pary)!=count:

       g.add_nodes_from (aaa_binary)
       t1 = (aaa_binary[0],aaa_binary[1])
       t2 = (aaa_binary[1],aaa_binary[2])
       t3 = (aaa_binary[2],aaa_binary[3])                                                 

       added_now = []                      
       for edge in (t1,t2,t3):
           if not g.has_edge(*edge):
              g.add_edge(*edge)
              added_now.append(edge)

       dodane_pary.append(aaa_binary)  

       for j in range(len(dodane_pary)):
           if nx.shortest_path(g, aaa_binary[0], aaa_binary[3])!=aaa_binary or nx.shortest_path(g, dodane_pary[j][0], dodane_pary[j][3])!=dodane_pary[j]:
              for edge in added_now:
                  g.remove_edge(*edge)
              dodane_pary.remove(aaa_binary)
              break
    else: 
        break

因此,我可能无法在我的程序中使用多处理,所以我想首先测试代码的速度,然后将其作为列表展平.

怎么做得最好？用碎片压扁是否更好？例如,对于for/if？或者更大的碎片？