标签: nested-lists

我需要在Python中创建一个列表列表,所以我输入以下内容:

myList = [[1] * 4] * 3

列表看起来像这样:

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

然后我改变了最里面的一个值:

myList[0][0] = 5

现在我的列表看起来像这样:

[[5, 1, 1, 1], [5, 1, 1, 1], [5, 1, 1, 1]]  

这不是我想要或期望的.有人可以解释一下发生了什么,以及如何解决这个问题？

W3文档有一个前缀为的嵌套列表示例DEPRECATED EXAMPLE:,但它们从未使用非弃用示例对其进行更正,也未解释该示例的确切错误.

那么这些方法中哪一种是编写HTML列表的正确方法？

选项1:嵌套<ul>是父级的子级<ul>

<ul>
    <li>List item one</li>
    <li>List item two with subitems:</li>
    <ul>
        <li>Subitem 1</li>
        <li>Subitem 2</li>
    </ul>
    <li>Final list item</li>
</ul>

选项2:嵌套<ul>是<li>它所属的子级

<ul>
    <li>List item one</li>
    <li>List item two with subitems:
        <ul>
            <li>Subitem 1</li>
            <li>Subitem 2</li>
        </ul>
    </li>
    <li>Final list item</li>
</ul>

我正试图在Bitbucket页面的浏览器中查看时,看到我的markdown嵌套列表项呈现了相应的缩进.但即使使用他们的例子(更新),我也无法弄清楚它是如何工作的:

* Item 1
* Item 2
* Item 3
  * Item 3a
  * Item 3b
  * Item 3c

它忽略了项目3a-c的缩进:

我希望它看起来像这样(语法在SE和Github上运行得非常好):

它们在列表中列表的例子是特别不能接受的:

1. Step 1
2. Step 2
3. Step 3
   * Item 3a
   * Item 3b
   * Item 3c

这是我为此设立的回购.

为什么这两个操作(append()分别+)给出不同的结果？

>>> c = [1, 2, 3]
>>> c
[1, 2, 3]
>>> c += c
>>> c
[1, 2, 3, 1, 2, 3]
>>> c = [1, 2, 3]
>>> c.append(c)
>>> c
[1, 2, 3, [...]]
>>> 

在最后一种情况下,实际上存在无限递归.c[-1]并且c是一样的.为什么它与+操作不同？

假设,作为记录代码(Javadoc)的一部分,您希望使用深度缩进来指示元素之间的关系.

如何创建嵌套列表:

• 一些元素
  • 其他一些因素
    • 还有一些其他因素

有没有办法让twitter引导程序中的嵌套列表看起来像普通列表,嵌套项只是简单缩进(并使其适用于任意深度嵌套)？默认情况下,嵌套列表如下所示:

<ul class="list-group">
    <li class="list-group-item">One</li>
    <li class="list-group-item">Two
        <ul class="list-group">
            <li class="list-group-item">Item 2a</li>
            <li class="list-group-item">Item 2b</li>
        </ul>
    </li>
    <li class="list-group-item">Three
        <ul class="list-group">
            <li class="list-group-item">Item 3a</li>
            <li class="list-group-item">Item 3b</li>
        </ul>
    </li>
</ul>

如何使这些嵌套列表看起来像这样(或以类似的方式):

如果你错过了上面的链接,这里是JSFiddle:https://jsfiddle.net/7o8rp0kv/1/

我有一个2D列表,如下所示:

table = [['donkey', '2', '1', '0'], ['goat', '5', '3', '2']]

我想将最后三个元素更改为整数,但下面的代码感觉非常难看:

for row in table:
    for i in range(len(row)-1):
        row[i+1] = int(row[i+1])

但我宁愿有一些看起来像:

for row in table:
    for col in row[1:]:
        col = int(col)

我认为应该有一种方法来编写上面的代码,但是切片创建了一个与原始代码分开的迭代器/新列表,因此引用不会延续.

有没有办法获得更多的Pythonic解决方案？

是否可以直接选择列表中所有嵌套列表的列？
我的列表是使用aggregate()和table()创建的:

AgN=aggregate(data,by=list(d$date),FUN=table,useNA="no")

AgN$x 好像:

$`0`

      1           2           3           9          11 
0.447204969 0.438509317 0.096894410 0.009937888 0.007453416 

$`1`

          1           2           4           8          11 
0.489974937 0.389724311 0.102756892 0.006265664 0.011278195 

…

$n

我想获得每个表的特定列的向量,例如包含名为"1"的所有列的值的向量.我仍然是R初学者,但即使经过长时间的搜索和尝试,我找不到好的解决方案.如果我想获得列表的字段,我可以简单地用括号对其进行索引,例如[i,j].
在线我发现了一些矩阵的例子,所以我尝试做同样的事情,首先只选择一个嵌套列表的列AgN$x[1][1],但是仍然选择一个完整的列表:

$0

     1           2           3           8          11 

Run Code Online (Sandbox Code Playgroud)

0.447204969 0.438509317 0.096894410 0.009937888 0.007453416

我的下一次尝试是AgN$x[[1]][1],它正在工作:

  1 

Run Code Online (Sandbox Code Playgroud)

0.447205

所以我试图选择所有嵌套列表的每个第一列的值:

AgN$x[[1:length(AgN$x]][1]
Recursive indexing failed at level 2

显然问题是如果使用双括号则禁止选择范围.

我的最后一次尝试是使用for循环:

cduR=NULL 
for (i in 1:length(AgN$x)){
t=AgN$x[[i]]
cduR=c(cduR,as.vector(t["1"]))
}

最后,到目前为止似乎有效.但是这样我每次想要选择列时都必须构建一个循环.有没有直接的方法？

谢谢你的帮助.

我试图将嵌套的列表列表转换为Python 3.3中的元组列表.但是,似乎我没有这样做的逻辑.

输入如下:

>>> nested_lst = [['tom', 'cat'], ['jerry', 'mouse'], ['spark', 'dog']]

所需的输出应如下所示:

nested_lst_of_tuples = [('tom', 'cat'), ('jerry', 'mouse'), ('spark', 'dog')]

说我有一个这样的列表:

[1, 4, None, 6, 9, None, 3, 9, 4 ]

我决定将其拆分为嵌套列表None,以获得:

[ [ 1, 4 ], [ 6, 9 ], [ 3, 9, 4 ] ]

当然,我可能想要这样做,(9, None)在这种情况下,我们会得到:

[ [ 1, 4 ], [ 6 ], [ 3 ], [ 4 ] ]

通过迭代使用列表追加(在for循环中)这是微不足道的

我很想知道这是否可以更快地完成 - 比如列表理解？

如果没有,为什么不(例如,列表推导每次迭代不能返回多个列表元素？)