programming.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2019, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2019-05-06 11:59-0400\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#: ../Doc/faq/programming.rst:5
msgid "Programming FAQ"
msgstr ""

#: ../Doc/faq/programming.rst:8
msgid "Contents"
msgstr ""

#: ../Doc/faq/programming.rst:12
msgid "General Questions"
msgstr ""

#: ../Doc/faq/programming.rst:15
msgid ""
"Is there a source code level debugger with breakpoints, single-stepping, "
"etc.?"
msgstr ""

#: ../Doc/faq/programming.rst:17 ../Doc/faq/programming.rst:60
msgid "Yes."
msgstr ""

#: ../Doc/faq/programming.rst:19
msgid ""
"The pdb module is a simple but adequate console-mode debugger for Python. It "
"is part of the standard Python library, and is :mod:`documented in the "
"Library Reference Manual <pdb>`. You can also write your own debugger by "
"using the code for pdb as an example."
msgstr ""

#: ../Doc/faq/programming.rst:24
msgid ""
"The IDLE interactive development environment, which is part of the standard "
"Python distribution (normally available as Tools/scripts/idle), includes a "
"graphical debugger."
msgstr ""

#: ../Doc/faq/programming.rst:28
msgid ""
"PythonWin is a Python IDE that includes a GUI debugger based on pdb.  The "
"Pythonwin debugger colors breakpoints and has quite a few cool features such "
"as debugging non-Pythonwin programs.  Pythonwin is available as part of the "
"`Python for Windows Extensions <https://sourceforge.net/projects/pywin32/"
">`__ project and as a part of the ActivePython distribution (see https://www."
"activestate.com/activepython\\ )."
msgstr ""

#: ../Doc/faq/programming.rst:35
msgid ""
"`Boa Constructor <http://boa-constructor.sourceforge.net/>`_ is an IDE and "
"GUI builder that uses wxWidgets.  It offers visual frame creation and "
"manipulation, an object inspector, many views on the source like object "
"browsers, inheritance hierarchies, doc string generated html documentation, "
"an advanced debugger, integrated help, and Zope support."
msgstr ""

#: ../Doc/faq/programming.rst:41
msgid ""
"`Eric <http://eric-ide.python-projects.org/>`_ is an IDE built on PyQt and "
"the Scintilla editing component."
msgstr ""

#: ../Doc/faq/programming.rst:44
msgid ""
"Pydb is a version of the standard Python debugger pdb, modified for use with "
"DDD (Data Display Debugger), a popular graphical debugger front end.  Pydb "
"can be found at http://bashdb.sourceforge.net/pydb/ and DDD can be found at "
"https://www.gnu.org/software/ddd."
msgstr ""

#: ../Doc/faq/programming.rst:49
msgid ""
"There are a number of commercial Python IDEs that include graphical "
"debuggers. They include:"
msgstr ""

#: ../Doc/faq/programming.rst:52
msgid "Wing IDE (https://wingware.com/)"
msgstr ""

#: ../Doc/faq/programming.rst:53
msgid "Komodo IDE (https://komodoide.com/)"
msgstr ""

#: ../Doc/faq/programming.rst:54
msgid "PyCharm (https://www.jetbrains.com/pycharm/)"
msgstr ""

#: ../Doc/faq/programming.rst:58
msgid "Is there a tool to help find bugs or perform static analysis?"
msgstr ""

#: ../Doc/faq/programming.rst:62
msgid ""
"PyChecker is a static analysis tool that finds bugs in Python source code "
"and warns about code complexity and style.  You can get PyChecker from "
"http://pychecker.sourceforge.net/."
msgstr ""

#: ../Doc/faq/programming.rst:66
msgid ""
"`Pylint <https://www.pylint.org/>`_ is another tool that checks if a module "
"satisfies a coding standard, and also makes it possible to write plug-ins to "
"add a custom feature.  In addition to the bug checking that PyChecker "
"performs, Pylint offers some additional features such as checking line "
"length, whether variable names are well-formed according to your coding "
"standard, whether declared interfaces are fully implemented, and more. "
"https://docs.pylint.org/ provides a full list of Pylint's features."
msgstr ""

#: ../Doc/faq/programming.rst:74
msgid ""
"Static type checkers such as `Mypy <http://mypy-lang.org/>`_, `Pyre <https://"
"pyre-check.org/>`_, and `Pytype <https://github.com/google/pytype>`_ can "
"check type hints in Python source code."
msgstr ""

#: ../Doc/faq/programming.rst:81
msgid "How can I create a stand-alone binary from a Python script?"
msgstr ""

#: ../Doc/faq/programming.rst:83
msgid ""
"You don't need the ability to compile Python to C code if all you want is a "
"stand-alone program that users can download and run without having to "
"install the Python distribution first.  There are a number of tools that "
"determine the set of modules required by a program and bind these modules "
"together with a Python binary to produce a single executable."
msgstr ""

#: ../Doc/faq/programming.rst:89
msgid ""
"One is to use the freeze tool, which is included in the Python source tree "
"as ``Tools/freeze``. It converts Python byte code to C arrays; a C compiler "
"you can embed all your modules into a new program, which is then linked with "
"the standard Python modules."
msgstr ""

#: ../Doc/faq/programming.rst:94
msgid ""
"It works by scanning your source recursively for import statements (in both "
"forms) and looking for the modules in the standard Python path as well as in "
"the source directory (for built-in modules).  It then turns the bytecode for "
"modules written in Python into C code (array initializers that can be turned "
"into code objects using the marshal module) and creates a custom-made config "
"file that only contains those built-in modules which are actually used in "
"the program.  It then compiles the generated C code and links it with the "
"rest of the Python interpreter to form a self-contained binary which acts "
"exactly like your script."
msgstr ""

#: ../Doc/faq/programming.rst:103
msgid ""
"Obviously, freeze requires a C compiler.  There are several other utilities "
"which don't. One is Thomas Heller's py2exe (Windows only) at"
msgstr ""

#: ../Doc/faq/programming.rst:106
msgid "http://www.py2exe.org/"
msgstr ""

#: ../Doc/faq/programming.rst:108
msgid ""
"Another tool is Anthony Tuininga's `cx_Freeze <https://anthony-tuininga."
"github.io/cx_Freeze/>`_."
msgstr ""

#: ../Doc/faq/programming.rst:112
msgid "Are there coding standards or a style guide for Python programs?"
msgstr ""

#: ../Doc/faq/programming.rst:114
msgid ""
"Yes.  The coding style required for standard library modules is documented "
"as :pep:`8`."
msgstr ""

#: ../Doc/faq/programming.rst:119
msgid "Core Language"
msgstr ""

#: ../Doc/faq/programming.rst:122
msgid "Why am I getting an UnboundLocalError when the variable has a value?"
msgstr ""

#: ../Doc/faq/programming.rst:124
msgid ""
"It can be a surprise to get the UnboundLocalError in previously working code "
"when it is modified by adding an assignment statement somewhere in the body "
"of a function."
msgstr ""

#: ../Doc/faq/programming.rst:128
msgid "This code:"
msgstr ""

#: ../Doc/faq/programming.rst:136
msgid "works, but this code:"
msgstr ""

#: ../Doc/faq/programming.rst:143
msgid "results in an UnboundLocalError:"
msgstr ""

#: ../Doc/faq/programming.rst:150
msgid ""
"This is because when you make an assignment to a variable in a scope, that "
"variable becomes local to that scope and shadows any similarly named "
"variable in the outer scope.  Since the last statement in foo assigns a new "
"value to ``x``, the compiler recognizes it as a local variable.  "
"Consequently when the earlier ``print(x)`` attempts to print the "
"uninitialized local variable and an error results."
msgstr ""

#: ../Doc/faq/programming.rst:157
msgid ""
"In the example above you can access the outer scope variable by declaring it "
"global:"
msgstr ""

#: ../Doc/faq/programming.rst:168
msgid ""
"This explicit declaration is required in order to remind you that (unlike "
"the superficially analogous situation with class and instance variables) you "
"are actually modifying the value of the variable in the outer scope:"
msgstr ""

#: ../Doc/faq/programming.rst:175
msgid ""
"You can do a similar thing in a nested scope using the :keyword:`nonlocal` "
"keyword:"
msgstr ""

#: ../Doc/faq/programming.rst:192
msgid "What are the rules for local and global variables in Python?"
msgstr ""

#: ../Doc/faq/programming.rst:194
msgid ""
"In Python, variables that are only referenced inside a function are "
"implicitly global.  If a variable is assigned a value anywhere within the "
"function's body, it's assumed to be a local unless explicitly declared as "
"global."
msgstr ""

#: ../Doc/faq/programming.rst:198
msgid ""
"Though a bit surprising at first, a moment's consideration explains this.  "
"On one hand, requiring :keyword:`global` for assigned variables provides a "
"bar against unintended side-effects.  On the other hand, if ``global`` was "
"required for all global references, you'd be using ``global`` all the time.  "
"You'd have to declare as global every reference to a built-in function or to "
"a component of an imported module.  This clutter would defeat the usefulness "
"of the ``global`` declaration for identifying side-effects."
msgstr ""

#: ../Doc/faq/programming.rst:208
msgid ""
"Why do lambdas defined in a loop with different values all return the same "
"result?"
msgstr ""

