# 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: 2024-06-01 22:23+0200\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"

"Language: \n"

"MIME-Version: 1.0\n"

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

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

#: faq/programming.rst:5

msgid "Programming FAQ"

msgstr ""

#: faq/programming.rst:8

msgid "Contents"

msgstr ""

#: faq/programming.rst:12

msgid "General Questions"

msgstr ""

#: faq/programming.rst:15

msgid ""

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

"etc.?"

msgstr ""

#: faq/programming.rst:58

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 `Tools/scripts/idle3 <https://"

"github.com/python/cpython/blob/main/Tools/scripts/idle3>`_), includes a "

"graphical debugger."

msgstr ""

#: faq/programming.rst:32

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:39

msgid ""

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

"the Scintilla editing component."

msgstr ""

#: faq/programming.rst:42

msgid ""

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

"debugger."

msgstr ""

#: faq/programming.rst:44

msgid ""

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

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

msgstr ""

#: faq/programming.rst:47

msgid ""

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

"debuggers. They include:"

msgstr ""

#: faq/programming.rst:50

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

msgstr ""

#: faq/programming.rst:51

msgid "`Komodo IDE <https://www.activestate.com/products/komodo-ide/>`_"

msgstr ""

#: faq/programming.rst:52

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

msgstr ""

#: faq/programming.rst:56

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

msgstr ""

#: faq/programming.rst:60

msgid ""

"`Pylint <https://pylint.pycqa.org/en/latest/index.html>`_ and `Pyflakes "

"<https://github.com/PyCQA/pyflakes>`_ do basic checking that will help you "

"catch bugs sooner."

msgstr ""

#: faq/programming.rst:64

msgid ""

"Static type checkers such as `Mypy <https://mypy-lang.org/>`_, `Pyre "

"<https://pyre-check.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 `Tools/freeze <https://github.com/python/cpython/tree/main/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:107

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

msgstr ""

#: faq/programming.rst:109

msgid ""

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

"as :pep:`8`."

msgstr ""

#: faq/programming.rst:114

msgid "Core Language"

msgstr ""

#: faq/programming.rst:119

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

msgstr ""

#: faq/programming.rst:121

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:125

msgid "This code:"

msgstr ""

#: faq/programming.rst:134

msgid "works, but this code:"

msgstr ""

#: faq/programming.rst:141

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

msgstr ""

#: faq/programming.rst:148

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:155

msgid ""

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

"global:"

msgstr ""

#: faq/programming.rst:167

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:174

msgid ""

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

"keyword:"

msgstr ""

#: faq/programming.rst:192

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

msgstr ""

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

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

#: faq/programming.rst:208

msgid ""

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

"result?"

msgstr ""

#: faq/programming.rst:210

msgid ""

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

"functions), e.g.::"

msgstr ""

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

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

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

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

#: faq/programming.rst:255

msgid ""

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

"functions too."

msgstr ""

#: faq/programming.rst:260

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

msgstr ""

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

#: faq/programming.rst:268

msgid "config.py::"

msgstr ""

#: faq/programming.rst:272

msgid "mod.py::"

msgstr ""

#: faq/programming.rst:277

msgid "main.py::"

msgstr ""

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

#: faq/programming.rst:288

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

msgstr ""

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

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

#: faq/programming.rst:299

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

msgstr ""

#: faq/programming.rst:301

msgid ""

"standard library modules -- e.g. :mod:`sys`, :mod:`os`, :mod:`argparse`, :"

"mod:`re`"

msgstr ""

#: faq/programming.rst:302

msgid ""

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

"directory) -- e.g. :mod:`!dateutil`, :mod:`!requests`, :mod:`!PIL.Image`"

msgstr ""

#: faq/programming.rst:304

msgid "locally developed modules"

msgstr ""

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

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

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

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

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

#: faq/programming.rst:338

msgid "Why are default values shared between objects?"

msgstr ""

#: faq/programming.rst:340

msgid ""

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

"function::"

msgstr ""

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

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

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

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

#: faq/programming.rst:368

msgid "but::"

msgstr ""

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

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

#: faq/programming.rst:394

msgid ""

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

msgstr ""

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

#: faq/programming.rst:415

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

msgstr ""

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

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

"the function definition::"

msgstr ""

#: faq/programming.rst:426

msgid ""

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

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

msgstr ""

#: faq/programming.rst:431

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

msgstr ""

#: faq/programming.rst:435

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

msgstr ""

#: faq/programming.rst:437

msgid "If you wrote code like::"

msgstr ""

#: faq/programming.rst:447

msgid ""

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

msgstr ""

#: faq/programming.rst:449

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

msgstr ""

#: faq/programming.rst:451

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:455

msgid ""

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

msgstr ""

#: faq/programming.rst:457

msgid ""

"After the call to :meth:`!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:461

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

msgstr ""

#: faq/programming.rst:471

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:479

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:488

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:495

msgid "In other words:"

msgstr ""

#: faq/programming.rst:497

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

#: faq/programming.rst:500

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

#: faq/programming.rst:505

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:510

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

msgstr ""

#: faq/programming.rst:512

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

#: faq/programming.rst:517

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

msgstr ""

#: faq/programming.rst:528

