# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2021, Python Software Foundation

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# Maciej Olko <maciej.olko@gmail.com>, 2020

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2021-05-07 06:17+0000\n"

"PO-Revision-Date: 2017-02-16 23:28+0000\n"

"Last-Translator: Maciej Olko <maciej.olko@gmail.com>, 2020\n"

"Language-Team: Polish (https://www.transifex.com/python-doc/teams/5390/pl/)\n"

"MIME-Version: 1.0\n"

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

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

"Language: pl\n"

"Plural-Forms: nplurals=4; plural=(n==1 ? 0 : (n%10>=2 && n%10<=4) && "

"(n%100<12 || n%100>14) ? 1 : n!=1 && (n%10>=0 && n%10<=1) || (n%10>=5 && "

"n%10<=9) || (n%100>=12 && n%100<=14) ? 2 : 3);\n"

msgid ":mod:`string` --- Common string operations"

msgstr ""

msgid "**Source code:** :source:`Lib/string.py`"

msgstr ""

msgid ":ref:`textseq`"

msgstr ":ref:`textseq`"

msgid ":ref:`string-methods`"

msgstr ":ref:`string-methods`"

msgid "String constants"

msgstr ""

msgid "The constants defined in this module are:"

msgstr ""

msgid ""

"The concatenation of the :const:`ascii_lowercase` and :const:"

"`ascii_uppercase` constants described below. This value is not locale-"

"dependent."

msgstr ""

msgid ""

"The lowercase letters ``'abcdefghijklmnopqrstuvwxyz'``. This value is not "

"locale-dependent and will not change."

msgstr ""

msgid ""

"The uppercase letters ``'ABCDEFGHIJKLMNOPQRSTUVWXYZ'``. This value is not "

"locale-dependent and will not change."

msgstr ""

msgid "The string ``'0123456789'``."

msgstr ""

msgid "The string ``'0123456789abcdefABCDEF'``."

msgstr ""

msgid "The string ``'01234567'``."

msgstr ""

msgid ""

"String of ASCII characters which are considered punctuation characters in "

"the ``C`` locale: ``!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~``."

msgstr ""

msgid ""

"String of ASCII characters which are considered printable. This is a "

"combination of :const:`digits`, :const:`ascii_letters`, :const:"

"`punctuation`, and :const:`whitespace`."

msgstr ""

msgid ""

"A string containing all ASCII characters that are considered whitespace. "

"This includes the characters space, tab, linefeed, return, formfeed, and "

"vertical tab."

msgstr ""

msgid "Custom String Formatting"

msgstr ""

msgid ""

"The built-in string class provides the ability to do complex variable "

"substitutions and value formatting via the :meth:`~str.format` method "

"described in :pep:`3101`. The :class:`Formatter` class in the :mod:`string` "

"module allows you to create and customize your own string formatting "

"behaviors using the same implementation as the built-in :meth:`~str.format` "

"method."

msgstr ""

msgid "The :class:`Formatter` class has the following public methods:"

msgstr ""

msgid ""

"The primary API method. It takes a format string and an arbitrary set of "

"positional and keyword arguments. It is just a wrapper that calls :meth:"

"`vformat`."

msgstr ""

msgid ""

"A format string argument is now :ref:`positional-only <positional-"

"only_parameter>`."

msgstr ""

msgid ""

"This function does the actual work of formatting. It is exposed as a "

"separate function for cases where you want to pass in a predefined "

"dictionary of arguments, rather than unpacking and repacking the dictionary "

"as individual arguments using the ``*args`` and ``**kwargs`` syntax. :meth:"

"`vformat` does the work of breaking up the format string into character data "

"and replacement fields. It calls the various methods described below."

msgstr ""

msgid ""

"In addition, the :class:`Formatter` defines a number of methods that are "

"intended to be replaced by subclasses:"

msgstr ""

msgid ""

"Loop over the format_string and return an iterable of tuples "

"(*literal_text*, *field_name*, *format_spec*, *conversion*). This is used "

"by :meth:`vformat` to break the string into either literal text, or "

"replacement fields."

msgstr ""

msgid ""

"The values in the tuple conceptually represent a span of literal text "

"followed by a single replacement field. If there is no literal text (which "

"can happen if two replacement fields occur consecutively), then "

