# Python Documentation Turkish Translation

# Copyright (C) 2001-2024, Python Software Foundation

# This file is distributed under the same license as the Python package.

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.12\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2024-11-01 00:21+0000\n"

"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"

"Last-Translator: \n"

"Language-Team: TURKISH <python.docs.tr@gmail.com>\n"

"Language: tr\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

#: howto/functional.rst:3

msgid "Functional Programming HOWTO"

msgstr ""

#: howto/functional.rst:0

msgid "Author"

msgstr ""

#: howto/functional.rst:5

msgid "A. M. Kuchling"

msgstr ""

#: howto/functional.rst:0

msgid "Release"

msgstr ""

#: howto/functional.rst:6

msgid "0.32"

msgstr ""

#: 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 ""

#: howto/functional.rst:16

msgid "Introduction"

msgstr ""

#: 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 on :ref:`functional-howto-iterators`."

msgstr ""

#: howto/functional.rst:22

msgid ""

"Programming languages support decomposing problems in several different ways:"

msgstr ""

#: 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 ""

#: 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 ""

#: 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 ""

#: 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 ""

#: 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 ""

#: howto/functional.rst:58

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 ""

#: howto/functional.rst:66

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, such as printing to the screen or writing to a disk file. "

"Another example is a call to the :func:`print` or :func:`time.sleep` "

"function, neither of which returns a useful value. Both are called only for "

"their side effects of sending some text to the screen or pausing execution "

"for a second."

msgstr ""

#: 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 ""

#: 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 ""

#: 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 ""

#: howto/functional.rst:92

msgid "Formal provability."

msgstr ""

#: howto/functional.rst:93

msgid "Modularity."

msgstr ""

#: howto/functional.rst:94

msgid "Composability."

msgstr ""

#: howto/functional.rst:95

msgid "Ease of debugging and testing."

msgstr ""

#: howto/functional.rst:99

msgid "Formal provability"

msgstr ""

#: 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 ""

#: 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 ""

#: 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 ""

#: 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 ""

#: 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 ""

#: howto/functional.rst:135

msgid "Modularity"

msgstr ""

#: 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 ""

#: howto/functional.rst:145

msgid "Ease of debugging and testing"

msgstr ""

#: howto/functional.rst:147

msgid "Testing and debugging a functional-style program is easier."

msgstr ""

#: 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 ""

#: 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 ""

#: howto/functional.rst:161

msgid "Composability"

msgstr ""

#: 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 ""

#: 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 ""

#: howto/functional.rst:178

msgid "Iterators"

msgstr ""

#: howto/functional.rst:180

msgid ""

"I'll start by looking at a Python language feature that's an important "

"foundation for writing functional-style programs: iterators."

msgstr ""

#: howto/functional.rst:183

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 :meth:`~iterator.__next__` that takes no arguments and always returns "

"the next element of the stream. If there are no more elements in the "

"stream, :meth:`~iterator.__next__` must raise the :exc:`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 ""

#: howto/functional.rst:191

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 :term:`iterable` if you can get "

"an iterator for it."

msgstr ""

#: howto/functional.rst:198

msgid "You can experiment with the iteration interface manually:"

msgstr ""

#: howto/functional.rst:216

msgid ""

"Python expects iterable objects in several different contexts, the most "

"important being the :keyword:`for` statement. In the statement ``for X in "

"Y``, Y must be an iterator or some object for which :func:`iter` can create "

"an iterator. These two statements are equivalent::"

msgstr ""

#: howto/functional.rst:222

msgid ""

"for i in iter(obj):\n"

" print(i)\n"

"\n"

"for i in obj:\n"

" print(i)"

msgstr ""

#: howto/functional.rst:228

msgid ""

"Iterators can be materialized as lists or tuples by using the :func:`list` "

"or :func:`tuple` constructor functions:"

msgstr ""

#: howto/functional.rst:237

msgid ""

"Sequence unpacking also supports iterators: if you know an iterator will "

"return N elements, you can unpack them into an N-tuple:"

msgstr ""

#: howto/functional.rst:246

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; :func:`max`, :"

"func:`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 ""

