# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-09-14 20:17+0000\n"

"PO-Revision-Date: 2025-09-16 00:00+0000\n"

"Last-Translator: python-doc bot, 2025\n"

"Language-Team: German (https://app.transifex.com/python-doc/teams/5390/de/)\n"

"Language: de\n"

"MIME-Version: 1.0\n"

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

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

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

#: ../../faq/programming.rst:5

msgid "Programming FAQ"

msgstr ""

#: ../../faq/programming.rst:8

msgid "Contents"

msgstr "Inhalt"

#: ../../faq/programming.rst:12

msgid "General questions"

msgstr ""

#: ../../faq/programming.rst:15

msgid ""

"Is there a source code-level debugger with breakpoints and single-stepping?"

msgstr ""

#: ../../faq/programming.rst:17 ../../faq/programming.rst:56

msgid "Yes."

msgstr ""

#: ../../faq/programming.rst:19

msgid ""

"Several debuggers for Python are described below, and the built-in function :"

"func:`breakpoint` allows you to drop into any of them."

msgstr ""

#: ../../faq/programming.rst:22

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

#: ../../faq/programming.rst:27

msgid ""

"The IDLE interactive development environment, which is part of the standard "

"Python distribution (normally available as :mod:`idlelib`), includes a "

"graphical debugger."

msgstr ""

#: ../../faq/programming.rst:31

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 "

"`pywin32 <https://github.com/mhammond/pywin32>`_ project and as a part of "

"the `ActivePython <https://www.activestate.com/products/python/>`_ "

"distribution."

msgstr ""

#: ../../faq/programming.rst:38

msgid ""

"`Eric <https://eric-ide.python-projects.org/>`_ is an IDE built on PyQt and "

"the Scintilla editing component."

msgstr ""

#: ../../faq/programming.rst:41

msgid ""

"`trepan3k <https://github.com/rocky/python3-trepan/>`_ is a gdb-like "

"debugger."

msgstr ""

#: ../../faq/programming.rst:43

msgid ""

"`Visual Studio Code <https://code.visualstudio.com/>`_ is an IDE with "

"debugging tools that integrates with version-control software."

msgstr ""

#: ../../faq/programming.rst:46

msgid ""

"There are a number of commercial Python IDEs that include graphical "

"debuggers. They include:"

msgstr ""

#: ../../faq/programming.rst:49

msgid "`Wing IDE <https://wingware.com/>`_"

msgstr ""

#: ../../faq/programming.rst:50

msgid "`PyCharm <https://www.jetbrains.com/pycharm/>`_"

msgstr ""

#: ../../faq/programming.rst:54

msgid "Are there tools to help find bugs or perform static analysis?"

msgstr ""

#: ../../faq/programming.rst:58

msgid ""

"`Ruff <https://docs.astral.sh/ruff/>`__, `Pylint <https://pylint.readthedocs."

"io/>`__ and `Pyflakes <https://github.com/PyCQA/pyflakes>`__ do basic "

"checking that will help you catch bugs sooner."

msgstr ""

#: ../../faq/programming.rst:63

msgid ""

"Static type checkers such as `mypy <https://mypy-lang.org/>`__, `ty <https://"

"docs.astral.sh/ty/>`__, `Pyrefly <https://pyrefly.org/>`__, and `pytype "

"<https://github.com/google/pytype>`__ can check type hints in Python source "

"code."

msgstr ""

#: ../../faq/programming.rst:73

msgid "How can I create a stand-alone binary from a Python script?"

msgstr ""

#: ../../faq/programming.rst:75

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

#: ../../faq/programming.rst:81

msgid ""

"One is to use the freeze tool, which is included in the Python source tree "

"as :source:`Tools/freeze`. It converts Python byte code to C arrays; with a "

"C compiler you can embed all your modules into a new program, which is then "

"linked with the standard Python modules."

msgstr ""

#: ../../faq/programming.rst:87

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

#: ../../faq/programming.rst:96

msgid ""

"The following packages can help with the creation of console and GUI "

"executables:"

msgstr ""

#: ../../faq/programming.rst:99

msgid "`Nuitka <https://nuitka.net/>`_ (Cross-platform)"

msgstr ""

#: ../../faq/programming.rst:100

msgid "`PyInstaller <https://pyinstaller.org/>`_ (Cross-platform)"