"*literal_text* will be a zero-length string. If there is no replacement "

"field, then the values of *field_name*, *format_spec* and *conversion* will "

"be ``None``."

msgstr ""

msgid ""

"Given *field_name* as returned by :meth:`parse` (see above), convert it to "

"an object to be formatted. Returns a tuple (obj, used_key). The default "

"version takes strings of the form defined in :pep:`3101`, such as "

"\"0[name]\" or \"label.title\". *args* and *kwargs* are as passed in to :"

"meth:`vformat`. The return value *used_key* has the same meaning as the "

"*key* parameter to :meth:`get_value`."

msgstr ""

msgid ""

"Retrieve a given field value. The *key* argument will be either an integer "

"or a string. If it is an integer, it represents the index of the positional "

"argument in *args*; if it is a string, then it represents a named argument "

"in *kwargs*."

msgstr ""

msgid ""

"The *args* parameter is set to the list of positional arguments to :meth:"

"`vformat`, and the *kwargs* parameter is set to the dictionary of keyword "

"arguments."

msgstr ""

msgid ""

"For compound field names, these functions are only called for the first "

"component of the field name; subsequent components are handled through "

"normal attribute and indexing operations."

msgstr ""

msgid ""

"So for example, the field expression '0.name' would cause :meth:`get_value` "

"to be called with a *key* argument of 0. The ``name`` attribute will be "

"looked up after :meth:`get_value` returns by calling the built-in :func:"

"`getattr` function."

msgstr ""

msgid ""

"If the index or keyword refers to an item that does not exist, then an :exc:"

"`IndexError` or :exc:`KeyError` should be raised."

msgstr ""

msgid ""

"Implement checking for unused arguments if desired. The arguments to this "

"function is the set of all argument keys that were actually referred to in "

"the format string (integers for positional arguments, and strings for named "

"arguments), and a reference to the *args* and *kwargs* that was passed to "

"vformat. The set of unused args can be calculated from these parameters. :"

"meth:`check_unused_args` is assumed to raise an exception if the check fails."

msgstr ""

msgid ""

":meth:`format_field` simply calls the global :func:`format` built-in. The "

"method is provided so that subclasses can override it."

msgstr ""

msgid ""

"Converts the value (returned by :meth:`get_field`) given a conversion type "

"(as in the tuple returned by the :meth:`parse` method). The default version "

"understands 's' (str), 'r' (repr) and 'a' (ascii) conversion types."

msgstr ""

msgid "Format String Syntax"

msgstr ""

msgid ""

"The :meth:`str.format` method and the :class:`Formatter` class share the "

"same syntax for format strings (although in the case of :class:`Formatter`, "

"subclasses can define their own format string syntax). The syntax is "

"related to that of :ref:`formatted string literals <f-strings>`, but it is "

"less sophisticated and, in particular, does not support arbitrary "

"expressions."

msgstr ""

msgid ""

"Format strings contain \"replacement fields\" surrounded by curly braces ``{}"

"``. Anything that is not contained in braces is considered literal text, "

"which is copied unchanged to the output. If you need to include a brace "

"character in the literal text, it can be escaped by doubling: ``{{`` and ``}}"

"``."

msgstr ""

msgid "The grammar for a replacement field is as follows:"

msgstr ""

msgid ""

"In less formal terms, the replacement field can start with a *field_name* "

"that specifies the object whose value is to be formatted and inserted into "

"the output instead of the replacement field. The *field_name* is optionally "

"followed by a *conversion* field, which is preceded by an exclamation point "

"``'!'``, and a *format_spec*, which is preceded by a colon ``':'``. These "

"specify a non-default format for the replacement value."

msgstr ""

msgid "See also the :ref:`formatspec` section."

msgstr ""

msgid ""

"The *field_name* itself begins with an *arg_name* that is either a number or "

"a keyword. If it's a number, it refers to a positional argument, and if "

"it's a keyword, it refers to a named keyword argument. If the numerical "

"arg_names in a format string are 0, 1, 2, ... in sequence, they can all be "

"omitted (not just some) and the numbers 0, 1, 2, ... will be automatically "

"inserted in that order. Because *arg_name* is not quote-delimited, it is not "

"possible to specify arbitrary dictionary keys (e.g., the strings ``'10'`` or "