#: ../Doc/faq/programming.rst:210
msgid ""
"Assume you use a for loop to define a few different lambdas (or even plain "
"functions), e.g.::"
msgstr ""

#: ../Doc/faq/programming.rst:217
msgid ""
"This gives you a list that contains 5 lambdas that calculate ``x**2``.  You "
"might expect that, when called, they would return, respectively, ``0``, "
"``1``, ``4``, ``9``, and ``16``.  However, when you actually try you will "
"see that they all return ``16``::"
msgstr ""

#: ../Doc/faq/programming.rst:227
msgid ""
"This happens because ``x`` is not local to the lambdas, but is defined in "
"the outer scope, and it is accessed when the lambda is called --- not when "
"it is defined.  At the end of the loop, the value of ``x`` is ``4``, so all "
"the functions now return ``4**2``, i.e. ``16``.  You can also verify this by "
"changing the value of ``x`` and see how the results of the lambdas change::"
msgstr ""

#: ../Doc/faq/programming.rst:237
msgid ""
"In order to avoid this, you need to save the values in variables local to "
"the lambdas, so that they don't rely on the value of the global ``x``::"
msgstr ""

#: ../Doc/faq/programming.rst:244
msgid ""
"Here, ``n=x`` creates a new variable ``n`` local to the lambda and computed "
"when the lambda is defined so that it has the same value that ``x`` had at "
"that point in the loop.  This means that the value of ``n`` will be ``0`` in "
"the first lambda, ``1`` in the second, ``2`` in the third, and so on. "
"Therefore each lambda will now return the correct result::"
msgstr ""

#: ../Doc/faq/programming.rst:255
msgid ""
"Note that this behaviour is not peculiar to lambdas, but applies to regular "
"functions too."
msgstr ""

#: ../Doc/faq/programming.rst:260
msgid "How do I share global variables across modules?"
msgstr ""

#: ../Doc/faq/programming.rst:262
msgid ""
"The canonical way to share information across modules within a single "
"program is to create a special module (often called config or cfg).  Just "
"import the config module in all modules of your application; the module then "
"becomes available as a global name.  Because there is only one instance of "
"each module, any changes made to the module object get reflected "
"everywhere.  For example:"
msgstr ""

#: ../Doc/faq/programming.rst:268
msgid "config.py::"
msgstr ""

#: ../Doc/faq/programming.rst:272
msgid "mod.py::"
msgstr ""

#: ../Doc/faq/programming.rst:277
msgid "main.py::"
msgstr ""

#: ../Doc/faq/programming.rst:283
msgid ""
"Note that using a module is also the basis for implementing the Singleton "
"design pattern, for the same reason."
msgstr ""

#: ../Doc/faq/programming.rst:288
msgid "What are the \"best practices\" for using import in a module?"
msgstr ""

#: ../Doc/faq/programming.rst:290
msgid ""
"In general, don't use ``from modulename import *``.  Doing so clutters the "
"importer's namespace, and makes it much harder for linters to detect "
"undefined names."
msgstr ""

#: ../Doc/faq/programming.rst:294
msgid ""
"Import modules at the top of a file.  Doing so makes it clear what other "
"modules your code requires and avoids questions of whether the module name "
"is in scope. Using one import per line makes it easy to add and delete "
"module imports, but using multiple imports per line uses less screen space."
msgstr ""

#: ../Doc/faq/programming.rst:299
msgid "It's good practice if you import modules in the following order:"
msgstr ""

#: ../Doc/faq/programming.rst:301
msgid "standard library modules -- e.g. ``sys``, ``os``, ``getopt``, ``re``"
msgstr ""

#: ../Doc/faq/programming.rst:302
msgid ""
"third-party library modules (anything installed in Python's site-packages "
"directory) -- e.g. mx.DateTime, ZODB, PIL.Image, etc."
msgstr ""

#: ../Doc/faq/programming.rst:304
msgid "locally-developed modules"
msgstr ""

#: ../Doc/faq/programming.rst:306
msgid ""
"It is sometimes necessary to move imports to a function or class to avoid "
"problems with circular imports.  Gordon McMillan says:"
msgstr ""

#: ../Doc/faq/programming.rst:309
msgid ""
"Circular imports are fine where both modules use the \"import <module>\" "
"form of import.  They fail when the 2nd module wants to grab a name out of "
"the first (\"from module import name\") and the import is at the top level.  "
"That's because names in the 1st are not yet available, because the first "
"module is busy importing the 2nd."
msgstr ""

#: ../Doc/faq/programming.rst:315
msgid ""
"In this case, if the second module is only used in one function, then the "
"import can easily be moved into that function.  By the time the import is "
"called, the first module will have finished initializing, and the second "
"module can do its import."
msgstr ""

#: ../Doc/faq/programming.rst:320
msgid ""
"It may also be necessary to move imports out of the top level of code if "
"some of the modules are platform-specific.  In that case, it may not even be "
"possible to import all of the modules at the top of the file.  In this case, "
"importing the correct modules in the corresponding platform-specific code is "
"a good option."
msgstr ""

#: ../Doc/faq/programming.rst:325
msgid ""
"Only move imports into a local scope, such as inside a function definition, "
"if it's necessary to solve a problem such as avoiding a circular import or "
"are trying to reduce the initialization time of a module.  This technique is "
"especially helpful if many of the imports are unnecessary depending on how "
"the program executes.  You may also want to move imports into a function if "
"the modules are only ever used in that function.  Note that loading a module "
"the first time may be expensive because of the one time initialization of "
"the module, but loading a module multiple times is virtually free, costing "
"only a couple of dictionary lookups.  Even if the module name has gone out "
"of scope, the module is probably available in :data:`sys.modules`."
msgstr ""

#: ../Doc/faq/programming.rst:338
msgid "Why are default values shared between objects?"
msgstr ""

#: ../Doc/faq/programming.rst:340
msgid ""
"This type of bug commonly bites neophyte programmers.  Consider this "
"function::"
msgstr ""

#: ../Doc/faq/programming.rst:347
msgid ""
"The first time you call this function, ``mydict`` contains a single item.  "
"The second time, ``mydict`` contains two items because when ``foo()`` begins "
"executing, ``mydict`` starts out with an item already in it."
msgstr ""

#: ../Doc/faq/programming.rst:351
msgid ""
"It is often expected that a function call creates new objects for default "
"values. This is not what happens. Default values are created exactly once, "
"when the function is defined.  If that object is changed, like the "
"dictionary in this example, subsequent calls to the function will refer to "
"this changed object."
msgstr ""

#: ../Doc/faq/programming.rst:356
msgid ""
"By definition, immutable objects such as numbers, strings, tuples, and "
"``None``, are safe from change. Changes to mutable objects such as "
"dictionaries, lists, and class instances can lead to confusion."
msgstr ""

#: ../Doc/faq/programming.rst:360
msgid ""
"Because of this feature, it is good programming practice to not use mutable "
"objects as default values.  Instead, use ``None`` as the default value and "
"inside the function, check if the parameter is ``None`` and create a new "
"list/dictionary/whatever if it is.  For example, don't write::"
msgstr ""

#: ../Doc/faq/programming.rst:368
msgid "but::"
msgstr ""

#: ../Doc/faq/programming.rst:374
msgid ""
"This feature can be useful.  When you have a function that's time-consuming "
"to compute, a common technique is to cache the parameters and the resulting "
"value of each call to the function, and return the cached value if the same "
"value is requested again.  This is called \"memoizing\", and can be "
"implemented like this::"
msgstr ""

#: ../Doc/faq/programming.rst:389
msgid ""
"You could use a global variable containing a dictionary instead of the "
"default value; it's a matter of taste."
msgstr ""

#: ../Doc/faq/programming.rst:394
msgid ""
"How can I pass optional or keyword parameters from one function to another?"
msgstr ""

#: ../Doc/faq/programming.rst:396
msgid ""
"Collect the arguments using the ``*`` and ``**`` specifiers in the "
"function's parameter list; this gives you the positional arguments as a "
"tuple and the keyword arguments as a dictionary.  You can then pass these "
"arguments when calling another function by using ``*`` and ``**``::"
msgstr ""

#: ../Doc/faq/programming.rst:415
msgid "What is the difference between arguments and parameters?"
msgstr ""

#: ../Doc/faq/programming.rst:417
msgid ""
":term:`Parameters <parameter>` are defined by the names that appear in a "
"function definition, whereas :term:`arguments <argument>` are the values "
"actually passed to a function when calling it.  Parameters define what types "
"of arguments a function can accept.  For example, given the function "
"definition::"
msgstr ""

#: ../Doc/faq/programming.rst:425
msgid ""
"*foo*, *bar* and *kwargs* are parameters of ``func``.  However, when calling "
"``func``, for example::"
msgstr ""

#: ../Doc/faq/programming.rst:430
msgid "the values ``42``, ``314``, and ``somevar`` are arguments."
msgstr ""

#: ../Doc/faq/programming.rst:434
msgid "Why did changing list 'y' also change list 'x'?"
msgstr ""

#: ../Doc/faq/programming.rst:436
msgid "If you wrote code like::"
msgstr ""