msgstr ""

#: ../../faq/programming.rst:101

msgid ""

"`PyOxidizer <https://pyoxidizer.readthedocs.io/en/stable/>`_ (Cross-platform)"

msgstr ""

#: ../../faq/programming.rst:102

msgid ""

"`cx_Freeze <https://marcelotduarte.github.io/cx_Freeze/>`_ (Cross-platform)"

msgstr ""

#: ../../faq/programming.rst:103

msgid "`py2app <https://github.com/ronaldoussoren/py2app>`_ (macOS only)"

msgstr ""

#: ../../faq/programming.rst:104

msgid "`py2exe <https://www.py2exe.org/>`_ (Windows only)"

msgstr ""

#: ../../faq/programming.rst:108

msgid "Are there coding standards or a style guide for Python programs?"

msgstr ""

#: ../../faq/programming.rst:110

msgid ""

"Yes. The coding style required for standard library modules is documented "

"as :pep:`8`."

msgstr ""

#: ../../faq/programming.rst:115

msgid "Core language"

msgstr ""

#: ../../faq/programming.rst:120

msgid "Why am I getting an UnboundLocalError when the variable has a value?"

msgstr ""

#: ../../faq/programming.rst:122

msgid ""

"It can be a surprise to get the :exc:`UnboundLocalError` in previously "

"working code when it is modified by adding an assignment statement somewhere "

"in the body of a function."

msgstr ""

#: ../../faq/programming.rst:126

msgid "This code:"

msgstr ""

#: ../../faq/programming.rst:135

msgid "works, but this code:"

msgstr ""

#: ../../faq/programming.rst:142

msgid "results in an :exc:`!UnboundLocalError`:"

msgstr ""

#: ../../faq/programming.rst:149

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

#: ../../faq/programming.rst:156

msgid ""

"In the example above you can access the outer scope variable by declaring it "

"global:"

msgstr ""

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

#: ../../faq/programming.rst:175

msgid ""

"You can do a similar thing in a nested scope using the :keyword:`nonlocal` "

"keyword:"

msgstr ""

#: ../../faq/programming.rst:193

msgid "What are the rules for local and global variables in Python?"

msgstr ""

#: ../../faq/programming.rst:195

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

#: ../../faq/programming.rst:199

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

#: ../../faq/programming.rst:209

msgid ""

"Why do lambdas defined in a loop with different values all return the same "

"result?"

msgstr ""

#: ../../faq/programming.rst:211

msgid ""

"Assume you use a for loop to define a few different lambdas (or even plain "

"functions), for example::"

msgstr ""

#: ../../faq/programming.rst:214

msgid ""

">>> squares = []\n"

">>> for x in range(5):\n"

"... squares.append(lambda: x**2)"

msgstr ""

#: ../../faq/programming.rst:218

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

#: ../../faq/programming.rst:223

msgid ""

">>> squares[2]()\n"

"16\n"

">>> squares[4]()\n"

"16"

msgstr ""

#: ../../faq/programming.rst:228

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``, that is ``16``. You can also verify this "

"by changing the value of ``x`` and see how the results of the lambdas "

"change::"

msgstr ""

#: ../../faq/programming.rst:234

msgid ""

">>> x = 8\n"

">>> squares[2]()\n"

"64"

msgstr ""

#: ../../faq/programming.rst:238

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

#: ../../faq/programming.rst:241

msgid ""

">>> squares = []\n"

">>> for x in range(5):\n"

"... squares.append(lambda n=x: n**2)"

msgstr ""

#: ../../faq/programming.rst:245

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

#: ../../faq/programming.rst:251

msgid ""

">>> squares[2]()\n"

"4\n"

">>> squares[4]()\n"

"16"

msgstr ""

#: ../../faq/programming.rst:256

msgid ""

"Note that this behaviour is not peculiar to lambdas, but applies to regular "

"functions too."

msgstr ""

#: ../../faq/programming.rst:261

msgid "How do I share global variables across modules?"

msgstr ""

#: ../../faq/programming.rst:263

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

#: ../../faq/programming.rst:269

msgid "config.py::"

msgstr ""

#: ../../faq/programming.rst:271

msgid "x = 0 # Default value of the 'x' configuration setting"

msgstr ""

#: ../../faq/programming.rst:273

msgid "mod.py::"

msgstr ""

