标签: nested-lists

我确信这已在某个地方得到解答,但我不确定如何描述它.

假设我想创建一个包含3个空列表的列表,如下所示:

lst = [[], [], []]

这样做我以为我很聪明:

lst = [[]] * 3

但是我发现,在调试了一些奇怪的行为之后,这导致了对一个子列表的追加更新,比如lst[0].append(3),更新整个列表,[[3], [3], [3]]而不是[[3], [], []].

但是,如果我用列表初始化列表

lst = [[] for i in range(3)]

然后做lst[1].append(5)了预期的[[], [5], []]

我的问题是为什么会发生这种情况？有趣的是,如果我这样做

lst = [[]]*3
lst[0] = [5]
lst[0].append(3)

那么单元格0的"连接"就被打破了[[5,3],[],[]],但是我得到了,但lst[1].append(0)仍然会导致[[5,3],[0],[0].

我最好的猜测是在表单中使用乘法[[]]*x会导致Python存储对单个单元格的引用......？

我有一个分配给变量的列表my_list.价值my_list是[[1,2,3],[3,5,[2,3]], [[3,2],[5,[4]]]].我需要找到长度my_list,但len(my_list)只返回3.我希望它返回11.是否有任何Python函数将返回my_list嵌套列表的全长和所有.

例:

Input
[[1,2,3],[3,5,[2,3]], [[3,2],[5,[4]]]]

Output
11

我想如果这不仅适用于数字,还适用于字符串.

我有一个嵌套列表,其中包含不同的对象,它们是嵌套列表中的重复对象对象,我正在尝试删除它们但我一直在

TypeError: unorderable types: practice() < practice()

我知道这个错误是由我尝试使用对象而不是整数引起但我不知道如何删除重复项这里是我试过的

class practice:
    id = None

    def __init__(self,id):
        self.id = id

a = practice('a')
b = practice('b')
c = practice('c')
d = practice('d')
e = practice('e')
f = practice('f')

x = [[a,b],[c,d],[a,b],[e,f],[a,b]]

unique_list = list()
for item in x:
    if sorted(item) not in unique_list:
        unique_list.append(sorted(item))

print(unique_list)

在R中,我试图创建一种方法来将函数参数转换...为闭包函数中预定列表中的值.

我希望能够做到这样的事情:

function_generator <- function(args_list = list(a = "a", 
                                                b = "b", 
                                                c = list(d = "d", 
                                                         e = "e")){

    g <- function(...){
         ## ... will have same names as args list
         ## e.g. a = "changed_a", d = "changed_d"
         ## if absent, then args_list stays the same e.g. b="b", e="e"
         arguments <- list(...)
         modified_args_list <- amazing_function(arguments, args_list)
         return(modified_args_list)
         } 

    }

args_list每次都会有所不同 - 它是一个在httr请求中发送的正文对象.

如果列表没有嵌套列表,我有一个有效的函数:

substitute.list <- function(template, replace_me){

  template[names(replace_me)] <- 
    replace_me[intersect(names(template),names(replace_me))]

  return(template)

}

t …

假设我有一个代表一些嵌套列表的字符串,我想把它转换成真实的东西.我想,我能做到这一点:

exec "myList = ['foo', ['cat', ['ant', 'bee'], 'dog'], 'bar', 'baz']"

但是在用户可能提供字符串来执行的环境中,这可能是一个坏主意.有没有人想要一个能够完成同样事情的整洁解析器？

假设我想在Haskell中添加两个列表.最常用的方法是什么？

这是我做的:

addLists :: (Integral a) => [a] -> [a] -> [a]
addLists xs ys = map add $ zip xs ys
    where add (x, y) = x+y

这个星期我一直在修补python,我陷入了困境.如果我有这样的2D列表:myList = [[1,2],[3,4],[5,6]]

我这样做了

myList = [[1,2],[3,4],[5,6]]

它会回来

>>>myList.index([3,4])

但是,我想要列表中的某些内容的索引,就像这样

1

它会回来的

    >>>myList.index(3)

有什么可以做到这一点？

干杯

我尝试了一切(据我所知)分裂数组并将它们连接在一起甚至使用itertools:

import itertools

def oneDArray(x):
    return list(itertools.chain(*x))

我想要的结果:

一个) print oneDArray([1,[2,2,2],4]) == [1,2,2,2,4]

奇怪的是,它适用于

b) print oneDArray([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) == [1, 2, 3, 4, 5, 6, 7, 8, 9]

问题1)我如何以我想要的方式获得工作(任何提示？)

问题2)为什么以上代码适用于b部分而不是a部分？

我有这样的数据:

data = {'x':Counter({'a':1,'b':45}), 'y':Counter({'b':1, 'c':212})}

我的标签是其中的键,data内部字典的键是功能:

all_features = ['a','b','c']
all_labels = ['x','y']

我需要创建列表列表:

[[data[label][feat] for feat in all_features] for label in all_labels]

[OUT]:

[[1, 45, 0], [0, 1, 212]]

我len(all_features)的约为5,000,000,len(all_labels)约为100,000

最终目的是创建scipy稀疏矩阵,例如:

from collections import Counter
from scipy.sparse import csc_matrix
import numpy as np


all_features = ['a','b','c']
all_labels = ['x','y']

csc_matrix(np.array([[data[label][feat] for feat in all_features] for label in all_labels]))

但循环遍历大量列表是相当低效的.

那么如何才能有效地查看大量列表呢？

是否有其他方法可以创建scipy矩阵,而data无需循环遍历所有功能和标签？

我是python的初学者.我想知道是否有任何内置函数或其他方式,所以我可以在python 2.7中实现以下:

在列表和子列表中查找all -letter并将其替换为['not',letter]

例如:查找下面列表中以 - 开头的所有项目,并将其替换为['not',letter]

Input : ['and', ['or', '-S', 'Q'], ['or', '-S', 'R'], ['or', ['or', '-Q', '-R'], '-S']]
Output : ['and', ['or', ['not','S'], 'Q'], ['or', ['not','S'], 'R'], ['or', ['or', ['not','Q'], ['not','R']], ['not','S']]]

任何人都可以建议如何在python中做到这一点.谢谢