#: ../Doc/faq/programming.rst:446
msgid ""
"you might be wondering why appending an element to ``y`` changed ``x`` too."
msgstr ""

#: ../Doc/faq/programming.rst:448
msgid "There are two factors that produce this result:"
msgstr ""

#: ../Doc/faq/programming.rst:450
msgid ""
"Variables are simply names that refer to objects.  Doing ``y = x`` doesn't "
"create a copy of the list -- it creates a new variable ``y`` that refers to "
"the same object ``x`` refers to.  This means that there is only one object "
"(the list), and both ``x`` and ``y`` refer to it."
msgstr ""

#: ../Doc/faq/programming.rst:454
msgid ""
"Lists are :term:`mutable`, which means that you can change their content."
msgstr ""

#: ../Doc/faq/programming.rst:456
msgid ""
"After the call to :meth:`~list.append`, the content of the mutable object "
"has changed from ``[]`` to ``[10]``.  Since both the variables refer to the "
"same object, using either name accesses the modified value ``[10]``."
msgstr ""

#: ../Doc/faq/programming.rst:460
msgid "If we instead assign an immutable object to ``x``::"
msgstr ""

#: ../Doc/faq/programming.rst:470
msgid ""
"we can see that in this case ``x`` and ``y`` are not equal anymore.  This is "
"because integers are :term:`immutable`, and when we do ``x = x + 1`` we are "
"not mutating the int ``5`` by incrementing its value; instead, we are "
"creating a new object (the int ``6``) and assigning it to ``x`` (that is, "
"changing which object ``x`` refers to).  After this assignment we have two "
"objects (the ints ``6`` and ``5``) and two variables that refer to them "
"(``x`` now refers to ``6`` but ``y`` still refers to ``5``)."
msgstr ""

#: ../Doc/faq/programming.rst:478
msgid ""
"Some operations (for example ``y.append(10)`` and ``y.sort()``) mutate the "
"object, whereas superficially similar operations (for example ``y = y + "
"[10]`` and ``sorted(y)``) create a new object.  In general in Python (and in "
"all cases in the standard library) a method that mutates an object will "
"return ``None`` to help avoid getting the two types of operations confused.  "
"So if you mistakenly write ``y.sort()`` thinking it will give you a sorted "
"copy of ``y``, you'll instead end up with ``None``, which will likely cause "
"your program to generate an easily diagnosed error."
msgstr ""

#: ../Doc/faq/programming.rst:487
msgid ""
"However, there is one class of operations where the same operation sometimes "
"has different behaviors with different types:  the augmented assignment "
"operators.  For example, ``+=`` mutates lists but not tuples or ints "
"(``a_list += [1, 2, 3]`` is equivalent to ``a_list.extend([1, 2, 3])`` and "
"mutates ``a_list``, whereas ``some_tuple += (1, 2, 3)`` and ``some_int += "
"1`` create new objects)."
msgstr ""

#: ../Doc/faq/programming.rst:494
msgid "In other words:"
msgstr ""

#: ../Doc/faq/programming.rst:496
msgid ""
"If we have a mutable object (:class:`list`, :class:`dict`, :class:`set`, "
"etc.), we can use some specific operations to mutate it and all the "
"variables that refer to it will see the change."
msgstr ""

#: ../Doc/faq/programming.rst:499
msgid ""
"If we have an immutable object (:class:`str`, :class:`int`, :class:`tuple`, "
"etc.), all the variables that refer to it will always see the same value, "
"but operations that transform that value into a new value always return a "
"new object."
msgstr ""

#: ../Doc/faq/programming.rst:504
msgid ""
"If you want to know if two variables refer to the same object or not, you "
"can use the :keyword:`is` operator, or the built-in function :func:`id`."
msgstr ""

#: ../Doc/faq/programming.rst:509
msgid "How do I write a function with output parameters (call by reference)?"
msgstr ""

#: ../Doc/faq/programming.rst:511
msgid ""
"Remember that arguments are passed by assignment in Python.  Since "
"assignment just creates references to objects, there's no alias between an "
"argument name in the caller and callee, and so no call-by-reference per se.  "
"You can achieve the desired effect in a number of ways."
msgstr ""

#: ../Doc/faq/programming.rst:516
msgid "By returning a tuple of the results::"
msgstr ""

#: ../Doc/faq/programming.rst:527
msgid "This is almost always the clearest solution."
msgstr ""

#: ../Doc/faq/programming.rst:529
msgid ""
"By using global variables.  This isn't thread-safe, and is not recommended."
msgstr ""

#: ../Doc/faq/programming.rst:531
msgid "By passing a mutable (changeable in-place) object::"
msgstr ""

#: ../Doc/faq/programming.rst:541
msgid "By passing in a dictionary that gets mutated::"
msgstr ""

#: ../Doc/faq/programming.rst:551
msgid "Or bundle up values in a class instance::"
msgstr ""

#: ../Doc/faq/programming.rst:567
msgid "There's almost never a good reason to get this complicated."
msgstr ""

#: ../Doc/faq/programming.rst:569
msgid "Your best choice is to return a tuple containing the multiple results."
msgstr ""

#: ../Doc/faq/programming.rst:573
msgid "How do you make a higher order function in Python?"
msgstr ""

#: ../Doc/faq/programming.rst:575
msgid ""
"You have two choices: you can use nested scopes or you can use callable "
"objects. For example, suppose you wanted to define ``linear(a,b)`` which "
"returns a function ``f(x)`` that computes the value ``a*x+b``.  Using nested "
"scopes::"
msgstr ""

#: ../Doc/faq/programming.rst:584
msgid "Or using a callable object::"
msgstr ""

#: ../Doc/faq/programming.rst:594
msgid "In both cases, ::"
msgstr ""

#: ../Doc/faq/programming.rst:598
msgid "gives a callable object where ``taxes(10e6) == 0.3 * 10e6 + 2``."
msgstr ""

#: ../Doc/faq/programming.rst:600
msgid ""
"The callable object approach has the disadvantage that it is a bit slower "
"and results in slightly longer code.  However, note that a collection of "
"callables can share their signature via inheritance::"
msgstr ""

#: ../Doc/faq/programming.rst:609
msgid "Object can encapsulate state for several methods::"
msgstr ""

#: ../Doc/faq/programming.rst:627
msgid ""
"Here ``inc()``, ``dec()`` and ``reset()`` act like functions which share the "
"same counting variable."
msgstr ""

#: ../Doc/faq/programming.rst:632
msgid "How do I copy an object in Python?"
msgstr ""

#: ../Doc/faq/programming.rst:634
msgid ""
"In general, try :func:`copy.copy` or :func:`copy.deepcopy` for the general "
"case. Not all objects can be copied, but most can."
msgstr ""

#: ../Doc/faq/programming.rst:637
msgid ""
"Some objects can be copied more easily.  Dictionaries have a :meth:`~dict."
"copy` method::"
msgstr ""

#: ../Doc/faq/programming.rst:642
msgid "Sequences can be copied by slicing::"
msgstr ""

#: ../Doc/faq/programming.rst:648
msgid "How can I find the methods or attributes of an object?"
msgstr ""

#: ../Doc/faq/programming.rst:650
msgid ""
"For an instance x of a user-defined class, ``dir(x)`` returns an "
"alphabetized list of the names containing the instance attributes and "
"methods and attributes defined by its class."
msgstr ""

#: ../Doc/faq/programming.rst:656
msgid "How can my code discover the name of an object?"
msgstr ""

#: ../Doc/faq/programming.rst:658
msgid ""
"Generally speaking, it can't, because objects don't really have names. "
"Essentially, assignment always binds a name to a value; The same is true of "
"``def`` and ``class`` statements, but in that case the value is a callable. "
"Consider the following code::"
msgstr ""

#: ../Doc/faq/programming.rst:674
msgid ""
"Arguably the class has a name: even though it is bound to two names and "
"invoked through the name B the created instance is still reported as an "
"instance of class A.  However, it is impossible to say whether the "
"instance's name is a or b, since both names are bound to the same value."
msgstr ""

#: ../Doc/faq/programming.rst:679
msgid ""
"Generally speaking it should not be necessary for your code to \"know the "
"names\" of particular values. Unless you are deliberately writing "
"introspective programs, this is usually an indication that a change of "
"approach might be beneficial."
msgstr ""

#: ../Doc/faq/programming.rst:684
msgid ""
"In comp.lang.python, Fredrik Lundh once gave an excellent analogy in answer "
"to this question:"
msgstr ""

#: ../Doc/faq/programming.rst:687
msgid ""
"The same way as you get the name of that cat you found on your porch: the "
"cat (object) itself cannot tell you its name, and it doesn't really care -- "
"so the only way to find out what it's called is to ask all your neighbours "
"(namespaces) if it's their cat (object)..."
msgstr ""

#: ../Doc/faq/programming.rst:692
msgid ""
"....and don't be surprised if you'll find that it's known by many names, or "
"no name at all!"
msgstr ""

#: ../Doc/faq/programming.rst:697
msgid "What's up with the comma operator's precedence?"
msgstr ""

#: ../Doc/faq/programming.rst:699
msgid "Comma is not an operator in Python.  Consider this session::"
msgstr ""

