相关疑难解决方法(0)

我确定之前已经出现过这个问题,但我找不到一个确切的例子.

我有2个列表,并希望将第二个附加到第一个,只有值尚未存在.

到目前为止,我有工作代码,但想知道是否有更好的,更多的"Pythonic"是这样的:

>>> list1
[1, 2, 3]
>>> list2
[2, 4]
>>> list1.extend([x for x in list2 if x not in list1])
>>> list1
[1, 2, 3, 4]

编辑 基于所做的评论,此代码不满足仅添加一次,即:

>>> list1 = [1,2,3]
>>> list2 = [2,4,4,4]
>>> list1.extend([x for x in list2 if x not in list1])
>>> list1
[1, 2, 3, 4, 4, 4]

我怎么会最终得到:

[1, 2, 3, 4]

我正在使用从这个答案链接到的ordered_set模块的 1.2版本(目前是最新版本).我一直在做一些奇怪的行为,并追溯到这个:

from ordered_set import OrderedSet
import pickle

os_orig = OrderedSet()
print os_orig # 'OrderedSet'
print os_orig.items # '[]'
pickled = pickle.dumps(os_orig)
loaded = pickle.loads(pickled)
print loaded

哪个加注AttributeError: 'OrderedSet' object has no attribute 'items'.如果OrderedSet不为空,一切都会好起来的.

不幸的是,当谈到泡菜时,我总是在脑子里 - 出了什么问题？

编辑:我应该补充一点,该模块似乎支持泡菜.来自自述文件:"添加了一个__getstate__,__setstate__所以可以腌制"

可能重复:
如何在保留顺序的同时从Python中的列表中删除重复项？
Python有一个有序集吗？

我发现自己经常做以下事情:

list_of_items # I have a list of items
set(list_of_items) # I want to remove duplicates

但是,在转换为a时set,我失去了列表中的初始顺序,这很重要.

删除列表中重复项的最佳方法是什么？保持列表的初始(相对)排序？

我有两个示例列表，

vals = ["a", "c", "d", "e", "f", "g"]
xor  = ["c", "g"] 

我想vals根据xor列表对列表进行排序，即，中的值xor应按vals确切顺序排在列表的首位。中存在的其余值vals应保持相同的顺序。

此外，在这些情况下，值xor可能不在，vals只是忽略这些值。而且，在重复的情况下，我只需要一个值。

期望的输出：

vals = ["c", "g", "a", "d", "e", "f"]
# here a, d, e, f are not in xor so we keep them in same order as found in vals.

我的方法：

new_list = []
for x in vals:
    for y in xor:
        if x == y:
            new_list.append(x)
            
for x in vals: …

使用此代码:

print set(a**b for a in range(2, 5) for b in range(2, 5))

我得到了这个答案:

set([64, 256, 4, 8, 9, 16, 81, 27])

为什么没有排序？

在Python3中,我写了一个简单的一行代码,如下所示:

{ 2*x  for x in {1,2,3,4} } 

但我得到这样的答案(订单改变了).

{8, 2, 4, 6}

为什么我得到答案{8,2,4,6}而不是{2,4,6,8}？

我有以下python代码几乎适合我(我很接近!).我有一个正在开放的莎士比亚戏剧的文本文件:原始文本文件:

"但通过那个窗户打破了光线

它是东部,朱丽叶是太阳

太阳公平,杀死羡慕的月亮

谁已经病了,脸色苍白悲伤"

我给我的代码的结果是这样的:

['升起','但','它','朱丽叶','谁','已经','和','和','和','打破','东','羡慕','公平','悲伤','是','是','是','杀','轻','月亮','苍白','病态','软','太阳','太阳' ,'the','the','the','through','what','window','with','yonder']

所以这几乎就是我想要的:它已经按照我想要的方式排列在列表中,但是如何删除重复的单词呢？我正在尝试创建一个新的ResultsList并将单词附加到它,但它给了我上面的结果,而没有删除重复的单词.如果我"打印结果列表",它只会丢弃大量的单词.我现在的方式已接近,但我想摆脱额外的"和","是","太阳"和"'s"....我想保持简单并使用append(),但我不知道如何才能让它发挥作用.我不想对代码做任何疯狂的事情.为了删除重复的单词,我在代码中遗漏了哪些简单的东西？

fname = raw_input("Enter file name: ")  
fhand = open(fname)
NewList = list()      #create new list
ResultList = list()    #create new results list I want to append words to

for line in fhand:
    line.rstrip()       #strip white space
    words = line.split()    #split lines of words and make list
        NewList.extend(words)   #make the list from 4 lists to 1 list

    for word in line.split():   #for each word in line.split()
        if words not in line.split():    #if …

是否有一个运算符可以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，即：

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

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

我正在努力在我的絮凝功能中找到错误.

该函数的目标是获取一个列表并将每组连续值组合成一个值.例如...

[1, 4, 4, 2, 0, 3, 3, 3] => [1, 4, 2, 0, 3]

现在的功能是......

def flocculate(array):
    for index1, val1 in enumerate(array):
        if val1 == 0 or not not val1:
            new_array = array[index1+1:]
            for index2, val2 in enumerate(new_array):
                if array[index1] == val2:
                    array[index1 + index2 + 1] = False
                else:
                    break
    return [value for value in array if type(value) is not bool]

但是,它似乎没有很好地处理零.

例如,下面显示的输入得到一些零正确,但是错过了其他一些......

[2, 4, 4, 0, 3, 7, 0, 2, 2, 2, 8, 0, 0, 0] …

考虑这两个类:

class Test(int):
    difference = property(lambda self: self.__sub__)

class Test2(int):
    difference=lambda self: self.__sub__

这两个班级有什么区别吗？新增:如果是这样,使用该属性存储返回另一个函数的lambda函数的目的是什么？

更新:首先将问题更改为我应该问的问题.抱歉.虽然我现在可以从答案中知道解决方案,但在这种情况下我做自我回答是不公平的.(至少几天没有留下答案).

更新2:对不起,我还不够清楚.问题是关于特定的建筑,而不是一般的属性.

编辑:谢谢.我假设集合是有序的,因为输出几乎按字母顺序排列.但是,我想要一个有序集.

def create_table(secret):    
    sec = set(secret) 
    alpha = set("abcdefghiklmnopqrstuvwxyz")
    bet = alpha - sec

    newSecret = secret & bet

    print newSecret



 OUTPUT:  set(['A', 'C', 'B', 'E', 'D', 'G', 'F', 'I', 'H', 'K', 'M', 'L', 'O', 'N', 'Q', 'P', 'S', 'R', 'U', 'T', 'W', 'V', 'Y', 'X', 'Z'])

如何创建有序集？

示例:如果我取字符串"mathics"和字符串"abcdefghiklmnopqrstuvwxyz",基本上新字符串应该是"MATHEICSBDFGKLNOPQRUVWXYZ"(假设我的代码大写字符串).这个字符串中没有'J',所以它不是拼写错误.

我正在尝试从变量'secret'中获取唯一字符,并从变量'alpha'中获取唯一字符,并从两者中获取有序的唯一字符.

如何与列表和集合相交以保留列表的顺序？简单的例子:

k=[1,2,3,4]
d={3,2}
d.intersection(k)
[2,3]#this is the ideal result

编辑:速度是这里最重要的因素