python-docs-fr/functions.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 1990-2015, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.5\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2016-01-20 22:37+0100\n"
"PO-Revision-Date: 2016-01-20 23:51+0100\n"
"Last-Translator: \n"
"Language-Team: \n"
"Language: fr\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"
"X-Generator: Poedit 1.8.6\n"

#: library/abc.rst:329 library/cgi.rst:533 library/chunk.rst:130
#: library/configparser.rst:1308 library/csv.rst:530 library/datetime.rst:1974
#: library/doctest.rst:1835 library/email.rst:385 library/email-examples.rst:74
#: library/email.encoders.rst:58 library/email.generator.rst:231
#: library/email.parser.rst:304 library/email.util.rst:206
#: library/functions.rst:1588 library/gettext.rst:651 library/heapq.rst:298
#: library/html.entities.rst:45 library/json.rst:690 library/marshal.rst:113
#: library/pdb.rst:511 library/pickle.rst:903 library/pyexpat.rst:867
#: library/sqlite3.rst:944 library/stdtypes.rst:4611 library/time.rst:691
#: library/unicodedata.rst:168 library/webbrowser.rst:210
#: library/xml.dom.minidom.rst:249 library/xml.etree.elementtree.rst:1189
#: library/xmlrpc.client.rst:578
msgid "Footnotes"
msgstr "Notes"

#: library/array.rst:20 library/functions.rst:901 library/stdtypes.rst:3274
#: library/string.rst:405
msgid "``'b'``"
msgstr "``'b'``"

#: library/codecs.rst:289 library/codecs.rst:304 library/codecs.rst:337
#: library/curses.rst:1274 library/curses.rst:1526 library/curses.ascii.rst:15
#: library/datetime.rst:1809 library/dbm.rst:44 library/dbm.rst:153
#: library/dbm.rst:172 library/dbm.rst:265 library/difflib.rst:65
#: library/difflib.rst:488 library/fnmatch.rst:21 library/functions.rst:895
#: library/grp.rst:17 library/inspect.rst:661 library/locale.rst:61
#: library/mailbox.rst:813 library/mailbox.rst:980 library/mailbox.rst:1350
#: library/profile.rst:372 library/pwd.rst:17 library/select.rst:269
#: library/select.rst:373 library/select.rst:489 library/select.rst:518
#: library/select.rst:549 library/select.rst:557 library/select.rst:577
#: library/select.rst:600 library/selectors.rst:57 library/spwd.rst:20
#: library/stdtypes.rst:148 library/stdtypes.rst:2121 library/stdtypes.rst:2144
#: library/stdtypes.rst:3218 library/stdtypes.rst:3241 library/string.rst:316
#: library/string.rst:341 library/string.rst:392 library/string.rst:403
#: library/string.rst:435 library/sys.rst:556 library/time.rst:375
#: library/tkinter.rst:426 library/uuid.rst:66 library/winreg.rst:208
#: library/winreg.rst:315 library/winreg.rst:359
#: library/xml.etree.elementtree.rst:403 library/xmlrpc.client.rst:84
msgid "Meaning"
msgstr "Signification"

#: library/dbm.rst:46 library/dbm.rst:155 library/dbm.rst:267
#: library/functions.rst:897 library/stdtypes.rst:2177
#: library/stdtypes.rst:3284
msgid "``'r'``"
msgstr "``'r'``"

#: library/dbm.rst:49 library/dbm.rst:158 library/dbm.rst:270
#: library/functions.rst:898
msgid "``'w'``"
msgstr "``'w'``"

#: library/functions.rst:5 library/functions.rst:11
msgid "Built-in Functions"
msgstr "Fonctions Natives"

#: library/functions.rst:7
msgid ""
"The Python interpreter has a number of functions and types built into it "
"that are always available.  They are listed here in alphabetical order."
msgstr ""
"L'interpréteur Python propose quelques fonctions et types natifs qui sont "
"toujours disponibles. Ils sont listés ici par ordre alphabétique."

#: library/functions.rst:13 library/stdtypes.rst:295
msgid ":func:`abs`"
msgstr ":func:`abs`"

#: library/functions.rst:13
msgid "|func-dict|_"
msgstr "|func-dict|_"

#: library/functions.rst:13
msgid ":func:`help`"
msgstr ":func:`help`"

#: library/functions.rst:13
msgid ":func:`min`"
msgstr ":func:`min`"

#: library/functions.rst:13
msgid ":func:`setattr`"
msgstr ":func:`setattr`"

#: library/functions.rst:14
msgid ":func:`all`"
msgstr ":func:`all`"

#: library/functions.rst:14
msgid ":func:`dir`"
msgstr ":func:`dir`"

#: library/functions.rst:14
msgid ":func:`hex`"
msgstr ":func:`hex`"

#: library/functions.rst:14
msgid ":func:`next`"
msgstr ":func:`next`"

#: library/functions.rst:14
msgid ":func:`slice`"
msgstr ":func:`slice`"

#: library/functions.rst:15
msgid ":func:`any`"
msgstr ":func:`any`"

#: library/functions.rst:15 library/stdtypes.rst:309
msgid ":func:`divmod`"
msgstr ":func:`divmod`"

#: library/functions.rst:15
msgid ":func:`id`"
msgstr ":func:`id`"

#: library/functions.rst:15
msgid ":func:`object`"
msgstr ":func:`object`"

#: library/functions.rst:15
msgid ":func:`sorted`"
msgstr ":func:`sorted`"

#: library/functions.rst:16
msgid ":func:`ascii`"
msgstr ":func:`ascii`"

#: library/functions.rst:16
msgid ":func:`enumerate`"
msgstr ":func:`enumerate`"

#: library/functions.rst:16
msgid ":func:`input`"
msgstr ":func:`input`"

#: library/functions.rst:16
msgid ":func:`oct`"
msgstr ":func:`oct`"

#: library/functions.rst:16
msgid ":func:`staticmethod`"
msgstr ":func:`staticmethod`"

#: library/functions.rst:17
msgid ":func:`bin`"
msgstr ":func:`bin`"

#: library/functions.rst:17
msgid ":func:`eval`"
msgstr ":func:`eval`"

#: library/functions.rst:17 library/stdtypes.rst:298
msgid ":func:`int`"
msgstr ":func:`int`"

#: library/functions.rst:17
msgid ":func:`open`"
msgstr ":func:`open`"

#: library/functions.rst:17
msgid "|func-str|_"
msgstr "|func-str|_"

#: library/functions.rst:18
msgid ":func:`bool`"
msgstr ":func:`bool`"

#: library/functions.rst:18
msgid ":func:`exec`"
msgstr ":func:`exec`"

#: library/functions.rst:18
msgid ":func:`isinstance`"
msgstr ":func:`isinstance`"

#: library/functions.rst:18
msgid ":func:`ord`"
msgstr ":func:`ord`"

#: library/functions.rst:18
msgid ":func:`sum`"
msgstr ":func:`sum`"

#: library/functions.rst:19
msgid ":func:`bytearray`"
msgstr ":func:`bytearray`"

#: library/functions.rst:19
msgid ":func:`filter`"
msgstr ":func:`filter`"

#: library/functions.rst:19
msgid ":func:`issubclass`"
msgstr ":func:`issubclass`"

#: library/functions.rst:19 library/stdtypes.rst:311
msgid ":func:`pow`"
msgstr ":func:`pow`"

#: library/functions.rst:19
msgid ":func:`super`"
msgstr ":func:`super`"

#: library/functions.rst:20
msgid ":func:`bytes`"
msgstr ":func:`bytes`"

#: library/functions.rst:20 library/stdtypes.rst:300
msgid ":func:`float`"
msgstr ":func:`float`"

#: library/functions.rst:20
msgid ":func:`iter`"
msgstr ":func:`iter`"

#: library/functions.rst:20
msgid ":func:`print`"
msgstr ":func:`print`"

#: library/functions.rst:20
msgid "|func-tuple|_"
msgstr "|func-tuple|_"

#: library/functions.rst:21
msgid ":func:`callable`"
msgstr ":func:`callable`"

#: library/functions.rst:21
msgid ":func:`format`"
msgstr ":func:`format`"

#: library/functions.rst:21
msgid ":func:`len`"
msgstr ":func:`len`"

#: library/functions.rst:21
msgid ":func:`property`"
msgstr ":func:`property`"

#: library/functions.rst:21
msgid ":func:`type`"
msgstr ":func:`type`"

#: library/functions.rst:22
msgid ":func:`chr`"
msgstr ":func:`chr`"

#: library/functions.rst:22
msgid "|func-frozenset|_"
msgstr "|func-frozenset|_"

#: library/functions.rst:22
msgid "|func-list|_"
msgstr "|func-list|_"

#: library/functions.rst:22
msgid "|func-range|_"
msgstr "|func-range|_"

#: library/functions.rst:22
msgid ":func:`vars`"
msgstr ":func:`vars`"

#: library/functions.rst:23
msgid ":func:`classmethod`"
msgstr ":func:`classmethod`"

#: library/functions.rst:23
msgid ":func:`getattr`"
msgstr ":func:`getattr`"

#: library/functions.rst:23
msgid ":func:`locals`"
msgstr ":func:`locals`"

#: library/functions.rst:23
msgid ":func:`repr`"
msgstr ":func:`repr`"

#: library/functions.rst:23
msgid ":func:`zip`"
msgstr ":func:`zip`"

#: library/functions.rst:24
msgid ":func:`compile`"
msgstr ":func:`compile`"

#: library/functions.rst:24
msgid ":func:`globals`"
msgstr ":func:`globals`"

#: library/functions.rst:24
msgid ":func:`map`"
msgstr ":func:`map`"

#: library/functions.rst:24
msgid ":func:`reversed`"
msgstr ":func:`reversed`"

#: library/functions.rst:24
msgid ":func:`__import__`"
msgstr ":func:`__import__`"