#: ../Doc/faq/programming.rst:704
msgid ""
"Since the comma is not an operator, but a separator between expressions the "
"above is evaluated as if you had entered::"
msgstr ""

#: ../Doc/faq/programming.rst:709
msgid "not::"
msgstr ""

#: ../Doc/faq/programming.rst:713
msgid ""
"The same is true of the various assignment operators (``=``, ``+=`` etc).  "
"They are not truly operators but syntactic delimiters in assignment "
"statements."
msgstr ""

#: ../Doc/faq/programming.rst:718
msgid "Is there an equivalent of C's \"?:\" ternary operator?"
msgstr ""

#: ../Doc/faq/programming.rst:720
msgid "Yes, there is. The syntax is as follows::"
msgstr ""

#: ../Doc/faq/programming.rst:727
msgid ""
"Before this syntax was introduced in Python 2.5, a common idiom was to use "
"logical operators::"
msgstr ""

#: ../Doc/faq/programming.rst:732
msgid ""
"However, this idiom is unsafe, as it can give wrong results when *on_true* "
"has a false boolean value.  Therefore, it is always better to use the ``... "
"if ... else ...`` form."
msgstr ""

#: ../Doc/faq/programming.rst:738
msgid "Is it possible to write obfuscated one-liners in Python?"
msgstr ""

#: ../Doc/faq/programming.rst:740
msgid ""
"Yes.  Usually this is done by nesting :keyword:`lambda` within :keyword:`!"
"lambda`.  See the following three examples, due to Ulf Bartelt::"
msgstr ""

#: ../Doc/faq/programming.rst:767
msgid "Don't try this at home, kids!"
msgstr ""

#: ../Doc/faq/programming.rst:773
msgid "What does the slash(/) in the parameter list of a function mean?"
msgstr ""

#: ../Doc/faq/programming.rst:775
msgid ""
"A slash in the argument list of a function denotes that the parameters prior "
"to it are positional-only.  Positional-only parameters are the ones without "
"an externally-usable name.  Upon calling a function that accepts positional-"
"only parameters, arguments are mapped to parameters based solely on their "
"position. For example, :func:`pow` is a function that accepts positional-"
"only parameters. Its documentation looks like this::"
msgstr ""

#: ../Doc/faq/programming.rst:791
msgid ""
"The slash at the end of the parameter list means that all three parameters "
"are positional-only. Thus, calling :func:`pow` with keyword aguments would "
"lead to an error::"
msgstr ""

#: ../Doc/faq/programming.rst:800
msgid ""
"Note that as of this writing this is only documentational and no valid "
"syntax in Python, although there is :pep:`570`, which proposes a syntax for "
"position-only parameters in Python."
msgstr ""

#: ../Doc/faq/programming.rst:806
msgid "Numbers and strings"
msgstr ""

#: ../Doc/faq/programming.rst:809
msgid "How do I specify hexadecimal and octal integers?"
msgstr ""

#: ../Doc/faq/programming.rst:811
msgid ""
"To specify an octal digit, precede the octal value with a zero, and then a "
"lower or uppercase \"o\".  For example, to set the variable \"a\" to the "
"octal value \"10\" (8 in decimal), type::"
msgstr ""

#: ../Doc/faq/programming.rst:819
msgid ""
"Hexadecimal is just as easy.  Simply precede the hexadecimal number with a "
"zero, and then a lower or uppercase \"x\".  Hexadecimal digits can be "
"specified in lower or uppercase.  For example, in the Python interpreter::"
msgstr ""

#: ../Doc/faq/programming.rst:832
msgid "Why does -22 // 10 return -3?"
msgstr ""

#: ../Doc/faq/programming.rst:834
msgid ""
"It's primarily driven by the desire that ``i % j`` have the same sign as "
"``j``. If you want that, and also want::"
msgstr ""

#: ../Doc/faq/programming.rst:839
msgid ""
"then integer division has to return the floor.  C also requires that "
"identity to hold, and then compilers that truncate ``i // j`` need to make "
"``i % j`` have the same sign as ``i``."
msgstr ""

#: ../Doc/faq/programming.rst:843
msgid ""
"There are few real use cases for ``i % j`` when ``j`` is negative.  When "
"``j`` is positive, there are many, and in virtually all of them it's more "
"useful for ``i % j`` to be ``>= 0``.  If the clock says 10 now, what did it "
"say 200 hours ago?  ``-190 % 12 == 2`` is useful; ``-190 % 12 == -10`` is a "
"bug waiting to bite."
msgstr ""

#: ../Doc/faq/programming.rst:851
msgid "How do I convert a string to a number?"
msgstr ""

#: ../Doc/faq/programming.rst:853
msgid ""
"For integers, use the built-in :func:`int` type constructor, e.g. "
"``int('144') == 144``.  Similarly, :func:`float` converts to floating-point, "
"e.g. ``float('144') == 144.0``."
msgstr ""

#: ../Doc/faq/programming.rst:857
msgid ""
"By default, these interpret the number as decimal, so that ``int('0144') == "
"144`` and ``int('0x144')`` raises :exc:`ValueError`. ``int(string, base)`` "
"takes the base to convert from as a second optional argument, so "
"``int('0x144', 16) == 324``.  If the base is specified as 0, the number is "
"interpreted using Python's rules: a leading '0o' indicates octal, and '0x' "
"indicates a hex number."
msgstr ""

#: ../Doc/faq/programming.rst:863
msgid ""
"Do not use the built-in function :func:`eval` if all you need is to convert "
"strings to numbers.  :func:`eval` will be significantly slower and it "
"presents a security risk: someone could pass you a Python expression that "
"might have unwanted side effects.  For example, someone could pass "
"``__import__('os').system(\"rm -rf $HOME\")`` which would erase your home "
"directory."
msgstr ""

#: ../Doc/faq/programming.rst:870
msgid ""
":func:`eval` also has the effect of interpreting numbers as Python "
"expressions, so that e.g. ``eval('09')`` gives a syntax error because Python "
"does not allow leading '0' in a decimal number (except '0')."
msgstr ""

#: ../Doc/faq/programming.rst:876
msgid "How do I convert a number to a string?"
msgstr ""

#: ../Doc/faq/programming.rst:878
msgid ""
"To convert, e.g., the number 144 to the string '144', use the built-in type "
"constructor :func:`str`.  If you want a hexadecimal or octal representation, "
"use the built-in functions :func:`hex` or :func:`oct`.  For fancy "
"formatting, see the :ref:`f-strings` and :ref:`formatstrings` sections, e.g. "
"``\"{:04d}\".format(144)`` yields ``'0144'`` and ``\"{:.3f}\"."
"format(1.0/3.0)`` yields ``'0.333'``."
msgstr ""

#: ../Doc/faq/programming.rst:887
msgid "How do I modify a string in place?"
msgstr ""

#: ../Doc/faq/programming.rst:889
msgid ""
"You can't, because strings are immutable.  In most situations, you should "
"simply construct a new string from the various parts you want to assemble it "
"from.  However, if you need an object with the ability to modify in-place "
"unicode data, try using an :class:`io.StringIO` object or the :mod:`array` "
"module::"
msgstr ""

#: ../Doc/faq/programming.rst:919
msgid "How do I use strings to call functions/methods?"
msgstr ""

#: ../Doc/faq/programming.rst:921
msgid "There are various techniques."
msgstr ""

#: ../Doc/faq/programming.rst:923
msgid ""
"The best is to use a dictionary that maps strings to functions.  The primary "
"advantage of this technique is that the strings do not need to match the "
"names of the functions.  This is also the primary technique used to emulate "
"a case construct::"
msgstr ""

#: ../Doc/faq/programming.rst:938
msgid "Use the built-in function :func:`getattr`::"
msgstr ""

#: ../Doc/faq/programming.rst:943
msgid ""
"Note that :func:`getattr` works on any object, including classes, class "
"instances, modules, and so on."
msgstr ""

#: ../Doc/faq/programming.rst:946
msgid "This is used in several places in the standard library, like this::"
msgstr ""

#: ../Doc/faq/programming.rst:959
msgid "Use :func:`locals` or :func:`eval` to resolve the function name::"
msgstr ""

#: ../Doc/faq/programming.rst:972
msgid ""
"Note: Using :func:`eval` is slow and dangerous.  If you don't have absolute "
"control over the contents of the string, someone could pass a string that "
"resulted in an arbitrary function being executed."
msgstr ""

#: ../Doc/faq/programming.rst:977
msgid ""
"Is there an equivalent to Perl's chomp() for removing trailing newlines from "
"strings?"
msgstr ""

#: ../Doc/faq/programming.rst:979
msgid ""
"You can use ``S.rstrip(\"\\r\\n\")`` to remove all occurrences of any line "
"terminator from the end of the string ``S`` without removing other trailing "
"whitespace.  If the string ``S`` represents more than one line, with several "
"empty lines at the end, the line terminators for all the blank lines will be "
"removed::"
msgstr ""

#: ../Doc/faq/programming.rst:991
msgid ""
"Since this is typically only desired when reading text one line at a time, "
"using ``S.rstrip()`` this way works well."
msgstr ""

#: ../Doc/faq/programming.rst:996
msgid "Is there a scanf() or sscanf() equivalent?"
msgstr ""