"``':-]'``) within a format string. The *arg_name* can be followed by any "

"number of index or attribute expressions. An expression of the form ``'."

"name'`` selects the named attribute using :func:`getattr`, while an "

"expression of the form ``'[index]'`` does an index lookup using :func:"

"`__getitem__`."

msgstr ""

msgid ""

"The positional argument specifiers can be omitted for :meth:`str.format`, so "

"``'{} {}'.format(a, b)`` is equivalent to ``'{0} {1}'.format(a, b)``."

msgstr ""

msgid ""

"The positional argument specifiers can be omitted for :class:`Formatter`."

msgstr ""

msgid "Some simple format string examples::"

msgstr ""

msgid ""

"The *conversion* field causes a type coercion before formatting. Normally, "

"the job of formatting a value is done by the :meth:`__format__` method of "

"the value itself. However, in some cases it is desirable to force a type to "

"be formatted as a string, overriding its own definition of formatting. By "

"converting the value to a string before calling :meth:`__format__`, the "

"normal formatting logic is bypassed."

msgstr ""

msgid ""

"Three conversion flags are currently supported: ``'!s'`` which calls :func:"

"`str` on the value, ``'!r'`` which calls :func:`repr` and ``'!a'`` which "

"calls :func:`ascii`."

msgstr ""

msgid "Some examples::"

msgstr "Trochę przykładów::"

msgid ""

"The *format_spec* field contains a specification of how the value should be "

"presented, including such details as field width, alignment, padding, "

"decimal precision and so on. Each value type can define its own "

"\"formatting mini-language\" or interpretation of the *format_spec*."

msgstr ""

msgid ""

"Most built-in types support a common formatting mini-language, which is "

"described in the next section."

msgstr ""

msgid ""

"A *format_spec* field can also include nested replacement fields within it. "

"These nested replacement fields may contain a field name, conversion flag "

"and format specification, but deeper nesting is not allowed. The "

"replacement fields within the format_spec are substituted before the "

"*format_spec* string is interpreted. This allows the formatting of a value "

"to be dynamically specified."

msgstr ""

msgid "See the :ref:`formatexamples` section for some examples."

msgstr ""

msgid "Format Specification Mini-Language"

msgstr ""

msgid ""

"\"Format specifications\" are used within replacement fields contained "

"within a format string to define how individual values are presented (see :"

"ref:`formatstrings` and :ref:`f-strings`). They can also be passed directly "

"to the built-in :func:`format` function. Each formattable type may define "

"how the format specification is to be interpreted."

msgstr ""

msgid ""

"Most built-in types implement the following options for format "

"specifications, although some of the formatting options are only supported "

"by the numeric types."

msgstr ""

msgid ""

"A general convention is that an empty format specification produces the same "

"result as if you had called :func:`str` on the value. A non-empty format "

"specification typically modifies the result."

msgstr ""

msgid "The general form of a *standard format specifier* is:"

msgstr ""

msgid ""

"If a valid *align* value is specified, it can be preceded by a *fill* "

"character that can be any character and defaults to a space if omitted. It "

"is not possible to use a literal curly brace (\"``{``\" or \"``}``\") as the "

"*fill* character in a :ref:`formatted string literal <f-strings>` or when "

"using the :meth:`str.format` method. However, it is possible to insert a "

"curly brace with a nested replacement field. This limitation doesn't affect "

"the :func:`format` function."

msgstr ""

msgid "The meaning of the various alignment options is as follows:"

msgstr ""

msgid "Option"

msgstr ""

msgid "Meaning"

msgstr "Znaczenie"

msgid "``'<'``"

msgstr ""

msgid ""

"Forces the field to be left-aligned within the available space (this is the "

"default for most objects)."

msgstr ""

msgid "``'>'``"

msgstr ""

msgid ""

"Forces the field to be right-aligned within the available space (this is the "

"default for numbers)."

msgstr ""

msgid "``'='``"

msgstr ""

msgid ""

"Forces the padding to be placed after the sign (if any) but before the "

"digits. This is used for printing fields in the form '+000000120'. This "

"alignment option is only valid for numeric types. It becomes the default "

"when '0' immediately precedes the field width."

msgstr ""

msgid "``'^'``"

msgstr ""

