Получение пользовательского ввода в python с input()

Formatter Methods

The Formatter class takes no initialization arguments:

fmt = Formatter()

The public API methods of class Formatter are as follows:

-- format(format_string, *args, **kwargs)
-- vformat(format_string, args, kwargs)

‘format’ is the primary API method. It takes a format template, and an arbitrary set of positional and keyword arguments. ‘format’ is just a wrapper that calls ‘vformat’.

‘vformat’ is the function that 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 **kwds syntax. ‘vformat’ does the work of breaking up the format template string into character data and replacement fields. It calls the ‘get_positional’ and ‘get_index’ methods as appropriate (described below.)

Formatter defines the following overridable methods:

-- get_value(key, args, kwargs)
-- check_unused_args(used_args, args, kwargs)
-- format_field(value, format_spec)

‘get_value’ is used to 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’.

The ‘args’ parameter is set to the list of positional arguments to ‘vformat’, and the ‘kwargs’ parameter is set to the dictionary of positional arguments.

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.

So for example, the field expression ‘0.name’ would cause ‘get_value’ to be called with a ‘key’ argument of 0. The ‘name’ attribute will be looked up after ‘get_value’ returns by calling the built-in ‘getattr’ function.

If the index or keyword refers to an item that does not exist, then an IndexError/KeyError should be raised.

‘check_unused_args’ is used to 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. ‘check_unused_args’ is assumed to throw an exception if the check fails.

‘format_field’ simply calls the global ‘format’ built-in. The method is provided so that subclasses can override it.

To get a better understanding of how these functions relate to each other, here is pseudocode that explains the general operation of vformat:

def vformat(format_string, args, kwargs):

  # Output buffer and set of used args
  buffer = StringIO.StringIO()
  used_args = set()

  # Tokens are either format fields or literal strings
  for token in self.parse(format_string):
    if is_format_field(token):
      # Split the token into field value and format spec
      field_spec, _, format_spec = token.partition(":")

      # Check for explicit type conversion
      explicit, _, field_spec  = field_spec.rpartition("!")

      # 'first_part' is the part before the first '.' or ' or .subfield. Assume that 'components'
      # returns an iterator of the various subfields, not including
      # the first part.
      for comp in components(field_spec):
        value = resolve_subfield(value, comp)

      # Handle explicit type conversion
      if explicit == 'r':
        value = repr(value)
      elif explicit == 's':
        value = str(value)

      # Call the global 'format' function and write out the converted
      # value.
      buffer.write(self.format_field(value, format_spec))


  self.check_unused_args(used_args, args, kwargs)
  return buffer.getvalue()

No binary f-strings

For the same reason that we don’t support bytes.format(), you may not combine 'f' with 'b' string literals. The primary problem is that an object’s __format__() method may return Unicode data that is not compatible with a bytes string.

Binary f-strings would first require a solution for bytes.format(). This idea has been proposed in the past, most recently in PEP 461 . The discussions of such a feature usually suggest either

  • adding a method such as __bformat__() so an object can control how it is converted to bytes, or
  • having bytes.format() not be as general purpose or extensible as str.format().

Error handling

There are two classes of exceptions which can occur during formatting: exceptions generated by the formatter code itself, and exceptions generated by user code (such as a field object’s ‘getattr’ function).

In general, exceptions generated by the formatter code itself are of the «ValueError» variety — there is an error in the actual «value» of the format string. (This is not always true; for example, the string.format() function might be passed a non-string as its first parameter, which would result in a TypeError.)

The text associated with these internally generated ValueError exceptions will indicate the location of the exception inside the format string, as well as the nature of the exception.

For exceptions generated by user code, a trace record and dummy frame will be added to the traceback stack to help in determining the location in the string where the exception occurred. The inserted traceback will indicate that the error occurred at:

File "<format_string>;", line XX, in column_YY

where XX and YY represent the line and character position information in the string, respectively.

5.6. Приемы использования цикла

Когда цикл проходит по словарям, ключ и связанное значение могут быть извлечены одновременно с помощью метода .

Когда цикл проходит через последовательность, позиционный индекс и связанное значение могут быть извлечены одновременно с помощью функции .

При прохождении цикла через две и более последовательности одновременно, записи могут быть объединены в пары с помощью функции .