#: ../../faq/programming.rst:275

msgid ""

"import config\n"

"config.x = 1"

msgstr ""

#: ../../faq/programming.rst:278

msgid "main.py::"

msgstr ""

#: ../../faq/programming.rst:280

msgid ""

"import config\n"

"import mod\n"

"print(config.x)"

msgstr ""

#: ../../faq/programming.rst:284

msgid ""

"Note that using a module is also the basis for implementing the singleton "

"design pattern, for the same reason."

msgstr ""

#: ../../faq/programming.rst:289

msgid "What are the \"best practices\" for using import in a module?"

msgstr ""

#: ../../faq/programming.rst:291

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

#: ../../faq/programming.rst:295

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

#: ../../faq/programming.rst:300

msgid "It's good practice if you import modules in the following order:"

msgstr ""

#: ../../faq/programming.rst:302

msgid ""

"standard library modules -- such as :mod:`sys`, :mod:`os`, :mod:`argparse`, :"

"mod:`re`"

msgstr ""

#: ../../faq/programming.rst:303

msgid ""

"third-party library modules (anything installed in Python's site-packages "

"directory) -- such as :pypi:`dateutil`, :pypi:`requests`, :pypi:`tzdata`"

msgstr ""

#: ../../faq/programming.rst:305

msgid "locally developed modules"

msgstr ""

#: ../../faq/programming.rst:307

msgid ""

"It is sometimes necessary to move imports to a function or class to avoid "

"problems with circular imports. Gordon McMillan says:"

msgstr ""

#: ../../faq/programming.rst:310

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

#: ../../faq/programming.rst:316

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

#: ../../faq/programming.rst:321

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

#: ../../faq/programming.rst:326

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

#: ../../faq/programming.rst:339

msgid "Why are default values shared between objects?"

msgstr ""

#: ../../faq/programming.rst:341

msgid ""

"This type of bug commonly bites neophyte programmers. Consider this "

"function::"

msgstr ""

#: ../../faq/programming.rst:343

msgid ""

"def foo(mydict={}): # Danger: shared reference to one dict for all calls\n"

" ... compute something ...\n"

" mydict[key] = value\n"

" return mydict"

msgstr ""

#: ../../faq/programming.rst:348

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

#: ../../faq/programming.rst:352

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

#: ../../faq/programming.rst:357

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

#: ../../faq/programming.rst:361

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

#: ../../faq/programming.rst:366

msgid ""

"def foo(mydict={}):\n"

" ..."

msgstr ""

#: ../../faq/programming.rst:369

msgid "but::"

msgstr ""

#: ../../faq/programming.rst:371

msgid ""

"def foo(mydict=None):\n"

" if mydict is None:\n"

" mydict = {} # create a new dict for local namespace"

msgstr ""

#: ../../faq/programming.rst:375

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

#: ../../faq/programming.rst:380

msgid ""

"# Callers can only provide two parameters and optionally pass _cache by "

"keyword\n"

"def expensive(arg1, arg2, *, _cache={}):\n"

" if (arg1, arg2) in _cache:\n"

" return _cache[(arg1, arg2)]\n"

"\n"

" # Calculate the value\n"

" result = ... expensive computation ...\n"

" _cache[(arg1, arg2)] = result # Store result in the cache\n"

" return result"

msgstr ""

#: ../../faq/programming.rst:390

msgid ""

"You could use a global variable containing a dictionary instead of the "

"default value; it's a matter of taste."

msgstr ""

#: ../../faq/programming.rst:395

msgid ""

"How can I pass optional or keyword parameters from one function to another?"

msgstr ""

#: ../../faq/programming.rst:397

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

#: ../../faq/programming.rst:402

msgid ""

"def f(x, *args, **kwargs):\n"

" ...\n"

" kwargs['width'] = '14.3c'\n"

" ...\n"

" g(x, *args, **kwargs)"

msgstr ""

#: ../../faq/programming.rst:416

msgid "What is the difference between arguments and parameters?"

msgstr ""

#: ../../faq/programming.rst:418

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

"`kind of arguments <parameter>` a function can accept. For example, given "

"the function definition::"

msgstr ""

#: ../../faq/programming.rst:424

msgid ""

"def func(foo, bar=None, **kwargs):\n"

" pass"

msgstr ""

#: ../../faq/programming.rst:427