msgid "Forces the field to be centered within the available space."

msgstr ""

msgid ""

"Note that unless a minimum field width is defined, the field width will "

"always be the same size as the data to fill it, so that the alignment option "

"has no meaning in this case."

msgstr ""

msgid ""

"The *sign* option is only valid for number types, and can be one of the "

"following:"

msgstr ""

msgid "``'+'``"

msgstr ""

msgid ""

"indicates that a sign should be used for both positive as well as negative "

"numbers."

msgstr ""

msgid "``'-'``"

msgstr ""

msgid ""

"indicates that a sign should be used only for negative numbers (this is the "

"default behavior)."

msgstr ""

msgid "space"

msgstr ""

msgid ""

"indicates that a leading space should be used on positive numbers, and a "

"minus sign on negative numbers."

msgstr ""

msgid ""

"The ``'#'`` option causes the \"alternate form\" to be used for the "

"conversion. The alternate form is defined differently for different types. "

"This option is only valid for integer, float and complex types. For "

"integers, when binary, octal, or hexadecimal output is used, this option "

"adds the respective prefix ``'0b'``, ``'0o'``, ``'0x'``, or ``'0X'`` to the "

"output value. For float and complex the alternate form causes the result of "

"the conversion to always contain a decimal-point character, even if no "

"digits follow it. Normally, a decimal-point character appears in the result "

"of these conversions only if a digit follows it. In addition, for ``'g'`` "

"and ``'G'`` conversions, trailing zeros are not removed from the result."

msgstr ""

msgid ""

"The ``','`` option signals the use of a comma for a thousands separator. For "

"a locale aware separator, use the ``'n'`` integer presentation type instead."

msgstr ""

msgid "Added the ``','`` option (see also :pep:`378`)."

msgstr ""

msgid ""

"The ``'_'`` option signals the use of an underscore for a thousands "

"separator for floating point presentation types and for integer presentation "

"type ``'d'``. For integer presentation types ``'b'``, ``'o'``, ``'x'``, and "

"``'X'``, underscores will be inserted every 4 digits. For other "

"presentation types, specifying this option is an error."

msgstr ""

msgid "Added the ``'_'`` option (see also :pep:`515`)."

msgstr ""

msgid ""

"*width* is a decimal integer defining the minimum total field width, "

"including any prefixes, separators, and other formatting characters. If not "

"specified, then the field width will be determined by the content."

msgstr ""

msgid ""

"When no explicit alignment is given, preceding the *width* field by a zero "

"(``'0'``) character enables sign-aware zero-padding for numeric types. This "

"is equivalent to a *fill* character of ``'0'`` with an *alignment* type of "

"``'='``."

msgstr ""

msgid ""

"The *precision* is a decimal number indicating how many digits should be "

"displayed after the decimal point for a floating point value formatted with "

"``'f'`` and ``'F'``, or before and after the decimal point for a floating "

"point value formatted with ``'g'`` or ``'G'``. For non-number types the "

"field indicates the maximum field size - in other words, how many characters "

"will be used from the field content. The *precision* is not allowed for "

"integer values."

msgstr ""

msgid "Finally, the *type* determines how the data should be presented."

msgstr ""

msgid "The available string presentation types are:"

msgstr ""

msgid "Type"

msgstr ""

msgid "``'s'``"

msgstr ""

msgid "String format. This is the default type for strings and may be omitted."

msgstr ""

msgid "None"

msgstr ""

msgid "The same as ``'s'``."

msgstr ""

msgid "The available integer presentation types are:"

msgstr ""

msgid "``'b'``"

msgstr "``'b'``"

msgid "Binary format. Outputs the number in base 2."

msgstr ""

msgid "``'c'``"

msgstr ""

msgid ""

"Character. Converts the integer to the corresponding unicode character "

"before printing."

msgstr ""

msgid "``'d'``"

msgstr "``'d'``"

msgid "Decimal Integer. Outputs the number in base 10."

msgstr ""

msgid "``'o'``"

msgstr ""

msgid "Octal format. Outputs the number in base 8."

msgstr ""

msgid "``'x'``"

msgstr ""

msgid ""

"Hex format. Outputs the number in base 16, using lower-case letters for the "

"digits above 9."

msgstr ""