#: ../Doc/faq/programming.rst:998
msgid "Not as such."
msgstr ""

#: ../Doc/faq/programming.rst:1000
msgid ""
"For simple input parsing, the easiest approach is usually to split the line "
"into whitespace-delimited words using the :meth:`~str.split` method of "
"string objects and then convert decimal strings to numeric values using :"
"func:`int` or :func:`float`.  ``split()`` supports an optional \"sep\" "
"parameter which is useful if the line uses something other than whitespace "
"as a separator."
msgstr ""

#: ../Doc/faq/programming.rst:1006
msgid ""
"For more complicated input parsing, regular expressions are more powerful "
"than C's :c:func:`sscanf` and better suited for the task."
msgstr ""

#: ../Doc/faq/programming.rst:1011
msgid "What does 'UnicodeDecodeError' or 'UnicodeEncodeError' error  mean?"
msgstr ""

#: ../Doc/faq/programming.rst:1013
msgid "See the :ref:`unicode-howto`."
msgstr ""

#: ../Doc/faq/programming.rst:1017
msgid "Performance"
msgstr ""

#: ../Doc/faq/programming.rst:1020
msgid "My program is too slow. How do I speed it up?"
msgstr ""

#: ../Doc/faq/programming.rst:1022
msgid ""
"That's a tough one, in general.  First, here are a list of things to "
"remember before diving further:"
msgstr ""

#: ../Doc/faq/programming.rst:1025
msgid ""
"Performance characteristics vary across Python implementations.  This FAQ "
"focusses on :term:`CPython`."
msgstr ""

#: ../Doc/faq/programming.rst:1027
msgid ""
"Behaviour can vary across operating systems, especially when talking about I/"
"O or multi-threading."
msgstr ""

#: ../Doc/faq/programming.rst:1029
msgid ""
"You should always find the hot spots in your program *before* attempting to "
"optimize any code (see the :mod:`profile` module)."
msgstr ""

#: ../Doc/faq/programming.rst:1031
msgid ""
"Writing benchmark scripts will allow you to iterate quickly when searching "
"for improvements (see the :mod:`timeit` module)."
msgstr ""

#: ../Doc/faq/programming.rst:1033
msgid ""
"It is highly recommended to have good code coverage (through unit testing or "
"any other technique) before potentially introducing regressions hidden in "
"sophisticated optimizations."
msgstr ""

#: ../Doc/faq/programming.rst:1037
msgid ""
"That being said, there are many tricks to speed up Python code.  Here are "
"some general principles which go a long way towards reaching acceptable "
"performance levels:"
msgstr ""

#: ../Doc/faq/programming.rst:1041
msgid ""
"Making your algorithms faster (or changing to faster ones) can yield much "
"larger benefits than trying to sprinkle micro-optimization tricks all over "
"your code."
msgstr ""

#: ../Doc/faq/programming.rst:1045
msgid ""
"Use the right data structures.  Study documentation for the :ref:`bltin-"
"types` and the :mod:`collections` module."
msgstr ""

#: ../Doc/faq/programming.rst:1048
msgid ""
"When the standard library provides a primitive for doing something, it is "
"likely (although not guaranteed) to be faster than any alternative you may "
"come up with.  This is doubly true for primitives written in C, such as "
"builtins and some extension types.  For example, be sure to use either the :"
"meth:`list.sort` built-in method or the related :func:`sorted` function to "
"do sorting (and see the :ref:`sortinghowto` for examples of moderately "
"advanced usage)."
msgstr ""

#: ../Doc/faq/programming.rst:1056
msgid ""
"Abstractions tend to create indirections and force the interpreter to work "
"more.  If the levels of indirection outweigh the amount of useful work done, "
"your program will be slower.  You should avoid excessive abstraction, "
"especially under the form of tiny functions or methods (which are also often "
"detrimental to readability)."
msgstr ""

#: ../Doc/faq/programming.rst:1062
msgid ""
"If you have reached the limit of what pure Python can allow, there are tools "
"to take you further away.  For example, `Cython <http://cython.org>`_ can "
"compile a slightly modified version of Python code into a C extension, and "
"can be used on many different platforms.  Cython can take advantage of "
"compilation (and optional type annotations) to make your code significantly "
"faster than when interpreted.  If you are confident in your C programming "
"skills, you can also :ref:`write a C extension module <extending-index>` "
"yourself."
msgstr ""

#: ../Doc/faq/programming.rst:1072
msgid ""
"The wiki page devoted to `performance tips <https://wiki.python.org/moin/"
"PythonSpeed/PerformanceTips>`_."
msgstr ""

#: ../Doc/faq/programming.rst:1078
msgid "What is the most efficient way to concatenate many strings together?"
msgstr ""

#: ../Doc/faq/programming.rst:1080
msgid ""
":class:`str` and :class:`bytes` objects are immutable, therefore "
"concatenating many strings together is inefficient as each concatenation "
"creates a new object.  In the general case, the total runtime cost is "
"quadratic in the total string length."
msgstr ""

#: ../Doc/faq/programming.rst:1085
msgid ""
"To accumulate many :class:`str` objects, the recommended idiom is to place "
"them into a list and call :meth:`str.join` at the end::"
msgstr ""

#: ../Doc/faq/programming.rst:1093
msgid "(another reasonably efficient idiom is to use :class:`io.StringIO`)"
msgstr ""

#: ../Doc/faq/programming.rst:1095
msgid ""
"To accumulate many :class:`bytes` objects, the recommended idiom is to "
"extend a :class:`bytearray` object using in-place concatenation (the ``+=`` "
"operator)::"
msgstr ""

#: ../Doc/faq/programming.rst:1104
msgid "Sequences (Tuples/Lists)"
msgstr ""

#: ../Doc/faq/programming.rst:1107
msgid "How do I convert between tuples and lists?"
msgstr ""

#: ../Doc/faq/programming.rst:1109
msgid ""
"The type constructor ``tuple(seq)`` converts any sequence (actually, any "
"iterable) into a tuple with the same items in the same order."
msgstr ""

#: ../Doc/faq/programming.rst:1112
msgid ""
"For example, ``tuple([1, 2, 3])`` yields ``(1, 2, 3)`` and ``tuple('abc')`` "
"yields ``('a', 'b', 'c')``.  If the argument is a tuple, it does not make a "
"copy but returns the same object, so it is cheap to call :func:`tuple` when "
"you aren't sure that an object is already a tuple."
msgstr ""

#: ../Doc/faq/programming.rst:1117
msgid ""
"The type constructor ``list(seq)`` converts any sequence or iterable into a "
"list with the same items in the same order.  For example, ``list((1, 2, "
"3))`` yields ``[1, 2, 3]`` and ``list('abc')`` yields ``['a', 'b', 'c']``.  "
"If the argument is a list, it makes a copy just like ``seq[:]`` would."
msgstr ""

#: ../Doc/faq/programming.rst:1124
msgid "What's a negative index?"
msgstr ""

#: ../Doc/faq/programming.rst:1126
msgid ""
"Python sequences are indexed with positive numbers and negative numbers.  "
"For positive numbers 0 is the first index 1 is the second index and so "
"forth.  For negative indices -1 is the last index and -2 is the penultimate "
"(next to last) index and so forth.  Think of ``seq[-n]`` as the same as "
"``seq[len(seq)-n]``."
msgstr ""

#: ../Doc/faq/programming.rst:1131
msgid ""
"Using negative indices can be very convenient.  For example ``S[:-1]`` is "
"all of the string except for its last character, which is useful for "
"removing the trailing newline from a string."
msgstr ""

#: ../Doc/faq/programming.rst:1137
msgid "How do I iterate over a sequence in reverse order?"
msgstr ""

#: ../Doc/faq/programming.rst:1139
msgid ""
"Use the :func:`reversed` built-in function, which is new in Python 2.4::"
msgstr ""

#: ../Doc/faq/programming.rst:1144
msgid ""
"This won't touch your original sequence, but build a new copy with reversed "
"order to iterate over."
msgstr ""

#: ../Doc/faq/programming.rst:1147
msgid "With Python 2.3, you can use an extended slice syntax::"
msgstr ""

#: ../Doc/faq/programming.rst:1154
msgid "How do you remove duplicates from a list?"
msgstr ""

#: ../Doc/faq/programming.rst:1156
msgid "See the Python Cookbook for a long discussion of many ways to do this:"
msgstr ""

#: ../Doc/faq/programming.rst:1158
msgid "https://code.activestate.com/recipes/52560/"
msgstr ""

#: ../Doc/faq/programming.rst:1160
msgid ""
"If you don't mind reordering the list, sort it and then scan from the end of "
"the list, deleting duplicates as you go::"
msgstr ""

#: ../Doc/faq/programming.rst:1172
msgid ""
"If all elements of the list may be used as set keys (i.e. they are all :term:"
"`hashable`) this is often faster ::"
msgstr ""

#: ../Doc/faq/programming.rst:1177
msgid ""
"This converts the list into a set, thereby removing duplicates, and then "
"back into a list."
msgstr ""

#: ../Doc/faq/programming.rst:1182
msgid "How do you make an array in Python?"
msgstr ""

#: ../Doc/faq/programming.rst:1184
msgid "Use a list::"
msgstr ""

