From 9fff496394dcd94c4084694ca96a5e07ab836274 Mon Sep 17 00:00:00 2001 From: yum Date: Mon, 23 Jan 2023 14:28:53 -0800 Subject: package.ps1 now fetches all dependencies Don't literally check in Python since it looks dodgy (rightfully so). Instead the build script just fetches it. * Update README, simplifying language and documenting other projects --- .../future-0.18.2/docs/dict_object.rst | 92 ---------------------- 1 file changed, 92 deletions(-) delete mode 100644 FOSS/Python/Dependencies/future-0.18.2/docs/dict_object.rst (limited to 'FOSS/Python/Dependencies/future-0.18.2/docs/dict_object.rst') diff --git a/FOSS/Python/Dependencies/future-0.18.2/docs/dict_object.rst b/FOSS/Python/Dependencies/future-0.18.2/docs/dict_object.rst deleted file mode 100644 index 165cf76..0000000 --- a/FOSS/Python/Dependencies/future-0.18.2/docs/dict_object.rst +++ /dev/null @@ -1,92 +0,0 @@ -.. _dict-object: - -dict ----- - -Python 3 dictionaries have ``.keys()``, ``.values()``, and ``.items()`` -methods which return memory-efficient set-like iterator objects, not lists. -(See `PEP 3106 `_.) - -If your dictionaries are small, performance is not critical, and you don't need -the set-like behaviour of iterator objects from Python 3, you can of course -stick with standard Python 3 code in your Py2/3 compatible codebase:: - - # Assuming d is a native dict ... - - for key in d: - # code here - - for item in d.items(): - # code here - - for value in d.values(): - # code here - -In this case there will be memory overhead of list creation on Py2 for each -call to ``items``, ``values`` or ``keys``. - -For improved efficiency, ``future.builtins`` (aliased to ``builtins``) provides -a Python 2 ``dict`` subclass whose :func:`keys`, :func:`values`, and -:func:`items` methods return iterators on all versions of Python >= 2.7. On -Python 2.7, these iterators also have the same set-like view behaviour as -dictionaries in Python 3. This can streamline code that iterates over large -dictionaries. For example:: - - from __future__ import print_function - from builtins import dict, range - - # Memory-efficient construction: - d = dict((i, i**2) for i in range(10**7)) - - assert not isinstance(d.items(), list) - - # Because items() is memory-efficient, so is this: - d2 = dict((v, k) for (k, v) in d.items()) - -As usual, on Python 3 ``dict`` imported from either ``builtins`` or -``future.builtins`` is just the built-in ``dict`` class. - - -Memory-efficiency and alternatives -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -If you already have large native dictionaries, the downside to wrapping them in -a ``dict`` call is that memory is copied (on both Py3 and on Py2). For -example:: - - # This allocates and then frees a large amount of temporary memory: - d = dict({i: i**2 for i in range(10**7)}) - -If dictionary methods like ``values`` and ``items`` are called only once, this -obviously negates the memory benefits offered by the overridden methods through -not creating temporary lists. - -The memory-efficient (and CPU-efficient) alternatives are: - -- to construct a dictionary from an iterator. The above line could use a - generator like this:: - - d = dict((i, i**2) for i in range(10**7)) - -- to construct an empty dictionary with a ``dict()`` call using - ``builtins.dict`` (rather than ``{}``) and then update it; - -- to use the ``viewitems`` etc. functions from :mod:`future.utils`, passing in - regular dictionaries:: - - from future.utils import viewkeys, viewvalues, viewitems - - for (key, value) in viewitems(hugedictionary): - # some code here - - # Set intersection: - d = {i**2: i for i in range(1000)} - both = viewkeys(d) & set(range(0, 1000, 7)) - - # Set union: - both = viewvalues(d1) | viewvalues(d2) - -For compatibility, the functions ``iteritems`` etc. are also available in -:mod:`future.utils`. These are equivalent to the functions of the same names in -``six``, which is equivalent to calling the ``iteritems`` etc. methods on -Python 2, or to calling ``items`` etc. on Python 3. -- cgit v1.2.3