Для перебора последовательности в обратном направлении, сначала указывают последовательность в прямом направлении и затем вызывают функцию :

Для цикла по последовательности в отсортированном порядке, используйте функцию , которая возвращает новый отсортированный список, оставляя исходный неизменным.

Иногда заманчиво изменить список, пока вы перебираете его в цикле; однако вместо этого обычно проще и безопаснее создать новый список.

Arguments as format codes using format()

You can also pass format codes like precision, alignment, fill character as positional or keyword arguments dynamically.

Example 10: Dynamic formatting using format()




  • In the first example, ‘cat’ is the positional argument is to be formatted. Likewise, , and are keyword arguments.
  • In the template string, these keyword arguments are not retrieved as normal strings to be printed but as the actual format codes . The arguments replaces the corresponding named placeholders and the string ‘cat’ is formatted accordingly.
  • Likewise, in the second example, 123.236 is the positional argument and, align, width and precision are passed to the template string as format codes.

Formatting class and dictionary members using format()

Python internally uses for class members in the form «.age». And, it uses lookup for dictionary members in the form «».

Example 8: Formatting class members using format()


Adam's age is: 23

Here, object is passed as a keyword argument p.

Inside the template string, Person’s name and age are accessed using and respectively.

Example 9: Formatting dictionary members using format()


Adam's age is: 23

Similar to class, dictionary is passed as a keyword argument p.

Inside the template string, person’s name and age are accessed using and respectively.

There’s an easier way to format dictionaries in Python using .

is a format parameter (minimum field width).

Python f-строки: особенности использования

Теперь, когда вы узнали все о том, почему f-строки великолепны, я уверен, что вы захотите начать их использовать. Вот несколько деталей, о которых нужно помнить, когда вы отправляетесь в этот дивный новый мир.


Вы можете использовать различные типы кавычек внутри выражений. Просто убедитесь, что вы не используете кавычки того же типа на внешней стороне f-строки, которые вы используете в выражении.

Этот код будет работать:

>>> f"{'Eric Idle'}"
'Eric Idle'

Этот код также будет работать:

>>> f'{"Eric Idle"}'
'Eric Idle'

Вы также можете использовать тройные кавычки:

>>> f"""Eric Idle"""
'Eric Idle'
>>> f'''Eric Idle'''
'Eric Idle'

Если вам нужно использовать одинаковый тип кавычки как внутри, так и снаружи строки, вы можете сделать это с помощью \:

>>> f"The \"comedian\" is {name}, aged {age}."
'The "comedian" is Eric Idle, aged 74.'


Говоря о кавычках, следите, когда вы работаете со словарями. Если вы собираетесь использовать одинарные кавычки для ключей словаря, то не забудьте убедиться, что вы используете двойные кавычки для f-строк, содержащих ключи.

>>> comedian = {'name': 'Eric Idle', 'age': 74}
>>> f"The comedian is {comedian}, aged {comedian}."
The comedian is Eric Idle, aged 74.

Пример с синтаксической ошибкой:

>>> comedian = {'name': 'Eric Idle', 'age': 74}
>>> f'The comedian is {comedian}, aged {comedian}.'
  File "<stdin>", line 1
    f'The comedian is {comedian}, aged {comedian}.'
SyntaxError: invalid syntax

Если вы используете тот же тип кавычки вокруг ключей словаря, что и на внешней стороне f-строки, то кавычка в начале первого ключа словаря будет интерпретироваться как конец строки.

Фигурные скобки

Чтобы в скобках появилась скобка, вы должны использовать двойные скобки:

>>> f"{{74}}"

Обратите внимание, что использование тройных скобок приведет к тому, что в вашей строке будут только одиночные скобки:

>>> f"{{{74}}}"

Тем не менее, вы можете получить больше фигурных скобок, если вы используете больше, чем тройные фигурные скобки:

>>> f"{{{{74}}}}"

Обратный слеш

Как вы видели ранее, вы можете использовать обратные слэши в строковой части f-строки. Однако вы не можете использовать обратную косую черту для экранирования части выражения f-строки:

>>> f"{\"Eric Idle\"}"
  File "<stdin>", line 1
    f"{\"Eric Idle\"}"
SyntaxError: f-string expression part cannot include a backslash