#: ../Doc/faq/programming.rst:1188
msgid ""
"Lists are equivalent to C or Pascal arrays in their time complexity; the "
"primary difference is that a Python list can contain objects of many "
"different types."
msgstr ""

#: ../Doc/faq/programming.rst:1191
msgid ""
"The ``array`` module also provides methods for creating arrays of fixed "
"types with compact representations, but they are slower to index than "
"lists.  Also note that the Numeric extensions and others define array-like "
"structures with various characteristics as well."
msgstr ""

#: ../Doc/faq/programming.rst:1196
msgid ""
"To get Lisp-style linked lists, you can emulate cons cells using tuples::"
msgstr ""

#: ../Doc/faq/programming.rst:1200
msgid ""
"If mutability is desired, you could use lists instead of tuples.  Here the "
"analogue of lisp car is ``lisp_list[0]`` and the analogue of cdr is "
"``lisp_list[1]``.  Only do this if you're sure you really need to, because "
"it's usually a lot slower than using Python lists."
msgstr ""

#: ../Doc/faq/programming.rst:1209
msgid "How do I create a multidimensional list?"
msgstr ""

#: ../Doc/faq/programming.rst:1211
msgid "You probably tried to make a multidimensional array like this::"
msgstr ""

#: ../Doc/faq/programming.rst:1215
msgid "This looks correct if you print it:"
msgstr ""

#: ../Doc/faq/programming.rst:1226
msgid "But when you assign a value, it shows up in multiple places:"
msgstr ""

#: ../Doc/faq/programming.rst:1238
msgid ""
"The reason is that replicating a list with ``*`` doesn't create copies, it "
"only creates references to the existing objects.  The ``*3`` creates a list "
"containing 3 references to the same list of length two.  Changes to one row "
"will show in all rows, which is almost certainly not what you want."
msgstr ""

#: ../Doc/faq/programming.rst:1243
msgid ""
"The suggested approach is to create a list of the desired length first and "
"then fill in each element with a newly created list::"
msgstr ""

#: ../Doc/faq/programming.rst:1250
msgid ""
"This generates a list containing 3 different lists of length two.  You can "
"also use a list comprehension::"
msgstr ""

#: ../Doc/faq/programming.rst:1256
msgid ""
"Or, you can use an extension that provides a matrix datatype; `NumPy <http://"
"www.numpy.org/>`_ is the best known."
msgstr ""

#: ../Doc/faq/programming.rst:1261
msgid "How do I apply a method to a sequence of objects?"
msgstr ""

#: ../Doc/faq/programming.rst:1263
msgid "Use a list comprehension::"
msgstr ""

#: ../Doc/faq/programming.rst:1270
msgid ""
"Why does a_tuple[i] += ['item'] raise an exception when the addition works?"
msgstr ""

#: ../Doc/faq/programming.rst:1272
msgid ""
"This is because of a combination of the fact that augmented assignment "
"operators are *assignment* operators, and the difference between mutable and "
"immutable objects in Python."
msgstr ""

#: ../Doc/faq/programming.rst:1276
msgid ""
"This discussion applies in general when augmented assignment operators are "
"applied to elements of a tuple that point to mutable objects, but we'll use "
"a ``list`` and ``+=`` as our exemplar."
msgstr ""

#: ../Doc/faq/programming.rst:1280
msgid "If you wrote::"
msgstr ""

#: ../Doc/faq/programming.rst:1288
msgid ""
"The reason for the exception should be immediately clear: ``1`` is added to "
"the object ``a_tuple[0]`` points to (``1``), producing the result object, "
"``2``, but when we attempt to assign the result of the computation, ``2``, "
"to element ``0`` of the tuple, we get an error because we can't change what "
"an element of a tuple points to."
msgstr ""

#: ../Doc/faq/programming.rst:1294
msgid ""
"Under the covers, what this augmented assignment statement is doing is "
"approximately this::"
msgstr ""

#: ../Doc/faq/programming.rst:1303
msgid ""
"It is the assignment part of the operation that produces the error, since a "
"tuple is immutable."
msgstr ""

#: ../Doc/faq/programming.rst:1306
msgid "When you write something like::"
msgstr ""

#: ../Doc/faq/programming.rst:1314
msgid ""
"The exception is a bit more surprising, and even more surprising is the fact "
"that even though there was an error, the append worked::"
msgstr ""

#: ../Doc/faq/programming.rst:1320
msgid ""
"To see why this happens, you need to know that (a) if an object implements "
"an ``__iadd__`` magic method, it gets called when the ``+=`` augmented "
"assignment is executed, and its return value is what gets used in the "
"assignment statement; and (b) for lists, ``__iadd__`` is equivalent to "
"calling ``extend`` on the list and returning the list.  That's why we say "
"that for lists, ``+=`` is a \"shorthand\" for ``list.extend``::"
msgstr ""

#: ../Doc/faq/programming.rst:1332
msgid "This is equivalent to::"
msgstr ""

#: ../Doc/faq/programming.rst:1337
msgid ""
"The object pointed to by a_list has been mutated, and the pointer to the "
"mutated object is assigned back to ``a_list``.  The end result of the "
"assignment is a no-op, since it is a pointer to the same object that "
"``a_list`` was previously pointing to, but the assignment still happens."
msgstr ""

#: ../Doc/faq/programming.rst:1342
msgid "Thus, in our tuple example what is happening is equivalent to::"
msgstr ""

#: ../Doc/faq/programming.rst:1350
msgid ""
"The ``__iadd__`` succeeds, and thus the list is extended, but even though "
"``result`` points to the same object that ``a_tuple[0]`` already points to, "
"that final assignment still results in an error, because tuples are "
"immutable."
msgstr ""

#: ../Doc/faq/programming.rst:1356
msgid ""
"I want to do a complicated sort: can you do a Schwartzian Transform in "
"Python?"
msgstr ""

#: ../Doc/faq/programming.rst:1358
msgid ""
"The technique, attributed to Randal Schwartz of the Perl community, sorts "
"the elements of a list by a metric which maps each element to its \"sort "
"value\". In Python, use the ``key`` argument for the :meth:`list.sort` "
"method::"
msgstr ""

#: ../Doc/faq/programming.rst:1367
msgid "How can I sort one list by values from another list?"
msgstr ""

#: ../Doc/faq/programming.rst:1369
msgid ""
"Merge them into an iterator of tuples, sort the resulting list, and then "
"pick out the element you want. ::"
msgstr ""

#: ../Doc/faq/programming.rst:1383
msgid "An alternative for the last step is::"
msgstr ""

#: ../Doc/faq/programming.rst:1388
msgid ""
"If you find this more legible, you might prefer to use this instead of the "
"final list comprehension.  However, it is almost twice as slow for long "
"lists.  Why? First, the ``append()`` operation has to reallocate memory, and "
"while it uses some tricks to avoid doing that each time, it still has to do "
"it occasionally, and that costs quite a bit.  Second, the expression "
"\"result.append\" requires an extra attribute lookup, and third, there's a "
"speed reduction from having to make all those function calls."
msgstr ""

#: ../Doc/faq/programming.rst:1398
msgid "Objects"
msgstr ""

#: ../Doc/faq/programming.rst:1401
msgid "What is a class?"
msgstr ""

#: ../Doc/faq/programming.rst:1403
msgid ""
"A class is the particular object type created by executing a class "
"statement. Class objects are used as templates to create instance objects, "
"which embody both the data (attributes) and code (methods) specific to a "
"datatype."
msgstr ""

#: ../Doc/faq/programming.rst:1407
msgid ""
"A class can be based on one or more other classes, called its base "
"class(es). It then inherits the attributes and methods of its base classes. "
"This allows an object model to be successively refined by inheritance.  You "
"might have a generic ``Mailbox`` class that provides basic accessor methods "
"for a mailbox, and subclasses such as ``MboxMailbox``, ``MaildirMailbox``, "
"``OutlookMailbox`` that handle various specific mailbox formats."
msgstr ""

#: ../Doc/faq/programming.rst:1416
msgid "What is a method?"
msgstr ""

#: ../Doc/faq/programming.rst:1418
msgid ""
"A method is a function on some object ``x`` that you normally call as ``x."
"name(arguments...)``.  Methods are defined as functions inside the class "
"definition::"
msgstr ""

#: ../Doc/faq/programming.rst:1428
msgid "What is self?"
msgstr ""

#: ../Doc/faq/programming.rst:1430
msgid ""
"Self is merely a conventional name for the first argument of a method.  A "
"method defined as ``meth(self, a, b, c)`` should be called as ``x.meth(a, b, "
"c)`` for some instance ``x`` of the class in which the definition occurs; "
"the called method will think it is called as ``meth(x, a, b, c)``."
msgstr ""

#: ../Doc/faq/programming.rst:1435
msgid "See also :ref:`why-self`."
msgstr ""

#: ../Doc/faq/programming.rst:1439
msgid ""
"How do I check if an object is an instance of a given class or of a subclass "
"of it?"
msgstr ""