#: howto/functional.rst:254

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 :meth:`~iterator.__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 ""

#: howto/functional.rst:264

msgid "Data Types That Support Iterators"

msgstr ""

#: howto/functional.rst:266

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 ""

#: howto/functional.rst:270

msgid ""

"Calling :func:`iter` on a dictionary returns an iterator that will loop over "

"the dictionary's keys::"

msgstr ""

#: howto/functional.rst:273

msgid ""

">>> m = {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,\n"

"... 'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}\n"

">>> for key in m:\n"

"... print(key, m[key])\n"

"Jan 1\n"

"Feb 2\n"

"Mar 3\n"

"Apr 4\n"

"May 5\n"

"Jun 6\n"

"Jul 7\n"

"Aug 8\n"

"Sep 9\n"

"Oct 10\n"

"Nov 11\n"

"Dec 12"

msgstr ""

#: howto/functional.rst:290

msgid ""

"Note that starting with Python 3.7, dictionary iteration order is guaranteed "

"to be the same as the insertion order. In earlier versions, the behaviour "

"was unspecified and could vary between implementations."

msgstr ""

#: howto/functional.rst:294

msgid ""

"Applying :func:`iter` to a dictionary always loops over the keys, but "

"dictionaries have methods that return other iterators. If you want to "

"iterate over values or key/value pairs, you can explicitly call the :meth:"

"`~dict.values` or :meth:`~dict.items` methods to get an appropriate iterator."

msgstr ""

#: howto/functional.rst:300

msgid ""

"The :func:`dict` constructor can accept an iterator that returns a finite "

"stream of ``(key, value)`` tuples:"

msgstr ""

#: howto/functional.rst:307

msgid ""

"Files also support iteration by calling the :meth:`~io.TextIOBase.readline` "

"method until there are no more lines in the file. This means you can read "

"each line of a file like this::"

msgstr ""

#: howto/functional.rst:311

msgid ""

"for line in file:\n"

" # do something for each line\n"

" ..."

msgstr ""

#: howto/functional.rst:315

msgid ""

"Sets can take their contents from an iterable and let you iterate over the "

"set's elements::"

msgstr ""

#: howto/functional.rst:318

msgid ""

">>> S = {2, 3, 5, 7, 11, 13}\n"

">>> for i in S:\n"

"... print(i)\n"

"2\n"

"3\n"

"5\n"

"7\n"

"11\n"

"13"

msgstr ""

#: howto/functional.rst:331

msgid "Generator expressions and list comprehensions"

msgstr ""

#: howto/functional.rst:333

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 ""

#: howto/functional.rst:339

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 ""

#: howto/functional.rst:344

msgid ""

">>> line_list = [' line 1\\n', 'line 2 \\n', ' \\n', '']\n"

"\n"

">>> # Generator expression -- returns iterator\n"

">>> stripped_iter = (line.strip() for line in line_list)\n"

"\n"

">>> # List comprehension -- returns list\n"

">>> stripped_list = [line.strip() for line in line_list]"

msgstr ""

#: howto/functional.rst:352

msgid ""

"You can select only certain elements by adding an ``\"if\"`` condition::"

msgstr ""

#: howto/functional.rst:354

msgid ""

">>> stripped_list = [line.strip() for line in line_list\n"

"... if line != \"\"]"

msgstr ""

#: howto/functional.rst:357

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 ""

#: howto/functional.rst:364

msgid ""

"Generator expressions are surrounded by parentheses (\"()\") and list "

"comprehensions are surrounded by square brackets (\"[]\"). Generator "

"expressions have the form::"

msgstr ""

#: howto/functional.rst:368

msgid ""

"( expression for expr in sequence1\n"

" if condition1\n"

" for expr2 in sequence2\n"

" if condition2\n"

" for expr3 in sequence3\n"

" ...\n"

" if condition3\n"

" for exprN in sequenceN\n"

" if conditionN )"

msgstr ""

#: howto/functional.rst:378

msgid ""

"Again, for a list comprehension only the outside brackets are different "

"(square brackets instead of parentheses)."

msgstr ""

#: howto/functional.rst:381

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 ""

#: howto/functional.rst:385

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 ""

#: howto/functional.rst:389

msgid "obj_total = sum(obj.count for obj in list_all_objects())"

msgstr ""

#: howto/functional.rst:391

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 ""

#: howto/functional.rst:397

msgid ""

"To put it another way, a list comprehension or generator expression is "

"equivalent to the following Python code::"

msgstr ""

#: howto/functional.rst:400

msgid ""

"for expr1 in sequence1:\n"

" if not (condition1):\n"

" continue # Skip this element\n"

" for expr2 in sequence2:\n"

" if not (condition2):\n"

" continue # Skip this element\n"

" ...\n"

" for exprN in sequenceN:\n"

" if not (conditionN):\n"

" continue # Skip this element\n"

"\n"

" # Output the value of\n"

" # the expression."

msgstr ""

#: howto/functional.rst:414

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 ""

#: howto/functional.rst:426

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 ""

#: howto/functional.rst:430

msgid ""

"# Syntax error\n"

"[x, y for x in seq1 for y in seq2]\n"

"# Correct\n"

"[(x, y) for x in seq1 for y in seq2]"

msgstr ""

#: howto/functional.rst:437

msgid "Generators"

msgstr ""

#: howto/functional.rst:439

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 ""

#: howto/functional.rst:443

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 ""

#: howto/functional.rst:452

msgid "Here's the simplest example of a generator function:"

msgstr ""

#: howto/functional.rst:458

msgid ""

"Any function containing a :keyword:`yield` keyword is a generator function; "

"this is detected by Python's :term:`bytecode` compiler which compiles the "

"function specially as a result."

msgstr ""

#: howto/functional.rst:462

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 :meth:`~generator.__next__` "

"method, the function will resume executing."

msgstr ""

#: howto/functional.rst:471

msgid "Here's a sample usage of the ``generate_ints()`` generator:"

msgstr ""

#: howto/functional.rst:488

msgid ""

"You could equally write ``for i in generate_ints(5)``, or ``a, b, c = "

"generate_ints(3)``."

msgstr ""

#: howto/functional.rst:491

msgid ""

"Inside a generator function, ``return value`` causes "

"``StopIteration(value)`` to be raised from the :meth:`~generator.__next__` "

"method. Once this happens, or the bottom of the function is reached, the "

"procession of values ends and the generator cannot yield any further values."

msgstr ""

#: howto/functional.rst:496

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 :meth:`~iterator.__next__` "

"method increment ``self.count`` and return it. However, for a moderately "

"complicated generator, writing a corresponding class can be much messier."

msgstr ""

#: howto/functional.rst:504

msgid ""

"The test suite included with Python's library, :source:`Lib/test/"