msgid ""

"*foo*, *bar* and *kwargs* are parameters of ``func``. However, when calling "

"``func``, for example::"

msgstr ""

#: ../../faq/programming.rst:430

msgid "func(42, bar=314, extra=somevar)"

msgstr ""

#: ../../faq/programming.rst:432

msgid "the values ``42``, ``314``, and ``somevar`` are arguments."

msgstr ""

#: ../../faq/programming.rst:436

msgid "Why did changing list 'y' also change list 'x'?"

msgstr ""

#: ../../faq/programming.rst:438

msgid "If you wrote code like::"

msgstr ""

#: ../../faq/programming.rst:440

msgid ""

">>> x = []\n"

">>> y = x\n"

">>> y.append(10)\n"

">>> y\n"

"[10]\n"

">>> x\n"

"[10]"

msgstr ""

#: ../../faq/programming.rst:448

msgid ""

"you might be wondering why appending an element to ``y`` changed ``x`` too."

msgstr ""

#: ../../faq/programming.rst:450

msgid "There are two factors that produce this result:"

msgstr ""

#: ../../faq/programming.rst:452

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

#: ../../faq/programming.rst:456

msgid ""

"Lists are :term:`mutable`, which means that you can change their content."

msgstr ""

#: ../../faq/programming.rst:458

msgid ""

"After the call to :meth:`~sequence.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 ""

#: ../../faq/programming.rst:462

msgid "If we instead assign an immutable object to ``x``::"

msgstr ""

#: ../../faq/programming.rst:464

msgid ""

">>> x = 5 # ints are immutable\n"

">>> y = x\n"

">>> x = x + 1 # 5 can't be mutated, we are creating a new object here\n"

">>> x\n"

"6\n"

">>> y\n"

"5"

msgstr ""

#: ../../faq/programming.rst:472

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

#: ../../faq/programming.rst:480

msgid ""

"Some operations (for example ``y.append(10)`` and ``y.sort()``) mutate the "

"object, whereas superficially similar operations (for example ``y = y + "

"[10]`` and :func:`sorted(y) <sorted>`) 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 ""

#: ../../faq/programming.rst:489

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

#: ../../faq/programming.rst:496

msgid "In other words:"

msgstr ""

#: ../../faq/programming.rst:498

msgid ""

"If we have a mutable object (such as :class:`list`, :class:`dict`, :class:"

"`set`), we can use some specific operations to mutate it and all the "

"variables that refer to it will see the change."

msgstr ""

#: ../../faq/programming.rst:501

msgid ""

"If we have an immutable object (such as :class:`str`, :class:`int`, :class:"

"`tuple`), 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 ""

#: ../../faq/programming.rst:506

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

#: ../../faq/programming.rst:511

msgid "How do I write a function with output parameters (call by reference)?"

msgstr ""

#: ../../faq/programming.rst:513

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 consequently no call-by-"

"reference. You can achieve the desired effect in a number of ways."

msgstr ""

#: ../../faq/programming.rst:518

msgid "By returning a tuple of the results::"

msgstr ""

#: ../../faq/programming.rst:520

msgid ""

">>> def func1(a, b):\n"

"... a = 'new-value' # a and b are local names\n"

"... b = b + 1 # assigned to new objects\n"

"... return a, b # return new values\n"

"...\n"

">>> x, y = 'old-value', 99\n"

">>> func1(x, y)\n"

"('new-value', 100)"

msgstr ""

#: ../../faq/programming.rst:529

msgid "This is almost always the clearest solution."

msgstr ""

#: ../../faq/programming.rst:531

msgid ""

"By using global variables. This isn't thread-safe, and is not recommended."

msgstr ""

#: ../../faq/programming.rst:533

msgid "By passing a mutable (changeable in-place) object::"

msgstr ""

#: ../../faq/programming.rst:535

msgid ""

">>> def func2(a):\n"

"... a[0] = 'new-value' # 'a' references a mutable list\n"

"... a[1] = a[1] + 1 # changes a shared object\n"

"...\n"

">>> args = ['old-value', 99]\n"

">>> func2(args)\n"

">>> args\n"

"['new-value', 100]"

msgstr ""

#: ../../faq/programming.rst:544

msgid "By passing in a dictionary that gets mutated::"

msgstr ""

#: ../../faq/programming.rst:546

