/usr/lib/python3/dist-packages/first-2.0.0.egg-info/PKG-INFO is in python3-first 2.0.0-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 | Metadata-Version: 1.1
Name: first
Version: 2.0.0
Summary: Return the first true value of an iterable.
Home-page: http://github.com/hynek/first/
Author: Hynek Schlawack
Author-email: hs@ox.cx
License: MIT
Description: first: The function you always missed in Python
===============================================
*first* is a MIT licensed Python package with a simple function that returns
the first true value from an iterable, or ``None`` if there is none. If you
need more power, you can also supply a ``key`` function that is used to judge
the truth value of the element or a ``default`` value if ``None`` doesn’t fit
your use case.
I’m using the term “true” consistently with Python docs for ``any()`` and
``all()`` — it means that the value evaluates to true like: ``True``, ``1``,
``"foo"`` or ``[None]``. But **not**: ``None``, ``False`` or ``0``. In
JavaScript, they call this “truthy”.
Examples
========
A simple example to get started: ::
>>> from first import first
>>> first([0, None, False, [], (), 42])
42
However, it’s especially useful for dealing with regular expressions in
``if/elif/else`` branches: ::
import re
from first import first
re1 = re.compile('b(.*)')
re2 = re.compile('a(.*)')
m = first(regexp.match('abc') for regexp in [re1, re2])
if not m:
print('no match!')
elif m.re is re1:
print('re1', m.group(1))
elif m.re is re2:
print('re2', m.group(1))
The optional ``key`` function gives you even *more* selection power. If you
want to return the first even number from a list, just do the following::
>>> from first import first
>>> first([1, 1, 3, 4, 5], key=lambda x: x % 2 == 0)
4
``default`` on the other hand allows you to specify a value that is returned
if none of the elements is true: ::
>>> from first import first
>>> first([0, None, False, [], ()], default=42)
42
Usage
=====
The package consists of one module consisting of one function::
from first import first
first(iterable, default=None, key=None)
This function returns the first element of ``iterable`` that is true if
``key`` is ``None``. If there is no true element, the value of ``default`` is
returned, which is ``None`` by default.
If a callable is supplied in ``key``, the result of ``key(element)`` is
used to judge the truth value of the element, but the element itself is
returned.
*first* has no dependencies and should work with any Python available. Of
course, it works with the awesome `Python 3`_ everybody should be using.
Alternatives
============
*first* brings nothing to the table that wasn’t possible before. However the
existing solutions aren’t very idiomatic for such a common and simple problem.
The following constructs are equivalent to ``first(seq)`` and work since Python
2.6: ::
next(itertools.ifilter(None, seq), None)
next(itertools.ifilter(bool, seq), None)
next((x for x in seq if x), None)
None of them is as pretty as I’d like them to be. The ``re`` example from
above would look like the following: ::
next(itertools.ifilter(None, (regexp.match('abc') for regexp in [re1, re2])), None)
next((regexp.match('abc') for regexp in [re1, re2] if regexp.match('abc')), None)
Note that in the second case you have to call ``regexp.match()`` *twice*. For
comparison, one more time the *first*-version: ::
first(regexp.match('abc') for regexp in [re1, re2])
Idiomatic, clear and readable. Pythonic. :)
Background
==========
The idea for *first* goes back to a discussion I had with `Łukasz Langa`_ about
how the ``re`` example above is painful in Python. We figured such a function
is missing Python, however it’s rather unlikely we’d get it in and even if, it
wouldn’t get in before 3.4 anyway, which is years away as of yours truly is
writing this.
So I decided to release it as a package for now. If it proves popular enough,
it may even make it into Python’s stdlib in the end.
.. _`Python 3`: http://getpython3.com/
.. _`Łukasz Langa`: https://github.com/ambv
History
=======
2.0.0 (2012-10-13)
------------------
- `pred` proved to be rather useless. Changed to `key` which is just
a selector. This is a *backward incompatible* change and the reason for
going 2.0.
- Add `default` argument which is returned instead of `None` if no true
element is found.
1.0.2 (2012-10-09)
------------------
- Fix packaging. I get this never right the first time. :-/
1.0.1 (2012-10-09)
------------------
- Documentation fixes only.
1.0.0 (2012-10-09)
------------------
- Initial release.
Credits
=======
“first” is written and maintained by Hynek Schlawack and various contributors:
- Łukasz Langa
- Nick Coghlan
- Vincent Driessen
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: Natural Language :: English
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.3
Classifier: Programming Language :: Python :: 2.4
Classifier: Programming Language :: Python :: 2.5
Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.0
Classifier: Programming Language :: Python :: 3.1
Classifier: Programming Language :: Python :: 3.2
Classifier: Programming Language :: Python :: 3.3
Classifier: Topic :: Software Development :: Libraries :: Python Modules
|