Вы можете обойти это, предварительно посчитав выражение и используя результат в f-строке:

>>> name = "Eric Idle"
>>> f"{name}"
'Eric Idle'

Выражения не должны содержать комментарии, использующие символ #. Используя это вы получите синтаксическую ошибку:

>>> f"Eric is {2 * 37 #Oh my!}."
  File "<stdin>", line 1
    f"Eric is {2 * 37 #Oh my!}."
SyntaxError: f-string expression part cannot include '#'

User-Defined Formatting

There will be times when customizing the formatting of fields on a per-type basis is not enough. An example might be a spreadsheet application, which displays hash marks ‘#’ when a value is too large to fit in the available space.

For more powerful and flexible formatting, access to the underlying format engine can be obtained through the ‘Formatter’ class that lives in the ‘string’ module. This class takes additional options which are not accessible via the normal str.format method.

An application can subclass the Formatter class to create its own customized formatting behavior.

The PEP does not attempt to exactly specify all methods and properties defined by the Formatter class; instead, those will be defined and documented in the initial implementation. However, this PEP will specify the general requirements for the Formatter class, which are listed below.

Создание файла

В Python, чтобы создать файл, надо его открыть в режиме записи (‘w’, ‘wb’) или дозаписи (‘a’, ‘ab’).

f2 = open("text2.txt", 'w')

Функция open() возвращает файловый объект.

Без ‘b’ создается текстовый файл, представляющий собой поток символов. С ‘b’ — файл, содержащий поток байтов.

В Python также существует режим ‘x’ или ‘xb’. В этом режиме проверяется, есть ли файл. Если файл с определенным именем уже существует, он не будет создан. В режиме ‘w’ файл создается заново, старый при этом теряется.

>>> f1 = open('text1.txt', 'w')
>>> f2 = open('text1.txt', 'x')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FileExistsError: Errno 17 File exists: 'text1.txt'
>>> f3 = open('text1.txt', 'w')

String format()

The method allows you to format selected parts of a string.

Sometimes there are parts of a text that you do not control, maybe they come from a database, or user input?

To control such values, add placeholders (curly brackets ) in the text, and run the values through the method:


Add a placeholder where you want to display the price:

price = 49txt = «The price is {} dollars»print(txt.format(price))

You can add parameters inside the curly brackets to specify how to convert the value:


Format the price to be displayed as a number with two decimals:

txt = «The price is {:.2f} dollars»

Check out all formatting types in our String format() Reference.

The Placeholders

The placeholders can be identified using named indexes , numbered indexes , or even empty placeholders .


Using different placeholder values:

txt1 = «My name is {fname}, I’am {age}».format(fname = «John», age = 36)txt2 = «My name is {0}, I’am {1}».format(«John»,36)txt3 = «My name is {}, I’am {}».format(«John»,36)

Formatting Types

Inside the placeholders you can add a formatting type to format the result:

Try it Left aligns the result (within the available space)
Try it Right aligns the result (within the available space)
Try it Center aligns the result (within the available space)
Try it Places the sign to the left most position
Try it Use a plus sign to indicate if the result is positive or negative
Try it Use a minus sign for negative values only
Try it Use a space to insert an extra space before positive numbers (and a minus sign befor negative numbers)
Try it Use a comma as a thousand separator
Try it Use a underscore as a thousand separator
Try it Binary format
Converts the value into the corresponding unicode character
Try it Decimal format
Try it Scientific format, with a lower case e
Try it Scientific format, with an upper case E
Try it Fix point number format
Try it Fix point number format, in uppercase format (show and as and )
General format
General format (using a upper case E for scientific notations)
Try it Octal format
Try it Hex format, lower case
Try it Hex format, upper case
Number format
Try it Percentage format

1 – «Старый стиль» форматирования строк

Строки в Python содержат встроенный оператор, к которому можно получить доступ с помощью символа %. Он позволяет легко упростить позиционное форматирование. Если раньше вы работали с функцией printf в C, то простой пример далее будет понятен мгновенно:

Здесь используется спецификатор формата %s, для указания Python, где заменить значение имени, представленного в виде строки.