msgid ""

">>> def func3(args):\n"

"... args['a'] = 'new-value' # args is a mutable dictionary\n"

"... args['b'] = args['b'] + 1 # change it in-place\n"

"...\n"

">>> args = {'a': 'old-value', 'b': 99}\n"

">>> func3(args)\n"

">>> args\n"

"{'a': 'new-value', 'b': 100}"

msgstr ""

#: ../../faq/programming.rst:555

msgid "Or bundle up values in a class instance::"

msgstr ""

#: ../../faq/programming.rst:557

msgid ""

">>> class Namespace:\n"

"... def __init__(self, /, **args):\n"

"... for key, value in args.items():\n"

"... setattr(self, key, value)\n"

"...\n"

">>> def func4(args):\n"

"... args.a = 'new-value' # args is a mutable Namespace\n"

"... args.b = args.b + 1 # change object in-place\n"

"...\n"

">>> args = Namespace(a='old-value', b=99)\n"

">>> func4(args)\n"

">>> vars(args)\n"

"{'a': 'new-value', 'b': 100}"

msgstr ""

#: ../../faq/programming.rst:572

msgid "There's almost never a good reason to get this complicated."

msgstr ""

#: ../../faq/programming.rst:574

msgid "Your best choice is to return a tuple containing the multiple results."

msgstr ""

#: ../../faq/programming.rst:578

msgid "How do you make a higher order function in Python?"

msgstr ""

#: ../../faq/programming.rst:580

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

#: ../../faq/programming.rst:584

msgid ""

"def linear(a, b):\n"

" def result(x):\n"

" return a * x + b\n"

" return result"

msgstr ""

#: ../../faq/programming.rst:589

msgid "Or using a callable object::"

msgstr ""

#: ../../faq/programming.rst:591

msgid ""

"class linear:\n"

"\n"

" def __init__(self, a, b):\n"

" self.a, self.b = a, b\n"

"\n"

" def __call__(self, x):\n"

" return self.a * x + self.b"

msgstr ""

#: ../../faq/programming.rst:599

msgid "In both cases, ::"

msgstr ""

#: ../../faq/programming.rst:601

msgid "taxes = linear(0.3, 2)"

msgstr ""

#: ../../faq/programming.rst:603

msgid "gives a callable object where ``taxes(10e6) == 0.3 * 10e6 + 2``."

msgstr ""

#: ../../faq/programming.rst:605

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

#: ../../faq/programming.rst:609

msgid ""

"class exponential(linear):\n"

" # __init__ inherited\n"

" def __call__(self, x):\n"

" return self.a * (x ** self.b)"

msgstr ""

#: ../../faq/programming.rst:614

msgid "Object can encapsulate state for several methods::"

msgstr ""

#: ../../faq/programming.rst:616

msgid ""

"class counter:\n"

"\n"

" value = 0\n"

"\n"

" def set(self, x):\n"

" self.value = x\n"

"\n"

" def up(self):\n"

" self.value = self.value + 1\n"

"\n"

" def down(self):\n"

" self.value = self.value - 1\n"

"\n"

"count = counter()\n"

"inc, dec, reset = count.up, count.down, count.set"

msgstr ""

#: ../../faq/programming.rst:632

msgid ""

"Here ``inc()``, ``dec()`` and ``reset()`` act like functions which share the "

"same counting variable."

msgstr ""

#: ../../faq/programming.rst:637

msgid "How do I copy an object in Python?"

msgstr ""

#: ../../faq/programming.rst:639

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

#: ../../faq/programming.rst:642

msgid ""

"Some objects can be copied more easily. Dictionaries have a :meth:`~dict."

"copy` method::"

msgstr ""

#: ../../faq/programming.rst:645

msgid "newdict = olddict.copy()"

msgstr ""

#: ../../faq/programming.rst:647

msgid "Sequences can be copied by slicing::"

msgstr ""

#: ../../faq/programming.rst:649

msgid "new_l = l[:]"

msgstr ""

#: ../../faq/programming.rst:653

msgid "How can I find the methods or attributes of an object?"

msgstr ""

#: ../../faq/programming.rst:655

msgid ""

"For an instance ``x`` of a user-defined class, :func:`dir(x) <dir>` returns "

"an alphabetized list of the names containing the instance attributes and "

"methods and attributes defined by its class."