#: library/functions.rst:25 library/stdtypes.rst:302
msgid ":func:`complex`"
msgstr ":func:`complex`"

#: library/functions.rst:25
msgid ":func:`hasattr`"
msgstr ":func:`hasattr`"

#: library/functions.rst:25
msgid ":func:`max`"
msgstr ":func:`max`"

#: library/functions.rst:25
msgid ":func:`round`"
msgstr ":func:`round`"

#: library/functions.rst:26
msgid ":func:`delattr`"
msgstr ":func:`delattr`"

#: library/functions.rst:26
msgid ":func:`hash`"
msgstr ":func:`hash`"

#: library/functions.rst:26
msgid "|func-memoryview|_"
msgstr "|func-memoryview|_"

#: library/functions.rst:26
msgid "|func-set|_"
msgstr "|func-set|_"

#: library/functions.rst:44
msgid ""
"Return the absolute value of a number.  The argument may be an integer or a "
"floating point number.  If the argument is a complex number, its magnitude "
"is returned."
msgstr ""
"Donne la valeur absolue d'un nombre. L'argument peut être un nombre entier "
"ou un nombre à virgule flottante. Si l'argument est un nombre complexe, son "
"`module <https://fr.wikipedia.org/wiki/Module_d%27un_nombre_complexe>` est "
"donné."

#: library/functions.rst:51
msgid ""
"Return ``True`` if all elements of the *iterable* are true (or if the "
"iterable is empty).  Equivalent to::"
msgstr ""
"Donne ``True` si tous les éléments de *iterable* sont vrais (ou s'il est "
"vide), équivaut à ::"

#: library/functions.rst:63
msgid ""
"Return ``True`` if any element of the *iterable* is true.  If the iterable "
"is empty, return ``False``.  Equivalent to::"
msgstr ""
"Donne ``True`` si au moins un élément de *iterable* est vrai. Faux est donné "
"dans le cas d'un itérable vide, équivaut à ::"

#: library/functions.rst:75
msgid ""
"As :func:`repr`, return a string containing a printable representation of an "
"object, but escape the non-ASCII characters in the string returned by :func:"
"`repr` using ``\\x``, ``\\u`` or ``\\U`` escapes.  This generates a string "
"similar to that returned by :func:`repr` in Python 2."
msgstr ""
"Donne, tout comme :func:`repr`, une chaîne contenant une représentation "
"affichable d'un objet, entransformant les caractères non-ASCII donnés par :"
"func:`repr` en utilisant des séquences d'échappement ``\\x``, ``\\u`` ou ``"
"\\U``. Cela peut ressembler à ce que donnait :func:`repr` en Python 2."

#: library/functions.rst:83
msgid ""
"Convert an integer number to a binary string. The result is a valid Python "
"expression.  If *x* is not a Python :class:`int` object, it has to define "
"an :meth:`__index__` method that returns an integer."
msgstr ""
"Convertit un nombre entier en binaire dans une chaîne. Le résultat est une "
"expression Python valide. Si *x* n'est pas un :class:`int`, il doit définir "
"une méthode :meth:`__index__`` donnant un nombre entier."

#: library/functions.rst:90
msgid ""
"Return a Boolean value, i.e. one of ``True`` or ``False``.  *x* is converted "
"using the standard :ref:`truth testing procedure <truth>`.  If *x* is false "
"or omitted, this returns ``False``; otherwise it returns ``True``.  The :"
"class:`bool` class is a subclass of :class:`int` (see :ref:`typesnumeric`). "
"It cannot be subclassed further.  Its only instances are ``False`` and "
"``True`` (see :ref:`bltin-boolean-values`)."
msgstr ""
"Donne une valeur booléenne, c'est à dire soit ``True``, soit ``False``. *x* "
"est converti en utilisant la :ref:`procédure standard d'évaluation de valeur "
"de vérité<truth>`. Si *x* est faux, ou omis, elle donne ``False``, sinon, "
"elle donne ``True``. La :class:`bool` hérite de :class:`int` (voir :ref:"
"`typesnumeric`). Il n'est pas possible d'en hériter. Ses seules instances "
"sont ``False`` et ``True``(voir :ref:`bltin-boolean-values`)."

#: library/functions.rst:103
msgid ""
"Return a new array of bytes.  The :class:`bytearray` class is a mutable "
"sequence of integers in the range 0 <= x < 256.  It has most of the usual "
"methods of mutable sequences, described in :ref:`typesseq-mutable`, as well "
"as most methods that the :class:`bytes` type has, see :ref:`bytes-methods`."
msgstr ""
"Donne un nouvel array de *bytes*. La classe :class:`bytearray` est une "
"séquence variable de nombre entiers dans l'intervalle 0 <= x < 256. Il "
"possède la plupart des méthodes des séquences variables, décrites dans :ref:"
"`typesseq-mutable`, ainsi que la plupart des méthodes de la classe :class:"
"bytes`, voir :ref:`bytes-methods`."

#: library/functions.rst:108
msgid ""
"The optional *source* parameter can be used to initialize the array in a few "
"different ways:"
msgstr ""
"Le paramètre optionnel *source* peut être utilisé pour initialiser l'*array* "
"de quelques manières différentes :"

#: library/functions.rst:111
msgid ""
"If it is a *string*, you must also give the *encoding* (and optionally, "
"*errors*) parameters; :func:`bytearray` then converts the string to bytes "
"using :meth:`str.encode`."
msgstr ""
"Si c'est une *chaîne*, vous devez aussi donner les paramètre *encoding* pour "
"l'encodage (et éventuellement *errors*). La fonction :func:`bytearray` "
"convertis ensuite la chaîne en *bytes* via la méthode :meth:`str.encode`."

#: library/functions.rst:115
msgid ""
"If it is an *integer*, the array will have that size and will be initialized "
"with null bytes."
msgstr ""
"Si c'est un *entier*, l'*array* aura cette taille et sera initialisé de "
"*null bytes*."

#: library/functions.rst:118
msgid ""
"If it is an object conforming to the *buffer* interface, a read-only buffer "
"of the object will be used to initialize the bytes array."
msgstr ""
"Si c'est un objet conforme à l'interface *buffer*, un *buffer* en lecture "
"seule de l'objet sera utilisé pour initialiser l'*array*."

#: library/functions.rst:121
msgid ""
"If it is an *iterable*, it must be an iterable of integers in the range ``0 "
"<= x < 256``, which are used as the initial contents of the array."
msgstr ""
"Si c'est un *itérable*, il doit itérer sur des nombres entier dans "
"l'intervalle ``0 <= x < 256``, qui seront utilisés pour initialiser le "
"contenu de l'*array*."

#: library/functions.rst:124
msgid "Without an argument, an array of size 0 is created."
msgstr "Sans argument, un *array* de taille vide est crée."

#: library/functions.rst:126
msgid "See also :ref:`binaryseq` and :ref:`typebytearray`."
msgstr ""

#: library/functions.rst:132
msgid ""
"Return a new \"bytes\" object, which is an immutable sequence of integers in "
"the range ``0 <= x < 256``.  :class:`bytes` is an immutable version of :"
"class:`bytearray` -- it has the same non-mutating methods and the same "
"indexing and slicing behavior."
msgstr ""

#: library/functions.rst:137
msgid ""
"Accordingly, constructor arguments are interpreted as for :func:`bytearray`."
msgstr ""

#: library/functions.rst:139
msgid "Bytes objects can also be created with literals, see :ref:`strings`."
msgstr ""

#: library/functions.rst:141
msgid "See also :ref:`binaryseq`, :ref:`typebytes`, and :ref:`bytes-methods`."
msgstr ""

#: library/functions.rst:146
msgid ""
"Return :const:`True` if the *object* argument appears callable, :const:"
"`False` if not.  If this returns true, it is still possible that a call "
"fails, but if it is false, calling *object* will never succeed. Note that "
"classes are callable (calling a class returns a new instance); instances are "
"callable if their class has a :meth:`__call__` method."
msgstr ""

#: library/functions.rst:152
msgid ""
"This function was first removed in Python 3.0 and then brought back in "
"Python 3.2."
msgstr ""

#: library/functions.rst:159
msgid ""
"Return the string representing a character whose Unicode code point is the "
"integer *i*.  For example, ``chr(97)`` returns the string ``'a'``, while "
"``chr(957)`` returns the string ``'ν'``. This is the inverse of :func:`ord`."
msgstr ""

#: library/functions.rst:163
msgid ""
"The valid range for the argument is from 0 through 1,114,111 (0x10FFFF in "
"base 16).  :exc:`ValueError` will be raised if *i* is outside that range."
msgstr ""

#: library/functions.rst:169
msgid "Return a class method for *function*."
msgstr ""

#: library/functions.rst:171
msgid ""
"A class method receives the class as implicit first argument, just like an "
"instance method receives the instance. To declare a class method, use this "
"idiom::"
msgstr ""

#: library/functions.rst:179
msgid ""
"The ``@classmethod`` form is a function :term:`decorator` -- see the "
"description of function definitions in :ref:`function` for details."
msgstr ""

#: library/functions.rst:182
msgid ""
"It can be called either on the class (such as ``C.f()``) or on an instance "
"(such as ``C().f()``).  The instance is ignored except for its class. If a "
"class method is called for a derived class, the derived class object is "
"passed as the implied first argument."
msgstr ""

#: library/functions.rst:187
msgid ""
"Class methods are different than C++ or Java static methods. If you want "
"those, see :func:`staticmethod` in this section."
msgstr ""

#: library/functions.rst:190
msgid ""
"For more information on class methods, consult the documentation on the "
"standard type hierarchy in :ref:`types`."
msgstr ""

#: library/functions.rst:196
msgid ""
"Compile the *source* into a code or AST object.  Code objects can be "
"executed by :func:`exec` or :func:`eval`.  *source* can either be a normal "
"string, a byte string, or an AST object.  Refer to the :mod:`ast` module "
"documentation for information on how to work with AST objects."
msgstr ""

