blocks|key|329395|text|为什么这很奇怪。如果字符串是不可变的，那么只将其存储一次很有意义。.NET具有相同的行为。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|329396|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Why is it strange. If the string is immutable it makes a lot of sense to only store it once. .NET has the same behavior.

blocks|key|3304186|text|Python+(如Java、C、C%2B%2B、.NET)使用字符串池/互操作。解释器意识到"hello“和"hello”是一样的，所以它优化并使用内存中的相同位置。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3304187|另一个好东西："hell"+%2B+"o"+is+"hello"+==>+True|offset|length|style|CODE|3304188|entityMap^0|0|7|N|Z|4|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]|$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|I|$]]

Python (like Java, C, C++, .NET) uses string pooling / interning. The interpreter realises that "hello" is the same as "hello", so it optimizes and uses the same location in memory.

Another goodie: <code>"hell" + "o" is "hello"</code> ==> <code>True</code>

blocks|key|329430|text|Python解释器/编译器解析字符串文字，即带引号的字符列表。当它这样做时，它可以检测到“我以前见过这个字符串”，并使用与上次相同的表示。它可以这样做，因为它知道以这种方式定义的字符串不能更改。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|329431|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The Python interpreter/compiler parses the string literals, i.e. the quoted list of characters. When it does this, it can detect "I've seen this string before", and use the same representation as last time. It can do this since it knows that strings defined in this way cannot be changed.

blocks|key|3091398|text|文字字符串可能是根据它们的散列或类似内容进行分组的。两个相同的文字字符串将存储在相同的内存中，任何引用都会引用该字符串。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3091399|+Memory++++++++Code
-------
%7C++++++++++myLine+=+"hello"
%7C++++++++/
%7Chello++<
%7C++++++++\
%7C++++++++++myLine+=+"hello"
-------|code-block|syntax|javascript|3091400|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Literal strings are probably grouped based on their hash or something similar. Two of the same literal strings will be stored in the same memory, and any references both refer to that.

<pre><code> Memory Code
-------
| myLine = "hello"
| /
|hello &lt;
| \
| myLine = "hello"
-------
</code></pre>

blocks|key|334461|text|如果两个参数都是同一个对象，则is运算符返回true。你的结果就是这样的结果，引用的部分。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|334462|在字符串文字的情况下，这些字符串是内嵌的，这意味着它们将与已知字符串进行比较。如果已知一个相同的字符串，则文字将采用该值，而不是另一个值。因此，它们成为相同的对象，并且表达式为真。|334463|entityMap^0|F|2|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

The <code>is</code> operator returns true if both arguments are the same object. Your result is a consequence of this, and the quoted bit. 

In the case of string literals, these are interned, meaning they are compared to known strings. If an identical string is already known, the literal takes that value, instead of an alternative one. Thus, they become the same object, and the expression is true.

blocks|key|332152|text|所以每个|type|unstyled|depth|inlineStyleRanges|entityRanges|data|332153|字符串在内存中只有一个位置？|blockquote|332154|332155|332156|不，只有解释器决定对其进行优化，这是一个基于策略的决定，该策略不是语言规范的一部分，并且在不同的CPython版本中可能会发生变化。|332157|例如：在我的安装(2.6.2+Linux)上：|332158|>>>+'X'*10+is+'X'*10
True
>>>+'X'*30+is+'X'*30
False|code-block|syntax|javascript|332159|ints也是如此：|332160|>>>+2**8+is+2**8
True
>>>+2**9+is+2**9
False|332161|所以不要依赖'string‘就是'string'：即使只是看看C实现，它也是不安全的。|332162|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Y|8|@]|9|@]|A|$]]|$1|E|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|11|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|12|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|13|8|@]|9|@]|A|$N|O]]|$1|P|3|Q|5|6|7|14|8|@]|9|@]|A|$]]|$1|R|3|S|5|M|7|15|8|@]|9|@]|A|$N|O]]|$1|T|3|U|5|6|7|16|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|W|$]]

<blockquote>
 So there is one and only one place in memory for every Python string?
</blockquote>

No, only ones the interpreter has decided to optimise, which is a decision based on a policy that isn't part of the language specification and which may change in different CPython versions.

eg. on my install (2.6.2 Linux):

<pre><code>&gt;&gt;&gt; 'X'*10 is 'X'*10
True
&gt;&gt;&gt; 'X'*30 is 'X'*30
False
</code></pre>

similarly for ints:

<pre><code>&gt;&gt;&gt; 2**8 is 2**8
True
&gt;&gt;&gt; 2**9 is 2**9
False
</code></pre>

So don't rely on 'string' is 'string': even just looking at the C implementation it isn't safe.

blocks|key|3091531|text|我认为如果任何两个变量(不仅仅是字符串)包含相同的值，该值将只存储一次，而不是两次，并且两个变量将指向相同的位置。这节省了内存。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3091532|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I think if any two variables (not just strings) contain the same value, the value will be stored only once not twice and both the variables will point to the same location. This saves memory.

Why does <code>"hello" is "hello"</code> produce <code>True</code> in Python?

I read the following <a href="http://zetcode.com/tutorials/pythontutorial/keywords/" rel="noreferrer">here</a>:

<blockquote>
 If two string literals are equal, they have been put to same
 memory location. A string is an immutable entity. No harm can
 be done.
</blockquote>

So there is one and only one place in memory for every Python string? Sounds pretty strange. What's going on here?

Python: Why does ("hello" is "hello") evaluate as True?

编译器

解释器

Python

Linux

Java

为什么"hello" is "hello"会在Python中生成True？我阅读了下面的如果两个字符串文字相等，则它们已放入相同的内存位置。字符串是一个不可变的实体。不能造成任何伤害。所以每个Python字符串在内存中只有一个位置？听起来很奇怪。这里发生了什么事？

问Python:为什么("hello“是"hello")计算为True？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python:为什么("hello“是"hello")计算为True？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python:为什么("hello“是"hello")计算为True？
EN