msgid "This is almost always the clearest solution."

msgstr ""

#: faq/programming.rst:530

msgid ""

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

msgstr ""

#: faq/programming.rst:532

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

msgstr ""

#: faq/programming.rst:543

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

msgstr ""

#: faq/programming.rst:554

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

msgstr ""

#: faq/programming.rst:571

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

msgstr ""

#: faq/programming.rst:573

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

msgstr ""

#: faq/programming.rst:577

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

msgstr ""

#: faq/programming.rst:579

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:588

msgid "Or using a callable object::"

msgstr ""

#: faq/programming.rst:598

msgid "In both cases, ::"

msgstr ""

#: faq/programming.rst:602

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

msgstr ""

#: faq/programming.rst:604

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:613

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

msgstr ""

#: faq/programming.rst:631

msgid ""

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

"same counting variable."

msgstr ""

#: faq/programming.rst:636

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

msgstr ""

#: faq/programming.rst:638

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:641

msgid ""

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

"copy` method::"

msgstr ""

#: faq/programming.rst:646

msgid "Sequences can be copied by slicing::"

msgstr ""

#: faq/programming.rst:652

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

msgstr ""

#: faq/programming.rst:654

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

msgstr ""

#: faq/programming.rst:660

msgid "How can my code discover the name of an object?"

msgstr ""

#: faq/programming.rst:662

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

#: faq/programming.rst:678

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

#: faq/programming.rst:683

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

#: faq/programming.rst:688

msgid ""

"In comp.lang.python, Fredrik Lundh once gave an excellent analogy in answer "

"to this question:"

msgstr ""

#: faq/programming.rst:691

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

#: faq/programming.rst:696

msgid ""

"....and don't be surprised if you'll find that it's known by many names, or "

"no name at all!"

msgstr ""

#: faq/programming.rst:701

msgid "What's up with the comma operator's precedence?"

msgstr ""

#: faq/programming.rst:703

msgid "Comma is not an operator in Python. Consider this session::"

msgstr ""

#: faq/programming.rst:708

msgid ""

"Since the comma is not an operator, but a separator between expressions the "

"above is evaluated as if you had entered::"

msgstr ""

#: faq/programming.rst:713

msgid "not::"

msgstr ""

#: faq/programming.rst:717

msgid ""

"The same is true of the various assignment operators (``=``, ``+=`` etc). "

"They are not truly operators but syntactic delimiters in assignment "

"statements."

msgstr ""

#: faq/programming.rst:722

msgid "Is there an equivalent of C's \"?:\" ternary operator?"

msgstr ""

#: faq/programming.rst:724

msgid "Yes, there is. The syntax is as follows::"

msgstr ""

#: faq/programming.rst:731

msgid ""

"Before this syntax was introduced in Python 2.5, a common idiom was to use "

"logical operators::"

msgstr ""

#: faq/programming.rst:736

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

#: faq/programming.rst:742

msgid "Is it possible to write obfuscated one-liners in Python?"

msgstr ""

#: faq/programming.rst:744

msgid ""

"Yes. Usually this is done by nesting :keyword:`lambda` within :keyword:`!"

"lambda`. See the following three examples, slightly adapted from Ulf "

"Bartelt::"

msgstr ""

#: faq/programming.rst:771

msgid "Don't try this at home, kids!"

msgstr ""

#: faq/programming.rst:777

msgid "What does the slash(/) in the parameter list of a function mean?"

msgstr ""

#: faq/programming.rst:779

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:`divmod` is a function that accepts positional-"

"only parameters. Its documentation looks like this::"

msgstr ""

#: faq/programming.rst:792

msgid ""

"The slash at the end of the parameter list means that both parameters are "

"positional-only. Thus, calling :func:`divmod` with keyword arguments would "

"lead to an error::"

msgstr ""

#: faq/programming.rst:803

msgid "Numbers and strings"

msgstr ""

#: faq/programming.rst:806

msgid "How do I specify hexadecimal and octal integers?"

msgstr ""

#: faq/programming.rst:808

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

#: faq/programming.rst:816

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

#: faq/programming.rst:829

msgid "Why does -22 // 10 return -3?"

msgstr ""

#: faq/programming.rst:831

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

#: faq/programming.rst:836

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

#: faq/programming.rst:840

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

#: faq/programming.rst:848

msgid "How do I get int literal attribute instead of SyntaxError?"

msgstr ""

#: faq/programming.rst:850

msgid ""

"Trying to lookup an ``int`` literal attribute in the normal manner gives a :"

"exc:`SyntaxError` because the period is seen as a decimal point::"

msgstr ""

#: faq/programming.rst:859

msgid ""

"The solution is to separate the literal from the period with either a space "

"or parentheses."

msgstr ""

#: faq/programming.rst:869

msgid "How do I convert a string to a number?"

msgstr ""

#: faq/programming.rst:871

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

#: faq/programming.rst:875

msgid ""

"By default, these interpret the number as decimal, so that ``int('0144') == "

"144`` holds true, 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 ""

#: faq/programming.rst:882

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

#: faq/programming.rst:889

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

#: faq/programming.rst:895

msgid "How do I convert a number to a string?"

msgstr ""

#: faq/programming.rst:897