#: library/functions.rst:201
msgid ""
"The *filename* argument should give the file from which the code was read; "
"pass some recognizable value if it wasn't read from a file (``'<string>'`` "
"is commonly used)."
msgstr ""

#: library/functions.rst:205
msgid ""
"The *mode* argument specifies what kind of code must be compiled; it can be "
"``'exec'`` if *source* consists of a sequence of statements, ``'eval'`` if "
"it consists of a single expression, or ``'single'`` if it consists of a "
"single interactive statement (in the latter case, expression statements that "
"evaluate to something other than ``None`` will be printed)."
msgstr ""

#: library/functions.rst:211
msgid ""
"The optional arguments *flags* and *dont_inherit* control which future "
"statements (see :pep:`236`) affect the compilation of *source*.  If neither "
"is present (or both are zero) the code is compiled with those future "
"statements that are in effect in the code that is calling :func:`compile`.  "
"If the *flags* argument is given and *dont_inherit* is not (or is zero) then "
"the future statements specified by the *flags* argument are used in addition "
"to those that would be used anyway. If *dont_inherit* is a non-zero integer "
"then the *flags* argument is it -- the future statements in effect around "
"the call to compile are ignored."
msgstr ""

#: library/functions.rst:221
msgid ""
"Future statements are specified by bits which can be bitwise ORed together "
"to specify multiple statements.  The bitfield required to specify a given "
"feature can be found as the :attr:`~__future__._Feature.compiler_flag` "
"attribute on the :class:`~__future__._Feature` instance in the :mod:"
"`__future__` module."
msgstr ""

#: library/functions.rst:226
msgid ""
"The argument *optimize* specifies the optimization level of the compiler; "
"the default value of ``-1`` selects the optimization level of the "
"interpreter as given by :option:`-O` options.  Explicit levels are ``0`` (no "
"optimization; ``__debug__`` is true), ``1`` (asserts are removed, "
"``__debug__`` is false) or ``2`` (docstrings are removed too)."
msgstr ""

#: library/functions.rst:232
msgid ""
"This function raises :exc:`SyntaxError` if the compiled source is invalid, "
"and :exc:`TypeError` if the source contains null bytes."
msgstr ""

#: library/functions.rst:235
msgid ""
"If you want to parse Python code into its AST representation, see :func:`ast."
"parse`."
msgstr ""

#: library/functions.rst:240
msgid ""
"When compiling a string with multi-line code in ``'single'`` or ``'eval'`` "
"mode, input must be terminated by at least one newline character.  This is "
"to facilitate detection of incomplete and complete statements in the :mod:"
"`code` module."
msgstr ""

#: library/functions.rst:245
msgid ""
"Allowed use of Windows and Mac newlines.  Also input in ``'exec'`` mode does "
"not have to end in a newline anymore.  Added the *optimize* parameter."
msgstr ""

#: library/functions.rst:252
msgid ""
"Return a complex number with the value *real* + *imag*\\*1j or convert a "
"string or number to a complex number.  If the first parameter is a string, "
"it will be interpreted as a complex number and the function must be called "
"without a second parameter.  The second parameter can never be a string. "
"Each argument may be any numeric type (including complex).  If *imag* is "
"omitted, it defaults to zero and the constructor serves as a numeric "
"conversion like :class:`int` and :class:`float`.  If both arguments are "
"omitted, returns ``0j``."
msgstr ""

#: library/functions.rst:263
msgid ""
"When converting from a string, the string must not contain whitespace around "
"the central ``+`` or ``-`` operator.  For example, ``complex('1+2j')`` is "
"fine, but ``complex('1 + 2j')`` raises :exc:`ValueError`."
msgstr ""

#: library/functions.rst:268
msgid "The complex type is described in :ref:`typesnumeric`."
msgstr ""

#: library/functions.rst:273
msgid ""
"This is a relative of :func:`setattr`.  The arguments are an object and a "
"string.  The string must be the name of one of the object's attributes.  The "
"function deletes the named attribute, provided the object allows it.  For "
"example, ``delattr(x, 'foobar')`` is equivalent to ``del x.foobar``."
msgstr ""

#: library/functions.rst:285
msgid ""
"Create a new dictionary.  The :class:`dict` object is the dictionary class. "
"See :class:`dict` and :ref:`typesmapping` for documentation about this class."
msgstr ""

#: library/functions.rst:288
msgid ""
"For other containers see the built-in :class:`list`, :class:`set`, and :"
"class:`tuple` classes, as well as the :mod:`collections` module."
msgstr ""

#: library/functions.rst:294
msgid ""
"Without arguments, return the list of names in the current local scope.  "
"With an argument, attempt to return a list of valid attributes for that "
"object."
msgstr ""

#: library/functions.rst:297
msgid ""
"If the object has a method named :meth:`__dir__`, this method will be called "
"and must return the list of attributes. This allows objects that implement a "
"custom :func:`__getattr__` or :func:`__getattribute__` function to customize "
"the way :func:`dir` reports their attributes."
msgstr ""

#: library/functions.rst:302
msgid ""
"If the object does not provide :meth:`__dir__`, the function tries its best "
"to gather information from the object's :attr:`__dict__` attribute, if "
"defined, and from its type object.  The resulting list is not necessarily "
"complete, and may be inaccurate when the object has a custom :func:"
"`__getattr__`."
msgstr ""

#: library/functions.rst:307
msgid ""
"The default :func:`dir` mechanism behaves differently with different types "
"of objects, as it attempts to produce the most relevant, rather than "
"complete, information:"
msgstr ""

#: library/functions.rst:311
msgid ""
"If the object is a module object, the list contains the names of the "
"module's attributes."
msgstr ""

#: library/functions.rst:314
msgid ""
"If the object is a type or class object, the list contains the names of its "
"attributes, and recursively of the attributes of its bases."
msgstr ""

#: library/functions.rst:317
msgid ""
"Otherwise, the list contains the object's attributes' names, the names of "
"its class's attributes, and recursively of the attributes of its class's "
"base classes."
msgstr ""

#: library/functions.rst:321
msgid "The resulting list is sorted alphabetically.  For example:"
msgstr ""

#: library/functions.rst:340
msgid ""
"Because :func:`dir` is supplied primarily as a convenience for use at an "
"interactive prompt, it tries to supply an interesting set of names more than "
"it tries to supply a rigorously or consistently defined set of names, and "
"its detailed behavior may change across releases.  For example, metaclass "
"attributes are not in the result list when the argument is a class."
msgstr ""

#: library/functions.rst:350
msgid ""
"Take two (non complex) numbers as arguments and return a pair of numbers "
"consisting of their quotient and remainder when using integer division.  "
"With mixed operand types, the rules for binary arithmetic operators apply.  "
"For integers, the result is the same as ``(a // b, a % b)``. For floating "
"point numbers the result is ``(q, a % b)``, where *q* is usually ``math."
"floor(a / b)`` but may be 1 less than that.  In any case ``q * b + a % b`` "
"is very close to *a*, if ``a % b`` is non-zero it has the same sign as *b*, "
"and ``0 <= abs(a % b) < abs(b)``."
msgstr ""

#: library/functions.rst:362
msgid ""
"Return an enumerate object. *iterable* must be a sequence, an :term:"
"`iterator`, or some other object which supports iteration. The :meth:"
"`~iterator.__next__` method of the iterator returned by :func:`enumerate` "
"returns a tuple containing a count (from *start* which defaults to 0) and "
"the values obtained from iterating over *iterable*."
msgstr ""

#: library/functions.rst:374 library/itertools.rst:100
#: library/itertools.rst:192 library/itertools.rst:241
#: library/itertools.rst:467 library/operator.rst:269 library/operator.rst:301
#: library/operator.rst:347 library/stdtypes.rst:465
msgid "Equivalent to::"
msgstr ""

#: library/functions.rst:385
msgid ""
"The arguments are a string and optional globals and locals.  If provided, "
"*globals* must be a dictionary.  If provided, *locals* can be any mapping "
"object."
msgstr ""

#: library/functions.rst:389
msgid ""
"The *expression* argument is parsed and evaluated as a Python expression "
"(technically speaking, a condition list) using the *globals* and *locals* "
"dictionaries as global and local namespace.  If the *globals* dictionary is "
"present and lacks '__builtins__', the current globals are copied into "
"*globals* before *expression* is parsed.  This means that *expression* "
"normally has full access to the standard :mod:`builtins` module and "
"restricted environments are propagated.  If the *locals* dictionary is "
"omitted it defaults to the *globals* dictionary.  If both dictionaries are "
"omitted, the expression is executed in the environment where :func:`eval` is "
"called.  The return value is the result of the evaluated expression. Syntax "
"errors are reported as exceptions.  Example:"
msgstr ""

#: library/functions.rst:404
msgid ""
"This function can also be used to execute arbitrary code objects (such as "
"those created by :func:`compile`).  In this case pass a code object instead "
"of a string.  If the code object has been compiled with ``'exec'`` as the "
"*mode* argument, :func:`eval`\\'s return value will be ``None``."
msgstr ""

#: library/functions.rst:409
msgid ""
"Hints: dynamic execution of statements is supported by the :func:`exec` "
"function.  The :func:`globals` and :func:`locals` functions returns the "
"current global and local dictionary, respectively, which may be useful to "
"pass around for use by :func:`eval` or :func:`exec`."
msgstr ""

#: library/functions.rst:414
msgid ""
"See :func:`ast.literal_eval` for a function that can safely evaluate strings "
"with expressions containing only literals."
msgstr ""

