python-3.7.4-docs.zip

.. XXX: reference/datamodel and this have quite a few overlaps! .. _bltin-types: ************** Built-in Types ************** The following sections describe the standard types that are built into the interpreter. .. index:: pair: built-in; types The principal built-in types are numerics, sequences, mappings, classes, instances and exceptions. Some collection classes are mutable. The methods that add, subtract, or rearrange their members in place, and don't return a specific item, never return the collection instance itself but ``None``. Some operations are supported by several object types; in particular, practically all objects can be compared, tested for truth value, and converted to a string (with the :func:`repr` function or the slightly different :func:`str` function). The latter function is implicitly used when an object is written by the :func:`print` function. .. _truth: Truth Value Testing =================== .. index:: statement: if statement: while pair: truth; value pair: Boolean; operations single: false Any object can be tested for truth value, for use in an :keyword:`if` or :keyword:`while` condition or as operand of the Boolean operations below. .. index:: single: true By default, an object is considered true unless its class defines either a :meth:`__bool__` method that returns ``False`` or a :meth:`__len__` method that returns zero, when called with the object. [1]_ Here are most of the built-in objects considered false: .. index:: single: None (Built-in object) single: False (Built-in object) * constants defined to be false: ``None`` and ``False``. * zero of any numeric type: ``0``, ``0.0``, ``0j``, ``Decimal(0)``, ``Fraction(0, 1)`` * empty sequences and collections: ``''``, ``()``, ``[]``, ``{}``, ``set()``, ``range(0)`` .. index:: operator: or operator: and single: False single: True Operations and built-in functions that have a Boolean result always return ``0`` or ``False`` for false and ``1`` or ``True`` for true, unless otherwise stated. (Important exception: the Boolean operations ``or`` and ``and`` always return one of their operands.) .. _boolean: Boolean Operations --- :keyword:`!and`, :keyword:`!or`, :keyword:`!not` ======================================================================= .. index:: pair: Boolean; operations These are the Boolean operations, ordered by ascending priority: +-------------+---------------------------------+-------+ | Operation | Result | Notes | +=============+=================================+=======+ | ``x or y`` | if *x* is false, then *y*, else | \(1) | | | *x* | | +-------------+---------------------------------+-------+ | ``x and y`` | if *x* is false, then *x*, else | \(2) | | | *y* | | +-------------+---------------------------------+-------+ | ``not x`` | if *x* is false, then ``True``, | \(3) | | | else ``False`` | | +-------------+---------------------------------+-------+ .. index:: operator: and operator: or operator: not Notes: (1) This is a short-circuit operator, so it only evaluates the second argument if the first one is false. (2) This is a short-circuit operator, so it only evaluates the second argument if the first one is true. (3) ``not`` has a lower priority than non-Boolean operators, so ``not a == b`` is interpreted as ``not (a == b)``, and ``a == not b`` is a syntax error. .. _stdcomparisons: Comparisons =========== .. index:: pair: chaining; comparisons pair: operator; comparison operator: == operator: < (less) operator: <= operator: > (greater) operator: >= operator: != operator: is operator: is not There are eight comparison operations in Python. They all have the same priority (which is higher than that of the Boolean operations). Comparisons can be chained arbitrarily; for example, ``x < y <= z`` is equivalent to ``x < y and y <= z``, except that *y* is evaluated only once (but in both cases *z* is not evaluated at all when ``x < y`` is found to be false). This table summarizes the comparison operations: +------------+-------------------------+ | Operation | Meaning | +============+=========================+ | ``<`` | strictly less than | +------------+-------------------------+ | ``<=`` | less than or equal | +------------+-------------------------+ | ``>`` | strictly greater than | +------------+-------------------------+ | ``>=`` | greater than or equal | +------------+-------------------------+ | ``==`` | equal | +------------+-------------------------+ | ``!=`` | not equal | +------------+-------------------------+ | ``is`` | object identity | +------------+-------------------------+ | ``is not`` | negated object identity | +------------+-------------------------+ .. index:: pair: object; numeric pair: objects; comparing Objects of different types, except different numeric types, never compare equal. Furthermore, some types (for example, function objects) support only a degenerate notion of comparison where any two objects of that type are unequal. The ``<``, ``<=``, ``>`` and ``>=`` operators will raise a :exc:`TypeError` exception when comparing a complex number with another built-in numeric type, when the objects are of different types that cannot be compared, or in other cases where there is no defined ordering. .. index:: single: __eq__() (instance method) single: __ne__() (instance method) single: __lt__() (instance method) single: __le__() (instance method) single: __gt__() (instance method) single: __ge__() (instance method) Non-identical instances of a class normally compare as non-equal unless the class defines the :meth:`__eq__` method. Instances of a class cannot be ordered with respect to other instances of the same class, or other types of object, unless the class defines enough of the methods :meth:`__lt__`, :meth:`__le__`, :meth:`__gt__`, and :meth:`__ge__` (in general, :meth:`__lt__` and :meth:`__eq__` are sufficient, if you want the conventional meanings of the comparison operators). The behavior of the :keyword:`is` and :keyword:`is not` operators cannot be customized; also they can be applied to any two objects and never raise an exception. .. index:: operator: in operator: not in Two more operations with the same syntactic priority, :keyword:`in` and :keyword:`not in`, are supported by types that are :term:`iterable` or implement the :meth:`__contains__` method. .. _typesnumeric: Numeric Types --- :class:`int`, :class:`float`, :class:`complex` ================================================================ .. index:: object: numeric object: Boolean object: integer object: floating point object: complex number pair: C; language There are three distinct numeric types: :dfn:`integers`, :dfn:`floating point numbers`, and :dfn:`complex numbers`. In addition, Booleans are a subtype of integers. Integers have unlimited precision. Floating point numbers are usually implemented using :c:type:`double` in C; information about the precision and internal representation of floating point numbers for the machine on which your program is running is available in :data:`sys.float_info`. Complex numbers have a real and imaginary part, which are each a floating point number. To extract these parts from a complex number *z*, use ``z.real`` and ``z.imag``. (The standard library includes additional numeric types, :mod:`fractions` that hold rationals, and :mod:`decimal` that hold floating-point numbers with user-definable precision.) .. index:: pair: numeric; literals pair: integer; literals pair: floating point; literals pair: complex number; literals pair: hexadecimal; literal