Существуют и другие спецификаторы формата, которые позволяют управлять форматом вывода. Например, можно преобразовать числа в шестнадцатеричную систему счисления или добавить пробелы при генерации красиво отформатированных таблиц и отчетов.

Можно также использовать спецификатор формата % для преобразования значения int в строку представленное как шестнадцатеричное число:

Синтаксис форматирования строки «старого стиля» немного меняется, если нужно сделать несколько подстановок в одной строке. Поскольку оператор % принимает только один аргумент, нужно обернуть правую часть переменных в кортеж.

Также можно ссылаться на имена переменных в строке форматирования, если их передать в шаблон через словарь:

Это упрощает процесс форматирования и ускоряет его модификацию в будущем. Не нужно беспокоиться о том, что порядок, который передаётся в значениях, совпадает с порядком, на который ссылаются значения в строке формата. Конечно, недостатком является то, что этот метод требует немного большего набора текста.

После прочтения у вас может возникнуть вопрос, почему форматирование в стиле printf называется форматированием строки «старого стиля»? Потому что оно было технически заменено форматированием «нового стиля», о котором будет рассказано далее.

Customizing Formatters

This section describes some typical ways that Formatter objects can be customized.

To support alternative format-string syntax, the ‘vformat’ method can be overridden to alter the way format strings are parsed.

One common desire is to support a ‘default’ namespace, so that you don’t need to pass in keyword arguments to the format() method, but can instead use values in a pre-existing namespace. This can easily be done by overriding get_value() as follows:

class NamespaceFormatter(Formatter):
   def __init__(self, namespace={}):
       self.namespace = namespace

   def get_value(self, key, args, kwds):
       if isinstance(key, str):
               # Check explicitly passed arguments first
               return kwds
           except KeyError:
               return self.namespace
           Formatter.get_value(key, args, kwds)

One can use this to easily create a formatting function that allows access to global variables, for example:

fmt = NamespaceFormatter(globals())

greeting = "hello"
print(fmt.format("{greeting}, world!"))

A similar technique can be done with the locals() dictionary to gain access to the locals dictionary.

It would also be possible to create a ‘smart’ namespace formatter that could automatically access both locals and globals through snooping of the calling stack. Due to the need for compatibility with the different versions of Python, such a capability will not be included in the standard library, however it is anticipated that someone will create and publish a recipe for doing this.

Escape sequences

Backslashes may not appear inside the expression portions of f-strings, so you cannot use them, for example, to escape quotes inside f-strings:

>>> f'{\'quoted string\'}'
  File "<stdin>", line 1
SyntaxError: f-string expression part cannot include a backslash

You can use a different type of quote inside the expression:

>>> f'{"quoted string"}'
'quoted string'

Backslash escapes may appear inside the string portions of an f-string.

Note that the correct way to have a literal brace appear in the resulting string value is to double the brace:

>>> f'{{ {4*10} }}'
'{ 40 }'
>>> f'{{{4*10}}}'

Like all raw strings in Python, no escape processing is done for raw f-strings:

>>> fr'x={4*10}\n'

Due to Python’s string tokenizing rules, the f-string f'abc {a} def' is invalid. The tokenizer parses this as 3 tokens: f'abc {a[', x, and ']} def'. Just like regular strings, this cannot be fixed by using raw strings. There are a number of correct ways to write this f-string: with a different quote character:

f"abc {a} def"

Or with triple quotes:

5.3. Кортежи и последовательности

Мы видели, что списки и строки имеют много общих свойств, такие как индексирование и операция взятия среза. Они являются двумя примерами типа данных последовательностей (см. ). Поскольку Python — развивающийся язык, другие типы данных последовательностей могут быть добавлены. Существует также другой стандартный тип данных последовательностей: tuple (кортеж).

Кортеж состоит из ряда значений, разделенных запятыми, например:

Как вы видите, при выводе кортежи всегда заключены в скобки, так что вложенные кортежи интерпретируются корректно; они могут быть введены с и без окружающих скобок, хотя часто скобки необходимы в любом случае (если кортеж является частью большего выражения). Невозможно присвоить индивидуальному элементу кортежа, однако возможно создать кортежи, которые содержат изменяемые объекты, такие как списки.