#: ../Doc/faq/programming.rst:1441
msgid ""
"Use the built-in function ``isinstance(obj, cls)``.  You can check if an "
"object is an instance of any of a number of classes by providing a tuple "
"instead of a single class, e.g. ``isinstance(obj, (class1, class2, ...))``, "
"and can also check whether an object is one of Python's built-in types, e.g. "
"``isinstance(obj, str)`` or ``isinstance(obj, (int, float, complex))``."
msgstr ""

#: ../Doc/faq/programming.rst:1447
msgid ""
"Note that most programs do not use :func:`isinstance` on user-defined "
"classes very often.  If you are developing the classes yourself, a more "
"proper object-oriented style is to define methods on the classes that "
"encapsulate a particular behaviour, instead of checking the object's class "
"and doing a different thing based on what class it is.  For example, if you "
"have a function that does something::"
msgstr ""

#: ../Doc/faq/programming.rst:1461
msgid ""
"A better approach is to define a ``search()`` method on all the classes and "
"just call it::"
msgstr ""

#: ../Doc/faq/programming.rst:1476
msgid "What is delegation?"
msgstr ""

#: ../Doc/faq/programming.rst:1478
msgid ""
"Delegation is an object oriented technique (also called a design pattern). "
"Let's say you have an object ``x`` and want to change the behaviour of just "
"one of its methods.  You can create a new class that provides a new "
"implementation of the method you're interested in changing and delegates all "
"other methods to the corresponding method of ``x``."
msgstr ""

#: ../Doc/faq/programming.rst:1484
msgid ""
"Python programmers can easily implement delegation.  For example, the "
"following class implements a class that behaves like a file but converts all "
"written data to uppercase::"
msgstr ""

#: ../Doc/faq/programming.rst:1499
msgid ""
"Here the ``UpperOut`` class redefines the ``write()`` method to convert the "
"argument string to uppercase before calling the underlying ``self.__outfile."
"write()`` method.  All other methods are delegated to the underlying ``self."
"__outfile`` object.  The delegation is accomplished via the ``__getattr__`` "
"method; consult :ref:`the language reference <attribute-access>` for more "
"information about controlling attribute access."
msgstr ""

#: ../Doc/faq/programming.rst:1506
msgid ""
"Note that for more general cases delegation can get trickier. When "
"attributes must be set as well as retrieved, the class must define a :meth:"
"`__setattr__` method too, and it must do so carefully.  The basic "
"implementation of :meth:`__setattr__` is roughly equivalent to the "
"following::"
msgstr ""

#: ../Doc/faq/programming.rst:1517
msgid ""
"Most :meth:`__setattr__` implementations must modify ``self.__dict__`` to "
"store local state for self without causing an infinite recursion."
msgstr ""

#: ../Doc/faq/programming.rst:1522
msgid ""
"How do I call a method defined in a base class from a derived class that "
"overrides it?"
msgstr ""

#: ../Doc/faq/programming.rst:1524
msgid "Use the built-in :func:`super` function::"
msgstr ""

#: ../Doc/faq/programming.rst:1530
msgid ""
"For version prior to 3.0, you may be using classic classes: For a class "
"definition such as ``class Derived(Base): ...`` you can call method "
"``meth()`` defined in ``Base`` (or one of ``Base``'s base classes) as ``Base."
"meth(self, arguments...)``.  Here, ``Base.meth`` is an unbound method, so "
"you need to provide the ``self`` argument."
msgstr ""

#: ../Doc/faq/programming.rst:1538
msgid "How can I organize my code to make it easier to change the base class?"
msgstr ""

#: ../Doc/faq/programming.rst:1540
msgid ""
"You could define an alias for the base class, assign the real base class to "
"it before your class definition, and use the alias throughout your class.  "
"Then all you have to change is the value assigned to the alias.  "
"Incidentally, this trick is also handy if you want to decide dynamically (e."
"g. depending on availability of resources) which base class to use.  "
"Example::"
msgstr ""

#: ../Doc/faq/programming.rst:1555
msgid "How do I create static class data and static class methods?"
msgstr ""

#: ../Doc/faq/programming.rst:1557
msgid ""
"Both static data and static methods (in the sense of C++ or Java) are "
"supported in Python."
msgstr ""

#: ../Doc/faq/programming.rst:1560
msgid ""
"For static data, simply define a class attribute.  To assign a new value to "
"the attribute, you have to explicitly use the class name in the assignment::"
msgstr ""

#: ../Doc/faq/programming.rst:1572
msgid ""
"``c.count`` also refers to ``C.count`` for any ``c`` such that "
"``isinstance(c, C)`` holds, unless overridden by ``c`` itself or by some "
"class on the base-class search path from ``c.__class__`` back to ``C``."
msgstr ""

#: ../Doc/faq/programming.rst:1576
msgid ""
"Caution: within a method of C, an assignment like ``self.count = 42`` "
"creates a new and unrelated instance named \"count\" in ``self``'s own "
"dict.  Rebinding of a class-static data name must always specify the class "
"whether inside a method or not::"
msgstr ""

#: ../Doc/faq/programming.rst:1583
msgid "Static methods are possible::"
msgstr ""

#: ../Doc/faq/programming.rst:1591
msgid ""
"However, a far more straightforward way to get the effect of a static method "
"is via a simple module-level function::"
msgstr ""

#: ../Doc/faq/programming.rst:1597
msgid ""
"If your code is structured so as to define one class (or tightly related "
"class hierarchy) per module, this supplies the desired encapsulation."
msgstr ""

#: ../Doc/faq/programming.rst:1602
msgid "How can I overload constructors (or methods) in Python?"
msgstr ""

#: ../Doc/faq/programming.rst:1604
msgid ""
"This answer actually applies to all methods, but the question usually comes "
"up first in the context of constructors."
msgstr ""

#: ../Doc/faq/programming.rst:1607
msgid "In C++ you'd write"
msgstr ""

#: ../Doc/faq/programming.rst:1616
msgid ""
"In Python you have to write a single constructor that catches all cases "
"using default arguments.  For example::"
msgstr ""

#: ../Doc/faq/programming.rst:1626
msgid "This is not entirely equivalent, but close enough in practice."
msgstr ""

#: ../Doc/faq/programming.rst:1628
msgid "You could also try a variable-length argument list, e.g. ::"
msgstr ""

#: ../Doc/faq/programming.rst:1633
msgid "The same approach works for all method definitions."
msgstr ""

#: ../Doc/faq/programming.rst:1637
msgid "I try to use __spam and I get an error about _SomeClassName__spam."
msgstr ""

#: ../Doc/faq/programming.rst:1639
msgid ""
"Variable names with double leading underscores are \"mangled\" to provide a "
"simple but effective way to define class private variables.  Any identifier "
"of the form ``__spam`` (at least two leading underscores, at most one "
"trailing underscore) is textually replaced with ``_classname__spam``, where "
"``classname`` is the current class name with any leading underscores "
"stripped."
msgstr ""

#: ../Doc/faq/programming.rst:1645
msgid ""
"This doesn't guarantee privacy: an outside user can still deliberately "
"access the \"_classname__spam\" attribute, and private values are visible in "
"the object's ``__dict__``.  Many Python programmers never bother to use "
"private variable names at all."
msgstr ""

#: ../Doc/faq/programming.rst:1652
msgid "My class defines __del__ but it is not called when I delete the object."
msgstr ""

#: ../Doc/faq/programming.rst:1654
msgid "There are several possible reasons for this."
msgstr ""

#: ../Doc/faq/programming.rst:1656
msgid ""
"The del statement does not necessarily call :meth:`__del__` -- it simply "
"decrements the object's reference count, and if this reaches zero :meth:"
"`__del__` is called."
msgstr ""

#: ../Doc/faq/programming.rst:1660
msgid ""
"If your data structures contain circular links (e.g. a tree where each child "
"has a parent reference and each parent has a list of children) the reference "
"counts will never go back to zero.  Once in a while Python runs an algorithm "
"to detect such cycles, but the garbage collector might run some time after "
"the last reference to your data structure vanishes, so your :meth:`__del__` "
"method may be called at an inconvenient and random time. This is "
"inconvenient if you're trying to reproduce a problem. Worse, the order in "
"which object's :meth:`__del__` methods are executed is arbitrary.  You can "
"run :func:`gc.collect` to force a collection, but there *are* pathological "
"cases where objects will never be collected."
msgstr ""

#: ../Doc/faq/programming.rst:1671
msgid ""
"Despite the cycle collector, it's still a good idea to define an explicit "
"``close()`` method on objects to be called whenever you're done with them.  "
"The ``close()`` method can then remove attributes that refer to subobjects.  "
"Don't call :meth:`__del__` directly -- :meth:`__del__` should call "
"``close()`` and ``close()`` should make sure that it can be called more than "
"once for the same object."
msgstr ""

#: ../Doc/faq/programming.rst:1678
msgid ""
"Another way to avoid cyclical references is to use the :mod:`weakref` "
"module, which allows you to point to objects without incrementing their "
"reference count. Tree data structures, for instance, should use weak "
"references for their parent and sibling references (if they need them!)."
msgstr ""

#: ../Doc/faq/programming.rst:1691
msgid ""
"Finally, if your :meth:`__del__` method raises an exception, a warning "
"message is printed to :data:`sys.stderr`."
msgstr ""

#: ../Doc/faq/programming.rst:1696
msgid "How do I get a list of all instances of a given class?"
msgstr ""