#: library/functions.rst:421
msgid ""
"This function supports dynamic execution of Python code. *object* must be "
"either a string or a code object.  If it is a string, the string is parsed "
"as a suite of Python statements which is then executed (unless a syntax "
"error occurs). [#]_ If it is a code object, it is simply executed.  In all "
"cases, the code that's executed is expected to be valid as file input (see "
"the section \"File input\" in the Reference Manual). Be aware that the :"
"keyword:`return` and :keyword:`yield` statements may not be used outside of "
"function definitions even within the context of code passed to the :func:"
"`exec` function. The return value is ``None``."
msgstr ""

#: library/functions.rst:431
msgid ""
"In all cases, if the optional parts are omitted, the code is executed in the "
"current scope.  If only *globals* is provided, it must be a dictionary, "
"which will be used for both the global and the local variables.  If "
"*globals* and *locals* are given, they are used for the global and local "
"variables, respectively.  If provided, *locals* can be any mapping object.  "
"Remember that at module level, globals and locals are the same dictionary. "
"If exec gets two separate objects as *globals* and *locals*, the code will "
"be executed as if it were embedded in a class definition."
msgstr ""

#: library/functions.rst:440
msgid ""
"If the *globals* dictionary does not contain a value for the key "
"``__builtins__``, a reference to the dictionary of the built-in module :mod:"
"`builtins` is inserted under that key.  That way you can control what "
"builtins are available to the executed code by inserting your own "
"``__builtins__`` dictionary into *globals* before passing it to :func:`exec`."
msgstr ""

#: library/functions.rst:448
msgid ""
"The built-in functions :func:`globals` and :func:`locals` return the current "
"global and local dictionary, respectively, which may be useful to pass "
"around for use as the second and third argument to :func:`exec`."
msgstr ""

#: library/functions.rst:454
msgid ""
"The default *locals* act as described for function :func:`locals` below: "
"modifications to the default *locals* dictionary should not be attempted. "
"Pass an explicit *locals* dictionary if you need to see effects of the code "
"on *locals* after function :func:`exec` returns."
msgstr ""

#: library/functions.rst:462
msgid ""
"Construct an iterator from those elements of *iterable* for which *function* "
"returns true.  *iterable* may be either a sequence, a container which "
"supports iteration, or an iterator.  If *function* is ``None``, the identity "
"function is assumed, that is, all elements of *iterable* that are false are "
"removed."
msgstr ""

#: library/functions.rst:468
msgid ""
"Note that ``filter(function, iterable)`` is equivalent to the generator "
"expression ``(item for item in iterable if function(item))`` if function is "
"not ``None`` and ``(item for item in iterable if item)`` if function is "
"``None``."
msgstr ""

#: library/functions.rst:473
msgid ""
"See :func:`itertools.filterfalse` for the complementary function that "
"returns elements of *iterable* for which *function* returns false."
msgstr ""

#: library/functions.rst:483
msgid "Return a floating point number constructed from a number or string *x*."
msgstr ""

#: library/functions.rst:485
msgid ""
"If the argument is a string, it should contain a decimal number, optionally "
"preceded by a sign, and optionally embedded in whitespace.  The optional "
"sign may be ``'+'`` or ``'-'``; a ``'+'`` sign has no effect on the value "
"produced.  The argument may also be a string representing a NaN (not-a-"
"number), or a positive or negative infinity.  More precisely, the input must "
"conform to the following grammar after leading and trailing whitespace "
"characters are removed:"
msgstr ""

#: library/functions.rst:500
msgid ""
"Here ``floatnumber`` is the form of a Python floating-point literal, "
"described in :ref:`floating`.  Case is not significant, so, for example, "
"\"inf\", \"Inf\", \"INFINITY\" and \"iNfINity\" are all acceptable spellings "
"for positive infinity."
msgstr ""

#: library/functions.rst:505
msgid ""
"Otherwise, if the argument is an integer or a floating point number, a "
"floating point number with the same value (within Python's floating point "
"precision) is returned.  If the argument is outside the range of a Python "
"float, an :exc:`OverflowError` will be raised."
msgstr ""

#: library/functions.rst:510
msgid ""
"For a general Python object ``x``, ``float(x)`` delegates to ``x."
"__float__()``."
msgstr ""

#: library/functions.rst:513
msgid "If no argument is given, ``0.0`` is returned."
msgstr ""

#: library/functions.rst:515 library/pkgutil.rst:180 library/subprocess.rst:68
msgid "Examples::"
msgstr "Exemples ::"

#: library/functions.rst:528
msgid "The float type is described in :ref:`typesnumeric`."
msgstr ""

#: library/functions.rst:537
msgid ""
"Convert a *value* to a \"formatted\" representation, as controlled by "
"*format_spec*.  The interpretation of *format_spec* will depend on the type "
"of the *value* argument, however there is a standard formatting syntax that "
"is used by most built-in types: :ref:`formatspec`."
msgstr ""

#: library/functions.rst:542
msgid ""
"The default *format_spec* is an empty string which usually gives the same "
"effect as calling :func:`str(value) <str>`."
msgstr ""

#: library/functions.rst:545
msgid ""
"A call to ``format(value, format_spec)`` is translated to ``type(value)."
"__format__(value, format_spec)`` which bypasses the instance dictionary when "
"searching for the value's :meth:`__format__` method.  A :exc:`TypeError` "
"exception is raised if the method search reaches :mod:`object` and the "
"*format_spec* is non-empty, or if either the *format_spec* or the return "
"value are not strings."
msgstr ""

#: library/functions.rst:552
msgid ""
"``object().__format__(format_spec)`` raises :exc:`TypeError` if "
"*format_spec* is not an empty string."
msgstr ""

#: library/functions.rst:561
msgid ""
"Return a new :class:`frozenset` object, optionally with elements taken from "
"*iterable*.  ``frozenset`` is a built-in class.  See :class:`frozenset` and :"
"ref:`types-set` for documentation about this class."
msgstr ""

#: library/functions.rst:565
msgid ""
"For other containers see the built-in :class:`set`, :class:`list`, :class:"
"`tuple`, and :class:`dict` classes, as well as the :mod:`collections` module."
msgstr ""

#: library/functions.rst:572
msgid ""
"Return the value of the named attribute of *object*.  *name* must be a "
"string. If the string is the name of one of the object's attributes, the "
"result is the value of that attribute.  For example, ``getattr(x, "
"'foobar')`` is equivalent to ``x.foobar``.  If the named attribute does not "
"exist, *default* is returned if provided, otherwise :exc:`AttributeError` is "
"raised."
msgstr ""

#: library/functions.rst:581
msgid ""
"Return a dictionary representing the current global symbol table. This is "
"always the dictionary of the current module (inside a function or method, "
"this is the module where it is defined, not the module from which it is "
"called)."
msgstr ""

#: library/functions.rst:588
msgid ""
"The arguments are an object and a string.  The result is ``True`` if the "
"string is the name of one of the object's attributes, ``False`` if not. "
"(This is implemented by calling ``getattr(object, name)`` and seeing whether "
"it raises an :exc:`AttributeError` or not.)"
msgstr ""

#: library/functions.rst:596
msgid ""
"Return the hash value of the object (if it has one).  Hash values are "
"integers.  They are used to quickly compare dictionary keys during a "
"dictionary lookup.  Numeric values that compare equal have the same hash "
"value (even if they are of different types, as is the case for 1 and 1.0)."
msgstr ""

#: library/functions.rst:603
msgid ""
"For object's with custom :meth:`__hash__` methods, note that :func:`hash` "
"truncates the return value based on the bit width of the host machine. See :"
"meth:`__hash__` for details."
msgstr ""

#: library/functions.rst:609
msgid ""
"Invoke the built-in help system.  (This function is intended for interactive "
"use.)  If no argument is given, the interactive help system starts on the "
"interpreter console.  If the argument is a string, then the string is looked "
"up as the name of a module, function, class, method, keyword, or "
"documentation topic, and a help page is printed on the console.  If the "
"argument is any other kind of object, a help page on the object is generated."
msgstr ""

#: library/functions.rst:616
msgid ""
"This function is added to the built-in namespace by the :mod:`site` module."
msgstr ""

#: library/functions.rst:618
msgid ""
"Changes to :mod:`pydoc` and :mod:`inspect` mean that the reported signatures "
"for callables are now more comprehensive and consistent."
msgstr ""

#: library/functions.rst:625
msgid ""
"Convert an integer number to a lowercase hexadecimal string prefixed with "
"\"0x\", for example:"
msgstr ""

#: library/functions.rst:633
msgid ""
"If x is not a Python :class:`int` object, it has to define an __index__() "
"method that returns an integer."
msgstr ""

#: library/functions.rst:636
msgid ""
"See also :func:`int` for converting a hexadecimal string to an integer using "
"a base of 16."
msgstr ""

#: library/functions.rst:641
msgid ""
"To obtain a hexadecimal string representation for a float, use the :meth:"
"`float.hex` method."
msgstr ""

#: library/functions.rst:647
msgid ""
"Return the \"identity\" of an object.  This is an integer which is "
"guaranteed to be unique and constant for this object during its lifetime. "
"Two objects with non-overlapping lifetimes may have the same :func:`id` "
"value."
msgstr ""

#: library/functions.rst:657
msgid ""
"If the *prompt* argument is present, it is written to standard output "
"without a trailing newline.  The function then reads a line from input, "
"converts it to a string (stripping a trailing newline), and returns that.  "
"When EOF is read, :exc:`EOFError` is raised.  Example::"
msgstr ""

#: library/functions.rst:667
msgid ""
"If the :mod:`readline` module was loaded, then :func:`input` will use it to "
"provide elaborate line editing and history features."
msgstr ""

#: library/functions.rst:674
msgid ""
"Return an integer object constructed from a number or string *x*, or return "
"``0`` if no arguments are given.  If *x* is a number, return :meth:`x."
"__int__() <object.__int__>`.  For floating point numbers, this truncates "
"towards zero."
msgstr ""