msgid "``'X'``"

msgstr ""

msgid ""

"Hex format. Outputs the number in base 16, using upper-case letters for the "

"digits above 9. In case ``'#'`` is specified, the prefix ``'0x'`` will be "

"upper-cased to ``'0X'`` as well."

msgstr ""

msgid "``'n'``"

msgstr ""

msgid ""

"Number. This is the same as ``'d'``, except that it uses the current locale "

"setting to insert the appropriate number separator characters."

msgstr ""

msgid "The same as ``'d'``."

msgstr ""

msgid ""

"In addition to the above presentation types, integers can be formatted with "

"the floating point presentation types listed below (except ``'n'`` and "

"``None``). When doing so, :func:`float` is used to convert the integer to a "

"floating point number before formatting."

msgstr ""

msgid ""

"The available presentation types for :class:`float` and :class:`~decimal."

"Decimal` values are:"

msgstr ""

msgid "``'e'``"

msgstr ""

msgid ""

"Scientific notation. For a given precision ``p``, formats the number in "

"scientific notation with the letter 'e' separating the coefficient from the "

"exponent. The coefficient has one digit before and ``p`` digits after the "

"decimal point, for a total of ``p + 1`` significant digits. With no "

"precision given, uses a precision of ``6`` digits after the decimal point "

"for :class:`float`, and shows all coefficient digits for :class:`~decimal."

"Decimal`. If no digits follow the decimal point, the decimal point is also "

"removed unless the ``#`` option is used."

msgstr ""

msgid "``'E'``"

msgstr ""

msgid ""

"Scientific notation. Same as ``'e'`` except it uses an upper case 'E' as the "

"separator character."

msgstr ""

msgid "``'f'``"

msgstr "``'f'``"

msgid ""

"Fixed-point notation. For a given precision ``p``, formats the number as a "

"decimal number with exactly ``p`` digits following the decimal point. With "

"no precision given, uses a precision of ``6`` digits after the decimal point "

"for :class:`float`, and uses a precision large enough to show all "

"coefficient digits for :class:`~decimal.Decimal`. If no digits follow the "

"decimal point, the decimal point is also removed unless the ``#`` option is "

"used."

msgstr ""

msgid "``'F'``"

msgstr ""

msgid ""

"Fixed-point notation. Same as ``'f'``, but converts ``nan`` to ``NAN`` and "

"``inf`` to ``INF``."

msgstr ""

msgid "``'g'``"

msgstr ""

msgid ""

"General format. For a given precision ``p >= 1``, this rounds the number to "

"``p`` significant digits and then formats the result in either fixed-point "

"format or in scientific notation, depending on its magnitude. A precision of "

"``0`` is treated as equivalent to a precision of ``1``."

msgstr ""

msgid ""

"The precise rules are as follows: suppose that the result formatted with "

"presentation type ``'e'`` and precision ``p-1`` would have exponent "

"``exp``. Then, if ``m <= exp < p``, where ``m`` is -4 for floats and -6 "

"for :class:`Decimals <decimal.Decimal>`, the number is formatted with "

"presentation type ``'f'`` and precision ``p-1-exp``. Otherwise, the number "

"is formatted with presentation type ``'e'`` and precision ``p-1``. In both "

"cases insignificant trailing zeros are removed from the significand, and the "

"decimal point is also removed if there are no remaining digits following it, "

"unless the ``'#'`` option is used."

msgstr ""

msgid ""

"With no precision given, uses a precision of ``6`` significant digits for :"

"class:`float`. For :class:`~decimal.Decimal`, the coefficient of the result "

"is formed from the coefficient digits of the value; scientific notation is "

"used for values smaller than ``1e-6`` in absolute value and values where the "

"place value of the least significant digit is larger than 1, and fixed-point "

"notation is used otherwise."

msgstr ""

msgid ""

"Positive and negative infinity, positive and negative zero, and nans, are "

"formatted as ``inf``, ``-inf``, ``0``, ``-0`` and ``nan`` respectively, "

"regardless of the precision."

msgstr ""

msgid "``'G'``"

msgstr ""

msgid ""

"General format. Same as ``'g'`` except switches to ``'E'`` if the number "

"gets too large. The representations of infinity and NaN are uppercased, too."

msgstr ""

msgid ""

