# SOME DESCRIPTIVE TITLE. # Copyright (C) 1990-2016, Python Software Foundation # This file is distributed under the same license as the Python package. # FIRST AUTHOR , YEAR. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 2.7\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2016-10-30 10:44+0100\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: ../Doc/howto/functional.rst:3 msgid "Functional Programming HOWTO" msgstr "" #: ../Doc/howto/functional.rst:5 msgid "A. M. Kuchling" msgstr "" #: ../Doc/howto/functional.rst:6 msgid "0.31" msgstr "" #: ../Doc/howto/functional.rst:8 msgid "" "In this document, we'll take a tour of Python's features suitable for " "implementing programs in a functional style. After an introduction to the " "concepts of functional programming, we'll look at language features such as :" "term:`iterator`\\s and :term:`generator`\\s and relevant library modules " "such as :mod:`itertools` and :mod:`functools`." msgstr "" #: ../Doc/howto/functional.rst:16 msgid "Introduction" msgstr "Introduction" #: ../Doc/howto/functional.rst:18 msgid "" "This section explains the basic concept of functional programming; if you're " "just interested in learning about Python language features, skip to the next " "section." msgstr "" #: ../Doc/howto/functional.rst:22 msgid "" "Programming languages support decomposing problems in several different ways:" msgstr "" #: ../Doc/howto/functional.rst:24 msgid "" "Most programming languages are **procedural**: programs are lists of " "instructions that tell the computer what to do with the program's input. C, " "Pascal, and even Unix shells are procedural languages." msgstr "" #: ../Doc/howto/functional.rst:28 msgid "" "In **declarative** languages, you write a specification that describes the " "problem to be solved, and the language implementation figures out how to " "perform the computation efficiently. SQL is the declarative language you're " "most likely to be familiar with; a SQL query describes the data set you want " "to retrieve, and the SQL engine decides whether to scan tables or use " "indexes, which subclauses should be performed first, etc." msgstr "" #: ../Doc/howto/functional.rst:35 msgid "" "**Object-oriented** programs manipulate collections of objects. Objects " "have internal state and support methods that query or modify this internal " "state in some way. Smalltalk and Java are object-oriented languages. C++ " "and Python are languages that support object-oriented programming, but don't " "force the use of object-oriented features." msgstr "" #: ../Doc/howto/functional.rst:41 msgid "" "**Functional** programming decomposes a problem into a set of functions. " "Ideally, functions only take inputs and produce outputs, and don't have any " "internal state that affects the output produced for a given input. Well-" "known functional languages include the ML family (Standard ML, OCaml, and " "other variants) and Haskell." msgstr "" #: ../Doc/howto/functional.rst:47 msgid "" "The designers of some computer languages choose to emphasize one particular " "approach to programming. This often makes it difficult to write programs " "that use a different approach. Other languages are multi-paradigm languages " "that support several different approaches. Lisp, C++, and Python are multi-" "paradigm; you can write programs or libraries that are largely procedural, " "object-oriented, or functional in all of these languages. In a large " "program, different sections might be written using different approaches; the " "GUI might be object-oriented while the processing logic is procedural or " "functional, for example." msgstr "" #: ../Doc/howto/functional.rst:57 msgid "" "In a functional program, input flows through a set of functions. Each " "function operates on its input and produces some output. Functional style " "discourages functions with side effects that modify internal state or make " "other changes that aren't visible in the function's return value. Functions " "that have no side effects at all are called **purely functional**. Avoiding " "side effects means not using data structures that get updated as a program " "runs; every function's output must only depend on its input." msgstr "" #: ../Doc/howto/functional.rst:65 msgid "" "Some languages are very strict about purity and don't even have assignment " "statements such as ``a=3`` or ``c = a + b``, but it's difficult to avoid all " "side effects. Printing to the screen or writing to a disk file are side " "effects, for example. For example, in Python a ``print`` statement or a " "``time.sleep(1)`` both return no useful value; they're only called for their " "side effects of sending some text to the screen or pausing execution for a " "second." msgstr "" #: ../Doc/howto/functional.rst:73 msgid "" "Python programs written in functional style usually won't go to the extreme " "of avoiding all I/O or all assignments; instead, they'll provide a " "functional-appearing interface but will use non-functional features " "internally. For example, the implementation of a function will still use " "assignments to local variables, but won't modify global variables or have " "other side effects." msgstr "" #: ../Doc/howto/functional.rst:79 msgid "" "Functional programming can be considered the opposite of object-oriented " "programming. Objects are little capsules containing some internal state " "along with a collection of method calls that let you modify this state, and " "programs consist of making the right set of state changes. Functional " "programming wants to avoid state changes as much as possible and works with " "data flowing between functions. In Python you might combine the two " "approaches by writing functions that take and return instances representing " "objects in your application (e-mail messages, transactions, etc.)." msgstr "" #: ../Doc/howto/functional.rst:88 msgid "" "Functional design may seem like an odd constraint to work under. Why should " "you avoid objects and side effects? There are theoretical and practical " "advantages to the functional style:" msgstr "" #: ../Doc/howto/functional.rst:92 msgid "Formal provability." msgstr "" #: ../Doc/howto/functional.rst:93 msgid "Modularity." msgstr "" #: ../Doc/howto/functional.rst:94 msgid "Composability." msgstr "" #: ../Doc/howto/functional.rst:95 msgid "Ease of debugging and testing." msgstr "" #: ../Doc/howto/functional.rst:99 msgid "Formal provability" msgstr "" #: ../Doc/howto/functional.rst:101 msgid "" "A theoretical benefit is that it's easier to construct a mathematical proof " "that a functional program is correct." msgstr "" #: ../Doc/howto/functional.rst:104 msgid "" "For a long time researchers have been interested in finding ways to " "mathematically prove programs correct. This is different from testing a " "program on numerous inputs and concluding that its output is usually " "correct, or reading a program's source code and concluding that the code " "looks right; the goal is instead a rigorous proof that a program produces " "the right result for all possible inputs." msgstr "" #: ../Doc/howto/functional.rst:111 msgid "" "The technique used to prove programs correct is to write down " "**invariants**, properties of the input data and of the program's variables " "that are always true. For each line of code, you then show that if " "invariants X and Y are true **before** the line is executed, the slightly " "different invariants X' and Y' are true **after** the line is executed. " "This continues until you reach the end of the program, at which point the " "invariants should match the desired conditions on the program's output." msgstr "" #: ../Doc/howto/functional.rst:119 msgid "" "Functional programming's avoidance of assignments arose because assignments " "are difficult to handle with this technique; assignments can break " "invariants that were true before the assignment without producing any new " "invariants that can be propagated onward." msgstr "" #: ../Doc/howto/functional.rst:124 msgid "" "Unfortunately, proving programs correct is largely impractical and not " "relevant to Python software. Even trivial programs require proofs that are " "several pages long; the proof of correctness for a moderately complicated " "program would be enormous, and few or none of the programs you use daily " "(the Python interpreter, your XML parser, your web browser) could be proven " "correct. Even if you wrote down or generated a proof, there would then be " "the question of verifying the proof; maybe there's an error in it, and you " "wrongly believe you've proved the program correct." msgstr "" #: ../Doc/howto/functional.rst:135 msgid "Modularity" msgstr "" #: ../Doc/howto/functional.rst:137 msgid "" "A more practical benefit of functional programming is that it forces you to " "break apart your problem into small pieces. Programs are more modular as a " "result. It's easier to specify and write a small function that does one " "thing than a large function that performs a complicated transformation. " "Small functions are also easier to read and to check for errors." msgstr "" #: ../Doc/howto/functional.rst:145 msgid "Ease of debugging and testing" msgstr "" #: ../Doc/howto/functional.rst:147 msgid "Testing and debugging a functional-style program is easier." msgstr "" #: ../Doc/howto/functional.rst:149 msgid "" "Debugging is simplified because functions are generally small and clearly " "specified. When a program doesn't work, each function is an interface point " "where you can check that the data are correct. You can look at the " "intermediate inputs and outputs to quickly isolate the function that's " "responsible for a bug." msgstr "" #: ../Doc/howto/functional.rst:154 msgid "" "Testing is easier because each function is a potential subject for a unit " "test. Functions don't depend on system state that needs to be replicated " "before running a test; instead you only have to synthesize the right input " "and then check that the output matches expectations." msgstr "" #: ../Doc/howto/functional.rst:161 msgid "Composability" msgstr "" #: ../Doc/howto/functional.rst:163 msgid "" "As you work on a functional-style program, you'll write a number of " "functions with varying inputs and outputs. Some of these functions will be " "unavoidably specialized to a particular application, but others will be " "useful in a wide variety of programs. For example, a function that takes a " "directory path and returns all the XML files in the directory, or a function " "that takes a filename and returns its contents, can be applied to many " "different situations." msgstr "" #: ../Doc/howto/functional.rst:170 msgid "" "Over time you'll form a personal library of utilities. Often you'll " "assemble new programs by arranging existing functions in a new configuration " "and writing a few functions specialized for the current task." msgstr "" #: ../Doc/howto/functional.rst:176 msgid "Iterators" msgstr "Itérateurs" #: ../Doc/howto/functional.rst:178 msgid "" "I'll start by looking at a Python language feature that's an important " "foundation for writing functional-style programs: iterators." msgstr "" #: ../Doc/howto/functional.rst:181 msgid "" "An iterator is an object representing a stream of data; this object returns " "the data one element at a time. A Python iterator must support a method " "called ``next()`` that takes no arguments and always returns the next " "element of the stream. If there are no more elements in the stream, " "``next()`` must raise the ``StopIteration`` exception. Iterators don't have " "to be finite, though; it's perfectly reasonable to write an iterator that " "produces an infinite stream of data." msgstr "" #: ../Doc/howto/functional.rst:189 msgid "" "The built-in :func:`iter` function takes an arbitrary object and tries to " "return an iterator that will return the object's contents or elements, " "raising :exc:`TypeError` if the object doesn't support iteration. Several " "of Python's built-in data types support iteration, the most common being " "lists and dictionaries. An object is called an **iterable** object if you " "can get an iterator for it." msgstr "" #: ../Doc/howto/functional.rst:196 msgid "You can experiment with the iteration interface manually:" msgstr "" #: ../Doc/howto/functional.rst:214 msgid "" "Python expects iterable objects in several different contexts, the most " "important being the ``for`` statement. In the statement ``for X in Y``, Y " "must be an iterator or some object for which ``iter()`` can create an " "iterator. These two statements are equivalent::" msgstr "" #: ../Doc/howto/functional.rst:225 msgid "" "Iterators can be materialized as lists or tuples by using the :func:`list` " "or :func:`tuple` constructor functions:" msgstr "" #: ../Doc/howto/functional.rst:234 msgid "" "Sequence unpacking also supports iterators: if you know an iterator will " "return N elements, you can unpack them into an N-tuple:" msgstr "" #: ../Doc/howto/functional.rst:243 msgid "" "Built-in functions such as :func:`max` and :func:`min` can take a single " "iterator argument and will return the largest or smallest element. The ``" "\"in\"`` and ``\"not in\"`` operators also support iterators: ``X in " "iterator`` is true if X is found in the stream returned by the iterator. " "You'll run into obvious problems if the iterator is infinite; ``max()``, " "``min()`` will never return, and if the element X never appears in the " "stream, the ``\"in\"`` and ``\"not in\"`` operators won't return either." msgstr "" #: ../Doc/howto/functional.rst:251 msgid "" "Note that you can only go forward in an iterator; there's no way to get the " "previous element, reset the iterator, or make a copy of it. Iterator " "objects can optionally provide these additional capabilities, but the " "iterator protocol only specifies the ``next()`` method. Functions may " "therefore consume all of the iterator's output, and if you need to do " "something different with the same stream, you'll have to create a new " "iterator." msgstr "" #: ../Doc/howto/functional.rst:261 msgid "Data Types That Support Iterators" msgstr "" #: ../Doc/howto/functional.rst:263 msgid "" "We've already seen how lists and tuples support iterators. In fact, any " "Python sequence type, such as strings, will automatically support creation " "of an iterator." msgstr "" #: ../Doc/howto/functional.rst:267 msgid "" "Calling :func:`iter` on a dictionary returns an iterator that will loop over " "the dictionary's keys:" msgstr "" #: ../Doc/howto/functional.rst:291 msgid "" "Note that the order is essentially random, because it's based on the hash " "ordering of the objects in the dictionary." msgstr "" #: ../Doc/howto/functional.rst:294 msgid "" "Applying ``iter()`` to a dictionary always loops over the keys, but " "dictionaries have methods that return other iterators. If you want to " "iterate over keys, values, or key/value pairs, you can explicitly call the " "``iterkeys()``, ``itervalues()``, or ``iteritems()`` methods to get an " "appropriate iterator." msgstr "" #: ../Doc/howto/functional.rst:299 msgid "" "The :func:`dict` constructor can accept an iterator that returns a finite " "stream of ``(key, value)`` tuples:" msgstr "" #: ../Doc/howto/functional.rst:306 msgid "" "Files also support iteration by calling the ``readline()`` method until " "there are no more lines in the file. This means you can read each line of a " "file like this::" msgstr "" #: ../Doc/howto/functional.rst:314 msgid "" "Sets can take their contents from an iterable and let you iterate over the " "set's elements::" msgstr "" #: ../Doc/howto/functional.rst:324 msgid "Generator expressions and list comprehensions" msgstr "" #: ../Doc/howto/functional.rst:326 msgid "" "Two common operations on an iterator's output are 1) performing some " "operation for every element, 2) selecting a subset of elements that meet " "some condition. For example, given a list of strings, you might want to " "strip off trailing whitespace from each line or extract all the strings " "containing a given substring." msgstr "" #: ../Doc/howto/functional.rst:332 msgid "" "List comprehensions and generator expressions (short form: \"listcomps\" and " "\"genexps\") are a concise notation for such operations, borrowed from the " "functional programming language Haskell (https://www.haskell.org/). You can " "strip all the whitespace from a stream of strings with the following code::" msgstr "" #: ../Doc/howto/functional.rst:345 msgid "" "You can select only certain elements by adding an ``\"if\"`` condition::" msgstr "" #: ../Doc/howto/functional.rst:350 msgid "" "With a list comprehension, you get back a Python list; ``stripped_list`` is " "a list containing the resulting lines, not an iterator. Generator " "expressions return an iterator that computes the values as necessary, not " "needing to materialize all the values at once. This means that list " "comprehensions aren't useful if you're working with iterators that return an " "infinite stream or a very large amount of data. Generator expressions are " "preferable in these situations." msgstr "" #: ../Doc/howto/functional.rst:357 msgid "" "Generator expressions are surrounded by parentheses (\"()\") and list " "comprehensions are surrounded by square brackets (\"[]\"). Generator " "expressions have the form::" msgstr "" #: ../Doc/howto/functional.rst:370 msgid "" "Again, for a list comprehension only the outside brackets are different " "(square brackets instead of parentheses)." msgstr "" #: ../Doc/howto/functional.rst:373 msgid "" "The elements of the generated output will be the successive values of " "``expression``. The ``if`` clauses are all optional; if present, " "``expression`` is only evaluated and added to the result when ``condition`` " "is true." msgstr "" #: ../Doc/howto/functional.rst:377 msgid "" "Generator expressions always have to be written inside parentheses, but the " "parentheses signalling a function call also count. If you want to create an " "iterator that will be immediately passed to a function you can write::" msgstr "" #: ../Doc/howto/functional.rst:383 msgid "" "The ``for...in`` clauses contain the sequences to be iterated over. The " "sequences do not have to be the same length, because they are iterated over " "from left to right, **not** in parallel. For each element in ``sequence1``, " "``sequence2`` is looped over from the beginning. ``sequence3`` is then " "looped over for each resulting pair of elements from ``sequence1`` and " "``sequence2``." msgstr "" #: ../Doc/howto/functional.rst:389 msgid "" "To put it another way, a list comprehension or generator expression is " "equivalent to the following Python code::" msgstr "" #: ../Doc/howto/functional.rst:406 msgid "" "This means that when there are multiple ``for...in`` clauses but no ``if`` " "clauses, the length of the resulting output will be equal to the product of " "the lengths of all the sequences. If you have two lists of length 3, the " "output list is 9 elements long:" msgstr "" #: ../Doc/howto/functional.rst:421 msgid "" "To avoid introducing an ambiguity into Python's grammar, if ``expression`` " "is creating a tuple, it must be surrounded with parentheses. The first list " "comprehension below is a syntax error, while the second one is correct::" msgstr "" #: ../Doc/howto/functional.rst:432 msgid "Generators" msgstr "Générateurs" #: ../Doc/howto/functional.rst:434 msgid "" "Generators are a special class of functions that simplify the task of " "writing iterators. Regular functions compute a value and return it, but " "generators return an iterator that returns a stream of values." msgstr "" #: ../Doc/howto/functional.rst:438 msgid "" "You're doubtless familiar with how regular function calls work in Python or " "C. When you call a function, it gets a private namespace where its local " "variables are created. When the function reaches a ``return`` statement, " "the local variables are destroyed and the value is returned to the caller. " "A later call to the same function creates a new private namespace and a " "fresh set of local variables. But, what if the local variables weren't " "thrown away on exiting a function? What if you could later resume the " "function where it left off? This is what generators provide; they can be " "thought of as resumable functions." msgstr "" #: ../Doc/howto/functional.rst:447 msgid "Here's the simplest example of a generator function:" msgstr "" #: ../Doc/howto/functional.rst:455 msgid "" "Any function containing a ``yield`` keyword is a generator function; this is " "detected by Python's :term:`bytecode` compiler which compiles the function " "specially as a result." msgstr "" #: ../Doc/howto/functional.rst:459 msgid "" "When you call a generator function, it doesn't return a single value; " "instead it returns a generator object that supports the iterator protocol. " "On executing the ``yield`` expression, the generator outputs the value of " "``i``, similar to a ``return`` statement. The big difference between " "``yield`` and a ``return`` statement is that on reaching a ``yield`` the " "generator's state of execution is suspended and local variables are " "preserved. On the next call to the generator's ``.next()`` method, the " "function will resume executing." msgstr "" #: ../Doc/howto/functional.rst:467 msgid "Here's a sample usage of the ``generate_ints()`` generator:" msgstr "" #: ../Doc/howto/functional.rst:484 msgid "" "You could equally write ``for i in generate_ints(5)``, or ``a,b,c = " "generate_ints(3)``." msgstr "" #: ../Doc/howto/functional.rst:487 msgid "" "Inside a generator function, the ``return`` statement can only be used " "without a value, and signals the end of the procession of values; after " "executing a ``return`` the generator cannot return any further values. " "``return`` with a value, such as ``return 5``, is a syntax error inside a " "generator function. The end of the generator's results can also be " "indicated by raising ``StopIteration`` manually, or by just letting the flow " "of execution fall off the bottom of the function." msgstr "" #: ../Doc/howto/functional.rst:495 msgid "" "You could achieve the effect of generators manually by writing your own " "class and storing all the local variables of the generator as instance " "variables. For example, returning a list of integers could be done by " "setting ``self.count`` to 0, and having the ``next()`` method increment " "``self.count`` and return it. However, for a moderately complicated " "generator, writing a corresponding class can be much messier." msgstr "" #: ../Doc/howto/functional.rst:502 msgid "" "The test suite included with Python's library, ``test_generators.py``, " "contains a number of more interesting examples. Here's one generator that " "implements an in-order traversal of a tree using generators recursively. ::" msgstr "" #: ../Doc/howto/functional.rst:517 msgid "" "Two other examples in ``test_generators.py`` produce solutions for the N-" "Queens problem (placing N queens on an NxN chess board so that no queen " "threatens another) and the Knight's Tour (finding a route that takes a " "knight to every square of an NxN chessboard without visiting any square " "twice)." msgstr "" #: ../Doc/howto/functional.rst:525 msgid "Passing values into a generator" msgstr "" #: ../Doc/howto/functional.rst:527 msgid "" "In Python 2.4 and earlier, generators only produced output. Once a " "generator's code was invoked to create an iterator, there was no way to pass " "any new information into the function when its execution is resumed. You " "could hack together this ability by making the generator look at a global " "variable or by passing in some mutable object that callers then modify, but " "these approaches are messy." msgstr "" #: ../Doc/howto/functional.rst:534 msgid "" "In Python 2.5 there's a simple way to pass values into a generator. :keyword:" "`yield` became an expression, returning a value that can be assigned to a " "variable or otherwise operated on::" msgstr "" #: ../Doc/howto/functional.rst:540 msgid "" "I recommend that you **always** put parentheses around a ``yield`` " "expression when you're doing something with the returned value, as in the " "above example. The parentheses aren't always necessary, but it's easier to " "always add them instead of having to remember when they're needed." msgstr "" #: ../Doc/howto/functional.rst:545 msgid "" "(PEP 342 explains the exact rules, which are that a ``yield``-expression " "must always be parenthesized except when it occurs at the top-level " "expression on the right-hand side of an assignment. This means you can " "write ``val = yield i`` but have to use parentheses when there's an " "operation, as in ``val = (yield i) + 12``.)" msgstr "" #: ../Doc/howto/functional.rst:551 msgid "" "Values are sent into a generator by calling its ``send(value)`` method. " "This method resumes the generator's code and the ``yield`` expression " "returns the specified value. If the regular ``next()`` method is called, " "the ``yield`` returns ``None``." msgstr "" #: ../Doc/howto/functional.rst:556 msgid "" "Here's a simple counter that increments by 1 and allows changing the value " "of the internal counter." msgstr "" #: ../Doc/howto/functional.rst:571 msgid "And here's an example of changing the counter:" msgstr "" #: ../Doc/howto/functional.rst:588 msgid "" "Because ``yield`` will often be returning ``None``, you should always check " "for this case. Don't just use its value in expressions unless you're sure " "that the ``send()`` method will be the only method used to resume your " "generator function." msgstr "" #: ../Doc/howto/functional.rst:593 msgid "" "In addition to ``send()``, there are two other new methods on generators:" msgstr "" #: ../Doc/howto/functional.rst:595 msgid "" "``throw(type, value=None, traceback=None)`` is used to raise an exception " "inside the generator; the exception is raised by the ``yield`` expression " "where the generator's execution is paused." msgstr "" #: ../Doc/howto/functional.rst:599 msgid "" "``close()`` raises a :exc:`GeneratorExit` exception inside the generator to " "terminate the iteration. On receiving this exception, the generator's code " "must either raise :exc:`GeneratorExit` or :exc:`StopIteration`; catching the " "exception and doing anything else is illegal and will trigger a :exc:" "`RuntimeError`. ``close()`` will also be called by Python's garbage " "collector when the generator is garbage-collected." msgstr "" #: ../Doc/howto/functional.rst:606 msgid "" "If you need to run cleanup code when a :exc:`GeneratorExit` occurs, I " "suggest using a ``try: ... finally:`` suite instead of catching :exc:" "`GeneratorExit`." msgstr "" #: ../Doc/howto/functional.rst:609 msgid "" "The cumulative effect of these changes is to turn generators from one-way " "producers of information into both producers and consumers." msgstr "" #: ../Doc/howto/functional.rst:612 msgid "" "Generators also become **coroutines**, a more generalized form of " "subroutines. Subroutines are entered at one point and exited at another " "point (the top of the function, and a ``return`` statement), but coroutines " "can be entered, exited, and resumed at many different points (the ``yield`` " "statements)." msgstr "" #: ../Doc/howto/functional.rst:619 msgid "Built-in functions" msgstr "Fonctions natives" #: ../Doc/howto/functional.rst:621 msgid "" "Let's look in more detail at built-in functions often used with iterators." msgstr "" #: ../Doc/howto/functional.rst:623 msgid "" "Two of Python's built-in functions, :func:`map` and :func:`filter`, are " "somewhat obsolete; they duplicate the features of list comprehensions but " "return actual lists instead of iterators." msgstr "" #: ../Doc/howto/functional.rst:627 msgid "" "``map(f, iterA, iterB, ...)`` returns a list containing ``f(iterA[0], " "iterB[0]), f(iterA[1], iterB[1]), f(iterA[2], iterB[2]), ...``." msgstr "" #: ../Doc/howto/functional.rst:639 msgid "" "As shown above, you can achieve the same effect with a list comprehension. " "The :func:`itertools.imap` function does the same thing but can handle " "infinite iterators; it'll be discussed later, in the section on the :mod:" "`itertools` module." msgstr "" #: ../Doc/howto/functional.rst:643 msgid "" "``filter(predicate, iter)`` returns a list that contains all the sequence " "elements that meet a certain condition, and is similarly duplicated by list " "comprehensions. A **predicate** is a function that returns the truth value " "of some condition; for use with :func:`filter`, the predicate must take a " "single value." msgstr "" #: ../Doc/howto/functional.rst:655 msgid "This can also be written as a list comprehension:" msgstr "" #: ../Doc/howto/functional.rst:660 msgid "" ":func:`filter` also has a counterpart in the :mod:`itertools` module, :func:" "`itertools.ifilter`, that returns an iterator and can therefore handle " "infinite sequences just as :func:`itertools.imap` can." msgstr "" #: ../Doc/howto/functional.rst:664 msgid "" "``reduce(func, iter, [initial_value])`` doesn't have a counterpart in the :" "mod:`itertools` module because it cumulatively performs an operation on all " "the iterable's elements and therefore can't be applied to infinite " "iterables. ``func`` must be a function that takes two elements and returns a " "single value. :func:`reduce` takes the first two elements A and B returned " "by the iterator and calculates ``func(A, B)``. It then requests the third " "element, C, calculates ``func(func(A, B), C)``, combines this result with " "the fourth element returned, and continues until the iterable is exhausted. " "If the iterable returns no values at all, a :exc:`TypeError` exception is " "raised. If the initial value is supplied, it's used as a starting point and " "``func(initial_value, A)`` is the first calculation." msgstr "" #: ../Doc/howto/functional.rst:688 msgid "" "If you use :func:`operator.add` with :func:`reduce`, you'll add up all the " "elements of the iterable. This case is so common that there's a special " "built-in called :func:`sum` to compute it:" msgstr "" #: ../Doc/howto/functional.rst:699 msgid "" "For many uses of :func:`reduce`, though, it can be clearer to just write the " "obvious :keyword:`for` loop::" msgstr "" #: ../Doc/howto/functional.rst:711 msgid "" "``enumerate(iter)`` counts off the elements in the iterable, returning 2-" "tuples containing the count and each element." msgstr "" #: ../Doc/howto/functional.rst:720 msgid "" ":func:`enumerate` is often used when looping through a list and recording " "the indexes at which certain conditions are met::" msgstr "" #: ../Doc/howto/functional.rst:728 msgid "" "``sorted(iterable, [cmp=None], [key=None], [reverse=False])`` collects all " "the elements of the iterable into a list, sorts the list, and returns the " "sorted result. The ``cmp``, ``key``, and ``reverse`` arguments are passed " "through to the constructed list's ``.sort()`` method. ::" msgstr "" #: ../Doc/howto/functional.rst:743 msgid "" "(For a more detailed discussion of sorting, see the Sorting mini-HOWTO in " "the Python wiki at https://wiki.python.org/moin/HowTo/Sorting.)" msgstr "" #: ../Doc/howto/functional.rst:746 msgid "" "The ``any(iter)`` and ``all(iter)`` built-ins look at the truth values of an " "iterable's contents. :func:`any` returns ``True`` if any element in the " "iterable is a true value, and :func:`all` returns ``True`` if all of the " "elements are true values:" msgstr "" #: ../Doc/howto/functional.rst:766 msgid "Small functions and the lambda expression" msgstr "" #: ../Doc/howto/functional.rst:768 msgid "" "When writing functional-style programs, you'll often need little functions " "that act as predicates or that combine elements in some way." msgstr "" #: ../Doc/howto/functional.rst:771 msgid "" "If there's a Python built-in or a module function that's suitable, you don't " "need to define a new function at all::" msgstr "" #: ../Doc/howto/functional.rst:777 msgid "" "If the function you need doesn't exist, you need to write it. One way to " "write small functions is to use the ``lambda`` statement. ``lambda`` takes " "a number of parameters and an expression combining these parameters, and " "creates a small function that returns the value of the expression::" msgstr "" #: ../Doc/howto/functional.rst:788 msgid "" "An alternative is to just use the ``def`` statement and define a function in " "the usual way::" msgstr "" #: ../Doc/howto/functional.rst:800 msgid "" "Which alternative is preferable? That's a style question; my usual course " "is to avoid using ``lambda``." msgstr "" #: ../Doc/howto/functional.rst:803 msgid "" "One reason for my preference is that ``lambda`` is quite limited in the " "functions it can define. The result has to be computable as a single " "expression, which means you can't have multiway ``if... elif... else`` " "comparisons or ``try... except`` statements. If you try to do too much in a " "``lambda`` statement, you'll end up with an overly complicated expression " "that's hard to read. Quick, what's the following code doing?" msgstr "" #: ../Doc/howto/functional.rst:814 msgid "" "You can figure it out, but it takes time to disentangle the expression to " "figure out what's going on. Using a short nested ``def`` statements makes " "things a little bit better::" msgstr "" #: ../Doc/howto/functional.rst:823 msgid "But it would be best of all if I had simply used a ``for`` loop::" msgstr "" #: ../Doc/howto/functional.rst:829 msgid "Or the :func:`sum` built-in and a generator expression::" msgstr "" #: ../Doc/howto/functional.rst:833 msgid "Many uses of :func:`reduce` are clearer when written as ``for`` loops." msgstr "" #: ../Doc/howto/functional.rst:835 msgid "" "Fredrik Lundh once suggested the following set of rules for refactoring uses " "of ``lambda``:" msgstr "" #: ../Doc/howto/functional.rst:838 msgid "Write a lambda function." msgstr "" #: ../Doc/howto/functional.rst:839 msgid "Write a comment explaining what the heck that lambda does." msgstr "" #: ../Doc/howto/functional.rst:840 msgid "" "Study the comment for a while, and think of a name that captures the essence " "of the comment." msgstr "" #: ../Doc/howto/functional.rst:842 msgid "Convert the lambda to a def statement, using that name." msgstr "" #: ../Doc/howto/functional.rst:843 msgid "Remove the comment." msgstr "" #: ../Doc/howto/functional.rst:845 msgid "" "I really like these rules, but you're free to disagree about whether this " "lambda-free style is better." msgstr "" #: ../Doc/howto/functional.rst:850 msgid "The itertools module" msgstr "" #: ../Doc/howto/functional.rst:852 msgid "" "The :mod:`itertools` module contains a number of commonly-used iterators as " "well as functions for combining several iterators. This section will " "introduce the module's contents by showing small examples." msgstr "" #: ../Doc/howto/functional.rst:856 msgid "The module's functions fall into a few broad classes:" msgstr "" #: ../Doc/howto/functional.rst:858 msgid "Functions that create a new iterator based on an existing iterator." msgstr "" #: ../Doc/howto/functional.rst:859 msgid "Functions for treating an iterator's elements as function arguments." msgstr "" #: ../Doc/howto/functional.rst:860 msgid "Functions for selecting portions of an iterator's output." msgstr "" #: ../Doc/howto/functional.rst:861 msgid "A function for grouping an iterator's output." msgstr "" #: ../Doc/howto/functional.rst:864 msgid "Creating new iterators" msgstr "" #: ../Doc/howto/functional.rst:866 msgid "" "``itertools.count(n)`` returns an infinite stream of integers, increasing by " "1 each time. You can optionally supply the starting number, which defaults " "to 0::" msgstr "" #: ../Doc/howto/functional.rst:874 msgid "" "``itertools.cycle(iter)`` saves a copy of the contents of a provided " "iterable and returns a new iterator that returns its elements from first to " "last. The new iterator will repeat these elements infinitely. ::" msgstr "" #: ../Doc/howto/functional.rst:881 msgid "" "``itertools.repeat(elem, [n])`` returns the provided element ``n`` times, or " "returns the element endlessly if ``n`` is not provided. ::" msgstr "" #: ../Doc/howto/functional.rst:889 msgid "" "``itertools.chain(iterA, iterB, ...)`` takes an arbitrary number of " "iterables as input, and returns all the elements of the first iterator, then " "all the elements of the second, and so on, until all of the iterables have " "been exhausted. ::" msgstr "" #: ../Doc/howto/functional.rst:896 msgid "" "``itertools.izip(iterA, iterB, ...)`` takes one element from each iterable " "and returns them in a tuple::" msgstr "" #: ../Doc/howto/functional.rst:902 msgid "" "It's similar to the built-in :func:`zip` function, but doesn't construct an " "in-memory list and exhaust all the input iterators before returning; instead " "tuples are constructed and returned only if they're requested. (The " "technical term for this behaviour is `lazy evaluation `__.)" msgstr "" #: ../Doc/howto/functional.rst:908 msgid "" "This iterator is intended to be used with iterables that are all of the same " "length. If the iterables are of different lengths, the resulting stream " "will be the same length as the shortest iterable. ::" msgstr "" #: ../Doc/howto/functional.rst:915 msgid "" "You should avoid doing this, though, because an element may be taken from " "the longer iterators and discarded. This means you can't go on to use the " "iterators further because you risk skipping a discarded element." msgstr "" #: ../Doc/howto/functional.rst:919 msgid "" "``itertools.islice(iter, [start], stop, [step])`` returns a stream that's a " "slice of the iterator. With a single ``stop`` argument, it will return the " "first ``stop`` elements. If you supply a starting index, you'll get ``stop-" "start`` elements, and if you supply a value for ``step``, elements will be " "skipped accordingly. Unlike Python's string and list slicing, you can't use " "negative values for ``start``, ``stop``, or ``step``. ::" msgstr "" #: ../Doc/howto/functional.rst:933 msgid "" "``itertools.tee(iter, [n])`` replicates an iterator; it returns ``n`` " "independent iterators that will all return the contents of the source " "iterator. If you don't supply a value for ``n``, the default is 2. " "Replicating iterators requires saving some of the contents of the source " "iterator, so this can consume significant memory if the iterator is large " "and one of the new iterators is consumed more than the others. ::" msgstr "" #: ../Doc/howto/functional.rst:951 msgid "Calling functions on elements" msgstr "" #: ../Doc/howto/functional.rst:953 msgid "" "Two functions are used for calling other functions on the contents of an " "iterable." msgstr "" #: ../Doc/howto/functional.rst:956 msgid "" "``itertools.imap(f, iterA, iterB, ...)`` returns a stream containing " "``f(iterA[0], iterB[0]), f(iterA[1], iterB[1]), f(iterA[2], iterB[2]), ..." "``::" msgstr "" #: ../Doc/howto/functional.rst:962 msgid "" "The ``operator`` module contains a set of functions corresponding to " "Python's operators. Some examples are ``operator.add(a, b)`` (adds two " "values), ``operator.ne(a, b)`` (same as ``a!=b``), and ``operator." "attrgetter('id')`` (returns a callable that fetches the ``\"id\"`` " "attribute)." msgstr "" #: ../Doc/howto/functional.rst:967 msgid "" "``itertools.starmap(func, iter)`` assumes that the iterable will return a " "stream of tuples, and calls ``f()`` using these tuples as the arguments::" msgstr "" #: ../Doc/howto/functional.rst:978 msgid "Selecting elements" msgstr "" #: ../Doc/howto/functional.rst:980 msgid "" "Another group of functions chooses a subset of an iterator's elements based " "on a predicate." msgstr "" #: ../Doc/howto/functional.rst:983 msgid "" "``itertools.ifilter(predicate, iter)`` returns all the elements for which " "the predicate returns true::" msgstr "" #: ../Doc/howto/functional.rst:992 msgid "" "``itertools.ifilterfalse(predicate, iter)`` is the opposite, returning all " "elements for which the predicate returns false::" msgstr "" #: ../Doc/howto/functional.rst:998 msgid "" "``itertools.takewhile(predicate, iter)`` returns elements for as long as the " "predicate returns true. Once the predicate returns false, the iterator will " "signal the end of its results." msgstr "" #: ../Doc/howto/functional.rst:1013 msgid "" "``itertools.dropwhile(predicate, iter)`` discards elements while the " "predicate returns true, and then returns the rest of the iterable's results." msgstr "" #: ../Doc/howto/functional.rst:1026 msgid "Grouping elements" msgstr "" #: ../Doc/howto/functional.rst:1028 msgid "" "The last function I'll discuss, ``itertools.groupby(iter, key_func=None)``, " "is the most complicated. ``key_func(elem)`` is a function that can compute " "a key value for each element returned by the iterable. If you don't supply " "a key function, the key is simply each element itself." msgstr "" #: ../Doc/howto/functional.rst:1033 msgid "" "``groupby()`` collects all the consecutive elements from the underlying " "iterable that have the same key value, and returns a stream of 2-tuples " "containing a key value and an iterator for the elements with that key." msgstr "" #: ../Doc/howto/functional.rst:1061 msgid "" "``groupby()`` assumes that the underlying iterable's contents will already " "be sorted based on the key. Note that the returned iterators also use the " "underlying iterable, so you have to consume the results of iterator-1 before " "requesting iterator-2 and its corresponding key." msgstr "" #: ../Doc/howto/functional.rst:1068 msgid "The functools module" msgstr "" #: ../Doc/howto/functional.rst:1070 msgid "" "The :mod:`functools` module in Python 2.5 contains some higher-order " "functions. A **higher-order function** takes one or more functions as input " "and returns a new function. The most useful tool in this module is the :" "func:`functools.partial` function." msgstr "" #: ../Doc/howto/functional.rst:1075 msgid "" "For programs written in a functional style, you'll sometimes want to " "construct variants of existing functions that have some of the parameters " "filled in. Consider a Python function ``f(a, b, c)``; you may wish to create " "a new function ``g(b, c)`` that's equivalent to ``f(1, b, c)``; you're " "filling in a value for one of ``f()``'s parameters. This is called " "\"partial function application\"." msgstr "" #: ../Doc/howto/functional.rst:1081 msgid "" "The constructor for ``partial`` takes the arguments ``(function, arg1, " "arg2, ... kwarg1=value1, kwarg2=value2)``. The resulting object is " "callable, so you can just call it to invoke ``function`` with the filled-in " "arguments." msgstr "" #: ../Doc/howto/functional.rst:1085 msgid "Here's a small but realistic example::" msgstr "Voici un exemple court mais réaliste ::" #: ../Doc/howto/functional.rst:1099 msgid "The operator module" msgstr "" #: ../Doc/howto/functional.rst:1101 msgid "" "The :mod:`operator` module was mentioned earlier. It contains a set of " "functions corresponding to Python's operators. These functions are often " "useful in functional-style code because they save you from writing trivial " "functions that perform a single operation." msgstr "" #: ../Doc/howto/functional.rst:1106 msgid "Some of the functions in this module are:" msgstr "" #: ../Doc/howto/functional.rst:1108 msgid "" "Math operations: ``add()``, ``sub()``, ``mul()``, ``div()``, ``floordiv()``, " "``abs()``, ..." msgstr "" #: ../Doc/howto/functional.rst:1110 msgid "Logical operations: ``not_()``, ``truth()``." msgstr "" #: ../Doc/howto/functional.rst:1111 msgid "Bitwise operations: ``and_()``, ``or_()``, ``invert()``." msgstr "" #: ../Doc/howto/functional.rst:1112 msgid "" "Comparisons: ``eq()``, ``ne()``, ``lt()``, ``le()``, ``gt()``, and ``ge()``." msgstr "" #: ../Doc/howto/functional.rst:1113 msgid "Object identity: ``is_()``, ``is_not()``." msgstr "" #: ../Doc/howto/functional.rst:1115 msgid "Consult the operator module's documentation for a complete list." msgstr "" #: ../Doc/howto/functional.rst:1119 msgid "Revision History and Acknowledgements" msgstr "" #: ../Doc/howto/functional.rst:1121 msgid "" "The author would like to thank the following people for offering " "suggestions, corrections and assistance with various drafts of this article: " "Ian Bicking, Nick Coghlan, Nick Efford, Raymond Hettinger, Jim Jewett, Mike " "Krell, Leandro Lameiro, Jussi Salmela, Collin Winter, Blake Winton." msgstr "" #: ../Doc/howto/functional.rst:1126 msgid "Version 0.1: posted June 30 2006." msgstr "" #: ../Doc/howto/functional.rst:1128 msgid "Version 0.11: posted July 1 2006. Typo fixes." msgstr "" #: ../Doc/howto/functional.rst:1130 msgid "" "Version 0.2: posted July 10 2006. Merged genexp and listcomp sections into " "one. Typo fixes." msgstr "" #: ../Doc/howto/functional.rst:1133 msgid "" "Version 0.21: Added more references suggested on the tutor mailing list." msgstr "" #: ../Doc/howto/functional.rst:1135 msgid "" "Version 0.30: Adds a section on the ``functional`` module written by Collin " "Winter; adds short section on the operator module; a few other edits." msgstr "" #: ../Doc/howto/functional.rst:1140 msgid "References" msgstr "Références" #: ../Doc/howto/functional.rst:1143 msgid "General" msgstr "" #: ../Doc/howto/functional.rst:1145 msgid "" "**Structure and Interpretation of Computer Programs**, by Harold Abelson and " "Gerald Jay Sussman with Julie Sussman. Full text at https://mitpress.mit." "edu/sicp/. In this classic textbook of computer science, chapters 2 and 3 " "discuss the use of sequences and streams to organize the data flow inside a " "program. The book uses Scheme for its examples, but many of the design " "approaches described in these chapters are applicable to functional-style " "Python code." msgstr "" #: ../Doc/howto/functional.rst:1153 msgid "" "http://www.defmacro.org/ramblings/fp.html: A general introduction to " "functional programming that uses Java examples and has a lengthy historical " "introduction." msgstr "" #: ../Doc/howto/functional.rst:1156 msgid "" "https://en.wikipedia.org/wiki/Functional_programming: General Wikipedia " "entry describing functional programming." msgstr "" #: ../Doc/howto/functional.rst:1159 msgid "https://en.wikipedia.org/wiki/Coroutine: Entry for coroutines." msgstr "" #: ../Doc/howto/functional.rst:1161 msgid "" "https://en.wikipedia.org/wiki/Currying: Entry for the concept of currying." msgstr "" #: ../Doc/howto/functional.rst:1164 msgid "Python-specific" msgstr "" #: ../Doc/howto/functional.rst:1166 msgid "" "http://gnosis.cx/TPiP/: The first chapter of David Mertz's book :title-" "reference:`Text Processing in Python` discusses functional programming for " "text processing, in the section titled \"Utilizing Higher-Order Functions in " "Text Processing\"." msgstr "" #: ../Doc/howto/functional.rst:1171 msgid "" "Mertz also wrote a 3-part series of articles on functional programming for " "IBM's DeveloperWorks site; see" msgstr "" #: ../Doc/howto/functional.rst:1174 msgid "" "`part 1 `__, `part 2 `__, and `part 3 `__," msgstr "" #: ../Doc/howto/functional.rst:1180 msgid "Python documentation" msgstr "" #: ../Doc/howto/functional.rst:1182 msgid "Documentation for the :mod:`itertools` module." msgstr "" #: ../Doc/howto/functional.rst:1184 msgid "Documentation for the :mod:`operator` module." msgstr "" #: ../Doc/howto/functional.rst:1186 msgid ":pep:`289`: \"Generator Expressions\"" msgstr "" #: ../Doc/howto/functional.rst:1188 msgid "" ":pep:`342`: \"Coroutines via Enhanced Generators\" describes the new " "generator features in Python 2.5." msgstr ""