Хотя кортежи могут показаться подобными спискам, они часто используются в разных ситуациях и для различных целей. Кортежи неизменяемые (docs.python.org/3/glossary.html#term-immutable) и обычно включают разнородную последовательность элементов, которые доступны через распаковку (см. позже в этом разделе) или индексирование (или даже по атрибуту в случае namedtuples (docs.python.org/3/library/collections.html#collections.namedtuple)). Списки изменяемы (docs.python.org/3/glossary.html#term-mutable), а их элементы обычно однородны и доступны посредством итерации списка.

Особая проблема — создание кортежей, включающих 0 или 1 элемент: у синтаксиса есть некоторые дополнительные особенности для этого. Пустые кортежи создаются пустой парой скобок; кортежи с одним элементом — значением после которого идет запятая (недостаточно заключить одиночное значение в скобки). Уродливо, но эффективно. Например:

Выражение является примером упаковки кортежа: значения , и упаковываются вместе в кортеж. Обратная операция также возможна:

Это называется распаковкой последовательности и работает для любой последовательности с правой стороны. Распаковка последовательности требует, чтобы было в наличии так много переменных с левой стороны от знака равенства, сколько есть элементов в последовательности

Обратите внимание, что множественное присваивание на самом деле есть просто комбинирование упаковки кортежа и распаковки последовательности

Python NumPy

NumPy IntroNumPy Getting StartedNumPy Creating ArraysNumPy Array IndexingNumPy Array SlicingNumPy Data TypesNumPy Copy vs ViewNumPy Array ShapeNumPy Array ReshapeNumPy Array IteratingNumPy Array JoinNumPy Array SplitNumPy Array SearchNumPy Array SortNumPy Array FilterNumPy Random Random Intro Data Distribution Random Permutation Seaborn Module Normal Distribution Binomial Distribution Poisson Distribution Uniform Distribution Logistic Distribution Multinomial Distribution Exponential Distribution Chi Square Distribution Rayleigh Distribution Pareto Distribution Zipf Distribution

NumPy ufunc ufunc Intro ufunc Create Function ufunc Simple Arithmetic ufunc Rounding Decimals ufunc Logs ufunc Summations ufunc Products ufunc Differences ufunc Finding LCM ufunc Finding GCD ufunc Trigonometric ufunc Hyperbolic ufunc Set Operations

Чтение данных из файла

Если в функцию open() не передается второй аргумент, файл расценивается как текстовый и открывается на чтение.

Попытка открыть на чтение несуществующий файл вызывает ошибку.

>>> f = open("text10.txt")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IOError: Errno 2 No such file or directory: 'text10.txt'

Перехватить возникшее исключение можно с помощью конструкции try-except.

>>> try:
...     f = open("text10.txt")
... except IOError:
...     print ("No file")
No file

Получить все данные из файла можно с помощью метода read() файлового объекта, предварительно открыв файл на чтение. При этом файловый объект изменяется и получить из него данные еще раз не получится.

>>> f = open("text.txt")
>>> f
<_io.TextIOWrapper name='text.txt' mode='r' encoding='UTF-8'>
>>> fd = f.read()
>>> fd1 = f.read()
>>> fd
'Hello\n\tOne\n   Two\nThree Four\nШесть!\n'
>>> fd1

Методу read() может быть передан один аргумент, обозначающий количество байт для чтения.

>>> f = open("text.txt")
>>> fd = f.read(10)
>>> fd1 = f.read(5)
>>> fd
>>> fd1
'\n   T'

Метод readline() позволяет получать данные построчно.

>>> f = open("text.txt")
>>> f.readline()
>>> f.readline()
>>> f.readline()
'   Two\n'

Принимает аргумент — число байт.

>>> f.readline(3)
>>> f.readline(3)
'ee '
>>> f.readline(3)
>>> f.readline(3)
>>> f.readline(5)
>>> f.readline(5)

Метод readlines() считывает все строки и помещает их в список.

>>> f = open("text.txt")
>>> fd = f.readlines()
>>> fd
'Hello\n', '\tOne\n', '   Two\n', 'Three Four\n', 'Шесть!\n'

Может принимать количество байт, но дочитывает строку до конца.

>>> f = open("text.txt")
>>> fd = f.readlines(3)
>>> fd
>>> fd1 = f.readlines(6)
>>> fd1
'\tOne\n', '   Two\n'

С этим читают