"Number. This is the same as ``'g'``, except that it uses the current locale "

"setting to insert the appropriate number separator characters."

msgstr ""

msgid "``'%'``"

msgstr ""

msgid ""

"Percentage. Multiplies the number by 100 and displays in fixed (``'f'``) "

"format, followed by a percent sign."

msgstr ""

msgid ""

"For :class:`float` this is the same as ``'g'``, except that when fixed-point "

"notation is used to format the result, it always includes at least one digit "

"past the decimal point. The precision used is as large as needed to "

"represent the given value faithfully."

msgstr ""

msgid ""

"For :class:`~decimal.Decimal`, this is the same as either ``'g'`` or ``'G'`` "

"depending on the value of ``context.capitals`` for the current decimal "

"context."

msgstr ""

msgid ""

"The overall effect is to match the output of :func:`str` as altered by the "

"other format modifiers."

msgstr ""

msgid "Format examples"

msgstr ""

msgid ""

"This section contains examples of the :meth:`str.format` syntax and "

"comparison with the old ``%``-formatting."

msgstr ""

msgid ""

"In most of the cases the syntax is similar to the old ``%``-formatting, with "

"the addition of the ``{}`` and with ``:`` used instead of ``%``. For "

"example, ``'%03.2f'`` can be translated to ``'{:03.2f}'``."

msgstr ""

msgid ""

"The new format syntax also supports new and different options, shown in the "

"following examples."

msgstr ""

msgid "Accessing arguments by position::"

msgstr ""

msgid "Accessing arguments by name::"

msgstr ""

msgid "Accessing arguments' attributes::"

msgstr ""

msgid "Accessing arguments' items::"

msgstr ""

msgid "Replacing ``%s`` and ``%r``::"

msgstr ""

msgid "Aligning the text and specifying a width::"

msgstr ""

msgid "Replacing ``%+f``, ``%-f``, and ``% f`` and specifying a sign::"

msgstr ""

msgid ""

"Replacing ``%x`` and ``%o`` and converting the value to different bases::"

msgstr ""

msgid "Using the comma as a thousands separator::"

msgstr ""

msgid "Expressing a percentage::"

msgstr ""

msgid "Using type-specific formatting::"

msgstr ""

msgid "Nesting arguments and more complex examples::"

msgstr ""

msgid "Template strings"

msgstr ""

msgid ""

"Template strings provide simpler string substitutions as described in :pep:"

"`292`. A primary use case for template strings is for internationalization "

"(i18n) since in that context, the simpler syntax and functionality makes it "

"easier to translate than other built-in string formatting facilities in "

"Python. As an example of a library built on template strings for i18n, see "

"the `flufl.i18n <http://flufli18n.readthedocs.io/en/latest/>`_ package."

msgstr ""

msgid ""

"Template strings support ``$``-based substitutions, using the following "

"rules:"

msgstr ""

msgid "``$$`` is an escape; it is replaced with a single ``$``."

msgstr ""

msgid ""

"``$identifier`` names a substitution placeholder matching a mapping key of "

"``\"identifier\"``. By default, ``\"identifier\"`` is restricted to any "

"case-insensitive ASCII alphanumeric string (including underscores) that "

"starts with an underscore or ASCII letter. The first non-identifier "

"character after the ``$`` character terminates this placeholder "

"specification."

msgstr ""

msgid ""

"``${identifier}`` is equivalent to ``$identifier``. It is required when "

"valid identifier characters follow the placeholder but are not part of the "

"placeholder, such as ``\"${noun}ification\"``."

msgstr ""

msgid ""

"Any other appearance of ``$`` in the string will result in a :exc:"

"`ValueError` being raised."

msgstr ""

msgid ""

"The :mod:`string` module provides a :class:`Template` class that implements "

"these rules. The methods of :class:`Template` are:"

msgstr ""

msgid "The constructor takes a single argument which is the template string."

msgstr ""

msgid ""

"Performs the template substitution, returning a new string. *mapping* is "

"any dictionary-like object with keys that match the placeholders in the "

"template. Alternatively, you can provide keyword arguments, where the "

"keywords are the placeholders. When both *mapping* and *kwds* are given and "

"there are duplicates, the placeholders from *kwds* take precedence."

msgstr ""

msgid ""

