forked from AFPy/python-docs-fr
2166 lines
77 KiB
Plaintext
2166 lines
77 KiB
Plaintext
# 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 ""
|
||
|
||
#: library/functions.rst:108
|
||
msgid ""
|
||
"The optional *source* parameter can be used to initialize the array in a few "
|
||
"different ways:"
|
||
msgstr ""
|
||
|
||
#: 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 ""
|
||
|
||
#: library/functions.rst:115
|
||
msgid ""
|
||
"If it is an *integer*, the array will have that size and will be initialized "
|
||
"with null bytes."
|
||
msgstr ""
|
||
|
||
#: 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 ""
|
||
|
||
#: 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 ""
|
||
|
||
#: library/functions.rst:124
|
||
msgid "Without an argument, an array of size 0 is created."
|
||
msgstr ""
|
||
|
||
#: 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 ""
|