| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118 |
- .. _isinstance-calls:
- isinstance
- ----------
- The following tests all pass on Python 3::
-
- >>> assert isinstance(2**62, int)
- >>> assert isinstance(2**63, int)
- >>> assert isinstance(b'my byte-string', bytes)
- >>> assert isinstance(u'unicode string 1', str)
- >>> assert isinstance('unicode string 2', str)
- However, two of these normally fail on Python 2::
- >>> assert isinstance(2**63, int)
- Traceback (most recent call last):
- File "<stdin>", line 1, in <module>
- AssertionError
- >>> assert isinstance(u'my unicode string', str)
- Traceback (most recent call last):
- File "<stdin>", line 1, in <module>
- AssertionError
- And if this import is in effect on Python 2::
- >>> from __future__ import unicode_literals
- then the fifth test fails too::
- >>> assert isinstance('unicode string 2', str)
- Traceback (most recent call last):
- File "<stdin>", line 1, in <module>
- AssertionError
- After importing the builtins from ``future``, all these tests pass on
- Python 2 as on Python 3::
- >>> from builtins import bytes, int, str
- >>> assert isinstance(10, int)
- >>> assert isinstance(10**100, int)
- >>> assert isinstance(b'my byte-string', bytes)
- >>> assert isinstance(u'unicode string 1', str)
- However, note that the last test requires that ``unicode_literals`` be imported to succeed.::
- >>> from __future__ import unicode_literals
- >>> assert isinstance('unicode string 2', str)
- This works because the backported types ``int``, ``bytes`` and ``str``
- (and others) have metaclasses that override ``__instancecheck__``. See `PEP 3119
- <http://www.python.org/dev/peps/pep-3119/#overloading-isinstance-and-issubclass>`_
- for details.
- Passing data to/from Python 2 libraries
- ---------------------------------------
- If you are passing any of the backported types (``bytes``, ``int``, ``dict,
- ``str``) into brittle library code that performs type-checks using ``type()``,
- rather than ``isinstance()``, or requires that you pass Python 2's native types
- (rather than subclasses) for some other reason, it may be necessary to upcast
- the types from ``future`` to their native superclasses on Py2.
- The ``native`` function in ``future.utils`` is provided for this. Here is how
- to use it. (The output showing is from Py2)::
- >>> from builtins import int, bytes, str
- >>> from future.utils import native
- >>> a = int(10**20) # Py3-like long int
- >>> a
- 100000000000000000000
- >>> type(a)
- future.types.newint.newint
- >>> native(a)
- 100000000000000000000L
- >>> type(native(a))
- long
-
- >>> b = bytes(b'ABC')
- >>> type(b)
- future.types.newbytes.newbytes
- >>> native(b)
- 'ABC'
- >>> type(native(b))
- str
-
- >>> s = str(u'ABC')
- >>> type(s)
- future.types.newstr.newstr
- >>> native(s)
- u'ABC'
- >>> type(native(s))
- unicode
- On Py3, the :func:`native` function is a no-op.
- Native string type
- ------------------
- Some library code, include standard library code like the ``array.array()``
- constructor, require native strings on Python 2 and Python 3. This means that
- there is no simple way to pass the appropriate string type when the
- ``unicode_literals`` import from ``__future__`` is in effect.
- The objects ``native_str`` and ``native_bytes`` are available in
- ``future.utils`` for this case. These are equivalent to the ``str`` and
- ``bytes`` objects in ``__builtin__`` on Python 2 or in ``builtins`` on Python 3.
- The functions ``native_str_to_bytes`` and ``bytes_to_native_str`` are also
- available for more explicit conversions.
|