#: ../Doc/faq/programming.rst:1698
msgid ""
"Python does not keep track of all instances of a class (or of a built-in "
"type). You can program the class's constructor to keep track of all "
"instances by keeping a list of weak references to each instance."
msgstr ""

#: ../Doc/faq/programming.rst:1704
msgid "Why does the result of ``id()`` appear to be not unique?"
msgstr ""

#: ../Doc/faq/programming.rst:1706
msgid ""
"The :func:`id` builtin returns an integer that is guaranteed to be unique "
"during the lifetime of the object.  Since in CPython, this is the object's "
"memory address, it happens frequently that after an object is deleted from "
"memory, the next freshly created object is allocated at the same position in "
"memory.  This is illustrated by this example:"
msgstr ""

#: ../Doc/faq/programming.rst:1717
msgid ""
"The two ids belong to different integer objects that are created before, and "
"deleted immediately after execution of the ``id()`` call.  To be sure that "
"objects whose id you want to examine are still alive, create another "
"reference to the object:"
msgstr ""

#: ../Doc/faq/programming.rst:1730
msgid "Modules"
msgstr ""

#: ../Doc/faq/programming.rst:1733
msgid "How do I create a .pyc file?"
msgstr ""

#: ../Doc/faq/programming.rst:1735
msgid ""
"When a module is imported for the first time (or when the source file has "
"changed since the current compiled file was created) a ``.pyc`` file "
"containing the compiled code should be created in a ``__pycache__`` "
"subdirectory of the directory containing the ``.py`` file.  The ``.pyc`` "
"file will have a filename that starts with the same name as the ``.py`` "
"file, and ends with ``.pyc``, with a middle component that depends on the "
"particular ``python`` binary that created it.  (See :pep:`3147` for details.)"
msgstr ""

#: ../Doc/faq/programming.rst:1743
msgid ""
"One reason that a ``.pyc`` file may not be created is a permissions problem "
"with the directory containing the source file, meaning that the "
"``__pycache__`` subdirectory cannot be created. This can happen, for "
"example, if you develop as one user but run as another, such as if you are "
"testing with a web server."
msgstr ""

#: ../Doc/faq/programming.rst:1748
msgid ""
"Unless the :envvar:`PYTHONDONTWRITEBYTECODE` environment variable is set, "
"creation of a .pyc file is automatic if you're importing a module and Python "
"has the ability (permissions, free space, etc...) to create a "
"``__pycache__`` subdirectory and write the compiled module to that "
"subdirectory."
msgstr ""

#: ../Doc/faq/programming.rst:1753
msgid ""
"Running Python on a top level script is not considered an import and no ``."
"pyc`` will be created.  For example, if you have a top-level module ``foo."
"py`` that imports another module ``xyz.py``, when you run ``foo`` (by typing "
"``python foo.py`` as a shell command), a ``.pyc`` will be created for "
"``xyz`` because ``xyz`` is imported, but no ``.pyc`` file will be created "
"for ``foo`` since ``foo.py`` isn't being imported."
msgstr ""

#: ../Doc/faq/programming.rst:1760
msgid ""
"If you need to create a ``.pyc`` file for ``foo`` -- that is, to create a ``."
"pyc`` file for a module that is not imported -- you can, using the :mod:"
"`py_compile` and :mod:`compileall` modules."
msgstr ""

#: ../Doc/faq/programming.rst:1764
msgid ""
"The :mod:`py_compile` module can manually compile any module.  One way is to "
"use the ``compile()`` function in that module interactively::"
msgstr ""

#: ../Doc/faq/programming.rst:1770
msgid ""
"This will write the ``.pyc`` to a ``__pycache__`` subdirectory in the same "
"location as ``foo.py`` (or you can override that with the optional parameter "
"``cfile``)."
msgstr ""

#: ../Doc/faq/programming.rst:1774
msgid ""
"You can also automatically compile all files in a directory or directories "
"using the :mod:`compileall` module.  You can do it from the shell prompt by "
"running ``compileall.py`` and providing the path of a directory containing "
"Python files to compile::"
msgstr ""

#: ../Doc/faq/programming.rst:1783
msgid "How do I find the current module name?"
msgstr ""

#: ../Doc/faq/programming.rst:1785
msgid ""
"A module can find out its own module name by looking at the predefined "
"global variable ``__name__``.  If this has the value ``'__main__'``, the "
"program is running as a script.  Many modules that are usually used by "
"importing them also provide a command-line interface or a self-test, and "
"only execute this code after checking ``__name__``::"
msgstr ""

#: ../Doc/faq/programming.rst:1800
msgid "How can I have modules that mutually import each other?"
msgstr ""

#: ../Doc/faq/programming.rst:1802
msgid "Suppose you have the following modules:"
msgstr ""

#: ../Doc/faq/programming.rst:1804
msgid "foo.py::"
msgstr ""

#: ../Doc/faq/programming.rst:1809
msgid "bar.py::"
msgstr ""

#: ../Doc/faq/programming.rst:1814
msgid "The problem is that the interpreter will perform the following steps:"
msgstr ""

#: ../Doc/faq/programming.rst:1816
msgid "main imports foo"
msgstr ""

#: ../Doc/faq/programming.rst:1817
msgid "Empty globals for foo are created"
msgstr ""

#: ../Doc/faq/programming.rst:1818
msgid "foo is compiled and starts executing"
msgstr ""

#: ../Doc/faq/programming.rst:1819
msgid "foo imports bar"
msgstr ""

#: ../Doc/faq/programming.rst:1820
msgid "Empty globals for bar are created"
msgstr ""

#: ../Doc/faq/programming.rst:1821
msgid "bar is compiled and starts executing"
msgstr ""

#: ../Doc/faq/programming.rst:1822
msgid ""
"bar imports foo (which is a no-op since there already is a module named foo)"
msgstr ""

#: ../Doc/faq/programming.rst:1823
msgid "bar.foo_var = foo.foo_var"
msgstr ""

#: ../Doc/faq/programming.rst:1825
msgid ""
"The last step fails, because Python isn't done with interpreting ``foo`` yet "
"and the global symbol dictionary for ``foo`` is still empty."
msgstr ""

#: ../Doc/faq/programming.rst:1828
msgid ""
"The same thing happens when you use ``import foo``, and then try to access "
"``foo.foo_var`` in global code."
msgstr ""

#: ../Doc/faq/programming.rst:1831
msgid "There are (at least) three possible workarounds for this problem."
msgstr ""

#: ../Doc/faq/programming.rst:1833
msgid ""
"Guido van Rossum recommends avoiding all uses of ``from <module> import ..."
"``, and placing all code inside functions.  Initializations of global "
"variables and class variables should use constants or built-in functions "
"only.  This means everything from an imported module is referenced as "
"``<module>.<name>``."
msgstr ""

#: ../Doc/faq/programming.rst:1838
msgid ""
"Jim Roskind suggests performing steps in the following order in each module:"
msgstr ""

#: ../Doc/faq/programming.rst:1840
msgid ""
"exports (globals, functions, and classes that don't need imported base "
"classes)"
msgstr ""

#: ../Doc/faq/programming.rst:1842
msgid "``import`` statements"
msgstr ""

#: ../Doc/faq/programming.rst:1843
msgid ""
"active code (including globals that are initialized from imported values)."
msgstr ""

#: ../Doc/faq/programming.rst:1845
msgid ""
"van Rossum doesn't like this approach much because the imports appear in a "
"strange place, but it does work."
msgstr ""

#: ../Doc/faq/programming.rst:1848
msgid ""
"Matthias Urlichs recommends restructuring your code so that the recursive "
"import is not necessary in the first place."
msgstr ""

#: ../Doc/faq/programming.rst:1851
msgid "These solutions are not mutually exclusive."
msgstr ""

#: ../Doc/faq/programming.rst:1855
msgid "__import__('x.y.z') returns <module 'x'>; how do I get z?"
msgstr ""

#: ../Doc/faq/programming.rst:1857
msgid ""
"Consider using the convenience function :func:`~importlib.import_module` "
"from :mod:`importlib` instead::"
msgstr ""

#: ../Doc/faq/programming.rst:1864
msgid ""
"When I edit an imported module and reimport it, the changes don't show up.  "
"Why does this happen?"
msgstr ""

#: ../Doc/faq/programming.rst:1866
msgid ""
"For reasons of efficiency as well as consistency, Python only reads the "
"module file on the first time a module is imported.  If it didn't, in a "
"program consisting of many modules where each one imports the same basic "
"module, the basic module would be parsed and re-parsed many times.  To force "
"re-reading of a changed module, do this::"
msgstr ""

#: ../Doc/faq/programming.rst:1876
msgid ""
"Warning: this technique is not 100% fool-proof.  In particular, modules "
"containing statements like ::"
msgstr ""

#: ../Doc/faq/programming.rst:1881
msgid ""
"will continue to work with the old version of the imported objects.  If the "
"module contains class definitions, existing class instances will *not* be "
"updated to use the new class definition.  This can result in the following "
"paradoxical behaviour::"
msgstr ""

#: ../Doc/faq/programming.rst:1894
msgid ""
"The nature of the problem is made clear if you print out the \"identity\" of "
"the class objects::"
msgstr ""