line. The :func:`reduce` adds up all the numbers, and the rest is just some
pre- and postprocessing.
-On the same note, note that :func:`float`, :func:`int` and :func:`long` all
-accept arguments of type string, and so are suited to parsing --- assuming you
-are ready to deal with the :exc:`ValueError` they raise.
+On the same note, note that :func:`float` and :func:`int` accept arguments of
+type string, and so are suited to parsing --- assuming you are ready to deal
+with the :exc:`ValueError` they raise.
Using Backslash to Continue Statements
Detaches the Windows handle from the handle object.
- The result is an integer (or long on 64 bit Windows) that holds the value of the
- handle before it is detached. If the handle is already detached or closed, this
- will return zero.
+ The result is an integer that holds the value of the handle before it is
+ detached. If the handle is already detached or closed, this will return
+ zero.
After calling this function, the handle is effectively invalidated, but the
handle is not closed. You would call this function when you need the
+-----------+----------------+-------------------+-----------------------+
| ``'i'`` | signed int | int | 2 |
+-----------+----------------+-------------------+-----------------------+
-| ``'I'`` | unsigned int | long | 2 |
+| ``'I'`` | unsigned int | int | 2 |
+-----------+----------------+-------------------+-----------------------+
| ``'l'`` | signed long | int | 4 |
+-----------+----------------+-------------------+-----------------------+
-| ``'L'`` | unsigned long | long | 4 |
+| ``'L'`` | unsigned long | int | 4 |
+-----------+----------------+-------------------+-----------------------+
| ``'f'`` | float | float | 4 |
+-----------+----------------+-------------------+-----------------------+
There are, however, enough ways to crash Python with ``ctypes``, so you should
be careful anyway.
-``None``, integers, longs, byte strings and unicode strings are the only native
+``None``, integers, byte strings and unicode strings are the only native
Python objects that can directly be used as parameters in these function calls.
``None`` is passed as a C ``NULL`` pointer, byte strings and unicode strings are
passed as pointer to the memory block that contains their data (``char *`` or
-``wchar_t *``). Python integers and Python longs are passed as the platforms
+``wchar_t *``). Python integers are passed as the platforms
default C ``int`` type, their value is masked to fit into the C type.
Before we move on calling functions with other parameter types, we have to learn
+----------------------+--------------------------------+----------------------------+
| :class:`c_wchar` | ``wchar_t`` | 1-character unicode string |
+----------------------+--------------------------------+----------------------------+
- | :class:`c_byte` | ``char`` | int/long |
+ | :class:`c_byte` | ``char`` | int |
+----------------------+--------------------------------+----------------------------+
- | :class:`c_ubyte` | ``unsigned char`` | int/long |
+ | :class:`c_ubyte` | ``unsigned char`` | int |
+----------------------+--------------------------------+----------------------------+
- | :class:`c_short` | ``short`` | int/long |
+ | :class:`c_short` | ``short`` | int |
+----------------------+--------------------------------+----------------------------+
- | :class:`c_ushort` | ``unsigned short`` | int/long |
+ | :class:`c_ushort` | ``unsigned short`` | int |
+----------------------+--------------------------------+----------------------------+
- | :class:`c_int` | ``int`` | int/long |
+ | :class:`c_int` | ``int`` | int |
+----------------------+--------------------------------+----------------------------+
- | :class:`c_uint` | ``unsigned int`` | int/long |
+ | :class:`c_uint` | ``unsigned int`` | int |
+----------------------+--------------------------------+----------------------------+
- | :class:`c_long` | ``long`` | int/long |
+ | :class:`c_long` | ``long`` | int |
+----------------------+--------------------------------+----------------------------+
- | :class:`c_ulong` | ``unsigned long`` | int/long |
+ | :class:`c_ulong` | ``unsigned long`` | int |
+----------------------+--------------------------------+----------------------------+
- | :class:`c_longlong` | ``__int64`` or ``long long`` | int/long |
+ | :class:`c_longlong` | ``__int64`` or ``long long`` | int |
+----------------------+--------------------------------+----------------------------+
- | :class:`c_ulonglong` | ``unsigned __int64`` or | int/long |
+ | :class:`c_ulonglong` | ``unsigned __int64`` or | int |
| | ``unsigned long long`` | |
+----------------------+--------------------------------+----------------------------+
| :class:`c_float` | ``float`` | float |
+----------------------+--------------------------------+----------------------------+
| :class:`c_wchar_p` | ``wchar_t *`` (NUL terminated) | unicode or ``None`` |
+----------------------+--------------------------------+----------------------------+
- | :class:`c_void_p` | ``void *`` | int/long or ``None`` |
+ | :class:`c_void_p` | ``void *`` | int or ``None`` |
+----------------------+--------------------------------+----------------------------+
.. class:: timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]])
- All arguments are optional and default to ``0``. Arguments may be ints, longs,
+ All arguments are optional and default to ``0``. Arguments may be integers
or floats, and may be positive or negative.
Only *days*, *seconds* and *microseconds* are stored internally. Arguments are
| | == *t2* - *t3* and *t2* == *t1* + *t3* are |
| | true. (1) |
+--------------------------------+-----------------------------------------------+
-| ``t1 = t2 * i or t1 = i * t2`` | Delta multiplied by an integer or long. |
+| ``t1 = t2 * i or t1 = i * t2`` | Delta multiplied by an integer. |
| | Afterwards *t1* // i == *t2* is true, |
| | provided ``i != 0``. |
+--------------------------------+-----------------------------------------------+
.. class:: date(year, month, day)
- All arguments are required. Arguments may be ints or longs, in the following
+ All arguments are required. Arguments may be integers, in the following
ranges:
* ``MINYEAR <= year <= MAXYEAR``
.. class:: datetime(year, month, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]])
The year, month and day arguments are required. *tzinfo* may be ``None``, or an
- instance of a :class:`tzinfo` subclass. The remaining arguments may be ints or
- longs, in the following ranges:
+ instance of a :class:`tzinfo` subclass. The remaining arguments may be integers,
+ in the following ranges:
* ``MINYEAR <= year <= MAXYEAR``
* ``1 <= month <= 12``
.. class:: time(hour[, minute[, second[, microsecond[, tzinfo]]]])
All arguments are optional. *tzinfo* may be ``None``, or an instance of a
- :class:`tzinfo` subclass. The remaining arguments may be ints or longs, in the
+ :class:`tzinfo` subclass. The remaining arguments may be integers, in the
following ranges:
* ``0 <= hour < 24``
def factorial(n):
"""Return the factorial of n, an exact integer >= 0.
- If the result is small enough to fit in an int, return an int.
- Else return a long.
-
>>> [factorial(n) for n in range(6)]
[1, 1, 2, 6, 24, 120]
- >>> [factorial(long(n)) for n in range(6)]
- [1, 1, 2, 6, 24, 120]
>>> factorial(30)
- 265252859812191058636308480000000L
- >>> factorial(30L)
- 265252859812191058636308480000000L
+ 265252859812191058636308480000000
>>> factorial(-1)
Traceback (most recent call last):
...
...
ValueError: n must be exact integer
>>> factorial(30.0)
- 265252859812191058636308480000000L
+ 265252859812191058636308480000000
It must also not be ridiculously large:
>>> factorial(1e100)
Expecting:
[1, 1, 2, 6, 24, 120]
ok
- Trying:
- [factorial(long(n)) for n in range(6)]
- Expecting:
- [1, 1, 2, 6, 24, 120]
- ok
And so on, eventually ending with::
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 function serves as a numeric conversion function like :func:`int`,
- :func:`long` and :func:`float`. If both arguments are omitted, returns ``0j``.
+ the function serves as a numeric conversion function like :func:`int`
+ and :func:`float`. If both arguments are omitted, returns ``0j``.
The complex type is described in :ref:`typesnumeric`.
.. function:: divmod(a, b)
Take two (non complex) numbers as arguments and return a pair of numbers
- consisting of their quotient and remainder when using long division. With mixed
+ consisting of their quotient and remainder when using integer division. With mixed
operand types, the rules for binary arithmetic operators apply. For integers,
the result is the same as ``(a // b, a % b)``. For floating point
numbers the result is ``(q, a % b)``, where *q* is usually ``math.floor(a / b)``
containing all fields of a record according to the schema of the table. For
optional fields, ``None`` can be passed.
- Field values can be int or long numbers, strings, or instances of the Binary
- class.
+ Field values can be integers, strings, or instances of the Binary class.
.. class:: Binary(filename)
long option strings, :mod:`optparse` looks at the first short option string: the
default destination for ``"-f"`` is ``f``.
-:mod:`optparse` also includes built-in ``long`` and ``complex`` types. Adding
+:mod:`optparse` also includes the built-in ``complex`` type. Adding
types is covered in section :ref:`optparse-extending-optparse`.
Standard option types
^^^^^^^^^^^^^^^^^^^^^
-:mod:`optparse` has six built-in option types: ``string``, ``int``, ``long``,
+:mod:`optparse` has five built-in option types: ``string``, ``int``,
``choice``, ``float`` and ``complex``. If you need to add new option types, see
section :ref:`optparse-extending-optparse`.
Arguments to string options are not checked or converted in any way: the text on
the command line is stored in the destination (or passed to the callback) as-is.
-Integer arguments (type ``int`` or ``long``) are parsed as follows:
+Integer arguments (type ``int``) are parsed as follows:
* if the number starts with ``0x``, it is parsed as a hexadecimal number
* otherwise, the number is parsed as a decimal number
-The conversion is done by calling either ``int()`` or ``long()`` with the
-appropriate base (2, 8, 10, or 16). If this fails, so will :mod:`optparse`,
-although with a more useful error message.
+The conversion is done by calling ``int()`` with the appropriate base (2, 8, 10,
+or 16). If this fails, so will :mod:`optparse`, although with a more useful
+error message.
``float`` and ``complex`` option arguments are converted directly with
``float()`` and ``complex()``, with similar error-handling.
Large file support is enabled in Python when the size of an :ctype:`off_t` is
larger than a :ctype:`long` and the :ctype:`long long` type is available and is
-at least as large as an :ctype:`off_t`. Python longs are then used to represent
-file sizes, offsets and other values that can exceed the range of a Python int.
+at least as large as an :ctype:`off_t`.
It may be necessary to configure and compile Python with certain compiler flags
to enable this mode. For example, it is enabled by default with recent versions
of Irix, but with Solaris 2.6 and 2.7 you need to do something like::
they are used instead of the system time (see the :func:`os.urandom` function
for details on availability).
- If *x* is not ``None`` or an int or long, ``hash(x)`` is used instead. If *x* is
- an int or long, *x* is used directly.
+ If *x* is not ``None`` or an int, ``hash(x)`` is used instead. If *x* is an
+ int, *x* is used directly.
.. function:: getstate()
.. function:: getrandbits(k)
- Returns a python :class:`long` int with *k* random bits. This method is supplied
- with the MersenneTwister generator and some other generators may also provide it
+ Returns a python integer with *k* random bits. This method is supplied with
+ the MersenneTwister generator and some other generators may also provide it
as an optional part of the API. When available, :meth:`getrandbits` enables
:meth:`randrange` to handle arbitrarily large ranges.
Registers a callable to convert the custom Python type *type* into one of
SQLite's supported types. The callable *callable* accepts as single parameter
- the Python value, and must return a value of the following types: int, long,
+ the Python value, and must return a value of the following types: int,
float, str (UTF-8 encoded), unicode or buffer.
as the SQL function.
The function can return any of the types supported by SQLite: unicode, str, int,
- long, float, buffer and None.
+ float, buffer and None.
Example:
final result of the aggregate.
The ``finalize`` method can return any of the types supported by SQLite:
- unicode, str, int, long, float, buffer and None.
+ unicode, str, int, float, buffer and None.
Example:
+------------------------+-------------+
| ``int`` | INTEGER |
+------------------------+-------------+
-| ``long`` | INTEGER |
-+------------------------+-------------+
| ``float`` | REAL |
+------------------------+-------------+
| ``str (UTF8-encoded)`` | TEXT |
+=============+=============================================+
| ``NULL`` | None |
+-------------+---------------------------------------------+
-| ``INTEGER`` | int or long, depending on size |
+| ``INTEGER`` | int |
+-------------+---------------------------------------------+
| ``REAL`` | float |
+-------------+---------------------------------------------+
As described before, SQLite supports only a limited set of types natively. To
use other Python types with SQLite, you must **adapt** them to one of the
-sqlite3 module's supported types for SQLite: one of NoneType, int, long, float,
+sqlite3 module's supported types for SQLite: one of NoneType, int, float,
str, unicode, buffer.
The :mod:`sqlite3` module uses Python object adaptation, as described in
*__slots__*.
* *__slots__* do not work for classes derived from "variable-length" built-in
- types such as :class:`long`, :class:`str` and :class:`tuple`.
+ types such as :class:`int`, :class:`str` and :class:`tuple`.
* Any non-string iterable may be assigned to *__slots__*. Mappings may also be
used; however, in the future, special meaning may be assigned to the values
.. method:: object.__complex__(self)
object.__int__(self)
- object.__long__(self)
object.__float__(self)
.. index::
builtin: complex
builtin: int
- builtin: long
builtin: float
- Called to implement the built-in functions :func:`complex`, :func:`int`,
- :func:`long`, and :func:`float`. Should return a value of the appropriate type.
+ Called to implement the built-in functions :func:`complex`, :func:`int`
+ and :func:`float`. Should return a value of the appropriate type.
.. method:: object.__index__(self)
Called to implement :func:`operator.index`. Also called whenever Python needs
an integer object (such as in slicing, or in the built-in :func:`bin`,
- :func:`hex` and :func:`oct` functions). Must return an integer (int or long).
+ :func:`hex` and :func:`oct` functions). Must return an integer.
.. _context-managers:
projects / thirdparty / Python / cpython.git / commitdiff