"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 ""

#: howto/functional.rst:509

msgid ""

"# A recursive generator that generates Tree leaves in in-order.\n"

"def inorder(t):\n"

" if t:\n"

" for x in inorder(t.left):\n"

" yield x\n"

"\n"

" yield t.label\n"

"\n"

" for x in inorder(t.right):\n"

" yield x"

msgstr ""

#: howto/functional.rst:520

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 ""

#: howto/functional.rst:528

msgid "Passing values into a generator"

msgstr ""

#: howto/functional.rst:530

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 ""

#: howto/functional.rst:537

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 ""

#: howto/functional.rst:541

msgid "val = (yield i)"

msgstr ""

#: howto/functional.rst:543

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 ""

#: howto/functional.rst:548

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 ""

#: howto/functional.rst:554

msgid ""

"Values are sent into a generator by calling its :meth:`send(value) "

"<generator.send>` method. This method resumes the generator's code and the "

"``yield`` expression returns the specified value. If the regular :meth:"

"`~generator.__next__` method is called, the ``yield`` returns ``None``."

msgstr ""

#: howto/functional.rst:559

msgid ""

"Here's a simple counter that increments by 1 and allows changing the value "

"of the internal counter."

msgstr ""

#: howto/functional.rst:562

msgid ""

"def counter(maximum):\n"

" i = 0\n"

" while i < maximum:\n"

" val = (yield i)\n"

" # If value provided, change counter\n"

" if val is not None:\n"

" i = val\n"

" else:\n"

" i += 1"

msgstr ""

#: howto/functional.rst:574

msgid "And here's an example of changing the counter:"

msgstr ""

#: howto/functional.rst:591

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 :meth:`~generator.send` method will be the only method used to "

"resume your generator function."

msgstr ""

#: howto/functional.rst:596

msgid ""

"In addition to :meth:`~generator.send`, there are two other methods on "

"generators:"

msgstr ""

#: howto/functional.rst:599

msgid ""

":meth:`throw(value) <generator.throw>` 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 ""

#: howto/functional.rst:603

msgid ""

":meth:`~generator.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`. :meth:`~generator.close` will also "