#: library/functions.rst:679
msgid ""
"If *x* is not a number or if *base* is given, then *x* must be a string, :"
"class:`bytes`, or :class:`bytearray` instance representing an :ref:`integer "
"literal <integers>` in radix *base*.  Optionally, the literal can be "
"preceded by ``+`` or ``-`` (with no space in between) and surrounded by "
"whitespace.  A base-n literal consists of the digits 0 to n-1, with ``a`` to "
"``z`` (or ``A`` to ``Z``) having values 10 to 35.  The default *base* is 10. "
"The allowed values are 0 and 2-36. Base-2, -8, and -16 literals can be "
"optionally prefixed with ``0b``/``0B``, ``0o``/``0O``, or ``0x``/``0X``, as "
"with integer literals in code.  Base 0 means to interpret exactly as a code "
"literal, so that the actual base is 2, 8, 10, or 16, and so that "
"``int('010', 0)`` is not legal, while ``int('010')`` is, as well as "
"``int('010', 8)``."
msgstr ""

#: library/functions.rst:692
msgid "The integer type is described in :ref:`typesnumeric`."
msgstr ""

#: library/functions.rst:694
msgid ""
"If *base* is not an instance of :class:`int` and the *base* object has a :"
"meth:`base.__index__ <object.__index__>` method, that method is called to "
"obtain an integer for the base.  Previous versions used :meth:`base.__int__ "
"<object.__int__>` instead of :meth:`base.__index__ <object.__index__>`."
msgstr ""

#: library/functions.rst:703
msgid ""
"Return true if the *object* argument is an instance of the *classinfo* "
"argument, or of a (direct, indirect or :term:`virtual <abstract base "
"class>`) subclass thereof.  If *object* is not an object of the given type, "
"the function always returns false. If *classinfo* is a tuple of type objects "
"(or recursively, other such tuples), return true if *object* is an instance "
"of any of the types. If *classinfo* is not a type or tuple of types and such "
"tuples, a :exc:`TypeError` exception is raised."
msgstr ""

#: library/functions.rst:715
msgid ""
"Return true if *class* is a subclass (direct, indirect or :term:`virtual "
"<abstract base class>`) of *classinfo*.  A class is considered a subclass of "
"itself. *classinfo* may be a tuple of class objects, in which case every "
"entry in *classinfo* will be checked. In any other case, a :exc:`TypeError` "
"exception is raised."
msgstr ""

#: library/functions.rst:724
msgid ""
"Return an :term:`iterator` object.  The first argument is interpreted very "
"differently depending on the presence of the second argument. Without a "
"second argument, *object* must be a collection object which supports the "
"iteration protocol (the :meth:`__iter__` method), or it must support the "
"sequence protocol (the :meth:`__getitem__` method with integer arguments "
"starting at ``0``).  If it does not support either of those protocols, :exc:"
"`TypeError` is raised. If the second argument, *sentinel*, is given, then "
"*object* must be a callable object.  The iterator created in this case will "
"call *object* with no arguments for each call to its :meth:`~iterator."
"__next__` method; if the value returned is equal to *sentinel*, :exc:"
"`StopIteration` will be raised, otherwise the value will be returned."
msgstr ""

#: library/functions.rst:737
msgid "See also :ref:`typeiter`."
msgstr ""

#: library/functions.rst:739
msgid ""
"One useful application of the second form of :func:`iter` is to read lines "
"of a file until a certain line is reached.  The following example reads a "
"file until the :meth:`~io.TextIOBase.readline` method returns an empty "
"string::"
msgstr ""

#: library/functions.rst:750
msgid ""
"Return the length (the number of items) of an object.  The argument may be a "
"sequence (such as a string, bytes, tuple, list, or range) or a collection "
"(such as a dictionary, set, or frozen set)."
msgstr ""

#: library/functions.rst:759
msgid ""
"Rather than being a function, :class:`list` is actually a mutable sequence "
"type, as documented in :ref:`typesseq-list` and :ref:`typesseq`."
msgstr ""

#: library/functions.rst:765
msgid ""
"Update and return a dictionary representing the current local symbol table. "
"Free variables are returned by :func:`locals` when it is called in function "
"blocks, but not in class blocks."
msgstr ""

#: library/functions.rst:770
msgid ""
"The contents of this dictionary should not be modified; changes may not "
"affect the values of local and free variables used by the interpreter."
msgstr ""

#: library/functions.rst:775
msgid ""
"Return an iterator that applies *function* to every item of *iterable*, "
"yielding the results.  If additional *iterable* arguments are passed, "
"*function* must take that many arguments and is applied to the items from "
"all iterables in parallel.  With multiple iterables, the iterator stops when "
"the shortest iterable is exhausted.  For cases where the function inputs are "
"already arranged into argument tuples, see :func:`itertools.starmap`\\."
msgstr ""

#: library/functions.rst:786
msgid ""
"Return the largest item in an iterable or the largest of two or more "
"arguments."
msgstr ""

#: library/functions.rst:789
msgid ""
"If one positional argument is provided, it should be an :term:`iterable`. "
"The largest item in the iterable is returned.  If two or more positional "
"arguments are provided, the largest of the positional arguments is returned."
msgstr ""

#: library/functions.rst:794 library/functions.rst:828
msgid ""
"There are two optional keyword-only arguments. The *key* argument specifies "
"a one-argument ordering function like that used for :meth:`list.sort`. The "
"*default* argument specifies an object to return if the provided iterable is "
"empty. If the iterable is empty and *default* is not provided, a :exc:"
"`ValueError` is raised."
msgstr ""

#: library/functions.rst:800
msgid ""
"If multiple items are maximal, the function returns the first one "
"encountered.  This is consistent with other sort-stability preserving tools "
"such as ``sorted(iterable, key=keyfunc, reverse=True)[0]`` and ``heapq."
"nlargest(1, iterable, key=keyfunc)``."
msgstr ""

#: library/functions.rst:805 library/functions.rst:839
msgid "The *default* keyword-only argument."
msgstr ""

#: library/functions.rst:813
msgid ""
"Return a \"memory view\" object created from the given argument.  See :ref:"
"`typememoryview` for more information."
msgstr ""

#: library/functions.rst:820
msgid ""
"Return the smallest item in an iterable or the smallest of two or more "
"arguments."
msgstr ""

#: library/functions.rst:823
msgid ""
"If one positional argument is provided, it should be an :term:`iterable`. "
"The smallest item in the iterable is returned.  If two or more positional "
"arguments are provided, the smallest of the positional arguments is returned."
msgstr ""

#: library/functions.rst:834
msgid ""
"If multiple items are minimal, the function returns the first one "
"encountered.  This is consistent with other sort-stability preserving tools "
"such as ``sorted(iterable, key=keyfunc)[0]`` and ``heapq.nsmallest(1, "
"iterable, key=keyfunc)``."
msgstr ""

#: library/functions.rst:845
msgid ""
"Retrieve the next item from the *iterator* by calling its :meth:`~iterator."
"__next__` method.  If *default* is given, it is returned if the iterator is "
"exhausted, otherwise :exc:`StopIteration` is raised."
msgstr ""

#: library/functions.rst:852
msgid ""
"Return a new featureless object.  :class:`object` is a base for all classes. "
"It has the methods that are common to all instances of Python classes.  This "
"function does not accept any arguments."
msgstr ""

#: library/functions.rst:858
msgid ""
":class:`object` does *not* have a :attr:`~object.__dict__`, so you can't "
"assign arbitrary attributes to an instance of the :class:`object` class."
msgstr ""

#: library/functions.rst:864
msgid ""
"Convert an integer number to an octal string.  The result is a valid Python "
"expression.  If *x* is not a Python :class:`int` object, it has to define "
"an :meth:`__index__` method that returns an integer."
msgstr ""

#: library/functions.rst:874
msgid ""
"Open *file* and return a corresponding :term:`file object`.  If the file "
"cannot be opened, an :exc:`OSError` is raised."
msgstr ""

#: library/functions.rst:877
msgid ""
"*file* is either a string or bytes object giving the pathname (absolute or "
"relative to the current working directory) of the file to be opened or an "
"integer file descriptor of the file to be wrapped.  (If a file descriptor is "
"given, it is closed when the returned I/O object is closed, unless *closefd* "
"is set to ``False``.)"
msgstr ""

#: library/functions.rst:883
msgid ""
"*mode* is an optional string that specifies the mode in which the file is "
"opened.  It defaults to ``'r'`` which means open for reading in text mode. "
"Other common values are ``'w'`` for writing (truncating the file if it "
"already exists), ``'x'`` for exclusive creation and ``'a'`` for appending "
"(which on *some* Unix systems, means that *all* writes append to the end of "
"the file regardless of the current seek position).  In text mode, if "
"*encoding* is not specified the encoding used is platform dependent: "
"``locale.getpreferredencoding(False)`` is called to get the current locale "
"encoding. (For reading and writing raw bytes use binary mode and leave "
"*encoding* unspecified.)  The available modes are:"
msgstr ""

#: library/functions.rst:895 library/struct.rst:120
msgid "Character"
msgstr ""

#: library/functions.rst:897
msgid "open for reading (default)"
msgstr ""

#: library/functions.rst:898
msgid "open for writing, truncating the file first"
msgstr ""

#: library/functions.rst:899 library/stdtypes.rst:2154
#: library/stdtypes.rst:3251 library/string.rst:414
msgid "``'x'``"
msgstr "``'x'``"

#: library/functions.rst:899
msgid "open for exclusive creation, failing if the file already exists"
msgstr ""

#: library/functions.rst:900 library/stdtypes.rst:2183
#: library/stdtypes.rst:3281
msgid "``'a'``"
msgstr "``'a'``"

#: library/functions.rst:900
msgid "open for writing, appending to the end of the file if it exists"
msgstr ""

#: library/functions.rst:901
msgid "binary mode"
msgstr ""

#: library/functions.rst:902
msgid "``'t'``"
msgstr "``'t'``"

#: library/functions.rst:902
msgid "text mode (default)"
msgstr ""

