diff options
Diffstat (limited to 'devdocs/python~3.12/library%2Foperator.html')
| -rw-r--r-- | devdocs/python~3.12/library%2Foperator.html | 299 |
1 files changed, 299 insertions, 0 deletions
diff --git a/devdocs/python~3.12/library%2Foperator.html b/devdocs/python~3.12/library%2Foperator.html new file mode 100644 index 00000000..785a11a1 --- /dev/null +++ b/devdocs/python~3.12/library%2Foperator.html @@ -0,0 +1,299 @@ + <span id="operator-standard-operators-as-functions"></span><h1>operator — Standard operators as functions</h1> <p><strong>Source code:</strong> <a class="reference external" href="https://github.com/python/cpython/tree/3.12/Lib/operator.py">Lib/operator.py</a></p> <p>The <a class="reference internal" href="#module-operator" title="operator: Functions corresponding to the standard operators."><code>operator</code></a> module exports a set of efficient functions corresponding to the intrinsic operators of Python. For example, <code>operator.add(x, y)</code> is equivalent to the expression <code>x+y</code>. Many function names are those used for special methods, without the double underscores. For backward compatibility, many of these have a variant with the double underscores kept. The variants without the double underscores are preferred for clarity.</p> <p>The functions fall into categories that perform object comparisons, logical operations, mathematical operations and sequence operations.</p> <p>The object comparison functions are useful for all objects, and are named after the rich comparison operators they support:</p> <dl class="py function"> <dt class="sig sig-object py" id="operator.lt"> +<code>operator.lt(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.le"> +<code>operator.le(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.eq"> +<code>operator.eq(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.ne"> +<code>operator.ne(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.ge"> +<code>operator.ge(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.gt"> +<code>operator.gt(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__lt__"> +<code>operator.__lt__(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__le__"> +<code>operator.__le__(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__eq__"> +<code>operator.__eq__(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__ne__"> +<code>operator.__ne__(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__ge__"> +<code>operator.__ge__(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__gt__"> +<code>operator.__gt__(a, b)</code> </dt> <dd> +<p>Perform “rich comparisons” between <em>a</em> and <em>b</em>. Specifically, <code>lt(a, b)</code> is equivalent to <code>a < b</code>, <code>le(a, b)</code> is equivalent to <code>a <= b</code>, <code>eq(a, +b)</code> is equivalent to <code>a == b</code>, <code>ne(a, b)</code> is equivalent to <code>a != b</code>, <code>gt(a, b)</code> is equivalent to <code>a > b</code> and <code>ge(a, b)</code> is equivalent to <code>a +>= b</code>. Note that these functions can return any value, which may or may not be interpretable as a Boolean value. See <a class="reference internal" href="../reference/expressions#comparisons"><span class="std std-ref">Comparisons</span></a> for more information about rich comparisons.</p> </dd> +</dl> <p>The logical operations are also generally applicable to all objects, and support truth tests, identity tests, and boolean operations:</p> <dl class="py function"> <dt class="sig sig-object py" id="operator.not_"> +<code>operator.not_(obj)</code> </dt> <dt class="sig sig-object py" id="operator.__not__"> +<code>operator.__not__(obj)</code> </dt> <dd> +<p>Return the outcome of <a class="reference internal" href="../reference/expressions#not"><code>not</code></a> <em>obj</em>. (Note that there is no <code>__not__()</code> method for object instances; only the interpreter core defines this operation. The result is affected by the <a class="reference internal" href="../reference/datamodel#object.__bool__" title="object.__bool__"><code>__bool__()</code></a> and <a class="reference internal" href="../reference/datamodel#object.__len__" title="object.__len__"><code>__len__()</code></a> methods.)</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.truth"> +<code>operator.truth(obj)</code> </dt> <dd> +<p>Return <a class="reference internal" href="constants#True" title="True"><code>True</code></a> if <em>obj</em> is true, and <a class="reference internal" href="constants#False" title="False"><code>False</code></a> otherwise. This is equivalent to using the <a class="reference internal" href="functions#bool" title="bool"><code>bool</code></a> constructor.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.is_"> +<code>operator.is_(a, b)</code> </dt> <dd> +<p>Return <code>a is b</code>. Tests object identity.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.is_not"> +<code>operator.is_not(a, b)</code> </dt> <dd> +<p>Return <code>a is not b</code>. Tests object identity.</p> </dd> +</dl> <p>The mathematical and bitwise operations are the most numerous:</p> <dl class="py function"> <dt class="sig sig-object py" id="operator.abs"> +<code>operator.abs(obj)</code> </dt> <dt class="sig sig-object py" id="operator.__abs__"> +<code>operator.__abs__(obj)</code> </dt> <dd> +<p>Return the absolute value of <em>obj</em>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.add"> +<code>operator.add(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__add__"> +<code>operator.__add__(a, b)</code> </dt> <dd> +<p>Return <code>a + b</code>, for <em>a</em> and <em>b</em> numbers.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.and_"> +<code>operator.and_(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__and__"> +<code>operator.__and__(a, b)</code> </dt> <dd> +<p>Return the bitwise and of <em>a</em> and <em>b</em>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.floordiv"> +<code>operator.floordiv(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__floordiv__"> +<code>operator.__floordiv__(a, b)</code> </dt> <dd> +<p>Return <code>a // b</code>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.index"> +<code>operator.index(a)</code> </dt> <dt class="sig sig-object py" id="operator.__index__"> +<code>operator.__index__(a)</code> </dt> <dd> +<p>Return <em>a</em> converted to an integer. Equivalent to <code>a.__index__()</code>.</p> <div class="versionchanged"> <p><span class="versionmodified changed">Changed in version 3.10: </span>The result always has exact type <a class="reference internal" href="functions#int" title="int"><code>int</code></a>. Previously, the result could have been an instance of a subclass of <code>int</code>.</p> </div> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.inv"> +<code>operator.inv(obj)</code> </dt> <dt class="sig sig-object py" id="operator.invert"> +<code>operator.invert(obj)</code> </dt> <dt class="sig sig-object py" id="operator.__inv__"> +<code>operator.__inv__(obj)</code> </dt> <dt class="sig sig-object py" id="operator.__invert__"> +<code>operator.__invert__(obj)</code> </dt> <dd> +<p>Return the bitwise inverse of the number <em>obj</em>. This is equivalent to <code>~obj</code>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.lshift"> +<code>operator.lshift(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__lshift__"> +<code>operator.__lshift__(a, b)</code> </dt> <dd> +<p>Return <em>a</em> shifted left by <em>b</em>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.mod"> +<code>operator.mod(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__mod__"> +<code>operator.__mod__(a, b)</code> </dt> <dd> +<p>Return <code>a % b</code>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.mul"> +<code>operator.mul(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__mul__"> +<code>operator.__mul__(a, b)</code> </dt> <dd> +<p>Return <code>a * b</code>, for <em>a</em> and <em>b</em> numbers.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.matmul"> +<code>operator.matmul(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__matmul__"> +<code>operator.__matmul__(a, b)</code> </dt> <dd> +<p>Return <code>a @ b</code>.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 3.5.</span></p> </div> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.neg"> +<code>operator.neg(obj)</code> </dt> <dt class="sig sig-object py" id="operator.__neg__"> +<code>operator.__neg__(obj)</code> </dt> <dd> +<p>Return <em>obj</em> negated (<code>-obj</code>).</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.or_"> +<code>operator.or_(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__or__"> +<code>operator.__or__(a, b)</code> </dt> <dd> +<p>Return the bitwise or of <em>a</em> and <em>b</em>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.pos"> +<code>operator.pos(obj)</code> </dt> <dt class="sig sig-object py" id="operator.__pos__"> +<code>operator.__pos__(obj)</code> </dt> <dd> +<p>Return <em>obj</em> positive (<code>+obj</code>).</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.pow"> +<code>operator.pow(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__pow__"> +<code>operator.__pow__(a, b)</code> </dt> <dd> +<p>Return <code>a ** b</code>, for <em>a</em> and <em>b</em> numbers.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.rshift"> +<code>operator.rshift(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__rshift__"> +<code>operator.__rshift__(a, b)</code> </dt> <dd> +<p>Return <em>a</em> shifted right by <em>b</em>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.sub"> +<code>operator.sub(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__sub__"> +<code>operator.__sub__(a, b)</code> </dt> <dd> +<p>Return <code>a - b</code>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.truediv"> +<code>operator.truediv(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__truediv__"> +<code>operator.__truediv__(a, b)</code> </dt> <dd> +<p>Return <code>a / b</code> where 2/3 is .66 rather than 0. This is also known as “true” division.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.xor"> +<code>operator.xor(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__xor__"> +<code>operator.__xor__(a, b)</code> </dt> <dd> +<p>Return the bitwise exclusive or of <em>a</em> and <em>b</em>.</p> </dd> +</dl> <p>Operations which work with sequences (some of them with mappings too) include:</p> <dl class="py function"> <dt class="sig sig-object py" id="operator.concat"> +<code>operator.concat(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__concat__"> +<code>operator.__concat__(a, b)</code> </dt> <dd> +<p>Return <code>a + b</code> for <em>a</em> and <em>b</em> sequences.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.contains"> +<code>operator.contains(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__contains__"> +<code>operator.__contains__(a, b)</code> </dt> <dd> +<p>Return the outcome of the test <code>b in a</code>. Note the reversed operands.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.countOf"> +<code>operator.countOf(a, b)</code> </dt> <dd> +<p>Return the number of occurrences of <em>b</em> in <em>a</em>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.delitem"> +<code>operator.delitem(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__delitem__"> +<code>operator.__delitem__(a, b)</code> </dt> <dd> +<p>Remove the value of <em>a</em> at index <em>b</em>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.getitem"> +<code>operator.getitem(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__getitem__"> +<code>operator.__getitem__(a, b)</code> </dt> <dd> +<p>Return the value of <em>a</em> at index <em>b</em>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.indexOf"> +<code>operator.indexOf(a, b)</code> </dt> <dd> +<p>Return the index of the first of occurrence of <em>b</em> in <em>a</em>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.setitem"> +<code>operator.setitem(a, b, c)</code> </dt> <dt class="sig sig-object py" id="operator.__setitem__"> +<code>operator.__setitem__(a, b, c)</code> </dt> <dd> +<p>Set the value of <em>a</em> at index <em>b</em> to <em>c</em>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.length_hint"> +<code>operator.length_hint(obj, default=0)</code> </dt> <dd> +<p>Return an estimated length for the object <em>obj</em>. First try to return its actual length, then an estimate using <a class="reference internal" href="../reference/datamodel#object.__length_hint__" title="object.__length_hint__"><code>object.__length_hint__()</code></a>, and finally return the default value.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 3.4.</span></p> </div> </dd> +</dl> <p>The following operation works with callables:</p> <dl class="py function"> <dt class="sig sig-object py" id="operator.call"> +<code>operator.call(obj, /, *args, **kwargs)</code> </dt> <dt class="sig sig-object py" id="operator.__call__"> +<code>operator.__call__(obj, /, *args, **kwargs)</code> </dt> <dd> +<p>Return <code>obj(*args, **kwargs)</code>.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 3.11.</span></p> </div> </dd> +</dl> <p>The <a class="reference internal" href="#module-operator" title="operator: Functions corresponding to the standard operators."><code>operator</code></a> module also defines tools for generalized attribute and item lookups. These are useful for making fast field extractors as arguments for <a class="reference internal" href="functions#map" title="map"><code>map()</code></a>, <a class="reference internal" href="functions#sorted" title="sorted"><code>sorted()</code></a>, <a class="reference internal" href="itertools#itertools.groupby" title="itertools.groupby"><code>itertools.groupby()</code></a>, or other functions that expect a function argument.</p> <dl class="py function"> <dt class="sig sig-object py" id="operator.attrgetter"> +<code>operator.attrgetter(attr)</code> </dt> <dt class="sig sig-object py"> <span class="sig-prename descclassname">operator.</span><span class="sig-name descname">attrgetter</span><span class="sig-paren">(</span><em class="sig-param"><span class="o">*</span><span class="n">attrs</span></em><span class="sig-paren">)</span> +</dt> <dd> +<p>Return a callable object that fetches <em>attr</em> from its operand. If more than one attribute is requested, returns a tuple of attributes. The attribute names can also contain dots. For example:</p> <ul class="simple"> <li>After <code>f = attrgetter('name')</code>, the call <code>f(b)</code> returns <code>b.name</code>.</li> <li>After <code>f = attrgetter('name', 'date')</code>, the call <code>f(b)</code> returns <code>(b.name, b.date)</code>.</li> <li>After <code>f = attrgetter('name.first', 'name.last')</code>, the call <code>f(b)</code> returns <code>(b.name.first, b.name.last)</code>.</li> </ul> <p>Equivalent to:</p> <pre data-language="python">def attrgetter(*items): + if any(not isinstance(item, str) for item in items): + raise TypeError('attribute name must be a string') + if len(items) == 1: + attr = items[0] + def g(obj): + return resolve_attr(obj, attr) + else: + def g(obj): + return tuple(resolve_attr(obj, attr) for attr in items) + return g + +def resolve_attr(obj, attr): + for name in attr.split("."): + obj = getattr(obj, name) + return obj +</pre> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.itemgetter"> +<code>operator.itemgetter(item)</code> </dt> <dt class="sig sig-object py"> <span class="sig-prename descclassname">operator.</span><span class="sig-name descname">itemgetter</span><span class="sig-paren">(</span><em class="sig-param"><span class="o">*</span><span class="n">items</span></em><span class="sig-paren">)</span> +</dt> <dd> +<p>Return a callable object that fetches <em>item</em> from its operand using the operand’s <a class="reference internal" href="../reference/datamodel#object.__getitem__" title="object.__getitem__"><code>__getitem__()</code></a> method. If multiple items are specified, returns a tuple of lookup values. For example:</p> <ul class="simple"> <li>After <code>f = itemgetter(2)</code>, the call <code>f(r)</code> returns <code>r[2]</code>.</li> <li>After <code>g = itemgetter(2, 5, 3)</code>, the call <code>g(r)</code> returns <code>(r[2], r[5], r[3])</code>.</li> </ul> <p>Equivalent to:</p> <pre data-language="python">def itemgetter(*items): + if len(items) == 1: + item = items[0] + def g(obj): + return obj[item] + else: + def g(obj): + return tuple(obj[item] for item in items) + return g +</pre> <p>The items can be any type accepted by the operand’s <a class="reference internal" href="../reference/datamodel#object.__getitem__" title="object.__getitem__"><code>__getitem__()</code></a> method. Dictionaries accept any <a class="reference internal" href="../glossary#term-hashable"><span class="xref std std-term">hashable</span></a> value. Lists, tuples, and strings accept an index or a slice:</p> <pre data-language="python">>>> itemgetter(1)('ABCDEFG') +'B' +>>> itemgetter(1, 3, 5)('ABCDEFG') +('B', 'D', 'F') +>>> itemgetter(slice(2, None))('ABCDEFG') +'CDEFG' +>>> soldier = dict(rank='captain', name='dotterbart') +>>> itemgetter('rank')(soldier) +'captain' +</pre> <p>Example of using <a class="reference internal" href="#operator.itemgetter" title="operator.itemgetter"><code>itemgetter()</code></a> to retrieve specific fields from a tuple record:</p> <pre data-language="python">>>> inventory = [('apple', 3), ('banana', 2), ('pear', 5), ('orange', 1)] +>>> getcount = itemgetter(1) +>>> list(map(getcount, inventory)) +[3, 2, 5, 1] +>>> sorted(inventory, key=getcount) +[('orange', 1), ('banana', 2), ('apple', 3), ('pear', 5)] +</pre> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.methodcaller"> +<code>operator.methodcaller(name, /, *args, **kwargs)</code> </dt> <dd> +<p>Return a callable object that calls the method <em>name</em> on its operand. If additional arguments and/or keyword arguments are given, they will be given to the method as well. For example:</p> <ul class="simple"> <li>After <code>f = methodcaller('name')</code>, the call <code>f(b)</code> returns <code>b.name()</code>.</li> <li>After <code>f = methodcaller('name', 'foo', bar=1)</code>, the call <code>f(b)</code> returns <code>b.name('foo', bar=1)</code>.</li> </ul> <p>Equivalent to:</p> <pre data-language="python">def methodcaller(name, /, *args, **kwargs): + def caller(obj): + return getattr(obj, name)(*args, **kwargs) + return caller +</pre> </dd> +</dl> <section id="mapping-operators-to-functions"> <span id="operator-map"></span><h2>Mapping Operators to Functions</h2> <p>This table shows how abstract operations correspond to operator symbols in the Python syntax and the functions in the <a class="reference internal" href="#module-operator" title="operator: Functions corresponding to the standard operators."><code>operator</code></a> module.</p> <table class="docutils align-default"> <thead> <tr> +<th class="head"><p>Operation</p></th> <th class="head"><p>Syntax</p></th> <th class="head"><p>Function</p></th> </tr> </thead> <tr> +<td><p>Addition</p></td> <td><p><code>a + b</code></p></td> <td><p><code>add(a, b)</code></p></td> </tr> <tr> +<td><p>Concatenation</p></td> <td><p><code>seq1 + seq2</code></p></td> <td><p><code>concat(seq1, seq2)</code></p></td> </tr> <tr> +<td><p>Containment Test</p></td> <td><p><code>obj in seq</code></p></td> <td><p><code>contains(seq, obj)</code></p></td> </tr> <tr> +<td><p>Division</p></td> <td><p><code>a / b</code></p></td> <td><p><code>truediv(a, b)</code></p></td> </tr> <tr> +<td><p>Division</p></td> <td><p><code>a // b</code></p></td> <td><p><code>floordiv(a, b)</code></p></td> </tr> <tr> +<td><p>Bitwise And</p></td> <td><p><code>a & b</code></p></td> <td><p><code>and_(a, b)</code></p></td> </tr> <tr> +<td><p>Bitwise Exclusive Or</p></td> <td><p><code>a ^ b</code></p></td> <td><p><code>xor(a, b)</code></p></td> </tr> <tr> +<td><p>Bitwise Inversion</p></td> <td><p><code>~ a</code></p></td> <td><p><code>invert(a)</code></p></td> </tr> <tr> +<td><p>Bitwise Or</p></td> <td><p><code>a | b</code></p></td> <td><p><code>or_(a, b)</code></p></td> </tr> <tr> +<td><p>Exponentiation</p></td> <td><p><code>a ** b</code></p></td> <td><p><code>pow(a, b)</code></p></td> </tr> <tr> +<td><p>Identity</p></td> <td><p><code>a is b</code></p></td> <td><p><code>is_(a, b)</code></p></td> </tr> <tr> +<td><p>Identity</p></td> <td><p><code>a is not b</code></p></td> <td><p><code>is_not(a, b)</code></p></td> </tr> <tr> +<td><p>Indexed Assignment</p></td> <td><p><code>obj[k] = v</code></p></td> <td><p><code>setitem(obj, k, v)</code></p></td> </tr> <tr> +<td><p>Indexed Deletion</p></td> <td><p><code>del obj[k]</code></p></td> <td><p><code>delitem(obj, k)</code></p></td> </tr> <tr> +<td><p>Indexing</p></td> <td><p><code>obj[k]</code></p></td> <td><p><code>getitem(obj, k)</code></p></td> </tr> <tr> +<td><p>Left Shift</p></td> <td><p><code>a << b</code></p></td> <td><p><code>lshift(a, b)</code></p></td> </tr> <tr> +<td><p>Modulo</p></td> <td><p><code>a % b</code></p></td> <td><p><code>mod(a, b)</code></p></td> </tr> <tr> +<td><p>Multiplication</p></td> <td><p><code>a * b</code></p></td> <td><p><code>mul(a, b)</code></p></td> </tr> <tr> +<td><p>Matrix Multiplication</p></td> <td><p><code>a @ b</code></p></td> <td><p><code>matmul(a, b)</code></p></td> </tr> <tr> +<td><p>Negation (Arithmetic)</p></td> <td><p><code>- a</code></p></td> <td><p><code>neg(a)</code></p></td> </tr> <tr> +<td><p>Negation (Logical)</p></td> <td><p><code>not a</code></p></td> <td><p><code>not_(a)</code></p></td> </tr> <tr> +<td><p>Positive</p></td> <td><p><code>+ a</code></p></td> <td><p><code>pos(a)</code></p></td> </tr> <tr> +<td><p>Right Shift</p></td> <td><p><code>a >> b</code></p></td> <td><p><code>rshift(a, b)</code></p></td> </tr> <tr> +<td><p>Slice Assignment</p></td> <td><p><code>seq[i:j] = values</code></p></td> <td><p><code>setitem(seq, slice(i, j), values)</code></p></td> </tr> <tr> +<td><p>Slice Deletion</p></td> <td><p><code>del seq[i:j]</code></p></td> <td><p><code>delitem(seq, slice(i, j))</code></p></td> </tr> <tr> +<td><p>Slicing</p></td> <td><p><code>seq[i:j]</code></p></td> <td><p><code>getitem(seq, slice(i, j))</code></p></td> </tr> <tr> +<td><p>String Formatting</p></td> <td><p><code>s % obj</code></p></td> <td><p><code>mod(s, obj)</code></p></td> </tr> <tr> +<td><p>Subtraction</p></td> <td><p><code>a - b</code></p></td> <td><p><code>sub(a, b)</code></p></td> </tr> <tr> +<td><p>Truth Test</p></td> <td><p><code>obj</code></p></td> <td><p><code>truth(obj)</code></p></td> </tr> <tr> +<td><p>Ordering</p></td> <td><p><code>a < b</code></p></td> <td><p><code>lt(a, b)</code></p></td> </tr> <tr> +<td><p>Ordering</p></td> <td><p><code>a <= b</code></p></td> <td><p><code>le(a, b)</code></p></td> </tr> <tr> +<td><p>Equality</p></td> <td><p><code>a == b</code></p></td> <td><p><code>eq(a, b)</code></p></td> </tr> <tr> +<td><p>Difference</p></td> <td><p><code>a != b</code></p></td> <td><p><code>ne(a, b)</code></p></td> </tr> <tr> +<td><p>Ordering</p></td> <td><p><code>a >= b</code></p></td> <td><p><code>ge(a, b)</code></p></td> </tr> <tr> +<td><p>Ordering</p></td> <td><p><code>a > b</code></p></td> <td><p><code>gt(a, b)</code></p></td> </tr> </table> </section> <section id="in-place-operators"> <h2>In-place Operators</h2> <p>Many operations have an “in-place” version. Listed below are functions providing a more primitive access to in-place operators than the usual syntax does; for example, the <a class="reference internal" href="../glossary#term-statement"><span class="xref std std-term">statement</span></a> <code>x += y</code> is equivalent to <code>x = operator.iadd(x, y)</code>. Another way to put it is to say that <code>z = operator.iadd(x, y)</code> is equivalent to the compound statement <code>z = x; z += y</code>.</p> <p>In those examples, note that when an in-place method is called, the computation and assignment are performed in two separate steps. The in-place functions listed below only do the first step, calling the in-place method. The second step, assignment, is not handled.</p> <p>For immutable targets such as strings, numbers, and tuples, the updated value is computed, but not assigned back to the input variable:</p> <pre data-language="python">>>> a = 'hello' +>>> iadd(a, ' world') +'hello world' +>>> a +'hello' +</pre> <p>For mutable targets such as lists and dictionaries, the in-place method will perform the update, so no subsequent assignment is necessary:</p> <pre data-language="python">>>> s = ['h', 'e', 'l', 'l', 'o'] +>>> iadd(s, [' ', 'w', 'o', 'r', 'l', 'd']) +['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] +>>> s +['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] +</pre> <dl class="py function"> <dt class="sig sig-object py" id="operator.iadd"> +<code>operator.iadd(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__iadd__"> +<code>operator.__iadd__(a, b)</code> </dt> <dd> +<p><code>a = iadd(a, b)</code> is equivalent to <code>a += b</code>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.iand"> +<code>operator.iand(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__iand__"> +<code>operator.__iand__(a, b)</code> </dt> <dd> +<p><code>a = iand(a, b)</code> is equivalent to <code>a &= b</code>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.iconcat"> +<code>operator.iconcat(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__iconcat__"> +<code>operator.__iconcat__(a, b)</code> </dt> <dd> +<p><code>a = iconcat(a, b)</code> is equivalent to <code>a += b</code> for <em>a</em> and <em>b</em> sequences.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.ifloordiv"> +<code>operator.ifloordiv(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__ifloordiv__"> +<code>operator.__ifloordiv__(a, b)</code> </dt> <dd> +<p><code>a = ifloordiv(a, b)</code> is equivalent to <code>a //= b</code>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.ilshift"> +<code>operator.ilshift(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__ilshift__"> +<code>operator.__ilshift__(a, b)</code> </dt> <dd> +<p><code>a = ilshift(a, b)</code> is equivalent to <code>a <<= b</code>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.imod"> +<code>operator.imod(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__imod__"> +<code>operator.__imod__(a, b)</code> </dt> <dd> +<p><code>a = imod(a, b)</code> is equivalent to <code>a %= b</code>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.imul"> +<code>operator.imul(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__imul__"> +<code>operator.__imul__(a, b)</code> </dt> <dd> +<p><code>a = imul(a, b)</code> is equivalent to <code>a *= b</code>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.imatmul"> +<code>operator.imatmul(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__imatmul__"> +<code>operator.__imatmul__(a, b)</code> </dt> <dd> +<p><code>a = imatmul(a, b)</code> is equivalent to <code>a @= b</code>.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 3.5.</span></p> </div> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.ior"> +<code>operator.ior(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__ior__"> +<code>operator.__ior__(a, b)</code> </dt> <dd> +<p><code>a = ior(a, b)</code> is equivalent to <code>a |= b</code>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.ipow"> +<code>operator.ipow(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__ipow__"> +<code>operator.__ipow__(a, b)</code> </dt> <dd> +<p><code>a = ipow(a, b)</code> is equivalent to <code>a **= b</code>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.irshift"> +<code>operator.irshift(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__irshift__"> +<code>operator.__irshift__(a, b)</code> </dt> <dd> +<p><code>a = irshift(a, b)</code> is equivalent to <code>a >>= b</code>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.isub"> +<code>operator.isub(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__isub__"> +<code>operator.__isub__(a, b)</code> </dt> <dd> +<p><code>a = isub(a, b)</code> is equivalent to <code>a -= b</code>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.itruediv"> +<code>operator.itruediv(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__itruediv__"> +<code>operator.__itruediv__(a, b)</code> </dt> <dd> +<p><code>a = itruediv(a, b)</code> is equivalent to <code>a /= b</code>.</p> </dd> +</dl> <dl class="py function"> <dt class="sig sig-object py" id="operator.ixor"> +<code>operator.ixor(a, b)</code> </dt> <dt class="sig sig-object py" id="operator.__ixor__"> +<code>operator.__ixor__(a, b)</code> </dt> <dd> +<p><code>a = ixor(a, b)</code> is equivalent to <code>a ^= b</code>.</p> </dd> +</dl> </section> <div class="_attribution"> + <p class="_attribution-p"> + © 2001–2023 Python Software Foundation<br>Licensed under the PSF License.<br> + <a href="https://docs.python.org/3.12/library/operator.html" class="_attribution-link">https://docs.python.org/3.12/library/operator.html</a> + </p> +</div> |