"Like :meth:`substitute`, except that if placeholders are missing from "

"*mapping* and *kwds*, instead of raising a :exc:`KeyError` exception, the "

"original placeholder will appear in the resulting string intact. Also, "

"unlike with :meth:`substitute`, any other appearances of the ``$`` will "

"simply return ``$`` instead of raising :exc:`ValueError`."

msgstr ""

msgid ""

"While other exceptions may still occur, this method is called \"safe\" "

"because it always tries to return a usable string instead of raising an "

"exception. In another sense, :meth:`safe_substitute` may be anything other "

"than safe, since it will silently ignore malformed templates containing "

"dangling delimiters, unmatched braces, or placeholders that are not valid "

"Python identifiers."

msgstr ""

msgid ":class:`Template` instances also provide one public data attribute:"

msgstr ""

msgid ""

"This is the object passed to the constructor's *template* argument. In "

"general, you shouldn't change it, but read-only access is not enforced."

msgstr ""

msgid "Here is an example of how to use a Template::"

msgstr ""

msgid ""

"Advanced usage: you can derive subclasses of :class:`Template` to customize "

"the placeholder syntax, delimiter character, or the entire regular "

"expression used to parse template strings. To do this, you can override "

"these class attributes:"

msgstr ""

msgid ""

"*delimiter* -- This is the literal string describing a placeholder "

"introducing delimiter. The default value is ``$``. Note that this should "

"*not* be a regular expression, as the implementation will call :meth:`re."

"escape` on this string as needed. Note further that you cannot change the "

"delimiter after class creation (i.e. a different delimiter must be set in "

"the subclass's class namespace)."

msgstr ""

msgid ""

"*idpattern* -- This is the regular expression describing the pattern for non-"

"braced placeholders. The default value is the regular expression ``(?a:[_a-"

"z][_a-z0-9]*)``. If this is given and *braceidpattern* is ``None`` this "

"pattern will also apply to braced placeholders."

msgstr ""

msgid ""

"Since default *flags* is ``re.IGNORECASE``, pattern ``[a-z]`` can match with "

"some non-ASCII characters. That's why we use the local ``a`` flag here."

msgstr ""

msgid ""

"*braceidpattern* can be used to define separate patterns used inside and "

"outside the braces."

msgstr ""

msgid ""

"*braceidpattern* -- This is like *idpattern* but describes the pattern for "

"braced placeholders. Defaults to ``None`` which means to fall back to "

"*idpattern* (i.e. the same pattern is used both inside and outside braces). "

"If given, this allows you to define different patterns for braced and "

"unbraced placeholders."

msgstr ""

msgid ""

"*flags* -- The regular expression flags that will be applied when compiling "

"the regular expression used for recognizing substitutions. The default "

"value is ``re.IGNORECASE``. Note that ``re.VERBOSE`` will always be added "

"to the flags, so custom *idpattern*\\ s must follow conventions for verbose "

"regular expressions."

msgstr ""

msgid ""

"Alternatively, you can provide the entire regular expression pattern by "

"overriding the class attribute *pattern*. If you do this, the value must be "

"a regular expression object with four named capturing groups. The capturing "

"groups correspond to the rules given above, along with the invalid "

"placeholder rule:"

msgstr ""

msgid ""

"*escaped* -- This group matches the escape sequence, e.g. ``$$``, in the "

"default pattern."

msgstr ""

msgid ""

"*named* -- This group matches the unbraced placeholder name; it should not "

"include the delimiter in capturing group."

msgstr ""

msgid ""

"*braced* -- This group matches the brace enclosed placeholder name; it "

"should not include either the delimiter or braces in the capturing group."

msgstr ""

msgid ""

"*invalid* -- This group matches any other delimiter pattern (usually a "

"single delimiter), and it should appear last in the regular expression."

msgstr ""

msgid "Helper functions"

msgstr ""

msgid ""

"Split the argument into words using :meth:`str.split`, capitalize each word "

"using :meth:`str.capitalize`, and join the capitalized words using :meth:"

"`str.join`. If the optional second argument *sep* is absent or ``None``, "

"runs of whitespace characters are replaced by a single space and leading and "

"trailing whitespace are removed, otherwise *sep* is used to split and join "

"the words."

msgstr ""