<h1class="title">A.1 Python Built-In Function Reference</h1>
</header>
<section>
<p><em>Adapted from <ahref="https://docs.python.org/3/library/functions.html"class="uri">https://docs.python.org/3/library/functions.html</a>.</em> Note that not all built-in functions are shown.</p>
<divclass="fullwidth reference-table">
<table>
<colgroup>
<colstyle="width: 15%"/>
<colstyle="width: 84%"/>
</colgroup>
<thead>
<trclass="header">
<th>Built-in Function</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<trclass="odd">
<td><code>abs(x)</code></td>
<td>Return the absolute value of a number. The argument may be an integer or a floating point number.</td>
</tr>
<trclass="even">
<td><code>all(iterable)</code></td>
<td>Return <code>True</code> if all elements of the <code>iterable</code> are true (or if the <code>iterable</code> is empty).</td>
</tr>
<trclass="odd">
<td><code>any(iterable)</code></td>
<td>Return <code>True</code> if any element of the <code>iterable</code> is true. If the <code>iterable</code> is empty, return <code>False</code>.</td>
</tr>
<trclass="even">
<td><code>chr(i)</code></td>
<td><p>Return the string representing a character whose Unicode code point is the integer <em>i</em>. For example, <code>chr(97)</code> returns the string <code>'a'</code>, while <code>chr(8364)</code> returns the string <code>'€'</code>. This is the inverse of <code>ord()</code>.</p>
<p>The valid range for the argument is from 0 through 1,114,111. <code>ValueError</code> will be raised if <em>i</em> is outside that range.</p></td>
</tr>
<trclass="odd">
<td><code>divmod(a, b)</code></td>
<td>Take two (non complex) numbers as arguments and return a pair of numbers consisting of their quotient and remainder when using integer division. For integers, the result is the same as <code>(a // b, a % b)</code>.</td>
</tr>
<trclass="even">
<td><pre><code>filter(
function,
iterable
)</code></pre></td>
<td>Construct an iterator from those elements of <code>iterable</code> for which <code>function</code> returns <code>True</code>. <code>iterable</code> may be either a sequence, a container which supports iteration, or an iterator.</td>
</tr>
<trclass="odd">
<td><code>id(object)</code></td>
<td>Return the “identity” of an object. This is an integer which is guaranteed to be unique and constant for this object during its lifetime.</td>
</tr>
<trclass="even">
<td><code>input([prompt])</code></td>
<td><p>If the <code>prompt</code> argument is present, it is written to standard output without a trailing newline. The function then reads a line from input, converts it to a string (stripping a trailing newline), and returns that. Example:</p>
<divclass="sourceCode"id="cb2"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb2-1"><ahref="#cb2-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="bu">input</span>(<spanclass="st">'Type in a word: '</span>)</span>
<spanid="cb2-2"><ahref="#cb2-2"></a>Type <spanclass="kw">in</span> a word: Python <spanclass="co"># "Python" is user input</span></span>
<td>Return <code>True</code> if the <code>object</code> argument is an instance of the <code>classinfo</code> argument, or of a subclass thereof. If <code>object</code> is not an object of the given type, the function always returns <code>False</code>.</td>
</tr>
<trclass="even">
<td><code>len(s)</code></td>
<td>Return the length (the number of items) of an object.</td>
</tr>
<trclass="odd">
<td><pre><code># Form 1
max(
iterable,
*
[, key,
default]
)
# Form 2
max(
arg1,
arg2,
*args,
[key]
)</code></pre></td>
<td><p>Return the largest item in an <code>iterable</code> or the largest of two or more arguments.</p>
<p>If one positional argument is provided, it should be an iterable. The largest item in the iterable is returned. If two or more positional arguments are provided, the largest of the positional arguments is returned.</p>
<p>There are two optional keyword-only arguments. The <code>key</code> argument specifies a one-argument ordering function like that used for <code>list.sort()</code>.</p>
<p>The <code>default</code> argument specifies an object to return if the provided iterable is empty. If the iterable is empty and <code>default</code> is not provided, a <code>ValueError</code> is raised. If multiple items are maximal, the function returns the first one encountered.</p></td>
</tr>
<trclass="even">
<td><pre><code># Form 1
min(
iterable, *
[, key,
default]
)
# Form 2
min(
arg1,
arg2,
*args,
[key]
)</code></pre></td>
<td><p>Return the smallest item in an <code>iterable</code> or the smallest of two or more arguments.</p>
<p>If one positional argument is provided, it should be an iterable. The smallest item in the iterable is returned. If two or more positional arguments are provided, the smallest of the positional arguments is returned.</p>
<p>There are two optional keyword-only arguments. The <code>key</code> argument specifies a one-argument ordering function like that used for <code>list.sort()</code>.</p>
<p>The <code>default</code> argument specifies an object to return if the provided iterable is empty. If the iterable is empty and <code>default</code> is not provided, a <code>ValueError</code> is raised. If multiple items are minimal, the function returns the first one encountered.</p></td>
</tr>
<trclass="odd">
<td><pre><code>open(
file,
mode='r'
)</code></pre></td>
<td><p>Open <code>file</code> and return a corresponding file object. If the file cannot be opened, an <code>OSError</code> is raised.</p>
<p><code>file</code> is a path-like object giving the pathname (absolute or relative to the current working directory) of the file to be opened.</p>
<p><code>mode</code> is an optional string that specifies the mode in which the file is opened. It defaults to ‘r’ which means open for reading in text mode. Other common values are ‘w’ for writing (truncating the file if it already exists), ‘x’ for exclusive creation and ‘a’ for appending.</p></td>
</tr>
<trclass="even">
<td><code>ord(c)</code></td>
<td>Given a string representing one Unicode character, return an integer representing the Unicode code point of that character. For example, <code>ord('a')</code> returns the integer <code>97</code> and <code>ord('€')</code> (Euro sign) returns <code>8364</code>. This is the inverse of <code>chr()</code>.</td>
</tr>
<trclass="odd">
<td><pre><code>pow(
base, exp
[, mod]
)</code></pre></td>
<td>Return <code>base</code> to the power <code>exp</code>; if <code>mod</code> is present, return <code>base</code> to the power <code>exp</code>, modulo <code>mod</code> (computed more efficiently than <code>pow(base, exp) % mod</code>). The two-argument form <code>pow(base, exp)</code> is equivalent to using the power operator: <code>base ** exp</code>.</td>
</tr>
<trclass="even">
<td><pre><code>print(
*objects,
sep='',
end='\'
)</code></pre></td>
<td><p>Print <code>objects</code> to standard output, separated by <code>sep</code> and followed by <code>end</code>. <code>sep</code> and <code>end</code>, if present, must be given as keyword arguments.</p>
<p>Both <code>sep</code> and <code>end</code> must be strings; they can also be <code>None</code>, which means to use the default values.</p></td>
</tr>
<trclass="odd">
<td><code>reversed(seq)</code></td>
<td>Return a reverse iterator.</td>
</tr>
<trclass="even">
<td><pre><code>round(
number
[, ndigits]
)</code></pre></td>
<td><p>Return <code>number</code> rounded to <code>ndigits</code> precision after the decimal point. If <code>ndigits</code> is omitted or is <code>None</code>, it returns the nearest integer to its input.</p>
<p>For the built-in types supporting <code>round()</code>, values are rounded to the closest multiple of 10 to the power minus <em>ndigits</em>; if two multiples are equally close, rounding is done toward the even choice (so, for example, both <code>round(0.5)</code> and <code>round(-0.5)</code> are <code>0</code>, and <code>round(1.5)</code> is 2).</p>
<p>Any integer value is valid for <em>ndigits</em> (positive, zero, or negative). The return value is an integer if ndigits is omitted or None. Otherwise the return value has the same type as number. <em>Note</em>: The behavior of <code>round()</code> for floats can be surprising: for example, <code>round(2.675, 2)</code> gives <code>2.67</code> instead of the expected <code>2.68</code>. This is not a bug: it’s a result of the fact that most decimal fractions can’t be represented exactly as a float. See <ahref="https://docs.python.org/3/tutorial/floatingpoint.html#tut-fp-issues">Floating Point Arithmetic: Issues and Limitations</a> for more information.</p></td>
</tr>
<trclass="odd">
<td><pre><code>sorted(
iterable, *,
key=None,
reverse=False
)</code></pre></td>
<td><p>Return a new sorted list from the items in <code>iterable</code>.</p>
<p>Has two optional arguments which must be specified as keyword arguments.</p>
<p><code>key</code> specifies a function of one argument that is used to extract a comparison key from each element in iterable<code>(for example,</code>key=str.lower<code>). The default value is</code>None<code>(compare the elements directly).</code>reverse<code>is a boolean value. If set to</code>True`, then the list elements are sorted as if each comparison were reversed.</p></td>
</tr>
<trclass="even">
<td><pre><code>sum(
iterable,
/,
start=0
)</code></pre></td>
<td>Sums <code>start</code> and the items of an <code>iterable</code> from left to right and returns the total.</td>
</tr>
<trclass="odd">
<td><code>type(object)</code></td>
<td><p>Return the type of an <code>object</code>.</p>
<p>The <code>isinstance()</code> built-in function is recommended for testing the type of an object, because it takes subclasses into account.</p></td>
<p>There are two distinct numeric types: integers and floating point numbers. Numbers are created by numeric literals or as the result of built-in functions and operators. Unadorned integer literals yield integers. Numeric literals containing a decimal point or an exponent sign yield floating point numbers.</p>
<p>Python fully supports mixed arithmetic: when a binary arithmetic operator has operands of different numeric types, the operand with the “narrower” type is widened to that of the other, where integer is narrower than floating point. Comparisons between numbers of mixed type use the same rule.</p>
<p>All numeric types support the following operations (for priorities of the operations, see Operator precedence):</p>
<divclass="fullwidth reference-table">
<tablestyle="width:97%;">
<colgroup>
<colstyle="width: 25%"/>
<colstyle="width: 72%"/>
</colgroup>
<thead>
<trclass="header">
<th>Operation</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<trclass="odd">
<td><code>x + y</code></td>
<td><p>Returns the sum of <code>x</code> and <code>y</code>.</p>
<divclass="sourceCode"id="cb1"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb1-1"><ahref="#cb1-1"></a><spanclass="op">>>></span> x <spanclass="op">=</span><spanclass="dv">5</span></span>
<spanid="cb1-2"><ahref="#cb1-2"></a><spanclass="op">>>></span> y <spanclass="op">=</span><spanclass="dv">3</span></span>
<spanid="cb1-3"><ahref="#cb1-3"></a><spanclass="op">>>></span> x <spanclass="op">+</span> y</span>
<td><p>Returns the difference of <code>x</code> and <code>y</code>.</p>
<divclass="sourceCode"id="cb2"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb2-1"><ahref="#cb2-1"></a><spanclass="op">>>></span> x <spanclass="op">=</span><spanclass="dv">5</span></span>
<spanid="cb2-2"><ahref="#cb2-2"></a><spanclass="op">>>></span> y <spanclass="op">=</span><spanclass="dv">3</span></span>
<spanid="cb2-3"><ahref="#cb2-3"></a><spanclass="op">>>></span> x <spanclass="op">-</span> y</span>
<td><p>Returns the product of <code>x</code> and <code>y</code>.</p>
<divclass="sourceCode"id="cb3"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb3-1"><ahref="#cb3-1"></a><spanclass="op">>>></span> x <spanclass="op">=</span><spanclass="dv">5</span></span>
<spanid="cb3-2"><ahref="#cb3-2"></a><spanclass="op">>>></span> y <spanclass="op">=</span><spanclass="dv">3</span></span>
<spanid="cb3-3"><ahref="#cb3-3"></a><spanclass="op">>>></span> x <spanclass="op">*</span> y</span>
<td><p>Returns the quotient of <code>x</code> and <code>y</code>.</p>
<divclass="sourceCode"id="cb4"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb4-1"><ahref="#cb4-1"></a><spanclass="op">>>></span> x <spanclass="op">=</span><spanclass="dv">5</span></span>
<spanid="cb4-2"><ahref="#cb4-2"></a><spanclass="op">>>></span> y <spanclass="op">=</span><spanclass="dv">3</span></span>
<spanid="cb4-3"><ahref="#cb4-3"></a><spanclass="op">>>></span> x <spanclass="op">/</span> y</span>
<td><p>Returns the floored quotient of <code>x</code> and <code>y</code>. Also referred to as <em>integer division</em>.</p>
<divclass="sourceCode"id="cb5"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb5-1"><ahref="#cb5-1"></a><spanclass="op">>>></span> x <spanclass="op">=</span><spanclass="dv">5</span></span>
<spanid="cb5-2"><ahref="#cb5-2"></a><spanclass="op">>>></span> y <spanclass="op">=</span><spanclass="dv">3</span></span>
<spanid="cb5-3"><ahref="#cb5-3"></a><spanclass="op">>>></span> x <spanclass="op">//</span> y</span>
<td><p>Returns the remainder of <code>x / y</code>.</p>
<divclass="sourceCode"id="cb6"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb6-1"><ahref="#cb6-1"></a><spanclass="op">>>></span> x <spanclass="op">=</span><spanclass="dv">5</span></span>
<spanid="cb6-2"><ahref="#cb6-2"></a><spanclass="op">>>></span> y <spanclass="op">=</span><spanclass="dv">3</span></span>
<spanid="cb6-3"><ahref="#cb6-3"></a><spanclass="op">>>></span> x <spanclass="op">%</span> y</span>
<divclass="sourceCode"id="cb8"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb8-1"><ahref="#cb8-1"></a><spanclass="op">>>></span> x <spanclass="op">=</span><spanclass="dv">5</span></span>
<td><p>Returns <code>x</code> converted to integer. For floating-point numbers, this truncates towards 0.</p>
<divclass="sourceCode"id="cb9"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb9-1"><ahref="#cb9-1"></a><spanclass="op">>>></span> x <spanclass="op">=</span><spanclass="st">'3'</span></span>
<spanid="cb9-4"><ahref="#cb9-4"></a><spanclass="op">>>></span> x <spanclass="op">=</span><spanclass="op">-</span><spanclass="fl">1.5</span></span>
<td><p>Returns <code>x</code> converted to a floating point number.</p>
<divclass="sourceCode"id="cb10"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb10-1"><ahref="#cb10-1"></a><spanclass="op">>>></span> x <spanclass="op">=</span><spanclass="st">'3.5'</span></span>
<spanid="cb10-4"><ahref="#cb10-4"></a><spanclass="op">>>></span> x <spanclass="op">=</span><spanclass="op">-</span><spanclass="dv">1</span></span>
<p>See also the <ahref="../01-builtins.html">built-in functions</a><code>abs</code>, <code>divmod</code>, <code>pow</code>, and <code>round</code>.</p>
<td><p>Returns the concatenation of <code>s</code> and <code>t</code>.</p>
<divclass="sourceCode"id="cb15"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb15-1"><ahref="#cb15-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'Mon'</span></span>
<spanid="cb15-2"><ahref="#cb15-2"></a></span>
<spanid="cb15-3"><ahref="#cb15-3"></a><spanclass="op">>>></span> x <spanclass="op">=</span><spanclass="st">'day'</span></span>
<spanid="cb15-4"><ahref="#cb15-4"></a></span>
<spanid="cb15-5"><ahref="#cb15-5"></a><spanclass="op">>>></span> x <spanclass="op">+</span> s</span>
<td><p>Returns the equivalent to adding <code>s</code> to itself <code>n</code> times.</p>
<divclass="sourceCode"id="cb16"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb16-1"><ahref="#cb16-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'ha'</span></span>
<spanid="cb16-2"><ahref="#cb16-2"></a><spanclass="op">>>></span> x <spanclass="op">=</span><spanclass="dv">5</span></span>
<spanid="cb16-3"><ahref="#cb16-3"></a><spanclass="op">>>></span> x <spanclass="op">*</span> s</span>
<td><p>Returns the <code>i</code>th item of <code>s</code>, with starting index <code>0</code>.</p>
<divclass="sourceCode"id="cb17"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb17-1"><ahref="#cb17-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'Hugo'</span></span>
<td><p>Returns the slice of <code>s</code> from <code>i</code> to <code>j</code>.</p>
<divclass="sourceCode"id="cb18"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb18-1"><ahref="#cb18-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'Hugo'</span></span>
<td><p>Returns the slice of <code>s</code> from <code>i</code> to <code>j</code> with step <code>k</code>.</p>
<divclass="sourceCode"id="cb19"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb19-1"><ahref="#cb19-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'Hugo'</span></span>
<td><p>Returns the <code>index</code> of the first occurrence of <code>x</code> in <code>s</code> (at or after index <code>i</code> and before index <code>j</code>, if those parameters are given).</p>
<divclass="sourceCode"id="cb20"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb20-1"><ahref="#cb20-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'Bipbopboopbap'</span></span>
<td><p>Returns the total number of occurrences of <code>x</code> in <code>s</code>.</p>
<divclass="sourceCode"id="cb21"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb21-1"><ahref="#cb21-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'Bipbopboop'</span></span>
<p>See also the <ahref="../01-builtins.html">built-in functions</a><code>len</code>, <code>max</code>, and <code>min</code>.</p>
</div>
<p>Sequences of the same type also support comparisons. In particular, tuples and lists are compared lexicographically by comparing corresponding elements. This means that to compare equal, every element must compare equal and the two sequences must be of the same type and have the same length.</p>
<p>The <code>list</code> data type supports all of the immutable sequence operations from the previous section, as well as the following operations.</p>
<divclass="fullwidth reference-table">
<table>
<colgroup>
<colstyle="width: 27%"/>
<colstyle="width: 72%"/>
</colgroup>
<thead>
<trclass="header">
<th>Operation</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<trclass="odd">
<td><code>s[i] = x</code></td>
<td><p>Set the item at index <code>i</code> of <code>s</code> to be <code>x</code>.</p>
<td><p>Returns the item at <code>i</code> and also removes it from <code>self</code>. If <code>i</code> is omitted, the last item is removed and returned.</p>
<divclass="sourceCode"id="cb26"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb26-1"><ahref="#cb26-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span> [<spanclass="dv">1</span>, <spanclass="dv">2</span>, <spanclass="dv">3</span>, <spanclass="dv">4</span>, <spanclass="dv">5</span>]</span>
<td>Reverses the items of <code>self</code> in place (mutates <code>self</code>).</td>
</tr>
<trclass="even">
<td><pre><code>list.sort(
self, *,
key=None,
reverse=False
)</code></pre></td>
<td><p>Sorts <code>self</code> in place, using only <code><</code> comparisons between items.</p>
<p><code>key</code> specifies a function of one argument that is used to extract a comparison key from each list element (for example, <code>key=str.lower</code>). The key corresponding to each item in the list is calculated once and then used for the entire sorting process. The default value of <code>None</code> means that list items are sorted directly without calculating a separate key value.</p>
<p><code>reverse</code> is a boolean value. If set to <code>True</code>, then the list elements are sorted as if each comparison were reversed.</p>
<p>The <code>list.sort</code> method is guaranteed to be stable. A sort is stable if it guarantees not to change the relative order of elements that compare equal—this is helpful for sorting in multiple passes (for example, sort by department, then by salary grade).</p>
<p>Example:</p>
<divclass="sourceCode"id="cb29"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb29-1"><ahref="#cb29-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span> [<spanclass="dv">1</span>, <spanclass="op">-</span><spanclass="dv">1</span>, <spanclass="dv">0</span>, <spanclass="dv">2</span>, <spanclass="dv">3</span>]</span>
<p>Textual data in Python is handled with <code>str</code> objects, or <strong>strings</strong>. Strings are immutable sequences.</p>
<p>Triple quoted strings may span multiple lines—all associated whitespace will be included in the string literal.</p>
<p>Strings may also be created from other objects using the <code>str</code> constructor.</p>
<p>Since there is no separate “character” type, indexing a string produces strings of length 1. That is, for a non-empty string <code>s</code>, <code>s[0] == s[0:1]</code>. Strings implement all of the common sequence operations, along with the additional methods described below.</p>
<divclass="fullwidth reference-table">
<table>
<colgroup>
<colstyle="width: 31%"/>
<colstyle="width: 68%"/>
</colgroup>
<thead>
<trclass="header">
<th>Operation</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<trclass="odd">
<td><code>str.capitalize(self)</code></td>
<td><p>Return a copy of the string with its first character capitalized and the rest lowercased. Example:</p>
<divclass="sourceCode"id="cb30"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb30-1"><ahref="#cb30-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span> ABC<spanclass="st">'</span></span>
<td><p>Return the number of non-overlapping occurrences of substring <code>sub</code> in the range <code>[start, end]</code>.</p>
<p>Optional arguments <code>start</code> and <code>end</code> are interpreted as in slice notation.</p>
<p>Example:</p>
<divclass="sourceCode"id="cb32"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb32-1"><ahref="#cb32-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'Beepbopboopbop'</span></span>
<td><p>Return <code>True</code> if the string ends with the specified suffix, otherwise return <code>False</code><code>suffix</code> can also be a tuple of suffixes to look for.</p>
<p>With optional <code>start</code>, test beginning at that position. With optional <code>end</code>, stop comparing at that position.</p>
<p>Example:</p>
<divclass="sourceCode"id="cb34"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb34-1"><ahref="#cb34-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'www.google.com'</span></span>
<td><p>Return the lowest index in the string where substring <code>sub</code> is found within the slice <code>s[start:end]</code>.</p>
<p>Optional arguments <code>start</code> and <code>end</code> are interpreted as in slice notation.</p>
<p>Example:</p>
<divclass="sourceCode"id="cb35"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb35-1"><ahref="#cb35-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'www.google.com'</span></span>
<p>Return -1 if <code>sub</code> is not found.</p>
<p>Note: The <code>find()</code> method should be used only if you need to know the position of <code>sub</code>. To check if <code>sub</code> is a substring or not, use the <code>in</code> operator:</p>
<td><p>Like <code>find()</code>, but raise <code>ValueError</code> when the substring is not found.</p>
<p>Example:</p>
<divclass="sourceCode"id="cb38"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb38-1"><ahref="#cb38-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'www.google.com'</span></span>
<td><p>Return <code>True</code> if all characters in the string are alphanumeric and there is at least one character, <code>False</code> otherwise. A character <code>c</code> is alphanumeric if one of the following returns <code>True</code>: <code>c.isalpha()</code>, <code>c.isdecimal()</code>, <code>c.isdigit()</code>, or <code>c.isnumeric()</code>.</p>
<p>Example:</p>
<divclass="sourceCode"id="cb39"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb39-1"><ahref="#cb39-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'www.google.com'</span></span>
<td><p>Return <code>True</code> if all characters in the string are alphabetic and there is at least one character, <code>False</code> otherwise. Alphabetic characters are those characters defined in the Unicode character database as “Letter”, i.e., those with general category property being one of “Lm”, “Lt”, “Lu”, “Ll”, or “Lo”. Note that this is different from the “Alphabetic” property defined in the Unicode Standard.</p>
<p>Example:</p>
<divclass="sourceCode"id="cb40"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb40-1"><ahref="#cb40-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">''</span></span>
<td><p>Return <code>True</code> if all characters in the string are digits and there is at least one character, <code>False</code> otherwise. Example:</p>
<divclass="sourceCode"id="cb41"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb41-1"><ahref="#cb41-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'10'</span></span>
<td><p>Return <code>True</code> if all cased characters in the string are lowercase and there is at least one cased character, <code>False</code> otherwise.</p>
<p>Example:</p>
<divclass="sourceCode"id="cb42"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb42-1"><ahref="#cb42-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'www.google.com'</span></span>
<spanid="cb42-4"><ahref="#cb42-4"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'Capitalized'</span></span>
<td><p>Return <code>True</code> if all characters in the string are numeric characters, and there is at least one character, <code>False</code> otherwise. Numeric characters include digit characters, and all characters that have the Unicode numeric value property.</p>
<p>Example:</p>
<divclass="sourceCode"id="cb43"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb43-1"><ahref="#cb43-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'abc123'</span></span>
<td><p>Return <code>True</code> if all cased characters in the string are uppercase and there is at least one cased character, <code>False</code> otherwise.</p>
<p>Example:</p>
<divclass="sourceCode"id="cb44"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb44-1"><ahref="#cb44-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'www.google.com'</span></span>
<spanid="cb44-4"><ahref="#cb44-4"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'Capitalized'</span></span>
<td><p>Return a string which is the concatenation of the strings in <code>iterable</code>. A <code>TypeError</code> will be raised if there are any non-string values in <code>iterable</code>, including bytes objects. The separator between elements is the string providing this method.</p>
<spanid="cb45-2"><ahref="#cb45-2"></a><spanclass="op">>>></span> separator <spanclass="op">=</span><spanclass="st">', and '</span></span>
<spanid="cb45-4"><ahref="#cb45-4"></a><spanclass="co">'John, and David, and Jen'</span></span></code></pre></div></td>
</tr>
<trclass="odd">
<td><code>str.lower(self)</code></td>
<td><p>Return a copy of the string with all the cased characters converted to lowercase. Example:</p>
<divclass="sourceCode"id="cb46"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb46-1"><ahref="#cb46-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'lower'</span></span>
<spanid="cb46-4"><ahref="#cb46-4"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'Capitalized'</span></span>
<td><p>Return a copy of the string with all occurrences of substring <code>old</code> replaced by <code>new</code>. If the optional argument <code>count</code> is given, only the first <code>count</code> occurrences are replaced.</p>
<p>Example:</p>
<divclass="sourceCode"id="cb48"><preclass="sourceCode python"><codeclass="sourceCode python"><spanid="cb48-1"><ahref="#cb48-1"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'www.google.com'</span></span>
<spanid="cb48-4"><ahref="#cb48-4"></a><spanclass="op">>>></span> s <spanclass="op">=</span><spanclass="st">'Far Farquad on a Far Quad'</span></span>
<spanid="cb48-6"><ahref="#cb48-6"></a><spanclass="co">'Close Closequad on a Close Quad'</span></span></code></pre></div></td>
</tr>
<trclass="odd">
<td><pre><code>str.split(
self,
sep=None,
maxsplit=-1
)</code></pre></td>
<td><p>Return a list of the words in the string, using <code>sep</code> as the delimiter string. If <code>maxsplit</code> is given, at most <code>maxsplit</code> splits are done (thus, the list will have at most <code>maxsplit+1</code> elements). If <code>maxsplit</code> is not specified or -1, then there is no limit on the number of splits (all possible splits are made).</p>
<p>If <code>sep</code> is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings (for example, <code>'1,,2'.split(',')</code> returns <code>['1', '', '2']</code>). The <code>sep</code> argument may consist of multiple characters (for example, <code>'1<>2<>3'.split('<>')</code> returns <code>['1', '2', '3']</code>).</p>
<p>Splitting an empty string with a specified separator returns [’’].</p>
<p>If <code>sep</code> is not specified or is <code>None</code>, a different splitting algorithm is applied: runs of consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the string has leading or trailing whitespace. Consequently, splitting an empty string or a string consisting of just whitespace with a <code>None</code> separator returns <code>[]</code>.</p></td>
</tr>
<trclass="even">
<td><pre><code>str.startswith(
self, prefix,
[, start
[, end]]
)</code></pre></td>
<td>Return <code>True</code> if string starts with the <code>prefix</code>, otherwise return <code>False</code>. With optional <code>start</code>, test string begins at that position. With optional <code>end</code>, stop comparing string at that position.</td>
</tr>
<trclass="odd">
<td><code>str.strip(self, [chars])</code></td>
<td><p>Return a copy of the string with the leading and trailing characters removed. The <code>chars</code> argument is a string specifying the set of characters to be removed. If omitted or <code>None</code>, the chars argument defaults to removing whitespace.</p>
<p>The <code>chars</code> argument is not a prefix or suffix; rather, all combinations of its values are stripped.</p>
<p>The outermost leading and trailing chars argument values are stripped from the string. Characters are removed from the leading end until reaching a string character that is not contained in the set of characters in chars. A similar action takes place on the trailing end.</p>
<p>A set object is an unordered collection of distinct hashable objects. Common uses include membership testing, removing duplicates from a sequence, and computing mathematical operations such as intersection, union, difference, and symmetric difference.</p>
<p>Like other collections, sets support x in set, <code>len(set)</code>, and <code>for x in set</code>. Being an unordered collection, sets do not record element position or order of insertion. Accordingly, sets do not support indexing, slicing, or other sequence-like behavior.</p>
<p>The set type is mutable—the contents can be changed using methods like <code>add()</code> and <code>remove()</code>. Since it is mutable, it has no hash value and cannot be used as either a dictionary key or as an element of another set.</p>
<p>Non-empty sets can be created by placing a comma-separated list of elements within braces, for example: <code>{'jack', 'sjoerd'}</code>, in addition to the <code>set</code> constructor.</p>
<divclass="fullwidth reference-table">
<table>
<colgroup>
<colstyle="width: 38%"/>
<colstyle="width: 61%"/>
</colgroup>
<thead>
<trclass="header">
<th>Operation</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<trclass="odd">
<td><code>len(self)</code></td>
<td>Return the size (number of elements) of <code>self</code>.</td>
</tr>
<trclass="even">
<td><code>x in self</code></td>
<td>Return whether <code>x</code> is in <code>self</code>.</td>
</tr>
<trclass="odd">
<td><code>x not in self</code></td>
<td>Return whether <code>x</code> is <em>not</em> in <code>self</code>.</td>
</tr>
<trclass="even">
<td><code>set.isdisjoint(self, other)</code></td>
<td>Return whether the set <code>self</code> has no elements in common with <code>other</code>. Sets are disjoint if and only if their intersection is the empty set.</td>
</tr>
<trclass="odd">
<td><code>set.issubset(self, other)</code></td>
<td>Return whether every element in the set <code>self</code> is in <code>other</code>. Can also use <code>self <= other</code>.</td>
</tr>
<trclass="even">
<td><code>self < other</code></td>
<td>Return whether the set <code>self</code> is a proper subset of <code>other</code>, that is, <code>self <= other and self != other</code>.</td>
</tr>
<trclass="odd">
<td><code>set.issuperset(self, other)</code></td>
<td>Return whether every element in <code>other</code> is in the set <code>self</code>. Can also use <code>self >= other</code>.</td>
</tr>
<trclass="even">
<td><code>self > other</code></td>
<td>Return whether the set <code>self</code> is a proper superset of <code>other</code>, that is, <code>self >= other and self != other</code>.</td>
</tr>
<trclass="odd">
<td><code>set.union(self, *others)</code></td>
<td>Return a new set with elements from the set and all others.</td>
<td>Update the set, keeping only elements found in either set, but not in both.</td>
</tr>
<trclass="odd">
<td><code>set.add(self, elem)</code></td>
<td>Add element <code>elem</code> to the <code>set</code>.</td>
</tr>
<trclass="even">
<td><code>set.remove(self, elem)</code></td>
<td>Remove element <code>elem</code> from the set. Raises <code>KeyError</code> if <code>elem</code> is not contained in the set.</td>
</tr>
<trclass="odd">
<td><code>set.discard(self, elem)</code></td>
<td>Remove element <code>elem</code> from the set if it is present.</td>
</tr>
<trclass="even">
<td><code>set.pop(self)</code></td>
<td>Remove and return an arbitrary element from the set. Raises <code>KeyError</code> if the set is empty.</td>
</tr>
</tbody>
</table>
</div>
<p><code>set</code> supports set to set comparisons. Two sets are equal if and only if every element of each set is contained in the other (each is a subset of the other). A set is less than another set if and only if the first set is a proper subset of the second set (is a subset, but is not equal). A set is greater than another set if and only if the first set is a proper superset of the second set (is a superset, but is not equal).</p>
<p>A mapping object maps hashable values to arbitrary objects. Mappings are mutable objects. There is currently only one standard mapping type, the dictionary.</p>
<p>Dictionaries can be created by placing a comma-separated list of key: value pairs within braces, for example: <code>{'jack': 4098, 'sjoerd': 4127}</code> or <code>{4098: 'jack', 4127: 'sjoerd'}</code>, or by the <code>dic</code>t constructor.</p>
<p>These are the operations that dictionaries support (and therefore, custom mapping types should support too):</p>
<divclass="fullwidth reference-table">
<table>
<colgroup>
<colstyle="width: 21%"/>
<colstyle="width: 78%"/>
</colgroup>
<thead>
<trclass="header">
<th>Operation</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<trclass="odd">
<td><code>list(d)</code></td>
<td>Return a list of all the keys used in the dictionary <code>d</code>.</td>
</tr>
<trclass="even">
<td><code>len(d)</code></td>
<td>Return the number of items in the dictionary <code>d</code>.</td>
</tr>
<trclass="odd">
<td><code>d[key]</code></td>
<td>Return the item of <code>d</code> with key <code>key</code>. Raises a <code>KeyError</code> if <code>key</code> is not in the map.</td>
</tr>
<trclass="even">
<td><code>d[key] = value</code></td>
<td>Set <code>d[key]</code> to <code>value</code>.</td>
</tr>
<trclass="odd">
<td><code>key in d</code></td>
<td>Return <code>True</code> if <code>d</code> has a key <code>key</code>, else <code>False</code>.</td>
</tr>
<trclass="even">
<td><code>key not in d</code></td>
<td>Equivalent to <code>not key in d</code>.</td>
</tr>
<trclass="odd">
<td><pre><code>dict.get(self, key
[, default]
)</code></pre></td>
<td>Return the value for <code>key</code> if <code>key</code> is in the dictionary, else <code>default</code>. If <code>default</code> is not given, it defaults to <code>None</code>, so that this method never raises a <code>KeyError</code>.</td>
</tr>
<trclass="even">
<td><code>dict.items(self)</code></td>
<td>Return a new view of the dictionary’s items ((key, value) pairs).</td>
</tr>
<trclass="odd">
<td><pre><code>dict.pop(self, key
[, default]
)</code></pre></td>
<td>If <code>key</code> is in the dictionary, remove it and return its value, else return <code>default</code> If <code>default</code> is not given and <code>key</code> is not in the dictionary, a <code>KeyError</code> is raised.</td>
</tr>
<trclass="even">
<td><code>dict.popitem(self)</code></td>
<td>Remove and return a (key, value) pair from the dictionary. Pairs are returned in last-in-first-out (LIFO) order. <code>popitem()</code> is useful to destructively iterate over a dictionary, as often used in set algorithms. If the dictionary is empty, calling <code>popitem()</code> raises a <code>KeyError</code>.</td>
</tr>
<trclass="odd">
<td><pre><code>dict.setdefault(self, key
[, default]
)</code></pre></td>
<td>If <code>key</code> is in the dictionary, return its value. If not, insert <code>key</code> with a value of <code>default</code> and return <code>default</code>. <code>default</code> defaults to <code>None</code>.</td>
</tr>
</tbody>
</table>
</div>
<p>Dictionaries compare equal if and only if they have the same (key, value) pairs (regardless of ordering). Order comparisons (<code><</code>, <code><=</code>, <code>>=</code><code>></code>) raise <code>TypeError</code>.</p>
<p>Dictionaries preserve insertion order. Note that updating a key does not affect the order. Keys added after deletion are inserted at the end.</p>
<h2id="numeric-sequence-data-typerange">Numeric sequence data type—<code>range</code></h2>
<p>The <code>range</code> type represents an immutable sequence of numbers and is commonly used for looping a specific number of times in for loops.</p>
<p>Constructor: <code>range(stop)</code> or <code>range(start, stop[, step])</code>.</p>
<p>The arguments to the range constructor must be integers. If the <code>step</code> argument is omitted, it defaults to 1. If the <code>start</code> argument is omitted, it defaults to 0. If <code>step</code> is zero, <code>ValueError</code> is raised.</p>
<p>For a positive step, the contents of a range <code>r</code> are determined by the formula <code>r[i] = start + step*i</code> where <code>i >= 0</code> and <code>r[i] < stop</code>.</p>
<p>For a negative step, the contents of the range are still determined by the formula <code>r[i] = start + step*i</code>, but the constraints are <code>i >= 0</code> and <code>r[i] > stop</code>.</p>
<p>This object is returned by functions that don’t explicitly return a value. It supports no special operations. There is exactly one null object, named <code>None</code> (a built-in name).</p>
<h1class="title">A.3 Python Special Method Reference</h1>
</header>
<section>
<p><em>Adapted from <ahref="https://docs.python.org/3/reference/datamodel.html#special-method-names"class="uri">https://docs.python.org/3/reference/datamodel.html#special-method-names</a>.</em> Note that not all special methods are shown.</p>
<p>A class can implement certain operations that are invoked by special syntax (such as arithmetic operations or subscripting and slicing) by defining methods with special names. This is Python’s approach to operator overloading, allowing classes to define their own behavior with respect to language operators. For instance, if a class defines a method named <code>__getitem__()</code>, and <code>x</code> is an instance of this class, then <code>x[i]</code> is roughly equivalent to <code>type(x).__getitem__(x, i)</code>.</p>
<td><p>Called after the instance has been created, but before it is returned to the caller.</p>
<p>The arguments are those passed to the class constructor expression.</p>
<p>If a base class has an <code>__init__()</code> method, the derived class’s <code>__init__()</code> method, if any, must explicitly call it to ensure proper initialization of the base class part of the instance.</p></td>
</tr>
<trclass="even">
<td><code>object.__str__(self)</code></td>
<td>Called by <code>str(object)</code> and the built-in functions <code>format()</code> and <code>print()</code> to compute the “informal” or nicely printable string representation of an object. The return value must be a string object.</td>
<p>The following methods can be defined to implement container objects. Containers usually are sequences (such as lists or tuples) or mappings (like dictionaries), but can represent other containers as well.</p>
<divclass="fullwidth reference-table">
<table>
<colgroup>
<colstyle="width: 30%"/>
<colstyle="width: 69%"/>
</colgroup>
<thead>
<trclass="header">
<th>Method</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<trclass="odd">
<td><code>object.__len__(self)</code></td>
<td>Called to implement the built-in function <code>len()</code>. Should return the length of the object, an integer <code>>=</code> 0.</td>
<td><p>Called to implement evaluation of <code>self[key]</code>.</p>
<p>For sequence types, the accepted keys should be integers and slice objects. Note that the special interpretation of negative indexes (if the class wishes to emulate a sequence type) is up to the <code>__getitem__()</code> method.</p>
<p>If key is of an inappropriate type, <code>TypeError</code> may be raised; if of a value outside the set of indexes for the sequence (after any special interpretation of negative values), <code>IndexError</code> should be raised. For mapping types, if key is missing (not in the container), <code>KeyError</code> should be raised.</p></td>
<td><p>Called to implement assignment to <code>self[key]</code>.</p>
<p>Same note as for <code>__getitem__()</code>.</p>
<p>This should only be implemented for mappings if the objects support changes to the values for keys, or if new keys can be added, or for sequences if elements can be replaced.</p>
<p>The same exceptions should be raised for improper key values as for the <code>__getitem__()</code> method.</p></td>
<td><p>Called to implement membership test operators (<code>in</code> and <code>not in</code>). Should return <code>True</code> if <code>item</code> is in <code>self</code>, <code>False</code> otherwise.</p>
<p>For mapping objects, this should consider the keys of the mapping rather than the values or the key-item pairs.</p></td>
</tr>
<trclass="odd">
<td><code>object.__iter__(self)</code></td>
<td><p>This method is called when an iterator is required for a container. This method should return a new iterator object that can iterate over all the objects in the container.</p>
<p>For mappings, it should iterate over the keys of the container.</p></td>
<p><em>Adapted from <ahref="https://docs.python.org/3/library/exceptions.html"class="uri">https://docs.python.org/3/library/exceptions.html</a>.</em> Note: Not all built-in Python exceptions are shown.</p>
<divclass="fullwidth reference-table">
<table>
<colgroup>
<colstyle="width: 19%"/>
<colstyle="width: 80%"/>
</colgroup>
<thead>
<trclass="header">
<th>Exception</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<trclass="odd">
<td><code>AssertionError</code></td>
<td>Raised when an <code>assert</code> statement fails.</td>
</tr>
<trclass="even">
<td><code>AttributeError</code></td>
<td><p>Raised when an attribute reference or assignment fails.</p>
<p>(When an object does not support attribute references or attribute assignments at all, <code>TypeError</code> is raised.)</p></td>
</tr>
<trclass="odd">
<td><code>FileNotFoundError</code></td>
<td>Raised when a file or directory is requested but doesn’t exist.</td>
</tr>
<trclass="even">
<td><code>ImportError</code></td>
<td>Raised when the import statement has troubles trying to load a module. Also raised when the “from list” in <code>from ... import</code> has a name that cannot be found.</td>
</tr>
<trclass="odd">
<td><code>ModuleNotFoundError</code></td>
<td>A subclass of <code>ImportError</code> which is raised by <code>import</code> when a module could not be located.</td>
</tr>
<trclass="even">
<td><code>IndexError</code></td>
<td>Raised when a sequence subscript is out of range. (Slice indices are silently truncated to fall in the allowed range; if an index is not an integer, <code>TypeError</code> is raised.)</td>
</tr>
<trclass="odd">
<td><code>KeyError</code></td>
<td>Raised when a mapping (dictionary) key is not found in the set of existing keys.</td>
</tr>
<trclass="even">
<td><code>NameError</code></td>
<td>Raised when a local or global name is not found.</td>
</tr>
<trclass="odd">
<td><code>NotImplementedError</code></td>
<td>In user defined base classes, abstract methods should raise this exception when they require derived classes to override the method, or while the class is being developed to indicate that the real implementation still needs to be added.</td>
</tr>
<trclass="even">
<td><code>RecursionError</code></td>
<td>It is raised when the interpreter detects that the maximum recursion depth (see <code>sys.getrecursionlimit()</code>) is exceeded.</td>
</tr>
<trclass="odd">
<td><code>SyntaxError</code></td>
<td>Raised when the parser encounters a syntax error. This may occur in an import statement, in a call to the built-in functions <code>exec()</code> or <code>eval()</code>, or when reading the initial script or standard input (also interactively).</td>
</tr>
<trclass="even">
<td><code>IndentationError</code></td>
<td>Base class for syntax errors related to incorrect indentation.</td>
</tr>
<trclass="odd">
<td><code>TabError</code></td>
<td>Raised when indentation contains an inconsistent use of tabs and spaces.</td>
</tr>
<trclass="even">
<td><code>TypeError</code></td>
<td><p>Raised when an operation or function is applied to an object of inappropriate type. The associated value is a string giving details about the type mismatch.</p>
<p>This exception may be raised by user code to indicate that an attempted operation on an object is not supported, and is not meant to be. If an object is meant to support a given operation but has not yet provided an implementation, <code>NotImplementedError</code> is the proper exception to raise.</p>
<p>Passing arguments of the wrong type (e.g.passing a list when an int is expected) should result in a <code>TypeError</code>, but passing arguments with the wrong value (e.g.a number outside expected boundaries) should result in a <code>ValueError</code>.</p></td>
</tr>
<trclass="odd">
<td><code>ValueError</code></td>
<td>Raised when an operation or function receives an argument that has the right type but an inappropriate value, and the situation is not described by a more precise exception such as <code>IndexError</code>.</td>
</tr>
<trclass="even">
<td><code>ZeroDivisionError</code></td>
<td>Raised when the second argument of a division or modulo operation is zero. The associated value is a string indicating the type of the operands and the operation.</td>
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
Hykilpikonna