#: library/functions.rst:903 library/stdtypes.rst:2134
#: library/stdtypes.rst:3231 library/string.rst:343
msgid "``'+'``"
msgstr "``'+'``"

#: library/functions.rst:903
msgid "open a disk file for updating (reading and writing)"
msgstr ""

#: library/functions.rst:904
msgid "``'U'``"
msgstr "``'U'``"

#: library/functions.rst:904
msgid ":term:`universal newlines` mode (deprecated)"
msgstr ""

#: library/functions.rst:907
msgid ""
"The default mode is ``'r'`` (open for reading text, synonym of ``'rt'``). "
"For binary read-write access, the mode ``'w+b'`` opens and truncates the "
"file to 0 bytes.  ``'r+b'`` opens the file without truncation."
msgstr ""

#: library/functions.rst:911
msgid ""
"As mentioned in the :ref:`io-overview`, Python distinguishes between binary "
"and text I/O.  Files opened in binary mode (including ``'b'`` in the *mode* "
"argument) return contents as :class:`bytes` objects without any decoding.  "
"In text mode (the default, or when ``'t'`` is included in the *mode* "
"argument), the contents of the file are returned as :class:`str`, the bytes "
"having been first decoded using a platform-dependent encoding or using the "
"specified *encoding* if given."
msgstr ""

#: library/functions.rst:921
msgid ""
"Python doesn't depend on the underlying operating system's notion of text "
"files; all the processing is done by Python itself, and is therefore "
"platform-independent."
msgstr ""

#: library/functions.rst:925
msgid ""
"*buffering* is an optional integer used to set the buffering policy.  Pass 0 "
"to switch buffering off (only allowed in binary mode), 1 to select line "
"buffering (only usable in text mode), and an integer > 1 to indicate the "
"size in bytes of a fixed-size chunk buffer.  When no *buffering* argument is "
"given, the default buffering policy works as follows:"
msgstr ""

#: library/functions.rst:931
msgid ""
"Binary files are buffered in fixed-size chunks; the size of the buffer is "
"chosen using a heuristic trying to determine the underlying device's \"block "
"size\" and falling back on :attr:`io.DEFAULT_BUFFER_SIZE`.  On many systems, "
"the buffer will typically be 4096 or 8192 bytes long."
msgstr ""

#: library/functions.rst:936
msgid ""
"\"Interactive\" text files (files for which :meth:`~io.IOBase.isatty` "
"returns ``True``) use line buffering.  Other text files use the policy "
"described above for binary files."
msgstr ""

#: library/functions.rst:940
msgid ""
"*encoding* is the name of the encoding used to decode or encode the file. "
"This should only be used in text mode.  The default encoding is platform "
"dependent (whatever :func:`locale.getpreferredencoding` returns), but any :"
"term:`text encoding` supported by Python can be used.  See the :mod:`codecs` "
"module for the list of supported encodings."
msgstr ""

#: library/functions.rst:947
msgid ""
"*errors* is an optional string that specifies how encoding and decoding "
"errors are to be handled--this cannot be used in binary mode. A variety of "
"standard error handlers are available (listed under :ref:`error-handlers`), "
"though any error handling name that has been registered with :func:`codecs."
"register_error` is also valid.  The standard names include:"
msgstr ""

#: library/functions.rst:955
msgid ""
"``'strict'`` to raise a :exc:`ValueError` exception if there is an encoding "
"error.  The default value of ``None`` has the same effect."
msgstr ""

#: library/functions.rst:959
msgid ""
"``'ignore'`` ignores errors.  Note that ignoring encoding errors can lead to "
"data loss."
msgstr ""

#: library/functions.rst:962
msgid ""
"``'replace'`` causes a replacement marker (such as ``'?'``) to be inserted "
"where there is malformed data."
msgstr ""

#: library/functions.rst:965
msgid ""
"``'surrogateescape'`` will represent any incorrect bytes as code points in "
"the Unicode Private Use Area ranging from U+DC80 to U+DCFF.  These private "
"code points will then be turned back into the same bytes when the "
"``surrogateescape`` error handler is used when writing data.  This is useful "
"for processing files in an unknown encoding."
msgstr ""

#: library/functions.rst:972
msgid ""
"``'xmlcharrefreplace'`` is only supported when writing to a file. Characters "
"not supported by the encoding are replaced with the appropriate XML "
"character reference ``&#nnn;``."
msgstr ""

#: library/functions.rst:976
msgid ""
"``'backslashreplace'`` replaces malformed data by Python's backslashed "
"escape sequences."
msgstr ""

#: library/functions.rst:979
msgid ""
"``'namereplace'`` (also only supported when writing) replaces unsupported "
"characters with ``\\N{...}`` escape sequences."
msgstr ""

#: library/functions.rst:985
msgid ""
"*newline* controls how :term:`universal newlines` mode works (it only "
"applies to text mode).  It can be ``None``, ``''``, ``'\\n'``, ``'\\r'``, "
"and ``'\\r\\n'``.  It works as follows:"
msgstr ""

#: library/functions.rst:989
msgid ""
"When reading input from the stream, if *newline* is ``None``, universal "
"newlines mode is enabled.  Lines in the input can end in ``'\\n'``, "
"``'\\r'``, or ``'\\r\\n'``, and these are translated into ``'\\n'`` before "
"being returned to the caller.  If it is ``''``, universal newlines mode is "
"enabled, but line endings are returned to the caller untranslated.  If it "
"has any of the other legal values, input lines are only terminated by the "
"given string, and the line ending is returned to the caller untranslated."
msgstr ""

#: library/functions.rst:997 library/io.rst:857
msgid ""
"When writing output to the stream, if *newline* is ``None``, any ``'\\n'`` "
"characters written are translated to the system default line separator, :"
"data:`os.linesep`.  If *newline* is ``''`` or ``'\\n'``, no translation "
"takes place.  If *newline* is any of the other legal values, any ``'\\n'`` "
"characters written are translated to the given string."
msgstr ""

#: library/functions.rst:1003
msgid ""
"If *closefd* is ``False`` and a file descriptor rather than a filename was "
"given, the underlying file descriptor will be kept open when the file is "
"closed.  If a filename is given *closefd* must be ``True`` (the default) "
"otherwise an error will be raised."
msgstr ""

#: library/functions.rst:1008
msgid ""
"A custom opener can be used by passing a callable as *opener*. The "
"underlying file descriptor for the file object is then obtained by calling "
"*opener* with (*file*, *flags*). *opener* must return an open file "
"descriptor (passing :mod:`os.open` as *opener* results in functionality "
"similar to passing ``None``)."
msgstr ""

#: library/functions.rst:1014 library/io.rst:549
msgid "The newly created file is :ref:`non-inheritable <fd_inheritance>`."
msgstr ""

#: library/functions.rst:1016
msgid ""
"The following example uses the :ref:`dir_fd <dir_fd>` parameter of the :func:"
"`os.open` function to open a file relative to a given directory::"
msgstr ""

#: library/functions.rst:1029
msgid ""
"The type of :term:`file object` returned by the :func:`open` function "
"depends on the mode.  When :func:`open` is used to open a file in a text "
"mode (``'w'``, ``'r'``, ``'wt'``, ``'rt'``, etc.), it returns a subclass of :"
"class:`io.TextIOBase` (specifically :class:`io.TextIOWrapper`).  When used "
"to open a file in a binary mode with buffering, the returned class is a "
"subclass of :class:`io.BufferedIOBase`.  The exact class varies: in read "
"binary mode, it returns an :class:`io.BufferedReader`; in write binary and "
"append binary modes, it returns an :class:`io.BufferedWriter`, and in read/"
"write mode, it returns an :class:`io.BufferedRandom`.  When buffering is "
"disabled, the raw stream, a subclass of :class:`io.RawIOBase`, :class:`io."
"FileIO`, is returned."
msgstr ""

#: library/functions.rst:1050
msgid ""
"See also the file handling modules, such as, :mod:`fileinput`, :mod:`io` "
"(where :func:`open` is declared), :mod:`os`, :mod:`os.path`, :mod:"
"`tempfile`, and :mod:`shutil`."
msgstr ""

#: library/functions.rst:1054
msgid ""
"The *opener* parameter was added. The ``'x'`` mode was added. :exc:`IOError` "
"used to be raised, it is now an alias of :exc:`OSError`. :exc:"
"`FileExistsError` is now raised if the file opened in exclusive creation "
"mode (``'x'``) already exists."
msgstr ""

#: library/functions.rst:1061 library/io.rst:558
msgid "The file is now non-inheritable."
msgstr ""

#: library/functions.rst:1066
msgid "The ``'U'`` mode."
msgstr ""

#: library/functions.rst:1068 library/os.rst:888 library/os.rst:1068
#: library/os.rst:1186 library/os.rst:3328
msgid ""
"If the system call is interrupted and the signal handler does not raise an "
"exception, the function now retries the system call instead of raising an :"
"exc:`InterruptedError` exception (see :pep:`475` for the rationale)."
msgstr ""

#: library/functions.rst:1076
msgid ""
"Given a string representing one Unicode character, return an integer "
"representing the Unicode code point of that character.  For example, "
"``ord('a')`` returns the integer ``97`` and ``ord('ν')`` returns ``957``. "
"This is the inverse of :func:`chr`."
msgstr ""

#: library/functions.rst:1084
msgid ""
"Return *x* to the power *y*; if *z* is present, return *x* to the power *y*, "
"modulo *z* (computed more efficiently than ``pow(x, y) % z``). The two-"
"argument form ``pow(x, y)`` is equivalent to using the power operator: "
"``x**y``."
msgstr ""