"be called by Python's garbage collector when the generator is garbage-"

"collected."

msgstr ""

#: howto/functional.rst:611

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 ""

#: howto/functional.rst:614

msgid ""

"The cumulative effect of these changes is to turn generators from one-way "

"producers of information into both producers and consumers."

msgstr ""

#: howto/functional.rst:617

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 ""

#: howto/functional.rst:624

msgid "Built-in functions"

msgstr ""

#: howto/functional.rst:626

msgid ""

"Let's look in more detail at built-in functions often used with iterators."

msgstr ""

#: howto/functional.rst:628

msgid ""

"Two of Python's built-in functions, :func:`map` and :func:`filter` duplicate "

"the features of generator expressions:"

msgstr ""

#: howto/functional.rst:631

msgid ""

":func:`map(f, iterA, iterB, ...) <map>` returns an iterator over the sequence"

msgstr ""

#: howto/functional.rst:632

msgid ""

"``f(iterA[0], iterB[0]), f(iterA[1], iterB[1]), f(iterA[2], iterB[2]), ...``."

msgstr ""

#: howto/functional.rst:642

msgid "You can of course achieve the same effect with a list comprehension."

msgstr ""

#: howto/functional.rst:644

msgid ""

":func:`filter(predicate, iter) <filter>` returns an iterator over 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 ""

#: howto/functional.rst:657

msgid "This can also be written as a list comprehension:"

msgstr ""

#: howto/functional.rst:663

msgid ""

":func:`enumerate(iter, start=0) <enumerate>` counts off the elements in the "

"iterable returning 2-tuples containing the count (from *start*) and each "

"element. ::"

msgstr ""

#: howto/functional.rst:667

msgid ""

">>> for item in enumerate(['subject', 'verb', 'object']):\n"

"... print(item)\n"

"(0, 'subject')\n"

"(1, 'verb')\n"

"(2, 'object')"

msgstr ""

#: howto/functional.rst:673

msgid ""

":func:`enumerate` is often used when looping through a list and recording "

"the indexes at which certain conditions are met::"

msgstr ""

#: howto/functional.rst:676

msgid ""

"f = open('data.txt', 'r')\n"

"for i, line in enumerate(f):\n"

" if line.strip() == '':\n"

" print('Blank line at line #%i' % i)"

msgstr ""

#: howto/functional.rst:681

msgid ""

":func:`sorted(iterable, key=None, reverse=False) <sorted>` collects all the "

"elements of the iterable into a list, sorts the list, and returns the sorted "

"result. The *key* and *reverse* arguments are passed through to the "

"constructed list's :meth:`~list.sort` method. ::"

msgstr ""

#: howto/functional.rst:686

msgid ""

">>> import random\n"

">>> # Generate 8 random numbers between [0, 10000)\n"

">>> rand_list = random.sample(range(10000), 8)\n"

">>> rand_list \n"

"[769, 7953, 9828, 6431, 8442, 9878, 6213, 2207]\n"

">>> sorted(rand_list) \n"

"[769, 2207, 6213, 6431, 7953, 8442, 9828, 9878]\n"

">>> sorted(rand_list, reverse=True) \n"

"[9878, 9828, 8442, 7953, 6431, 6213, 2207, 769]"

msgstr ""

#: howto/functional.rst:696

msgid ""

"(For a more detailed discussion of sorting, see the :ref:`sortinghowto`.)"

msgstr ""

#: howto/functional.rst:699

msgid ""

"The :func:`any(iter) <any>` and :func:`all(iter) <all>` 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 ""

#: howto/functional.rst:718

msgid ""

":func:`zip(iterA, iterB, ...) <zip>` takes one element from each iterable "

"and returns them in a tuple::"

msgstr ""

#: howto/functional.rst:721

msgid ""

"zip(['a', 'b', 'c'], (1, 2, 3)) =>\n"

" ('a', 1), ('b', 2), ('c', 3)"

msgstr ""

#: howto/functional.rst:724

msgid ""

"It 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 <https://en.wikipedia.org/wiki/Lazy_evaluation>`__.)"

msgstr ""

#: howto/functional.rst:729

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 ""

#: howto/functional.rst:733

msgid ""

"zip(['a', 'b'], (1, 2, 3)) =>\n"

" ('a', 1), ('b', 2)"

msgstr ""

#: howto/functional.rst:736

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 ""