blocks|key|1451112|text|您正在使用list([0,+0])创建一个新列表，而不是一次又一次使用相同的列表。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1451113|entityMap^0|5|C|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

You're creating a new list with <code>list([0, 0])</code> versus using the same list over and over.

blocks|key|994004|text|list([0,0])每次都会创建一个新的list对象。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|994005|value+=+[0,+0]
v2+=+list(value)
assert+value+==+v2
assert+id(value)+!=+id(v2)|code-block|syntax|javascript|994006|entityMap^0|0|B|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

<code>list([0,0])</code> creates a new list object every time. 

<pre><code>value = [0, 0]
v2 = list(value)
assert value == v2
assert id(value) != id(v2)
</code></pre>

blocks|key|1451786|text|假设你有：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1451787|a+=+[0,+0]
b+=+list([0,+0])|code-block|syntax|javascript|1451788|a和b都是包含相同值的列表。但它们都是list的独特实例。|offset|length|style|CODE|1451789|现在，如果你这样做：|1451790|c+=+a
d+=+b|1451791|c指向a的同一个实例，d指向b，所以如果修改c的值，它也会反映在a中(+d和b也是一样)。|1451792|然而，如果你这样做了：|1451793|c+=+list(a)|1451794|您基本上是在创建a的浅表副本。这意味着，您创建了一个新的列表c，其中包含与a相同的值。因此，c的任何突变都不会影响a，因为它现在是唯一的list实例。|1451795|但是要小心，如果您的列表包含可变对象，它们仍然可以通过复制的列表进行变异。使用copy.deepcopy确保将所有对象复制为新对象。|1451796|entityMap^0|0|0|0|1|2|1|J|4|0|0|0|0|1|3|1|B|1|E|1|M|1|W|1|10|1|12|1|0|0|0|8|1|U|1|11|1|1A|1|1L|1|1W|4|0|13|D|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@$I|15|J|16|K|L]|$I|17|J|18|K|L]|$I|19|J|1A|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1B|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1D|8|@$I|1E|J|1F|K|L]|$I|1G|J|1H|K|L]|$I|1I|J|1J|K|L]|$I|1K|J|1L|K|L]|$I|1M|J|1N|K|L]|$I|1O|J|1P|K|L]|$I|1Q|J|1R|K|L]|$I|1S|J|1T|K|L]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1U|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1V|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1W|8|@$I|1X|J|1Y|K|L]|$I|1Z|J|20|K|L]|$I|21|J|22|K|L]|$I|23|J|24|K|L]|$I|25|J|26|K|L]|$I|27|J|28|K|L]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|29|8|@$I|2A|J|2B|K|L]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|2C|8|@]|9|@]|A|$]]]|11|$]]

Let's say you have:

<pre><code>a = [0, 0]
b = list([0, 0])
</code></pre>

Both <code>a</code> and <code>b</code> are lists containing the same values. But they're both unique instances of <code>list</code>.

Now, if you do:

<pre><code>c = a
d = b
</code></pre>

<code>c</code> points to the same instance of <code>a</code> and <code>d</code> to <code>b</code>, so if you modify the values of <code>c</code> it'll be reflected in <code>a</code> as well (same goes with <code>d</code> and <code>b</code>).

However, if you do:

<pre><code>c = list(a)
</code></pre>

You're basically creating a shallow copy of <code>a</code>. This means, you created a new list <code>c</code> containing the same values as those of <code>a</code>. So any mutation to <code>c</code> will not affect <code>a</code> since it's now a unique <code>list</code> instance.

Be careful though, if your list contains mutable objects they can still be mutated through the copied list. Use <code>copy.deepcopy</code> to ensure all objects are copied as new objects.

