{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Программирование на Python\n", "\n", "*Алла Тамбовцева, НИУ ВШЭ*\n", "\n", "*Данный ноутбук частично основан на [лекции](http://python.math-hse.info:8080/github/ischurov/pythonhse/blob/master/Lecture%201.ipynb) Щурова И.В., [курс](http://math-info.hse.ru/s15/m) «Программирование на языке Python для сбора и анализа данных» (НИУ ВШЭ).*" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Типы данных в Python и приведение типов" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Типы данных:\n", "\n", "* *integer (int)*: целочисленный;\n", "* *float*: числовой с плавающей точкой;\n", "* *string (str)*: строковый;\n", "* *boolean (bool)*: логический, значения `True` и `False`;\n", "* *list*: список, хранит элементы разных типов, можно изменять;\n", "* *tuple*: кортеж, хранит элементы разных типов, нельзя изменять;\n", "* *set*: множество, хранит уникальные элементы, их порядок не важен;\n", "* *dictionary (dict)*: словарь, хранит пары ключ-значение , их порядок не важен." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "С целочисленным типом и числами с плавающей точкой мы уже познакомились. Посмотрим, как определить тип переменной:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "float" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x = 2.34\n", "type(x)" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "int" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y = 2\n", "type(y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Чтобы создать переменную строкового типа, нужны кавычки, причём использовать можно как двойные, так и одинарные:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "str" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "text = \"hello\"\n", "text2 = 'hello'\n", "type(text)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Иногда требуется преобразовать тип переменной, например, из числа с плавающей точкой сделать целое число. Зачем это бывает нужно? Для удобства и для более корректной выдачи результатов. Например, у нас есть база данных по респондентам, в которой указан их год рождения, и мы хотим добавить столбец с возрастом респондентов (числом полных лет). Из-за того, что кто-то ввел год в виде 1993.0, возраст при вычислениях тоже получится числом с плавающей точкой — 25.0. Так как мы знаем, что возраст всегда будет целым, чтобы дробная часть не смущала, можно привести все значения к целочисленному типу. " ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "25" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "int(25.0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Вообще функции для изменения типа переменных называются так же, как и сами типы или их сокращённые названия." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "23.0" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "float(23)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'2'" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "str(2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Однако, если преобразование невозможно, Python выдаст ошибку (а точнее, исключение `ValueError`, про исключения поговорим позже):" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "ename": "ValueError", "evalue": "could not convert string to float: '23,56'", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'23,56'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mValueError\u001b[0m: could not convert string to float: '23,56'" ] } ], "source": [ "float('23,56')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Так как запятая в Python не воспринимается как десятичный разделитель (в качестве разделителя используется точка), превратить строку '23,56' в число не получится, нужно будет сначала заменить запятую на точку. Как работать со строками, мы обсудим позже, но если интересно, можно сделать следующее: создать любую строковую переменную, а потом после её названия поставить точку и нажать *Tab*. Так же, как и в случае с модулем `math`, выпадет список всех возможных методов, которые можно применять к строке. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "У Python активно реализуется перегрузка операторов, которая выражается в том, что одни и те же операторы могут выполнять разные задачи в зависимости от типа данных, к которым они применяются. Если говорить совсем формально и залезать в терминологию объектно-ориентированного программирования, для Python характерен полиморфизм – разное поведение операций и методов на разных классах. О классах мы будем говорить позже, а пока посмотрим на примеры такого поведения." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'abcdef'" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "one = \"abc\"\n", "two = \"def\"\n", "\n", "one + two" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "По идее, при исполнении кода выше мы должны были получить ошибку, нельзя применять сложение не к числам. Но нет: операция сложения в Python на строках тоже имеет смысл – она обеспечивает конкатенацию (склеивание) строк. А можно ли умножать строку на число? Давайте проверим:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'abcabc'" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "one * 2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Как выяснилось, можно. Здесь операция умножения работает как в математике: умножить число на число – то же самое что сложить это число необходимое количество раз. А складывать строки (то есть склеивать) Python умеет.\n", "Но, конечно, аналогии не могут продолжаться бесконечно:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "unsupported operand type(s) for ** or pow(): 'str' and 'int'", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mone\u001b[0m \u001b[0;34m**\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for ** or pow(): 'str' and 'int'" ] } ], "source": [ "one ** 2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Ввод и вывод" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Ввод информации с клавиатуры" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Иногда возникает необходимость запросить какую-нибудь информацию у пользователя — попросить ввести её с клавиатуры. Это может быть нужно, например, когда мы пытаемся имитировать заполнение какой-нибудь формы (собрать информацию и обработать) или написать функцию, которая будет работать по-разному в зависимости от режима (\"Если хотите выгрузить данные из файла, нажмите 1, если хотите вводить данные вручную, введите 2\"). \n", "\n", "Запросить данные с клавиатуры можно с помощью функции `input()`:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "smth\n" ] }, { "data": { "text/plain": [ "'smth'" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "input()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Однако обычно нам нужно не просто вывести на экран то, что ввёл пользователь (он и сам это видит), но и сохранить введенную информацию. Сделаем это (и заодно перейдём к числам)." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Введите какое-нибудь число: 5\n" ] } ], "source": [ "num = input(\"Введите какое-нибудь число: \")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Теперь мы можем работать с переменной `num`, в которую мы сохранили результат ввода с клавиатуры. " ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'5'" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "num" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Введенное нами число 5 сохранилось. Однако, если посмотреть внимательнее, это не совсем число, это строка! Проверим:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "str" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(num) # действительно" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Функция `input()` всегда возвращает обект типа *string*. Тут нам и пригодится преобразование типов переменных:" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "5" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "num = int(num)\n", "num" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "И теперь всё сразу: правильно и компактно." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Введите какое-нибудь число: 7\n" ] }, { "data": { "text/plain": [ "7" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "num = int(input(\"Введите какое-нибудь число: \"))\n", "num" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Раз мы не предлагаем пользователю ввести именно целое число, число может быть любым, даже дробным. Учтём это – будем конвертировать введенный текст в число с плавающей точкой. " ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Введите какое-нибудь число: 6.5\n" ] }, { "data": { "text/plain": [ "6.5" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "num = float(input(\"Введите какое-нибудь число: \"))\n", "num" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "С клавиатуры можно вводить сколько угодно объектов:" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Введите числа через пробел: 2 3\n" ] } ], "source": [ "numbers = input(\"Введите числа через пробел: \")" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'2 3'" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "numbers" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Только тогда для работы с отдельными элементами ввода потребуется разбить строку на части по какому-нибудь символу (в нашем случае – по пробелу). О разбиении текста на части поговорим позже, когда будем обсуждать работу со строками, а пока разберём вывод информации на экран." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Вывод информации на экран" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Как мы уже знаем, для вывода чего-либо на экран в Python существует функция `print()`:" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5\n", "Hello!\n" ] } ], "source": [ "print(5)\n", "print('Hello!')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Для того, чтобы вывести на экран сразу несколько объектов, нужно просто перечислить их через запятую в круглых скобках." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Your age is 23\n" ] } ], "source": [ "age = 23\n", "print('Your age is ', age)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "По умолчанию в качестве разделителей (отделяющих объекты друг от друга) используются пробелы. Но при желании это можно поправить, добавив аргумент `sep` (от *separator* – разделитель):" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2-3\n" ] } ], "source": [ "print(2, 3, sep='-')" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2------3\n" ] } ], "source": [ "print(2, 3, sep='------')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "При работе с функцией `print()` важно помнить, что эта функция используется исключительно для вывода текста на экран, она ничего не возвращает – не умеет сохранять то, что выводит на экран. Если попробуем сохранить результат её исполнения, получим пустой объект – объект особого типа `None`:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2-3\n", "None\n" ] } ], "source": [ "s = print(2, 3, sep='-')\n", "print(s)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Форматирование строк (string formatting)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "А теперь посмотрим на то, как подставлять значения в уже имеющийся текстовый шаблон, то есть форматировать строки. Чтобы понять, о чём идет речь, можно представить, что у нас есть электронная анкета, которую заполняет пользователь, и мы должны написать программу, которая выводит на экран введенные данные, чтобы пользователь мог их проверить.\n", "\n", "Пусть для начала пользователь вводит своё имя и возраст." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Введите Ваше имя: Алла\n", "Введите Ваш возраст: 28\n" ] } ], "source": [ "name = input(\"Введите Ваше имя: \")\n", "age = int(input(\"Введите Ваш возраст: \"))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Теперь выведем на экран сообщение вида \n", "\n", " Ваше имя: `имя`. Ваш возраст: `возраст`. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Но прежде, чем это сделать, поймем, какого типа будут значения, которые мы будем подставлять в шаблон. Имя – это строка (*string*), а возраст – это целое число (*integer*)." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Ваше имя: Алла. Ваш возраст: 28.\n" ] } ], "source": [ "result = \"Ваше имя: %s. Ваш возраст: %i.\" % (name, age)\n", "print(result)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Что за таинственные `%s` и `%i`? Все просто: оператор `%` в строке указывает место, на которое будет подставляться значение, а буква сразу после процента – сокращённое название типа данных (`s` – от *string* и `i` – от *integer*). Осталось только сообщить Python, что именно нужно подставлять – после кавычек поставить `%` и в скобках перечислить названия переменных, значения которых мы будем подставлять. \n", "\n", "Конечно, результат можно выводить сразу, не сохраняя полученную строку в переменную." ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Ваше имя: Алла. Ваш возраст: 28.\n" ] } ], "source": [ "print(\"Ваше имя: %s. Ваш возраст: %i.\" % (name, age))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ ">**Примечание:** не теряйте часть с переменными после самой строки, а также круглые скобки вокруг названий переменных, из которых мы подставляем значения, если их несколько." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Важно помнить, что если мы забудем указать какую-то из переменных, мы получим ошибку (точнее, исключение): Python не будет знать, откуда брать нужные значения. " ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "not enough arguments for format string", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Ваше имя: %s. Ваш возраст: %i.\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: not enough arguments for format string" ] } ], "source": [ "print(\"Ваше имя: %s. Ваш возраст: %i.\" % (name))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Кроме того, создавая такие текстовые шаблоны, нужно обращать внимание на типы переменных, значения которых мы подставляем. " ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Ваше имя: Алла. Ваш возраст: 28.\n" ] } ], "source": [ "print(\"Ваше имя: %s. Ваш возраст: %s.\" % (name, age)) # так сработает, int -> str" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "%i format: a number is required, not str", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Ваше имя: %i. Ваш возраст: %s.\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# а так нет, str !-> int\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: %i format: a number is required, not str" ] } ], "source": [ "print(\"Ваше имя: %i. Ваш возраст: %s.\" % (name, age)) # а так нет, str !-> int" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "А что будет, если мы будем подставлять не целое число, а дробное, с плавающей точкой? Попробуем!" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Введите Ваш рост (в метрах): 1.68\n" ] }, { "data": { "text/plain": [ "1.68" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "height = float(input(\"Введите Ваш рост (в метрах): \"))\n", "height" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Ваш рост: 1.680000 м.\n" ] } ], "source": [ "print(\"Ваш рост: %f м.\" % height) # f - от float" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "По умолчанию при подстановке значений типа *float* Python выводит число с шестью знаками после запятой. Но это можно исправить. Перед `f` нужно поставить точку и указать число знаков после запятой, которое мы хотим:" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Ваш рост: 1.68 м.\n" ] } ], "source": [ "print(\"Ваш рост: %.2f м.\" % height) # например, два" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Ваш рост: 1.7 м. \n" ] } ], "source": [ "print(\"Ваш рост: %.1f м. \" % height) # или один" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "В случае, если указанное число знаков после запятой меньше, чем есть на самом деле (как в ячейке выше), происходит обычное арифметическое округление." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Рассмотренный выше способ форматирования строк – не единственный. Он довольно стандартный, но при этом немного устаревший. В Python 3 есть другой способ – форматирование с помощью метода `.format()`. Кроме того, в Python 3.6 и более поздних версиях появился ещё более продвинутый способ форматирования строк ‒ *f-strings* *(formatted string literals)*. Этот способ позволяет не только подставлять в текстовый шаблон значения переменных, но и исполнять выражения с кодом внутри строки. \n", "\n", "F-strings очень удобны и просты в использовании: вместо `%` и сокращённого названия типа в фигурных скобках внутри текстового шаблона нужно указать название переменной, из которой должно подставляться значение, а перед всей строкой добавить `f`, чтобы Python знал, что нам нужна именно *f-string*." ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Ваше имя: Алла. Ваш возраст: 28.\n" ] } ], "source": [ "print(f\"Ваше имя: {name}. Ваш возраст: {age}.\")" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Ваш рост: 1.68.\n" ] } ], "source": [ "print(f\"Ваш рост: {height}.\") # нет лишних знаков" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Ваш рост: 1.7.\n" ] } ], "source": [ "print(f\"Ваш рост: {round(height, 1)}.\") # пример выражения" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Возраст в квадрате: 784.\n" ] } ], "source": [ "print(f\"Возраст в квадрате: {age ** 2}.\") # пример выражения" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.4" } }, "nbformat": 4, "nbformat_minor": 2 }