See also :func:`format` for more information.
-.. class:: bool(x=False)
+.. class:: bool(object=False, /)
- Return a Boolean value, i.e. one of ``True`` or ``False``. *x* is converted
- using the standard :ref:`truth testing procedure <truth>`. If *x* is false
+ Return a Boolean value, i.e. one of ``True`` or ``False``. The argument
+ is converted using the standard :ref:`truth testing procedure <truth>`.
+ If the argument is false
or omitted, this returns ``False``; otherwise, it returns ``True``. The
:class:`bool` class is a subclass of :class:`int` (see :ref:`typesnumeric`).
It cannot be subclassed further. Its only instances are ``False`` and
.. index:: pair: Boolean; type
.. versionchanged:: 3.7
- *x* is now a positional-only parameter.
+ The parameter is now positional-only.
.. function:: breakpoint(*args, **kws)
support for top-level ``await``, ``async for``, and ``async with``.
-.. class:: complex(real=0, imag=0)
- complex(string)
+.. class:: complex(number=0, /)
+ complex(string, /)
+ complex(real=0, imag=0)
+
+ Convert a single string or number to a complex number, or create a
+ complex number from real and imaginary parts.
+
+ Examples:
+
+ .. doctest::
+
+ >>> complex('+1.23')
+ (1.23+0j)
+ >>> complex('-4.5j')
+ -4.5j
+ >>> complex('-1.23+4.5j')
+ (-1.23+4.5j)
+ >>> complex('\t( -1.23+4.5J )\n')
+ (-1.23+4.5j)
+ >>> complex('-Infinity+NaNj')
+ (-inf+nanj)
+ >>> complex(1.23)
+ (1.23+0j)
+ >>> complex(imag=-4.5)
+ -4.5j
+ >>> complex(-1.23, 4.5)
+ (-1.23+4.5j)
+
+ If the argument is a string, it must contain either a real part (in the
+ same format as for :func:`float`) or an imaginary part (in the same
+ format but with a ``'j'`` or ``'J'`` suffix), or both real and imaginary
+ parts (the sign of the imaginary part is mandatory in this case).
+ The string can optionally be surrounded by whitespaces and the round
+ parentheses ``'('`` and ``')'``, which are ignored.
+ The string must not contain whitespace between ``'+'``, ``'-'``, the
+ ``'j'`` or ``'J'`` suffix, and the decimal number.
+ For example, ``complex('1+2j')`` is fine, but ``complex('1 + 2j')`` raises
+ :exc:`ValueError`.
+ More precisely, the input must conform to the :token:`~float:complexvalue`
+ production rule in the following grammar, after parentheses and leading and
+ trailing whitespace characters are removed:
- Return a complex number with the value *real* + *imag*\*1j or convert a string
- or number to a complex number. If the first parameter is a string, it will
- be interpreted as a complex number and the function must be called without a
- second parameter. The second parameter can never be a string. Each argument
- may be any numeric type (including complex). If *imag* is omitted, it
- defaults to zero and the constructor serves as a numeric conversion like
- :class:`int` and :class:`float`. If both arguments are omitted, returns
- ``0j``.
+ .. productionlist:: float
+ complexvalue: `floatvalue` |
+ : `floatvalue` ("j" | "J") |
+ : `floatvalue` `sign` `absfloatvalue` ("j" | "J")
+ If the argument is a number, the constructor serves as a numeric
+ conversion like :class:`int` and :class:`float`.
For a general Python object ``x``, ``complex(x)`` delegates to
- ``x.__complex__()``. If :meth:`~object.__complex__` is not defined then it falls back
- to :meth:`~object.__float__`. If :meth:`!__float__` is not defined then it falls back
+ ``x.__complex__()``.
+ If :meth:`~object.__complex__` is not defined then it falls back
+ to :meth:`~object.__float__`.
+ If :meth:`!__float__` is not defined then it falls back
to :meth:`~object.__index__`.
- .. note::
+ If two arguments are provided or keyword arguments are used, each argument
+ may be any numeric type (including complex).
+ If both arguments are real numbers, return a complex number with the real
+ component *real* and the imaginary component *imag*.
+ If both arguments are complex numbers, return a complex number with the real
+ component ``real.real-imag.imag`` and the imaginary component
+ ``real.imag+imag.real``.
+ If one of arguments is a real number, only its real component is used in
+ the above expressions.
- When converting from a string, the string must not contain whitespace
- around the central ``+`` or ``-`` operator. For example,
- ``complex('1+2j')`` is fine, but ``complex('1 + 2j')`` raises
- :exc:`ValueError`.
+ If all arguments are omitted, returns ``0j``.
The complex type is described in :ref:`typesnumeric`.
elements of *iterable* for which *function* is false.
-.. class:: float(x=0.0)
+.. class:: float(number=0.0, /)
+ float(string, /)
.. index::
single: NaN
single: Infinity
- Return a floating point number constructed from a number or string *x*.
+ Return a floating point number constructed from a number or a string.
+
+ Examples:
+
+ .. doctest::
+
+ >>> float('+1.23')
+ 1.23
+ >>> float(' -12345\n')
+ -12345.0
+ >>> float('1e-003')
+ 0.001
+ >>> float('+1E6')
+ 1000000.0
+ >>> float('-Infinity')
+ -inf
If the argument is a string, it should contain a decimal number, optionally
preceded by a sign, and optionally embedded in whitespace. The optional
sign may be ``'+'`` or ``'-'``; a ``'+'`` sign has no effect on the value
produced. The argument may also be a string representing a NaN
- (not-a-number), or positive or negative infinity. More precisely, the
- input must conform to the ``floatvalue`` production rule in the following
- grammar, after leading and trailing whitespace characters are removed:
+ (not-a-number), or positive or negative infinity.
+ More precisely, the input must conform to the :token:`~float:floatvalue`
+ production rule in the following grammar, after leading and trailing
+ whitespace characters are removed:
.. productionlist:: float
sign: "+" | "-"
digit: <a Unicode decimal digit, i.e. characters in Unicode general category Nd>
digitpart: `digit` (["_"] `digit`)*
number: [`digitpart`] "." `digitpart` | `digitpart` ["."]
- exponent: ("e" | "E") ["+" | "-"] `digitpart`
- floatnumber: number [`exponent`]
- floatvalue: [`sign`] (`floatnumber` | `infinity` | `nan`)
+ exponent: ("e" | "E") [`sign`] `digitpart`
+ floatnumber: `number` [`exponent`]
+ absfloatvalue: `floatnumber` | `infinity` | `nan`
+ floatvalue: [`sign`] `absfloatvalue`
Case is not significant, so, for example, "inf", "Inf", "INFINITY", and
"iNfINity" are all acceptable spellings for positive infinity.
If no argument is given, ``0.0`` is returned.
- Examples::
-
- >>> float('+1.23')
- 1.23
- >>> float(' -12345\n')
- -12345.0
- >>> float('1e-003')
- 0.001
- >>> float('+1E6')
- 1000000.0
- >>> float('-Infinity')
- -inf
-
The float type is described in :ref:`typesnumeric`.
.. versionchanged:: 3.6
Grouping digits with underscores as in code literals is allowed.
.. versionchanged:: 3.7
- *x* is now a positional-only parameter.
+ The parameter is now positional-only.
.. versionchanged:: 3.8
Falls back to :meth:`~object.__index__` if :meth:`~object.__float__` is not defined.
with the result after successfully reading input.
-.. class:: int(x=0)
- int(x, base=10)
+.. class:: int(number=0, /)
+ int(string, /, base=10)
+
+ Return an integer object constructed from a number or a string, or return
+ ``0`` if no arguments are given.
+
+ Examples:
+
+ .. doctest::
+
+ >>> int(123.45)
+ 123
+ >>> int('123')
+ 123
+ >>> int(' -12_345\n')
+ -12345
+ >>> int('FACE', 16)
+ 64206
+ >>> int('0xface', 0)
+ 64206
+ >>> int('01110011', base=2)
+ 115
- Return an integer object constructed from a number or string *x*, or return
- ``0`` if no arguments are given. If *x* defines :meth:`~object.__int__`,
- ``int(x)`` returns ``x.__int__()``. If *x* defines :meth:`~object.__index__`,
- it returns ``x.__index__()``. If *x* defines :meth:`~object.__trunc__`,
+ If the argument defines :meth:`~object.__int__`,
+ ``int(x)`` returns ``x.__int__()``. If the argument defines :meth:`~object.__index__`,
+ it returns ``x.__index__()``. If the argument defines :meth:`~object.__trunc__`,
it returns ``x.__trunc__()``.
For floating point numbers, this truncates towards zero.
- If *x* is not a number or if *base* is given, then *x* must be a string,
+ If the argument is not a number or if *base* is given, then it must be a string,
:class:`bytes`, or :class:`bytearray` instance representing an integer
in radix *base*. Optionally, the string can be preceded by ``+`` or ``-``
(with no space in between), have leading zeros, be surrounded by whitespace,
Grouping digits with underscores as in code literals is allowed.
.. versionchanged:: 3.7
- *x* is now a positional-only parameter.
+ The first parameter is now positional-only.
.. versionchanged:: 3.8
Falls back to :meth:`~object.__index__` if :meth:`~object.__int__` is not defined.
.. versionchanged:: 3.11
:class:`int` string inputs and string representations can be limited to
help avoid denial of service attacks. A :exc:`ValueError` is raised when
- the limit is exceeded while converting a string *x* to an :class:`int` or
+ the limit is exceeded while converting a string to an :class:`int` or
when converting an :class:`int` into a string would exceed the limit.
See the :ref:`integer string conversion length limitation
<int_max_str_digits>` documentation.
projects / thirdparty / Python / cpython.git / commitdiff