blocks|key|1451819|text|关于你的第二个问题，“本质上，我不明白的是list(0,0)如何不创建一个[0，0]列表？”|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1451820|list()函数的工作方式是，它接受某种类型的容器，特别是一个可迭代的容器作为参数，并对此进行迭代，将容器中的每个元素放入一个新列表中。|offset|length|style|CODE|1451821|例如，string是一个可迭代的元素，每个元素都是一个字符：|1451822|>>>+list('spam')
['s',+'p',+'a',+'m']|code-block|syntax|javascript|1451823|整数的tuple也是可迭代的：|1451824|>>>+list((1,+2,+3,+4))
[1,+2,+3,+4]|1451825|当然，列表本身是可迭代的，因此在现有的list()上运行list只会生成一个具有相同内容的新list：|1451826|>>>+list(['oranges','spam',22.3])
['oranges',+'spam',+22.3]|1451827|不能做的是将一个整数传递给list()，因为整数是不可迭代的：|1451828|>>>+list(42)
Traceback+(most+recent+call+last):
++File+"<stdin>",+line+1,+in+<module>
TypeError:+'int'+object+is+not+iterable|1451829|entityMap^0|0|0|6|0|3|6|0|0|3|5|0|0|J|6|S|4|1A|4|0|0|D|6|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@$D|14|E|15|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|16|8|@$D|17|E|18|F|G]]|9|@]|A|$]]|$1|J|3|K|5|L|7|19|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1A|8|@$D|1B|E|1C|F|G]]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1D|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1E|8|@$D|1F|E|1G|F|G]|$D|1H|E|1I|F|G]|$D|1J|E|1K|F|G]]|9|@]|A|$]]|$1|U|3|V|5|L|7|1L|8|@]|9|@]|A|$M|N]]|$1|W|3|X|5|6|7|1M|8|@$D|1N|E|1O|F|G]]|9|@]|A|$]]|$1|Y|3|Z|5|L|7|1P|8|@]|9|@]|A|$M|N]]|$1|10|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|11|$]]

Regarding your second question, "In essence, what I don't understand is how does list([0,0]) not create a list as [[0,0]]?"

The way the <code>list()</code> function works is that it takes as an argument some sort of container, specifically an iterable, and it iterates over this, putting each element in the container into a new list. 

For example, a <code>string</code> is an iterable and each element is a single character:

<pre><code>&gt;&gt;&gt; list('spam')
['s', 'p', 'a', 'm']
</code></pre>

A <code>tuple</code> of integers is also iterable:

<pre><code>&gt;&gt;&gt; list((1, 2, 3, 4))
[1, 2, 3, 4]
</code></pre>

And of course, a list itself is iterable, so running <code>list()</code> on an existing <code>list</code> just makes a new <code>list</code> with the same contents:

<pre><code>&gt;&gt;&gt; list(['oranges','spam',22.3])
['oranges', 'spam', 22.3]
</code></pre>

What you can't do is pass an integer to <code>list()</code> as an integer is not iterable:

<pre><code>&gt;&gt;&gt; list(42)
Traceback (most recent call last):
 File "&lt;stdin&gt;", line 1, in &lt;module&gt;
TypeError: 'int' object is not iterable
</code></pre>

blocks|key|994146|text|list(x)的意思是根据x的内容创建一个新的列表，而不是创建一个包含x作为其唯一元素的新元素列表。value的内容是两个数字(都是0)，因此list(value)生成了一个包含两个零的新列表。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|994147|在您的第一个示例中，没有创建任何新的列表；相同的列表value被设置为每个键的值。|994148|entityMap^0|0|7|Z|1|1E|5|1Z|B|0|Q|5|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|I|$]]

<code>list(x)</code> means to make a new list from the contents of x, not to make a new one-element list containing <code>x</code> as its only element. The contents of your <code>value</code> are two numbers (both 0), so <code>list(value)</code> makes a new list containing two zeros.

In your first example, no new lists are ever created; the same list <code>value</code> is set as the value for every key.

I ran into a problem as described in this <a href="https://stackoverflow.com/questions/15516413/dict-fromkeys-all-point-to-same-list">link</a>. While using the dict comprehension I typed

<pre><code>keys = [x for x in range(21)]
value = [0,0]
dict1 = {key: value for key in keys}
</code></pre>

instead of:

<pre><code>keys = [x for x in range(21)]
value = [0,0]
dict1 = {key: list(value) for key in keys}
</code></pre>

In the former case, the problem remains. All the key values point to the same list. Why does this happen? In essence, what I don't understand is how does list([0,0]) not create a list as [[0,0]]?

EDIT: I understand that list(arg) takes only 1 argument. But what does it mean to run list over a list?

python- How does list([0,0]) differ from [0,0]?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

我遇到了一个问题，如这个所描述的。在使用我输入的dict理解时keys = [x for x in range(21)]value = [0,0]dict1 = {key: value for key in keys}而不是：keys = [x for x in range(21)]value = [0,0]dict1...

问python- list( [0,0] )与[0，0]有什么不同？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问python- list( [0,0] )与[0，0]有什么不同？EN