#: library/functions.rst:1088
msgid ""
"The arguments must have numeric types.  With mixed operand types, the "
"coercion rules for binary arithmetic operators apply.  For :class:`int` "
"operands, the result has the same type as the operands (after coercion) "
"unless the second argument is negative; in that case, all arguments are "
"converted to float and a float result is delivered.  For example, ``10**2`` "
"returns ``100``, but ``10**-2`` returns ``0.01``.  If the second argument is "
"negative, the third argument must be omitted.  If *z* is present, *x* and "
"*y* must be of integer types, and *y* must be non-negative."
msgstr ""

#: library/functions.rst:1100
msgid ""
"Print *objects* to the text stream *file*, separated by *sep* and followed "
"by *end*.  *sep*, *end* and *file*, if present, must be given as keyword "
"arguments."
msgstr ""

#: library/functions.rst:1104
msgid ""
"All non-keyword arguments are converted to strings like :func:`str` does and "
"written to the stream, separated by *sep* and followed by *end*.  Both *sep* "
"and *end* must be strings; they can also be ``None``, which means to use the "
"default values.  If no *objects* are given, :func:`print` will just write "
"*end*."
msgstr ""

#: library/functions.rst:1110
msgid ""
"The *file* argument must be an object with a ``write(string)`` method; if it "
"is not present or ``None``, :data:`sys.stdout` will be used.  Since printed "
"arguments are converted to text strings, :func:`print` cannot be used with "
"binary mode file objects.  For these, use ``file.write(...)`` instead."
msgstr ""

#: library/functions.rst:1115
msgid ""
"Whether output is buffered is usually determined by *file*, but if the "
"*flush* keyword argument is true, the stream is forcibly flushed."
msgstr ""

#: library/functions.rst:1118
msgid "Added the *flush* keyword argument."
msgstr ""

#: library/functions.rst:1124
msgid "Return a property attribute."
msgstr ""

#: library/functions.rst:1126
msgid ""
"*fget* is a function for getting an attribute value.  *fset* is a function "
"for setting an attribute value. *fdel* is a function for deleting an "
"attribute value.  And *doc* creates a docstring for the attribute."
msgstr ""

#: library/functions.rst:1130
msgid "A typical use is to define a managed attribute ``x``::"
msgstr ""

#: library/functions.rst:1147
msgid ""
"If *c* is an instance of *C*, ``c.x`` will invoke the getter, ``c.x = "
"value`` will invoke the setter and ``del c.x`` the deleter."
msgstr ""

#: library/functions.rst:1150
msgid ""
"If given, *doc* will be the docstring of the property attribute. Otherwise, "
"the property will copy *fget*'s docstring (if it exists).  This makes it "
"possible to create read-only properties easily using :func:`property` as a :"
"term:`decorator`::"
msgstr ""

#: library/functions.rst:1163
msgid ""
"The ``@property`` decorator turns the :meth:`voltage` method into a \"getter"
"\" for a read-only attribute with the same name, and it sets the docstring "
"for *voltage* to \"Get the current voltage.\""
msgstr ""

#: library/functions.rst:1167
msgid ""
"A property object has :attr:`~property.getter`, :attr:`~property.setter`, "
"and :attr:`~property.deleter` methods usable as decorators that create a "
"copy of the property with the corresponding accessor function set to the "
"decorated function.  This is best explained with an example::"
msgstr ""

#: library/functions.rst:1189
msgid ""
"This code is exactly equivalent to the first example.  Be sure to give the "
"additional functions the same name as the original property (``x`` in this "
"case.)"
msgstr ""

#: library/functions.rst:1193
msgid ""
"The returned property object also has the attributes ``fget``, ``fset``, and "
"``fdel`` corresponding to the constructor arguments."
msgstr ""

#: library/functions.rst:1196
msgid "The docstrings of property objects are now writeable."
msgstr ""

#: library/functions.rst:1205
msgid ""
"Rather than being a function, :class:`range` is actually an immutable "
"sequence type, as documented in :ref:`typesseq-range` and :ref:`typesseq`."
msgstr ""

#: library/functions.rst:1211
msgid ""
"Return a string containing a printable representation of an object.  For "
"many types, this function makes an attempt to return a string that would "
"yield an object with the same value when passed to :func:`eval`, otherwise "
"the representation is a string enclosed in angle brackets that contains the "
"name of the type of the object together with additional information often "
"including the name and address of the object.  A class can control what this "
"function returns for its instances by defining a :meth:`__repr__` method."
msgstr ""

#: library/functions.rst:1222
msgid ""
"Return a reverse :term:`iterator`.  *seq* must be an object which has a :"
"meth:`__reversed__` method or supports the sequence protocol (the :meth:"
"`__len__` method and the :meth:`__getitem__` method with integer arguments "
"starting at ``0``)."
msgstr ""

#: library/functions.rst:1230
msgid ""
"Return the floating point value *number* rounded to *ndigits* digits after "
"the decimal point.  If *ndigits* is omitted, it returns the nearest integer "
"to its input.  Delegates to ``number.__round__(ndigits)``."
msgstr ""

#: library/functions.rst:1234
msgid ""
"For the built-in types supporting :func:`round`, values are rounded to the "
"closest multiple of 10 to the power minus *ndigits*; if two multiples are "
"equally close, rounding is done toward the even choice (so, for example, "
"both ``round(0.5)`` and ``round(-0.5)`` are ``0``, and ``round(1.5)`` is "
"``2``).  The return value is an integer if called with one argument, "
"otherwise of the same type as *number*."
msgstr ""

#: library/functions.rst:1243
msgid ""
"The behavior of :func:`round` for floats can be surprising: for example, "
"``round(2.675, 2)`` gives ``2.67`` instead of the expected ``2.68``. This is "
"not a bug: it's a result of the fact that most decimal fractions can't be "
"represented exactly as a float.  See :ref:`tut-fp-issues` for more "
"information."
msgstr ""

#: library/functions.rst:1254
msgid ""
"Return a new :class:`set` object, optionally with elements taken from "
"*iterable*.  ``set`` is a built-in class.  See :class:`set` and :ref:`types-"
"set` for documentation about this class."
msgstr ""

#: library/functions.rst:1258
msgid ""
"For other containers see the built-in :class:`frozenset`, :class:`list`, :"
"class:`tuple`, and :class:`dict` classes, as well as the :mod:`collections` "
"module."
msgstr ""

#: library/functions.rst:1265
msgid ""
"This is the counterpart of :func:`getattr`.  The arguments are an object, a "
"string and an arbitrary value.  The string may name an existing attribute or "
"a new attribute.  The function assigns the value to the attribute, provided "
"the object allows it.  For example, ``setattr(x, 'foobar', 123)`` is "
"equivalent to ``x.foobar = 123``."
msgstr ""

#: library/functions.rst:1277
msgid ""
"Return a :term:`slice` object representing the set of indices specified by "
"``range(start, stop, step)``.  The *start* and *step* arguments default to "
"``None``.  Slice objects have read-only data attributes :attr:`~slice."
"start`, :attr:`~slice.stop` and :attr:`~slice.step` which merely return the "
"argument values (or their default).  They have no other explicit "
"functionality; however they are used by Numerical Python and other third "
"party extensions. Slice objects are also generated when extended indexing "
"syntax is used.  For example: ``a[start:stop:step]`` or ``a[start:stop, "
"i]``.  See :func:`itertools.islice` for an alternate version that returns an "
"iterator."
msgstr ""

#: library/functions.rst:1290
msgid "Return a new sorted list from the items in *iterable*."
msgstr ""

#: library/functions.rst:1292 library/heapq.rst:95
msgid ""
"Has two optional arguments which must be specified as keyword arguments."
msgstr ""

#: library/functions.rst:1294
msgid ""
"*key* specifies a function of one argument that is used to extract a "
"comparison key from each list element: ``key=str.lower``.  The default value "
"is ``None`` (compare the elements directly)."
msgstr ""

#: library/functions.rst:1298 library/stdtypes.rst:1177
msgid ""
"*reverse* is a boolean value.  If set to ``True``, then the list elements "
"are sorted as if each comparison were reversed."
msgstr ""

#: library/functions.rst:1301
msgid ""
"Use :func:`functools.cmp_to_key` to convert an old-style *cmp* function to a "
"*key* function."
msgstr ""

#: library/functions.rst:1304
msgid ""
"The built-in :func:`sorted` function is guaranteed to be stable. A sort is "
"stable if it guarantees not to change the relative order of elements that "
"compare equal --- this is helpful for sorting in multiple passes (for "
"example, sort by department, then by salary grade)."
msgstr ""

#: library/functions.rst:1309 library/functools.rst:40
msgid ""
"For sorting examples and a brief sorting tutorial, see :ref:`sortinghowto`."
msgstr ""

#: library/functions.rst:1313
msgid "Return a static method for *function*."
msgstr ""

#: library/functions.rst:1315
msgid ""
"A static method does not receive an implicit first argument. To declare a "
"static method, use this idiom::"
msgstr ""

#: library/functions.rst:1322
msgid ""
"The ``@staticmethod`` form is a function :term:`decorator` -- see the "
"description of function definitions in :ref:`function` for details."
msgstr ""

#: library/functions.rst:1325
msgid ""
"It can be called either on the class (such as ``C.f()``) or on an instance "
"(such as ``C().f()``).  The instance is ignored except for its class."
msgstr ""

#: library/functions.rst:1328
msgid ""
"Static methods in Python are similar to those found in Java or C++. Also "
"see :func:`classmethod` for a variant that is useful for creating alternate "
"class constructors."
msgstr ""

#: library/functions.rst:1332
msgid ""
"For more information on static methods, consult the documentation on the "
"standard type hierarchy in :ref:`types`."
msgstr ""

#: library/functions.rst:1344
msgid ""
"Return a :class:`str` version of *object*.  See :func:`str` for details."
msgstr ""

#: library/functions.rst:1346
msgid ""
"``str`` is the built-in string :term:`class`.  For general information about "
"strings, see :ref:`textseq`."
msgstr ""

