mirror of
https://gitflic.ru/project/openide/openide.git
synced 2025-12-16 22:51:17 +07:00
c44fb89c28
Migrate to DocumentationMarkup elements GitOrigin-RevId: ea4d71638b1dd3a160521e655fd2a1670ea27701
98 lines
14 KiB
HTML
98 lines
14 KiB
HTML
<html><body><div class="content"><div class="section" id="notin">
|
|
<span id="in"></span><span id="isnot"></span><span id="is"></span><span id="comparisons"></span><span id="id12"></span><h2>Comparisons</h2>
|
|
<span class="target" id="index-970"></span><p id="index-971">Unlike C, all comparison operations in Python have the same priority, which is
|
|
lower than that of any arithmetic, shifting or bitwise operation. Also unlike
|
|
C, expressions like <tt class="docutils literal"><span class="pre">a</span> <span class="pre"><</span> <span class="pre">b</span> <span class="pre"><</span> <span class="pre">c</span></tt> have the interpretation that is conventional
|
|
in mathematics:</p>
|
|
<pre>
|
|
<strong id="grammar-token-comparison">comparison </strong> ::= <a class="reference internal" href="#grammar-token-or_expr"><tt class="xref docutils literal"><span class="pre">or_expr</span></tt></a> ( <a class="reference internal" href="#grammar-token-comp_operator"><tt class="xref docutils literal"><span class="pre">comp_operator</span></tt></a> <a class="reference internal" href="#grammar-token-or_expr"><tt class="xref docutils literal"><span class="pre">or_expr</span></tt></a> )*
|
|
<strong id="grammar-token-comp_operator">comp_operator</strong> ::= "<" | ">" | "==" | ">=" | "<=" | "<>" | "!="
|
|
| "is" ["not"] | ["not"] "in"
|
|
</pre>
|
|
<p>Comparisons yield boolean values: <tt class="xref docutils literal"><span class="pre">True</span></tt> or <tt class="xref docutils literal"><span class="pre">False</span></tt>.</p>
|
|
<p id="index-972">Comparisons can be chained arbitrarily, e.g., <tt class="docutils literal"><span class="pre">x</span> <span class="pre"><</span> <span class="pre">y</span> <span class="pre"><=</span> <span class="pre">z</span></tt> is equivalent to
|
|
<tt class="docutils literal"><span class="pre">x</span> <span class="pre"><</span> <span class="pre">y</span> <span class="pre">and</span> <span class="pre">y</span> <span class="pre"><=</span> <span class="pre">z</span></tt>, except that <tt class="docutils literal"><span class="pre">y</span></tt> is evaluated only once (but in both
|
|
cases <tt class="docutils literal"><span class="pre">z</span></tt> is not evaluated at all when <tt class="docutils literal"><span class="pre">x</span> <span class="pre"><</span> <span class="pre">y</span></tt> is found to be false).</p>
|
|
<p>Formally, if <em>a</em>, <em>b</em>, <em>c</em>, ..., <em>y</em>, <em>z</em> are expressions and <em>op1</em>, <em>op2</em>, ...,
|
|
<em>opN</em> are comparison operators, then <tt class="docutils literal"><span class="pre">a</span> <span class="pre">op1</span> <span class="pre">b</span> <span class="pre">op2</span> <span class="pre">c</span> <span class="pre">...</span> <span class="pre">y</span> <span class="pre">opN</span> <span class="pre">z</span></tt> is equivalent
|
|
to <tt class="docutils literal"><span class="pre">a</span> <span class="pre">op1</span> <span class="pre">b</span> <span class="pre">and</span> <span class="pre">b</span> <span class="pre">op2</span> <span class="pre">c</span> <span class="pre">and</span> <span class="pre">...</span> <span class="pre">y</span> <span class="pre">opN</span> <span class="pre">z</span></tt>, except that each expression is
|
|
evaluated at most once.</p>
|
|
<p>Note that <tt class="docutils literal"><span class="pre">a</span> <span class="pre">op1</span> <span class="pre">b</span> <span class="pre">op2</span> <span class="pre">c</span></tt> doesn’t imply any kind of comparison between <em>a</em> and
|
|
<em>c</em>, so that, e.g., <tt class="docutils literal"><span class="pre">x</span> <span class="pre"><</span> <span class="pre">y</span> <span class="pre">></span> <span class="pre">z</span></tt> is perfectly legal (though perhaps not
|
|
pretty).</p>
|
|
<p>The forms <tt class="docutils literal"><span class="pre"><></span></tt> and <tt class="docutils literal"><span class="pre">!=</span></tt> are equivalent; for consistency with C, <tt class="docutils literal"><span class="pre">!=</span></tt> is
|
|
preferred; where <tt class="docutils literal"><span class="pre">!=</span></tt> is mentioned below <tt class="docutils literal"><span class="pre"><></span></tt> is also accepted. The <tt class="docutils literal"><span class="pre"><></span></tt>
|
|
spelling is considered obsolescent.</p>
|
|
<p>The operators <tt class="docutils literal"><span class="pre"><</span></tt>, <tt class="docutils literal"><span class="pre">></span></tt>, <tt class="docutils literal"><span class="pre">==</span></tt>, <tt class="docutils literal"><span class="pre">>=</span></tt>, <tt class="docutils literal"><span class="pre"><=</span></tt>, and <tt class="docutils literal"><span class="pre">!=</span></tt> compare the
|
|
values of two objects. The objects need not have the same type. If both are
|
|
numbers, they are converted to a common type. Otherwise, objects of different
|
|
types <em>always</em> compare unequal, and are ordered consistently but arbitrarily.
|
|
You can control comparison behavior of objects of non-built-in types by defining
|
|
a <tt class="docutils literal"><span class="pre">__cmp__</span></tt> method or rich comparison methods like <tt class="docutils literal"><span class="pre">__gt__</span></tt>, described in
|
|
section <a class="reference external" href="datamodel.html#specialnames"><em>Special method names</em></a>.</p>
|
|
<p>(This unusual definition of comparison was used to simplify the definition of
|
|
operations like sorting and the <a class="reference internal" href="#in"><tt class="xref docutils literal"><span class="pre">in</span></tt></a> and <a class="reference internal" href="#notin"><tt class="xref docutils literal"><span class="pre">not</span> <span class="pre">in</span></tt></a> operators.
|
|
In the future, the comparison rules for objects of different types are likely to
|
|
change.)</p>
|
|
<p>Comparison of objects of the same type depends on the type:</p>
|
|
<ul>
|
|
<li><p class="first">Numbers are compared arithmetically.</p>
|
|
</li>
|
|
<li><p class="first">Strings are compared lexicographically using the numeric equivalents (the
|
|
result of the built-in function <a title="ord" class="reference external" href="../library/functions.html#ord"><tt class="xref docutils literal"><span class="pre">ord()</span></tt></a>) of their characters. Unicode and
|
|
8-bit strings are fully interoperable in this behavior. <a class="footnote-reference" href="#id22" id="id13">[4]</a></p>
|
|
</li>
|
|
<li><p class="first">Tuples and lists are compared lexicographically using comparison of
|
|
corresponding elements. This means that to compare equal, each element must
|
|
compare equal and the two sequences must be of the same type and have the same
|
|
length.</p>
|
|
<p>If not equal, the sequences are ordered the same as their first differing
|
|
elements. For example, <tt class="docutils literal"><span class="pre">cmp([1,2,x],</span> <span class="pre">[1,2,y])</span></tt> returns the same as
|
|
<tt class="docutils literal"><span class="pre">cmp(x,y)</span></tt>. If the corresponding element does not exist, the shorter sequence
|
|
is ordered first (for example, <tt class="docutils literal"><span class="pre">[1,2]</span> <span class="pre"><</span> <span class="pre">[1,2,3]</span></tt>).</p>
|
|
</li>
|
|
<li><p class="first">Mappings (dictionaries) compare equal if and only if their sorted (key, value)
|
|
lists compare equal. <a class="footnote-reference" href="#id23" id="id14">[5]</a> Outcomes other than equality are resolved
|
|
consistently, but are not otherwise defined. <a class="footnote-reference" href="#id24" id="id15">[6]</a></p>
|
|
</li>
|
|
<li><p class="first">Most other objects of built-in types compare unequal unless they are the same
|
|
object; the choice whether one object is considered smaller or larger than
|
|
another one is made arbitrarily but consistently within one execution of a
|
|
program.</p>
|
|
</li>
|
|
</ul>
|
|
<p id="membership-test-details">The operators <a class="reference internal" href="#in"><tt class="xref docutils literal"><span class="pre">in</span></tt></a> and <a class="reference internal" href="#notin"><tt class="xref docutils literal"><span class="pre">not</span> <span class="pre">in</span></tt></a> test for collection
|
|
membership. <tt class="docutils literal"><span class="pre">x</span> <span class="pre">in</span> <span class="pre">s</span></tt> evaluates to true if <em>x</em> is a member of the collection
|
|
<em>s</em>, and false otherwise. <tt class="docutils literal"><span class="pre">x</span> <span class="pre">not</span> <span class="pre">in</span> <span class="pre">s</span></tt> returns the negation of <tt class="docutils literal"><span class="pre">x</span> <span class="pre">in</span> <span class="pre">s</span></tt>.
|
|
The collection membership test has traditionally been bound to sequences; an
|
|
object is a member of a collection if the collection is a sequence and contains
|
|
an element equal to that object. However, it make sense for many other object
|
|
types to support membership tests without being a sequence. In particular,
|
|
dictionaries (for keys) and sets support membership testing.</p>
|
|
<p>For the list and tuple types, <tt class="docutils literal"><span class="pre">x</span> <span class="pre">in</span> <span class="pre">y</span></tt> is true if and only if there exists an
|
|
index <em>i</em> such that <tt class="docutils literal"><span class="pre">x</span> <span class="pre">==</span> <span class="pre">y[i]</span></tt> is true.</p>
|
|
<p>For the Unicode and string types, <tt class="docutils literal"><span class="pre">x</span> <span class="pre">in</span> <span class="pre">y</span></tt> is true if and only if <em>x</em> is a
|
|
substring of <em>y</em>. An equivalent test is <tt class="docutils literal"><span class="pre">y.find(x)</span> <span class="pre">!=</span> <span class="pre">-1</span></tt>. Note, <em>x</em> and <em>y</em>
|
|
need not be the same type; consequently, <tt class="docutils literal"><span class="pre">u'ab'</span> <span class="pre">in</span> <span class="pre">'abc'</span></tt> will return
|
|
<tt class="xref docutils literal"><span class="pre">True</span></tt>. Empty strings are always considered to be a substring of any other
|
|
string, so <tt class="docutils literal"><span class="pre">""</span> <span class="pre">in</span> <span class="pre">"abc"</span></tt> will return <tt class="xref docutils literal"><span class="pre">True</span></tt>.</p>
|
|
<p class="versionchanged">
|
|
<span class="versionmodified">Changed in version 2.3: </span>Previously, <em>x</em> was required to be a string of length <tt class="docutils literal"><span class="pre">1</span></tt>.</p>
|
|
<p>For user-defined classes which define the <a title="object.__contains__" class="reference external" href="datamodel.html#object.__contains__"><tt class="xref docutils literal"><span class="pre">__contains__()</span></tt></a> method, <tt class="docutils literal"><span class="pre">x</span> <span class="pre">in</span>
|
|
<span class="pre">y</span></tt> is true if and only if <tt class="docutils literal"><span class="pre">y.__contains__(x)</span></tt> is true.</p>
|
|
<p>For user-defined classes which do not define <a title="object.__contains__" class="reference external" href="datamodel.html#object.__contains__"><tt class="xref docutils literal"><span class="pre">__contains__()</span></tt></a> but do define
|
|
<a title="object.__iter__" class="reference external" href="datamodel.html#object.__iter__"><tt class="xref docutils literal"><span class="pre">__iter__()</span></tt></a>, <tt class="docutils literal"><span class="pre">x</span> <span class="pre">in</span> <span class="pre">y</span></tt> is true if some value <tt class="docutils literal"><span class="pre">z</span></tt> with <tt class="docutils literal"><span class="pre">x</span> <span class="pre">==</span> <span class="pre">z</span></tt> is
|
|
produced while iterating over <tt class="docutils literal"><span class="pre">y</span></tt>. If an exception is raised during the
|
|
iteration, it is as if <a class="reference internal" href="#in"><tt class="xref docutils literal"><span class="pre">in</span></tt></a> raised that exception.</p>
|
|
<p>Lastly, the old-style iteration protocol is tried: if a class defines
|
|
<a title="object.__getitem__" class="reference external" href="datamodel.html#object.__getitem__"><tt class="xref docutils literal"><span class="pre">__getitem__()</span></tt></a>, <tt class="docutils literal"><span class="pre">x</span> <span class="pre">in</span> <span class="pre">y</span></tt> is true if and only if there is a non-negative
|
|
integer index <em>i</em> such that <tt class="docutils literal"><span class="pre">x</span> <span class="pre">==</span> <span class="pre">y[i]</span></tt>, and all lower integer indices do not
|
|
raise <a title="exceptions.IndexError" class="reference external" href="../library/exceptions.html#exceptions.IndexError"><tt class="xref docutils literal"><span class="pre">IndexError</span></tt></a> exception. (If any other exception is raised, it is as
|
|
if <a class="reference internal" href="#in"><tt class="xref docutils literal"><span class="pre">in</span></tt></a> raised that exception).</p>
|
|
<p id="index-973">The operator <a class="reference internal" href="#notin"><tt class="xref docutils literal"><span class="pre">not</span> <span class="pre">in</span></tt></a> is defined to have the inverse true value of
|
|
<a class="reference internal" href="#in"><tt class="xref docutils literal"><span class="pre">in</span></tt></a>.</p>
|
|
<p id="index-974">The operators <a class="reference internal" href="#is"><tt class="xref docutils literal"><span class="pre">is</span></tt></a> and <a class="reference internal" href="#isnot"><tt class="xref docutils literal"><span class="pre">is</span> <span class="pre">not</span></tt></a> test for object identity: <tt class="docutils literal"><span class="pre">x</span>
|
|
<span class="pre">is</span> <span class="pre">y</span></tt> is true if and only if <em>x</em> and <em>y</em> are the same object. <tt class="docutils literal"><span class="pre">x</span> <span class="pre">is</span> <span class="pre">not</span> <span class="pre">y</span></tt>
|
|
yields the inverse truth value. <a class="footnote-reference" href="#id25" id="id16">[7]</a></p>
|
|
</div>
|
|
</div></body></html> |