#: library/functions.rst:1352
msgid ""
"Sums *start* and the items of an *iterable* from left to right and returns "
"the total.  *start* defaults to ``0``. The *iterable*'s items are normally "
"numbers, and the start value is not allowed to be a string."
msgstr ""

#: library/functions.rst:1356
msgid ""
"For some use cases, there are good alternatives to :func:`sum`. The "
"preferred, fast way to concatenate a sequence of strings is by calling ``''."
"join(sequence)``.  To add floating point values with extended precision, "
"see :func:`math.fsum`\\.  To concatenate a series of iterables, consider "
"using :func:`itertools.chain`."
msgstr ""

#: library/functions.rst:1364
msgid ""
"Return a proxy object that delegates method calls to a parent or sibling "
"class of *type*.  This is useful for accessing inherited methods that have "
"been overridden in a class. The search order is same as that used by :func:"
"`getattr` except that the *type* itself is skipped."
msgstr ""

#: library/functions.rst:1369
msgid ""
"The :attr:`~class.__mro__` attribute of the *type* lists the method "
"resolution search order used by both :func:`getattr` and :func:`super`.  The "
"attribute is dynamic and can change whenever the inheritance hierarchy is "
"updated."
msgstr ""

#: library/functions.rst:1374
msgid ""
"If the second argument is omitted, the super object returned is unbound.  If "
"the second argument is an object, ``isinstance(obj, type)`` must be true.  "
"If the second argument is a type, ``issubclass(type2, type)`` must be true "
"(this is useful for classmethods)."
msgstr ""

#: library/functions.rst:1379
msgid ""
"There are two typical use cases for *super*.  In a class hierarchy with "
"single inheritance, *super* can be used to refer to parent classes without "
"naming them explicitly, thus making the code more maintainable.  This use "
"closely parallels the use of *super* in other programming languages."
msgstr ""

#: library/functions.rst:1384
msgid ""
"The second use case is to support cooperative multiple inheritance in a "
"dynamic execution environment.  This use case is unique to Python and is not "
"found in statically compiled languages or languages that only support single "
"inheritance.  This makes it possible to implement \"diamond diagrams\" where "
"multiple base classes implement the same method.  Good design dictates that "
"this method have the same calling signature in every case (because the order "
"of calls is determined at runtime, because that order adapts to changes in "
"the class hierarchy, and because that order can include sibling classes that "
"are unknown prior to runtime)."
msgstr ""

#: library/functions.rst:1394
msgid "For both use cases, a typical superclass call looks like this::"
msgstr ""

#: library/functions.rst:1401
msgid ""
"Note that :func:`super` is implemented as part of the binding process for "
"explicit dotted attribute lookups such as ``super().__getitem__(name)``. It "
"does so by implementing its own :meth:`__getattribute__` method for "
"searching classes in a predictable order that supports cooperative multiple "
"inheritance. Accordingly, :func:`super` is undefined for implicit lookups "
"using statements or operators such as ``super()[name]``."
msgstr ""

#: library/functions.rst:1408
msgid ""
"Also note that, aside from the zero argument form, :func:`super` is not "
"limited to use inside methods.  The two argument form specifies the "
"arguments exactly and makes the appropriate references.  The zero argument "
"form only works inside a class definition, as the compiler fills in the "
"necessary details to correctly retrieve the class being defined, as well as "
"accessing the current instance for ordinary methods."
msgstr ""

#: library/functions.rst:1415
msgid ""
"For practical suggestions on how to design cooperative classes using :func:"
"`super`, see `guide to using super() <http://rhettinger.wordpress."
"com/2011/05/26/super-considered-super/>`_."
msgstr ""

#: library/functions.rst:1424
msgid ""
"Rather than being a function, :class:`tuple` is actually an immutable "
"sequence type, as documented in :ref:`typesseq-tuple` and :ref:`typesseq`."
msgstr ""

#: library/functions.rst:1433
msgid ""
"With one argument, return the type of an *object*.  The return value is a "
"type object and generally the same object as returned by :attr:`object."
"__class__ <instance.__class__>`."
msgstr ""

#: library/functions.rst:1437
msgid ""
"The :func:`isinstance` built-in function is recommended for testing the type "
"of an object, because it takes subclasses into account."
msgstr ""

#: library/functions.rst:1441
msgid ""
"With three arguments, return a new type object.  This is essentially a "
"dynamic form of the :keyword:`class` statement. The *name* string is the "
"class name and becomes the :attr:`~class.__name__` attribute; the *bases* "
"tuple itemizes the base classes and becomes the :attr:`~class.__bases__` "
"attribute; and the *dict* dictionary is the namespace containing definitions "
"for class body and becomes the :attr:`~object.__dict__` attribute.  For "
"example, the following two statements create identical :class:`type` objects:"
msgstr ""

#: library/functions.rst:1454
msgid "See also :ref:`bltin-type-objects`."
msgstr ""

#: library/functions.rst:1459
msgid ""
"Return the :attr:`~object.__dict__` attribute for a module, class, instance, "
"or any other object with a :attr:`__dict__` attribute."
msgstr ""

#: library/functions.rst:1462
msgid ""
"Objects such as modules and instances have an updateable :attr:`__dict__` "
"attribute; however, other objects may have write restrictions on their :attr:"
"`__dict__` attributes (for example, classes use a dictproxy to prevent "
"direct dictionary updates)."
msgstr ""

#: library/functions.rst:1467
msgid ""
"Without an argument, :func:`vars` acts like :func:`locals`.  Note, the "
"locals dictionary is only useful for reads since updates to the locals "
"dictionary are ignored."
msgstr ""

#: library/functions.rst:1474
msgid "Make an iterator that aggregates elements from each of the iterables."
msgstr ""

#: library/functions.rst:1476
msgid ""
"Returns an iterator of tuples, where the *i*-th tuple contains the *i*-th "
"element from each of the argument sequences or iterables.  The iterator "
"stops when the shortest input iterable is exhausted. With a single iterable "
"argument, it returns an iterator of 1-tuples.  With no arguments, it returns "
"an empty iterator.  Equivalent to::"
msgstr ""

#: library/functions.rst:1495
msgid ""
"The left-to-right evaluation order of the iterables is guaranteed. This "
"makes possible an idiom for clustering a data series into n-length groups "
"using ``zip(*[iter(s)]*n)``.  This repeats the *same* iterator ``n`` times "
"so that each output tuple has the result of ``n`` calls to the iterator. "
"This has the effect of dividing the input into n-length chunks."
msgstr ""

#: library/functions.rst:1501
msgid ""
":func:`zip` should only be used with unequal length inputs when you don't "
"care about trailing, unmatched values from the longer iterables.  If those "
"values are important, use :func:`itertools.zip_longest` instead."
msgstr ""

#: library/functions.rst:1505
msgid ""
":func:`zip` in conjunction with the ``*`` operator can be used to unzip a "
"list::"
msgstr ""

#: library/functions.rst:1526
msgid ""
"This is an advanced function that is not needed in everyday Python "
"programming, unlike :func:`importlib.import_module`."
msgstr ""

#: library/functions.rst:1529
msgid ""
"This function is invoked by the :keyword:`import` statement.  It can be "
"replaced (by importing the :mod:`builtins` module and assigning to "
"``builtins.__import__``) in order to change semantics of the :keyword:"
"`import` statement, but doing so is **strongly** discouraged as it is "
"usually simpler to use import hooks (see :pep:`302`) to attain the same "
"goals and does not cause issues with code which assumes the default import "
"implementation is in use.  Direct use of :func:`__import__` is also "
"discouraged in favor of :func:`importlib.import_module`."
msgstr ""

#: library/functions.rst:1538
msgid ""
"The function imports the module *name*, potentially using the given "
"*globals* and *locals* to determine how to interpret the name in a package "
"context. The *fromlist* gives the names of objects or submodules that should "
"be imported from the module given by *name*.  The standard implementation "
"does not use its *locals* argument at all, and uses its *globals* only to "
"determine the package context of the :keyword:`import` statement."
msgstr ""

#: library/functions.rst:1545
msgid ""
"*level* specifies whether to use absolute or relative imports. ``0`` (the "
"default) means only perform absolute imports.  Positive values for *level* "
"indicate the number of parent directories to search relative to the "
"directory of the module calling :func:`__import__` (see :pep:`328` for the "
"details)."
msgstr ""

#: library/functions.rst:1551
msgid ""
"When the *name* variable is of the form ``package.module``, normally, the "
"top-level package (the name up till the first dot) is returned, *not* the "
"module named by *name*.  However, when a non-empty *fromlist* argument is "
"given, the module named by *name* is returned."
msgstr ""

#: library/functions.rst:1556
msgid ""
"For example, the statement ``import spam`` results in bytecode resembling "
"the following code::"
msgstr ""

#: library/functions.rst:1561
msgid "The statement ``import spam.ham`` results in this call::"
msgstr ""

#: library/functions.rst:1565
msgid ""
"Note how :func:`__import__` returns the toplevel module here because this is "
"the object that is bound to a name by the :keyword:`import` statement."
msgstr ""

#: library/functions.rst:1568
msgid ""
"On the other hand, the statement ``from spam.ham import eggs, sausage as "
"saus`` results in ::"
msgstr ""

#: library/functions.rst:1575
msgid ""
"Here, the ``spam.ham`` module is returned from :func:`__import__`.  From "
"this object, the names to import are retrieved and assigned to their "
"respective names."
msgstr ""

#: library/functions.rst:1579
msgid ""
"If you simply want to import a module (potentially within a package) by "
"name, use :func:`importlib.import_module`."
msgstr ""

#: library/functions.rst:1582
msgid ""
"Negative values for *level* are no longer supported (which also changes the "
"default value to 0)."
msgstr ""

#: library/functions.rst:1589
msgid ""
"Note that the parser only accepts the Unix-style end of line convention. If "
"you are reading the code from a file, make sure to use newline conversion "
"mode to convert Windows or Mac-style newlines."
msgstr ""