diff --git a/arithmetic.ipynb b/arithmetic.ipynb index ef6c36b..ba393c2 100644 --- a/arithmetic.ipynb +++ b/arithmetic.ipynb @@ -303,7 +303,7 @@ "source": [ "a = 4\n", "b = 3\n", - "a ** b" + "a**b" ] }, { @@ -319,7 +319,7 @@ "\n", "Для создания комплексного числа можно использовать функцию `complex(a, b)`, в\n", "которую, в качестве первого аргумента, передается действительная часть, в качестве\n", - "второго – мнимая. Либо записать число в виде `a + bj`.\n", + "второго – мнимая. Либо записать число в виде `a+bj`.\n", "\n", "Рассмотрим несколько примеров.\n", "\n", @@ -334,7 +334,7 @@ }, "outputs": [], "source": [ - "z = 1 + 2j\n", + "z = 1+2j\n", "print(z)" ] }, @@ -346,8 +346,8 @@ }, "outputs": [], "source": [ - "x = complex ( 3 , 2 )\n", - "print (x)" + "x = complex(3, 2)\n", + "print(x)" ] }, { @@ -366,7 +366,7 @@ }, "outputs": [], "source": [ - "x + z" + "x+z" ] }, { @@ -377,7 +377,7 @@ }, "outputs": [], "source": [ - "x - z" + "x-z" ] }, { @@ -388,7 +388,7 @@ }, "outputs": [], "source": [ - "x * z" + "x*z" ] }, { @@ -399,7 +399,7 @@ }, "outputs": [], "source": [ - "x / z" + "x/z" ] }, { @@ -410,7 +410,7 @@ }, "outputs": [], "source": [ - "x ** z" + "x**z" ] }, { @@ -421,7 +421,7 @@ }, "outputs": [], "source": [ - "x ** 3" + "x**3" ] }, { @@ -439,7 +439,7 @@ }, "outputs": [], "source": [ - "x = 3 + 2j\n", + "x = 3+2j\n", "x.real" ] }, @@ -687,7 +687,7 @@ }, "outputs": [], "source": [ - "math.ceil( 3.2 )" + "math.ceil(3.2)" ] }, { @@ -747,7 +747,7 @@ }, "outputs": [], "source": [ - "math.floor( 3.2 )" + "math.floor(3.2)" ] }, { @@ -766,7 +766,7 @@ }, "outputs": [], "source": [ - "math.exp( 3 )" + "math.exp(3)" ] }, { @@ -805,7 +805,7 @@ }, "outputs": [], "source": [ - "math.log10( 1000 )" + "math.log10(1000)" ] }, { diff --git a/datatype.ipynb b/datatype.ipynb index 7ca4f8d..b3fff2f 100644 --- a/datatype.ipynb +++ b/datatype.ipynb @@ -10,6 +10,7 @@ " \n", "**С.В. Лемешевский** (email: `sergey.lemeshevsky@gmail.com`), Институт математики НАН Беларуси\n", "\n", + "Date: **Feb 24, 2020**\n", "\n", "\n", "\n", @@ -17,6 +18,7 @@ "\n", "\n", "\n", + "\n", "Здесь разберем как Python работает с переменными и определим, какие\n", "типы данных можно использовать в рамках этого языка. Подробно рассмотрим модель\n", "данных Python, а также механизмы создания и изменения значения\n", @@ -130,7 +132,7 @@ "\n", "\n", "\n", - "# Модель данных\n", + "## Модель данных\n", "
\n", "\n", "Рассмотрим как создаются объекты в памяти, их устройство, процесс объявления\n", @@ -168,7 +170,7 @@ "\n", "*Идентификатор* – это уникальный признак объекта, позволяющий отличать объекты\n", "друг от друга, а *значение* – непосредственно информация, хранящаяся в памяти,\n", - "которой управляет интерпретатор.\n", + "которой управляет интерпретатор. \n", "\n", "При инициализации переменной, на уровне интерпретатора, происходит\n", "следующее:\n", @@ -178,10 +180,28 @@ "\n", "* посредством оператора `=` создается ссылка между переменной `b` и целочисленным объектом `5` (переменная `b` ссылается на объект `5`).\n", "\n", - "> **Замечание.**\n", + "> **Об именах переменных.**\n", ">\n", + "> Допустимые имена переменных в языке Python – это последовательность\n", + "> символов произвольной длины, содержащей «начальный символ»\n", + "> и ноль или более «символов продолжения». Имя переменной должно\n", + "> следовать определенным правилам и соглашениям. \n", + "> \n", + "> Первое правило касается начального символа и символов\n", + "> продолжения. Начальным символом может быть любой символ, который в\n", + "> кодировке Юникод рассматривается как принадлежащий диапазону\n", + "> алфавитных символов ASCII (`a`, `b`, ..., `z`, `A`, `B`, ..., `Z`),\n", + "> символ подчеркивания (`_`), а также символы большинства национальных\n", + "> (не английских) алфавитов. Каждый символ продолжения может быть\n", + "> любым символом из тех, что пригодны в качестве начального символа,\n", + "> а также любым непробельным символом, включая символы, которые\n", + "> в кодировке Юникод считаются цифрами, такие как (`0`, `1`, ...,\n", + "> `9`), и символ Каталана `·`. Идентификаторы чувствительны к регистру,\n", + "> поэтому `TAXRATE`, `Taxrate`, `TaxRate`, `taxRate` и `taxrate` – это\n", + "> пять разных переменных. \n", + "> \n", "> Имя переменной не должно совпадать с ключевыми словами интерпретатора\n", - "> Python . Список ключевых слов можно получить непосредственно в программе, для\n", + "> Python. Список ключевых слов можно получить непосредственно в программе, для\n", "> этого нужно подключить модуль `keyword` и воспользоваться командой\n", "> `keyword.kwlist`." ] @@ -202,7 +222,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Проверить является или нет идентификатор ключевым словом можно так:" + "> \n", + "> Проверить является или нет идентификатор ключевым словом можно так:" ] }, { @@ -216,6 +237,13 @@ "keyword.iskeyword( \"try\" )" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + ">" + ] + }, { "cell_type": "code", "execution_count": 5, @@ -227,6 +255,42 @@ "keyword.iskeyword( \"b\" )" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> **Об использовании символа подчеркивания в именах переменных.**\n", + ">\n", + "> Не должны использоваться имена, начинающиеся и заканчивающиеся двумя\n", + "> символами подчеркивания (такие как `__lt__`). В языке \n", + "> Python определено множество различных специальных методов и переменных\n", + "> с такими именами (и в случае специальных методов мы можем заменять их,\n", + "> то есть создать свои версии этих методов), но мы не должны вводить\n", + "> новые имена такого рода.\n", + "> \n", + "> Символ подчеркивания сам по себе может использоваться в качестве\n", + "> идентификатора; внутри интерактивной оболочки интерпретатора или\n", + "> в командной оболочке Python в переменной с именем `_` сохраняется\n", + "> результат последнего вычисленного выражения. Во время выполнения\n", + "> обычной программы идентификатор `_` отсутствует, если мы явно не\n", + "> определяем его в своем программном коде. Некоторые программисты \n", + "> любят использовать `_` в качестве идентификатора переменной цикла\n", + "> в циклах `for` ... `in`, когда не требуется обращаться к элементам, по\n", + "> которым выполняются итерации. Например:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "for _ in (0, 1, 2, 3, 4, 5):\n", + " print(\"Hello\")" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -237,7 +301,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": { "collapsed": false }, @@ -250,7 +314,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": { "collapsed": false }, @@ -261,7 +325,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": { "collapsed": false }, @@ -293,7 +357,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": { "collapsed": false }, @@ -307,7 +371,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": { "collapsed": false }, @@ -318,7 +382,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": { "collapsed": false }, @@ -374,7 +438,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": { "collapsed": false }, @@ -386,7 +450,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": { "collapsed": false }, @@ -408,7 +472,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": { "collapsed": false }, @@ -420,7 +484,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": { "collapsed": false }, @@ -432,7 +496,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "metadata": { "collapsed": false }, @@ -461,6 +525,1145 @@ "\n", "\n", "\n", + "# Целочисленные типы\n", + "
\n", + "\n", + "В языке Python имеется два целочисленных типа, `int` и `bool`. И целые\n", + "числа, и логические значения являются неизменяемыми объектами,\n", + "но благодаря присутствию в языке Python комбинированных операторов\n", + "присваивания эта особенность практически незаметна. В логических\n", + "выражениях число `0` и значение `False` представляют `False`, а любое\n", + "другое целое число и значение `True` представляют `True`. В числовых \n", + "выражениях значение `True` представляет `1`, а `False` – `0`. Это означает,\n", + "что можно записывать весьма странные выражения, например, выражение `i\n", + "+= True` увеличит значение `i` на единицу. Естественно, более\n", + "правильным будет записывать подобные выражения как `i += 1`. \n", + "\n", + "Размер целого числа ограничивается только объемом памяти компьютера,\n", + "поэтому легко можно создать и обрабатывать целое число, состоящее из\n", + "тысяч цифр, правда, скорость работы с такими числами существенно\n", + "медленнее, чем с числами, которые соответствуют машинному\n", + "представлению.\n", + "\n", + "Литералы целых чисел по умолчанию записываются в десятичной сис-\n", + "теме счисления, но при желании можно использовать другие системы\n", + "счисления:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "14600926" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "0b110111101100101011011110" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "0o67545336" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "0xDECADE" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Двоичные числа записываются с префиксом `0b`, восьмеричные – в\n", + "префиксом `0o` и шестнадцатеричные – с префиксом `0x`. В префиксах\n", + "допускается использовать символы верхнего регистра.\n", + "\n", + "При работе с целыми числами могут использоваться обычные\n", + "математические функции и операторы, как показано в\n", + "табл. [Таблица 1 : Арифметические операторы и функции](#datatype:tbl:1). Для арифметических операций `+`, `-`, `/`,\n", + "`//`, `%` и `**` имеются соответствующие комбинированные операторы\n", + "присваивания: `+=`, `-=`, `/=`, `//=`, `%=` и `**=`, где выражение\n", + "`x op= y` является эквивалентом выражения `x = x op y`.\n", + "\n", + "\n", + "## Таблица 1 : Арифметические операторы и функции\n", + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Синтаксис Описание
x + y Складывает число x и число y
x - y Вычитает число y из числа x
x * y Умножает x на y
x / y Делит x на y – результатом всегда является значение типа float (или complex, если x или y является комплексным числом)
x // y Делит x на y, при этом усекает дробную часть, поэтому результатом всегда является значение типа int; смотрите также функцию round()
x % y Возвращает модуль (остаток) от деления x на y
x**y Возводит x в степень y; смотрите также функцию pow()
-x Изменяет знак числа x, если оно не является нулем, если ноль – ничего не происходит
+x Ничего не делает иногда используется для повышения удобочитаемости программного кода
abs(x) Возвращает абсолютное значение x
divmod(x, y) Возвращает частное и остаток деления x на y в виде кортежа двух значений типа int
pow(x, y) Возводит x в степень y; то же самое что и оператор **
pow(x, y, z) Более быстрая альтернатива выражению (x ** y) % z
round(x, n) Возвращает значение типа int, соответствующее значению x типа float, округленному до ближайшего целого числа (или значение типа float, округленное до $n$-го знака после запятой, если задан аргумент n)
\n", + "\n", + "\n", + "Объекты могут создаваться путем присваивания литералов переменным,\n", + "например, `x = 17`, или обращением к имени соответствующего типа как к\n", + "функции, например, `x = int(17)`. Создание объекта посредством\n", + "использования его типа может быть выполнено одним из трех способов:\n", + "\n", + "* вызов типа данных без аргументов. В этом случае объект приобретает значение по умолчанию, например, выражение `x = int()` создаст целое число `0`. Любые встроенные типы могут вызываться без аргументов.\n", + "\n", + "* тип вызывается с единственным аргументом. Если указан аргумент соответствующего типа, будет создана поверхностная копия оригинального объекта. Если задан аргумент другого типа, будет предпринята попытка выполнить преобразование. Такой способ использования описывается в табл. [datatype:tbl:2](#datatype:tbl:2)\n", + "\n", + "* передается два или более аргументов; не все типы поддерживают такую возможность, а для тех типов, что поддерживают ее, типы аргументов и их назначение отличаются. В случае типа `int` допускается передавать два аргумента, где первый аргумент – это строка с представлением целого числа, а второй аргумент – число основания системы счисления. Например, вызов `int(\"A4\", 16)` создаст десятичное значение `164`.\n", + "\n", + "## Таблица 2 : Функции преобразования целых чисел
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Синтаксис Описание
bin(i) Возвращает двоичное представление целого числа i в виде строки, например, bin(1980) == '0b11110111100'
hex(i) Возвращает шестнадцатеричное представление целого числа i в виде строки, например, hex(1980) == '0x7bc'
int(x) Преобразует объект x в целое число; в случае ошибки во время преобразования возбуждает исключение ValueError, а если тип объекта x не поддерживает преобразование в целое число возбуждает исключение TypeError. Если x является числом с плавающей точкой, оно преобразуется в целое число путем усечения дробной части.
int(s, base) Преобразует строку s в целое число; в случае ошибки возбуждает исключение ValueError. Если задан необязательный аргумент base, он должен быть целым числом в диапазоне от 2 до 36 включительно.
oct(i) Возвращает восьмеричное представление целого числа i в виде строки, например, oct(1980) == '0o3674'
\n", + "\n", + "\n", + "В табл. [datatype:tbl:3](#datatype:tbl:3) перечислены битовые операторы. Все битовые операторы\n", + "(`|`, `^`, `&`, `<<` и `>>`) имеют соответствующие комбинированные операторы\n", + "присваивания (`|=`, `^=`, `&=`, `<<=` и `>>=`), где выражение `i op= j` является\n", + "логическим эквивалентом выражения `i = i op j` в случае, когда обращение\n", + "к значению `i` не имеет побочных эффектов. \n", + "\n", + "\n", + "## Таблица 3 : Функции преобразования целых чисел
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Синтаксис Описание
i | j Битовая операция OR (ИЛИ) над целыми числами i и j; отрицательные числа представляются как двоичное дополнение
i ^ j Битовая операция XOR (исключающее ИЛИ) над целыми числами i и j
i & j Битовая операция AND (И) над целыми числами i и j
i << j Сдвигает значение i влево на j битов аналогично операции i * (2 ** j) без проверки на переполнение
i >> j Сдвигает значение i вправо на j битов аналогично операции i // (2 ** j) без проверки на переполнение
\\~i Инвертирует биты числа i
\n", + "\n", + "\n", + "## Логические значения\n", + "
\n", + "\n", + "Существует два встроенных логических объекта: `True` и `False`. Как\n", + "и все остальные типы данных в языке Python (встроенные, библиотечные\n", + "или ваши собственные), тип данных `bool` может вызываться как \n", + "функция – при вызове без аргументов возвращается значение `False`,\n", + "при вызове с аргументом типа `bool` возвращается копия аргумента,\n", + "а при вызове с любым другим аргументом предпринимается попытка\n", + "преобразовать указанный объект в тип `bool`. Все встроенные типы\n", + "данных и типы данных из стандартной библиотеки могут быть\n", + "преобразованы в тип `bool`, а добавить поддержку такого преобразования в\n", + "свои собственные типы данных не представляет никакой сложности. Ниже\n", + "приводится пара присваиваний логических значений и пара логических\n", + "выражений:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "t = True" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "f = False" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "t and f" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "t and True" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "в языке Python имеется три логических оператора: `and`, `or` и\n", + "`not`. Выражения с участием операторов `and` и `or` вычисляются в\n", + "соответствии с логикой сокращенных вычислений (*short-circuit logic*),\n", + "и возвращается операнд, определяющий значение всего\n", + "выражения, тогда как результатом оператора `not` всегда\n", + "является либо `True`, либо `False`.\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "# Типы чисел с плавающей точкой\n", + "
\n", + "\n", + "Язык Python предоставляет три типа значений с плавающей точкой:\n", + "встроенные типы `float` и `complex` и тип `decimal.Decimal` в\n", + "стандартной библиотеке. Все три типа данных относятся к категории\n", + "неизменяемых. Тип `float` представляет числа с плавающей точкой\n", + "двойной точности, диапазон значений которых зависит от компилятора\n", + "языка C (или C\\# или Java), применявшегося для компиляции интерпретатора\n", + "Python. Числа этого типа имеют ограниченную точность и не могут\n", + "надежно сравниваться на равенство значений. Числа типа `float`\n", + "записываются с десятичной точкой или в экспоненциальной форме записи, \n", + "например, `0.0`, `4.`, `5.7`, `-2.5`, `-2e9`, `8.9e-4`.\n", + "\n", + "В машинном представлении числа с плавающей точкой хранятся как\n", + "двоичные числа. Это означает, что одни дробные значения могут быть\n", + "представлены точно (такие как `0.5`), а другие – только приблизительно\n", + "(такие как `0.1` и `0.2`). Кроме того, для представления используется\n", + "фиксированное число битов, поэтому существует ограничение на\n", + "количество цифр в представлении таких чисел. Ниже приводится\n", + "поясняющий пример:" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "0.0, 5.4, -2.5, 8.9e-4" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Проблема потери точности – это не проблема, свойственная только\n", + "языку Python; все языки программирования обнаруживают проблему\n", + "с точным представлением чисел с плавающей точкой.\n", + "\n", + "Если действительно необходимо обеспечить высокую точность,\n", + "можно использовать числа типа `decimal.Decimal`. Эти числа\n", + "обеспечивают уровень точности, который вы укажете (по умолчанию 28\n", + "знаков после запятой), и могут точно представлять периодические числа,\n", + "такие как $0.1$ , но скорость работы с такими числами существенно\n", + "ниже, чем с обычными числами типа `float`. Вследствие высокой точности\n", + "числа типа `decimal.Decimal` прекрасно подходят для производства\n", + "финансовых вычислений.\n", + "\n", + "Смешанная арифметика поддерживается таким образом, что результатом\n", + "выражения с участием чисел типов `int` и `float` является число типа\n", + "`float`, а с участием типов `float` и `complex` результатом является\n", + "число типа `complex`. Поскольку числа типа `decimal.Decimal` имеют\n", + "фиксированную точность, они могут участвовать в выражениях только с\n", + "другими числами `decimal.Decimal` и с числами типа `int`; результатом \n", + "таких выражений является число `decimal.Decimal`. В случае попытки\n", + "выполнить операцию над несовместимыми типами возбуждается исключение\n", + "`TypeError`.\n", + "\n", + "## Числа с плавающей точкой\n", + "
\n", + "\n", + "Все числовые операторы и функции, представленные в\n", + "табл. [Таблица 1 : Арифметические операторы и функции](#datatype:tbl:1), могут применяться к числам типа float,\n", + "включая комбинированные операторы присваивания. Тип данных float может\n", + "вызываться как функция – без аргументов возвращается число `0.0`, с\n", + "аргументом типа float возвращается копия аргумента, а с аргументом\n", + "любого другого типа предпринимается попытка выполнить преобразование\n", + "указанного объекта в тип float. При преобразовании строки \n", + "аргумент может содержать либо простую форму записи числа с десятичной\n", + "точкой, либо экспоненциальное представление числа. При выполнении\n", + "операций с числами типа float может возникнуть ситуация, \n", + "когда в результате получается значение `NaN` (*not a number* – не\n", + "число) или «бесконечность». К сожалению, поведение интерпретатора в\n", + "таких ситуациях может отличаться в разных реализациях и зависит от \n", + "математической библиотеки системы.\n", + "\n", + "Ниже приводится пример простой функции, выполняющей сравнение\n", + "чисел типа float на равенство в пределах машинной точности:" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def equal_float(a, b):\n", + " return abs(a - b) <= sys.float_info.epsilon" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Чтобы воспользоваться этой функцией, необходимо импортировать\n", + "модуль `sys`. Объект `sys.float_info` имеет множество атрибутов. Так,\n", + "`sys.float_info.epsilon` хранит минимально возможную разницу между\n", + "двумя числами с плавающей точкой. На одной из 32-разрядных машин\n", + "автора книги это число чуть больше $0.000 000 000 000 000 2$.\n", + "Тип `float` в языке Python обеспечивает надежную точность до 17\n", + "значащих цифр.\n", + "\n", + "В дополнение к встроенным функциональным возможностям работы\n", + "с числами типа `float` модуль `math` предоставляет множество функций,\n", + "которые приводятся в табл. [datatype:tbl:4](#datatype:tbl:4). Ниже приводятся\n", + "несколько фрагментов программного кода, демонстрирующих, как можно\n", + "использовать функциональные возможности модуля:" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import math\n", + "math.pi * (5 ** 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "math.hypot(5, 12)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "math.modf(13.732)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Модуль `math` в значительной степени опирается на математическую\n", + "библиотеку, с которой был собран интерпретатор Python. Это означает,\n", + "что при некоторых условиях и в граничных случаях функции модуля могут\n", + "иметь различное поведение на различных платформах. \n", + "\n", + "\n", + "## Таблица 4 : Функции и константы модуля `math`
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Синтаксис Описание
math.acos(x) Возвращает арккосинус x в радианах
math.acosh(x) Возвращает гиперболический арккосинус x в радианах
math.asin(x) Возвращает арксинус x в радианах
math.asinh(x) Возвращает гиперболический арксинус x в радианах
math.atan(x) Возвращает арктангенс x в радианах
math.atan2(y x) Возвращает арктангенс y/x в радианах
math.atanh(x) Возвращает гиперболический арктангенс x в радианах
math.ceil(x) Возвращает $ | x | $, то есть наименьшее целое число типа int, большее и равное x, например, math.ceil(5.4) == 6
math.copysign(x y) Возвращает x со знаком числа y
math.cos(x) Возвращает косинус x в радианах
math.cosh(x) Возвращает гиперболический косинус x в радианах
math.degrees(r) Преобразует число r типа float из радианов в градусы
math.e Константа $e$, примерно равная значению $2.7182818284590451$
math.exp(x) Возвращает $e^x$, то есть math.e ** x
math.fabs(x) Возвращает $ | x | $, то есть абсолютное значение x в виде числа типа float
math.factorial(x) Возвращает $x!$
math.floor(x) Возвращает $ | x | $, то есть наименьшее целое число типа int, меньшее и равное x, например, math.floor(5.4) == 5
math.fmod(x y) Выполняет деление по модулю (возвращает остаток) числа x на число y; дает более точный результат, чем оператор %, применительно к числам типа float
math.frexp(x) Возвращает кортеж из двух элементов с мантиссой (в виде числа типа float) и экспонентой (в виде числа типа int)
math.fsum(i) Возвращает сумму значений в итерируемом объекте i в виде числа типа float
math.hypot(x y) Возвращает $\\sqrt{x^2 + y^2}$
math.isinf(x) Возвращает True, если значение x типа float является бесконечностью ($\\pm \\infty$)
math.isnan(x) Возвращает True, если значение x типа float не является числом
math.ldexp(m e) Возвращает $m\\times 2^e$ – операция обратная math.frexp()
math.log(x b) Возвращает $\\log_b x$, аргумент b является необязательным и по умолчанию имеет значение math.e
math.log10(x) Возвращает $log_{10} x$
math.log1p(x) Возвращает $log_e (1+x)$; дает точные значения даже когда значение x близко к 0
math.modf(x) Возвращает дробную и целую часть числа x в виде двух значений типа float
math.pi Константа $\\pi$, примерно равная $3.1415926535897931$
math.pow(x y) Возвращает $x^y$ в виде числа типа float
math.radians(d) Преобразует число d типа float из градусов в радианы
math.sin(x) Возвращает синус x в радианах
math.sinh(x) Возвращает гиперболический синус x в радианах
math.sqrt(x) Возвращает $\\sqrt{x}$
math.tan(x) Возвращает тангенс x в радианах
math.tanh(x) Возвращает гиперболический тангенс x в радианах
math.trunc(x) Возвращает целую часть числа x в виде значения типа int; то же самое что и int(x)
\n", + "\n", + "\n", + "## Комплексные числа\n", + "
\n", + "\n", + "Тип данных `complex` относится к категории неизменяемых и хранит пару\n", + "значений типа `float`, одно из которых представляет действительную\n", + "часть комплексного числа, а другое – мнимую. Литералы комплексных\n", + "чисел записываются как действительная и мнимая части, объединенные\n", + "знаком `+` или `-`, а за мнимой частью числа следует символ `j`.\n", + "Вот примеры нескольких комплексных чисел: `3.5+2j`, `0.5j`, `4+0j`,\n", + "`-1 - 3.7j`. Обратите внимание, что если действительная часть числа\n", + "равна `0`, ее можно вообще опустить.\n", + "\n", + "Отдельные части комплексного числа доступны в виде атрибутов `real`\n", + "и `imag`. Например:" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "z = -89.5+2.125j\n", + "z.real, z.imag" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "За исключением `//`, `%`, `divmod()` и версии `pow()` с тремя\n", + "аргументами все остальные арифметические операторы и функции,\n", + "перечисленные в табл. [Таблица 1 : Арифметические операторы и функции](#datatype:tbl:1) могут использоваться для\n", + "работы с комплексными числами, так же как и соответствующие\n", + "комбинированные операторы присваивания. Кроме того, значения типа\n", + "`complex` имеют метод `conjugate()`, который изменяет знак мнимой\n", + "части. Например:" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "z.conjugate()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "3-4j.conjugate()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Тип данных `complex` может вызываться как функция – без аргументов\n", + "она вернет значение `0j`, с аргументом типа `complex` она вернет копию\n", + "аргумента, а с аргументом любого другого типа она попытается\n", + "преобразовать указанный объект в значение типа `complex`. При\n", + "использовании для преобразования функция `complex()` принимает либо\n", + "единственный строковый аргумент, либо одно или два значения типа\n", + "`float`.\n", + "\n", + "Если ей передается единственное значение типа `float`, возвращается\n", + "комплексное число с мнимой частью, равной `0j`.\n", + "\n", + "Функции в модуле `math` не работают с комплексными числами. Это\n", + "сделано преднамеренно, чтобы гарантировать, что пользователи модуля \n", + "`math` будут получать исключения вместо получения комплексных чисел в\n", + "некоторых случаях.\n", + "\n", + "Если возникает необходимость использовать комплексные числа,\n", + "можно воспользоваться модулем `cmath`, который содержит комплексные\n", + "версии большинства тригонометрических и логарифмических функций,\n", + "присутствующих в модуле math, плюс ряд функций, специально\n", + "предназначенных для работы с комплексными числами, таких \n", + "как `cmath.phase()`, `cmath.polar()` и `cmath.rect()`, а также\n", + "константы `cmath.pi` и `cmath.e`, которые хранят те же самые значения\n", + "типа `float`, что и родственные им константы в модуле `math`.\n", + "\n", + "## Числа типа `Decimal`\n", + "
\n", + "\n", + "Во многих приложениях недостаток точности, свойственный числам\n", + "типа `float`, не имеет существенного значения, и эта неточность\n", + "окупается скоростью вычислений. Но в некоторых случаях предпочтение \n", + "отдается точности, даже в обмен на снижение скорости работы. Модуль\n", + "`decimal` реализует неизменяемый числовой тип `Decimal`, который\n", + "представляет числа с задаваемой точностью. Вычисления с участием \n", + "таких чисел производятся значительно медленнее, чем в случае\n", + "использования значений типа `float`, но насколько это важно, будет\n", + "зависеть от приложения.\n", + "\n", + "Чтобы создать объект типа `Decimal`, необходимо импортировать модуль\n", + "`decimal`. Например:" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import decimal\n", + "a = decimal.Decimal(9876)\n", + "b = decimal.Decimal(\"54321.012345678987654321\")\n", + "a + b" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "\n", + "\n", + "# Строки\n", + "
\n", + "\n", + "Строки в языке Python представлены неизменяемым типом данных `str`,\n", + "который хранит последовательность символов Юникода. Тип данных `str`\n", + "может вызываться как функция для создания строковых объектов – без\n", + "аргументов возвращается пустая строка; с аргументом, который не\n", + "является строкой, возвращается строковое представление аргумента; а в\n", + "случае, когда аргумент является строкой, возвращается его\n", + "копия. Функция `str()` может также использоваться как функция\n", + "преобразования. В этом случае первый аргумент должен быть строкой или\n", + "объектом, который можно преобразовать в строку, а, кроме того, функции\n", + "может быть передано до двух необязательных строковых аргументов, один\n", + "из которых определяет используемую кодировку, а второй определяет\n", + "порядок обработки ошибок кодирования.\n", + "\n", + "Литералы строк создаются с использованием кавычек или апострофов, при\n", + "этом важно, чтобы с обоих концов литерала использовались кавычки\n", + "одного и того же типа. В дополнение к этому мы можем использовать\n", + "строки в тройных кавычках, то есть строки, которые начинаются и\n", + "заканчиваются тремя символами кавычки (либо тремя кавычками, либо\n", + "тремя апострофами). Например:" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "text = \"\"\"Строки в тройных кавычках могут включать 'апострофы' и \"кавычки\"\n", + "без лишних формальностей. Мы можем даже экранировать символ перевода строки \\,\n", + "благодаря чему данная конкретная строка будет занимать всего две строки.\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Если нам потребуется использовать кавычки в строке, это можно сделать\n", + "без лишних формальностей – при условии, что они отличаются от кавычек,\n", + "ограничивающих строку; в противном случае символы кавычек или\n", + "апострофов внутри строки следует экранировать:" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "a = \"Здесь 'апострофы' можно не экранировать, а \\\"кавычки\\\" придется.\"\n", + "b = 'Здесь \\'апострофы\\' придется экранировать, а \"кавычки\" не обязательно.'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "В языке Python символ перевода строки интерпретируется как завершающий\n", + "символ инструкции, но не внутри круглых скобок (`()`), квадратных\n", + "скобок (`[]`), фигурных скобок (`{}`) и строк в тройных кавычках. \n", + "Символы перевода строки могут без лишних формальностей использоваться\n", + "в строках в тройных кавычках, и мы можем включать символы перевода\n", + "строки в любые строковые литералы с помощью экранированной\n", + "последовательности `\\n`.\n", + "\n", + "Все экранированные последовательности, допустимые в языке Python,\n", + "перечислены в табл. 2.6.\n", + "\n", + "\n", + "## Таблица 5 : Функции и константы модуля `math`
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Последовательность Значение
\\переводстроки Экранирует (то есть игнорирует) символ перевода строки
\\\\ Символ обратного слеша (\\)
\\' Апостроф (')
\\\" Кавычка (\")
\\a Символ ASCII «сигнал» (bell, BEL)
\\b Символ ASCII «забой» (backspace, BS)
\\f Символ ASCII «перевод формата» (formfeed, FF)
\\n Символ ASCII «перевод строки» (linefeed, LF)
\\N{название} Символ Юникода с заданным названием
\\ooo Символ с заданным восьмеричным кодом
\\r Символ ASCII «возврат каретки» (carriage return, CR)
\\t Символ ASCII «табуляция» (tab, TAB)
\\uhhhh Символ Юникода с указанным 16-битовым шестнадцатеричным значением
\\Uhhhhhhhh Символ Юникода с указанным 32-битовым шестнадцатеричным значением
\\v Символ ASCII «вертикальная табуляция» (vertical tab, VT)
\\xhh Символ с указанным 8-битовым шестнадцатеричным значением
\n", + "\n", + "\n", + "Если потребуется записать длинный строковый литерал, занимающий\n", + "две или более строк, но без использования тройных кавычек, то можно\n", + "использовать один из приемов, показанных ниже:" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "t = \"Это не самый лучший способ объединения двух длинных строк, \" + \\\n", + " \"потому что он основан на использовании неуклюжего экранирования\"\n", + "s = (\"Это отличный способ объединить две длинные строки, \"\n", + " \" потому что он основан на конкатенации строковых литералов.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Обратите внимание, что во втором случае для создания единственного\n", + "выражения мы должны были использовать круглые скобки – без этих\n", + "скобок переменной s была бы присвоена только первая строка, а наличие\n", + "второй строки вызвало бы исключение `IndentationError`. \n", + "\n", + "## Сравнение строк\n", + "
\n", + "\n", + "Строки поддерживают обычные операторы сравнения `<`, `<=`, `==`, `!=`,\n", + "`>` и `>=`. Эти операторы выполняют побайтовое сравнение строк в памяти.\n", + "К сожалению, возникают две проблемы при сравнении, например,\n", + "строк в отсортированных списках. Обе проблемы проявляются во всех\n", + "языках программирования и не являются характерной особенностью\n", + "Python.\n", + "\n", + "Первая проблема связана с тем, что символы Юникода могут быть\n", + "представлены двумя и более последовательностями байтов.\n", + "\n", + "Вторая проблема заключается в том, что порядок сортировки некоторых\n", + "символов зависит от конкретного языка.\n", + "\n", + "## Получение срезов строк\n", + "
\n", + "\n", + "Отдельные элементы последовательности, а, следовательно, и отдельные\n", + "символы в строках, могут извлекаться с помощью оператора доступа к\n", + "элементам (`[]`). В действительности этот оператор намного более\n", + "универсальный и может использоваться для извлечения не только одного\n", + "символа, но и целых комбинаций (подпоследовательностей) элементов или\n", + "символов, когда этот оператор используется в контексте оператора\n", + "извлечения среза.\n", + "\n", + "Для начала мы рассмотрим возможность извлечения отдельных\n", + "символов. Нумерация позиций символов в строках начинается с 0 и\n", + "продолжается до значений длины строки минус 1. Однако допускается\n", + "использовать и отрицательные индексы – в этом случае отсчет начинается\n", + "с последнего символа и ведется в обратном направлении к первому \n", + "символу. На рис. [datatype:strings:fig:1](#datatype:strings:fig:1) показано, как нумеруются\n", + "позиции символов в строке, если предположить, что было выполнено\n", + "присваивание `s = \"Light ray\"`. \n", + "\n", + "\n", + "\n", + "
\n", + "![Номера позиций символов в строке](fig-datatype/strings_1.png)\n", + "\n", + "\n", + "Отрицательные индексы удивительно удобны, особенно индекс `-1`,\n", + "который всегда соответствует последнему символу строки. Попытка\n", + "обращения к индексу, находящемуся за пределами строки (или к любому\n", + "индексу в пустой строке), будет вызывать исключение `IndexError`.\n", + "Оператор получения среза имеет три формы записи:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```Python\n", + " seq[start]\n", + " seq[start:end]\n", + " seq[start:end:step]\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ссылка `seq` может представлять любую последовательность, такую как\n", + "список, строку или кортеж. Значения `start`, `end` и `step` должны быть\n", + "целыми числами (или переменными, хранящими целые числа). Первая форма\n", + "— это запись оператора доступа к элементам: с ее помощью извлекается\n", + "элемент последовательности с индексом `start`. Вторая форма записи\n", + "извлекает подстроку, начиная с элемента с индексом `start` и заканчивая\n", + "элементом с индексом `end`, *не включая* его.\n", + "\n", + "При использовании второй формы записи (с одним двоеточием) мы можем\n", + "опустить любой из индексов. Если опустить начальный индекс, по\n", + "умолчанию будет использоваться значение `0`. Если опустить конечный\n", + "индекс, по умолчанию будет использоваться значение `len(seq)`. \n", + "Это означает, что если опустить оба индекса, например, `s[:]`, это будет\n", + "равносильно выражению `s[0:len(s)]`, и в результате будет извлечена,\n", + "то есть скопирована, последовательность целиком.\n", + "\n", + "На рис. [datatype:strings:fig:2](#datatype:strings:fig:2) приводятся некоторые примеры\n", + "извлечения срезов из строки `s`, которая получена в результате\n", + "присваивания `s = \"The waxwork man\"`.\n", + "\n", + "\n", + "\n", + "
\n", + "![Извлечение срезов из последовательности](fig-datatype/strings_2.png)\n", + "\n", + "\n", + "Один из способов вставить подстроку в строку состоит в смешивании\n", + "операторов извлечения среза и операторов конкатенации. Например:" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "s = s[:12] + \"wo\" + s[12:]" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "s" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Кроме того, поскольку текст «wo» присутствует в оригинальной строке,\n", + "тот же самый эффект можно было бы получить путем присваивания значения\n", + "выражения `s[:12] + s[7:9] + s[12:]`.\n", + "\n", + "Оператор конкатенации `+` и добавления подстроки `+=` не\n", + "особенно эффективны, когда в операции участвует множество строк. Для\n", + "объединения большого числа строк обычно лучше использовать метод\n", + "`str.join()`, с которым мы познакомимся в следующем подразделе.\n", + "\n", + "Третья форма записи (с двумя двоеточиями) напоминает вторую форму, но\n", + "в отличие от нее значение `step` определяет, с каким шагом следует\n", + "извлекать символы. Как и при использовании второй формы записи, мы\n", + "можем опустить любой из индексов. Если опустить начальный \n", + "индекс, по умолчанию будет использоваться значение `0`, при условии,\n", + "что задано неотрицательное значение step; в противном случае начальный\n", + "индекс по умолчанию получит значение `-1`. Если опустить конечный\n", + "индекс, по умолчанию будет использоваться значение `len(seq)`, \n", + "при условии, что задано неотрицательное значение step; в противном\n", + "случае конечный индекс по умолчанию получит значение индекса перед\n", + "началом строки. Мы не можем опустить значение step, и оно не может\n", + "быть равно нулю – если задание шага не требуется, то следует\n", + "использовать вторую форму записи (с одним двоеточием), в которой шаг \n", + "выбора элементов не указывается.\n", + "\n", + "На рис. [datatype:strings:fig:3](#datatype:strings:fig:3) приводится пара примеров извлечения разреженных срезов из\n", + "строки `s`, которая получена в результате присваивания\n", + "`s = \"he ate camel food\"`.\n", + "\n", + "\n", + "\n", + "
\n", + "![Извлечение разреженных срезов](fig-datatype/strings_3.png)\n", + "\n", + "\n", + "Здесь мы использовали значения по умолчанию для начального и ко-\n", + "нечного индексов, то есть извлечение среза s[:: – 2] начинается с по-\n", + "следнего символа строки и извлекается каждый второй символ по на-\n", + "правлению к началу строки. Аналогично извлечение среза s[::3] на-\n", + "чинается с первого символа строки и извлекается каждый третий сим-\n", + "вол по направлению к концу строки.\n", + "Существует возможность комбинировать индексы с размером шага,\n", + "как показано на рис. [datatype:strings:fig:4](#datatype:strings:fig:4).\n", + "\n", + "\n", + "\n", + "
\n", + "![Извлечение срезов из последовательности с определенным шагом](fig-datatype/strings_4.png)\n", + "\n", + "\n", + "Операция извлечения элементов с определенным шагом часто применяется к\n", + "последовательностям, отличным от строк, но один из ее вариантов часто\n", + "применяется к строкам:\n", + "\n", + "## Операторы и методы строк\n", + "
\n", + "\n", + "Поскольку строки относятся к категории неизменяемых\n", + "последовательностей, все функциональные возможности, применимые к\n", + "неизменяемым последовательностям, могут использоваться и со\n", + "строками. Сюда входят оператор проверки на вхождение `in`, оператор\n", + "конкатенации `+`, оператор добавления в конец `+=`, оператор\n", + "дублирования `*` и комбинированный оператор присваивания с\n", + "дублированием `*=`. Применение всех этих операторов в контексте строк\n", + "мы обсудим в этом подразделе, а также обсудим большинство строковых\n", + "методов. В табл. 2.7 приводится перечень некоторых строковых методов.\n", + "\n", + "Так как строки являются последовательностями, они являются объектами,\n", + "имеющими «размер», и поэтому мы можем вызывать функцию `len()`,\n", + "передавая ей строки в качестве аргумента. Возвращаемая функцией длина\n", + "представляет собой количество символов в строке (ноль – для пустых\n", + "строк).\n", + "\n", + "Мы уже знаем, что перегруженная версия оператора `+` для строк\n", + "выполняет операцию конкатенации. В случаях, когда требуется объединить\n", + "множество строк, лучше использовать метод `str.join()`. Метод \n", + "принимает в качестве аргумента последовательность (то есть список\n", + "или кортеж строк) и объединяет их в единую строку, вставляя между\n", + "ними строку, относительно которой был вызван метод. Например:" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "treatises = [\"Arithmetica\", \"Conics\", \"Elements\"]\n", + "\" \".join(treatises)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "\"-<>-\".join(treatises)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "\"\".join(treatises)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Метод `str.join()` может также использоваться в комбинации со\n", + "встроенной функцией `reversed()`, которая переворачивает строку –\n", + "например, `\"\".join(reversed(s))`, хотя тот же результат может быть\n", + "получен более кратким оператором извлечения разреженного среза –\n", + "например, `s[:: – 1]`.\n", + "\n", + "Оператор `*` обеспечивает возможность дублирования строки:" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "s = \"=\" * 5\n", + "print(s)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "s *= 10\n", + "print(s)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Как показано в примере, мы можем также использовать комбинированный\n", + "оператор присваивания с дублированием. \n", + "\n", + "# Форматирование строк с помощью метода `str.format()`\n", + "
\n", + "\n", + "Метод `str.format()` представляет собой очень мощное и гибкое средство\n", + "создания строк. Использование метода `str.format()` в простых случаях\n", + "не вызывает сложностей, но для более сложного форматирования нам\n", + "необходимо изучить синтаксис форматирования.\n", + "\n", + "Метод `str.format()` возвращает новую строку, замещая поля в\n", + "контекстной строке соответствующими аргументами. Например:" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "\"The novel '{0}' was published in {1}\".format(\"Hard Times\", 1854)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Каждое замещаемое поле идентифицируется именем поля в фигурных\n", + "скобках. Если в качестве имени поля используется целое число, оно\n", + "определяет порядковый номер аргумента, переданного методу\n", + "`str.format()`. Поэтому в данном случае поле с именем `0` было замещено\n", + "первым аргументом, а поле с именем `1` – вторым аргументом. \n", + "\n", + "Если бы нам потребовалось включить фигурные скобки в строку формата,\n", + "мы могли бы сделать это, дублируя их, как показано ниже:" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "\"{{{0}}} {1} ;-}}\".format(\"I'm in braces\", \"I'm not\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Если попытаться объединить строку и число, интерпретатор Python\n", + "совершенно справедливо возбудит исключение `TypeError`. Но это легко\n", + "можно сделать с помощью метода `str.format()`:" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "\"{0}{1}\".format(\"The amount due is $\", 200)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "С помощью `str.format()` мы также легко можем объединять строки\n", + "(хотя для этой цели лучше подходит метод `str.join()`):" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "x = \"three\"\n", + "s =\"{0} {1} {2}\"\n", + "s = s.format(\"The\", x, \"tops\")\n", + "s" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "\n", + "\n", + "# Примеры\n", + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "## `quadratic.py`\n", + "
\n", + "\n", + "Квадратные уравнения – это уравнения вида $ax^2 + bx + c = 0$, где $a \\ne 0$,\n", + "описывающие параболу. Корни таких уравнений находятся по формуле" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$$\n", + "x = \\frac{-b \\pm \\sqrt{b^2-4ac}}{2a}.\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Часть формулы $b^2 – 4ac$ называется дискриминантом – если это\n", + "положительная величина, уравнение имеет два действительных корня, если\n", + "дискриминант равен нулю – уравнение имеет один действительный корень,\n", + "и в случае отрицательного значения уравнение имеет два комплексных\n", + "корня. Мы напишем программу, которая будет принимать от пользователя\n", + "коэффициенты $a$, $b$ и $c$ (коэффициенты $b$ и c могут быть равны\n", + "нулю) и затем вычислять и выводить его корень или корни.\n", + "\n", + "\n", + "Для начала посмотрим, как работает программа:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "С коэффициентами $1.5$, $-3$ и $6$ программа выведет (некоторые цифры\n", + "обрезаны):\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", "\n", "\n", diff --git a/fig-datatype/strings_1.png b/fig-datatype/strings_1.png new file mode 100644 index 0000000..ceaa1b6 Binary files /dev/null and b/fig-datatype/strings_1.png differ diff --git a/fig-datatype/strings_2.png b/fig-datatype/strings_2.png new file mode 100644 index 0000000..ad36442 Binary files /dev/null and b/fig-datatype/strings_2.png differ diff --git a/fig-datatype/strings_3.png b/fig-datatype/strings_3.png new file mode 100644 index 0000000..c892e86 Binary files /dev/null and b/fig-datatype/strings_3.png differ diff --git a/fig-datatype/strings_4.png b/fig-datatype/strings_4.png new file mode 100644 index 0000000..05183cc Binary files /dev/null and b/fig-datatype/strings_4.png differ diff --git a/fig-intro/jupyter_1.png b/fig-intro/jupyter_1.png new file mode 100644 index 0000000..9cfd13f Binary files /dev/null and b/fig-intro/jupyter_1.png differ diff --git a/fig-intro/jupyter_2.png b/fig-intro/jupyter_2.png new file mode 100644 index 0000000..ab60d9c Binary files /dev/null and b/fig-intro/jupyter_2.png differ diff --git a/fig-intro/jupyter_3.png b/fig-intro/jupyter_3.png new file mode 100644 index 0000000..25bace0 Binary files /dev/null and b/fig-intro/jupyter_3.png differ diff --git a/fig-intro/jupyter_4.png b/fig-intro/jupyter_4.png new file mode 100644 index 0000000..5b8215b Binary files /dev/null and b/fig-intro/jupyter_4.png differ diff --git a/fig-intro/jupyter_5.png b/fig-intro/jupyter_5.png new file mode 100644 index 0000000..4a8b2ba Binary files /dev/null and b/fig-intro/jupyter_5.png differ diff --git a/fig-intro/jupyter_6.png b/fig-intro/jupyter_6.png new file mode 100644 index 0000000..a2aa8ff Binary files /dev/null and b/fig-intro/jupyter_6.png differ diff --git a/fig-intro/jupyter_6.png~ b/fig-intro/jupyter_6.png~ new file mode 100644 index 0000000..0fdc9c2 Binary files /dev/null and b/fig-intro/jupyter_6.png~ differ diff --git a/fig-intro/jupyter_7.png b/fig-intro/jupyter_7.png new file mode 100644 index 0000000..e55843c Binary files /dev/null and b/fig-intro/jupyter_7.png differ diff --git a/fig-intro/jupyter_7.png~ b/fig-intro/jupyter_7.png~ new file mode 100644 index 0000000..1e4d28a Binary files /dev/null and b/fig-intro/jupyter_7.png~ differ diff --git a/intro.ipynb b/intro.ipynb index b5302ed..76b7326 100644 --- a/intro.ipynb +++ b/intro.ipynb @@ -10,10 +10,7 @@ " \n", "**С.В. Лемешевский** (email: `sergey.lemeshevsky@gmail.com`), Институт математики НАН Беларуси\n", "\n", - "\n", - "\n", - "\n", - "\n", + "Date: **Feb 22, 2020**\n", "\n", "\n", "\n", @@ -21,6 +18,7 @@ "\n", "\n", "\n", + "\n", "# Установка\n", "
\n", "\n", @@ -453,8 +451,156 @@ "\n", "\n", "\n", - "# Запуск программ на Python\n", - "
\n", + "# Установка библиотек\n", + "
\n", + "\n", + "В зависимости от вашей системы и предыдущих инсталляций среда Python\n", + "может оказаться неукомплектованной всем тем, что может понадобиться.\n", + "\n", + "Чтобы установить любую нужную библиотеку, можно применить команду\n", + "`pip`. Инструмент установки библиотек Python `pip` непосредственно\n", + "получает доступ к Интернету и получает их из каталога библиотек Python\n", + "[PyPI](https://pypi.python.org/pypi). PyPI представляет собой\n", + "репозиторий, содержащий сторонние библиотеки с открытым исходным\n", + "кодом, которые постоянно поддерживаются в работоспособном состоянии и\n", + "сохраняются в репозитории их автором.\n", + "\n", + "Устанавливать библиотеки лучше всего при помощи `pip` по следующим\n", + "причинам:\n", + "* он является предпочтительным диспетчером библиотек Python и начиная с Python 2.7.9 и Python 3.4 по умолчанию включен в дистрибутивы Python;\n", + "\n", + "* он обеспечивает функциональность по деинсталляции библиотек;\n", + "\n", + "* он возвращает вашу систему в исходное состояние и оставляет ее чистой, если по какой-либо причине установленная библиотека перестала работать.\n", + "\n", + "Команда `pip` работает в командной строке. Чтобы удостовериться в том,\n", + "что инструмент `pip` установлен на локальной машине, выполните\n", + "следующую команду:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Terminal> pip -V\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "В некоторых инсталляциях в Linux и Mac OS устанавливается и Python 3 и\n", + "Python 2, в результате чего могут присутствовать команды `pip3` и\n", + "`pip2`. Если это так, то `pip2` подходит только для установки\n", + "библиотек в Python 2, а команды `pip` и `pip3` — только для библиотек\n", + "Python 3.\n", + "\n", + "Если проверка закончилась ошибкой, то вам действительно нужно\n", + "установить `pip` с нуля. Для установки `pip` следуйте инструкциям на\n", + ". Самый безопасный\n", + "путь состоит в том, чтобы скачать сценарий `get-pip.py` по прямой\n", + "ссылке с [get-pip.py](https://bootstrap.pypa.io/get-pip.py) и затем\n", + "выполнить его при помощи следующей команды:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Terminal> python get-pip.py\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "После того, как вы удостоверитесь, что инструмент `pip` установлен,\n", + "можно будет устанавливать дополнительные библиотеки Python. Чтобы\n", + "установить типовую библиотеку ``, нужно просто выполнить команду:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Terminal> pip install \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "После этого библиотека `` и все библиотеки, от которых она\n", + "зависит, будут скачаны и установлены.\n", + "\n", + "Если вы установили дистрибутив Anaconda, то в нем для управления\n", + "установкой библиотек используется инструмент `conda`\n", + "\n", + "## Способы обновления библиотек\n", + "
\n", + "\n", + "Как правило, может возникнуть ситуация, когда необходимо обновить\n", + "библиотеку, потому что некая связанная с ней другая библиотека,\n", + "т.н. зависимость, требует наличия более новой версии, либо имеется\n", + "дополнительный функционал, который требуется задействовать. Для этого\n", + "сначала нужно проверить версию установленной библиотеки, обратившись к\n", + "атрибуту `__version__`, как показано в примере с библиотекой NumPy\n", + "ниже:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import numpy\n", + ">>> numpy.__version__ # 2 символа подчеркивания перед ним и после него" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Далее если нужно ее обновить до более новой версии, скажем в точности\n", + "до версии 1.9.2, то из командной строки можно выполнить следующую ниже\n", + "команду:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Terminal> pip install -U numpy==1.9.2\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Если вы просто заинтересованы в обновлении до последней доступной\n", + "версии, то просто выполните команду" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Terminal> pip install -U numpy\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "\n", + "\n", + "# Среды для вычислений в Python\n", + "
\n", "\n", "Программный код на языке Python можно записать с помощью любого\n", "простого текстового редактора, который способен загружать и сохранять\n", @@ -486,22 +632,1360 @@ "интерпретируемых языках, выполняются интерпретатором и распространяются в виде\n", "исходного кода.\n", "\n", - "Python может работать в двух режимах:\n", - "* интерактивный;\n", + "Ниже представим несколько сред вычислений в Python.\n", "\n", - "* пакетный.\n", + "## Интерпретатор\n", + "
\n", "\n", - "## Интерактивный режим работы\n", - "
\n", - "\n", - "В интерактивный режим можно войти, набрав в командной строке" + "Стандартный способ выполнения файлов со сценариями Python — запуск программ\n", + "напрямую через интерпретатор с помощью команды `python`. Если в\n", + "качестве аргумента команды `python` передается исходный файл,\n", + "то выполняется код Python, записанный в файле:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - " Terminal> python\n" + " Terminal> python hello.py\n", + " Hello from Python!\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Здесь файл [hello.py](src-intro/hello.py) содержит одну строку:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "print(\"Hello from Python!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Кроме выполнения файлов со сценариями Python интерпретатор можно\n", + "использовать в качестве интерактивной консоли (REPL:\n", + "Read-Evaluate-Print-Loop). Выполнив команду `python` без аргументов,\n", + "вы можете запустить интерпретатор Python в интерактивном\n", + "режиме:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Terminal> python\n", + " Python 3.8.1 (default, Jan 22 2020, 06:38:00) \n", + " [GCC 9.2.0] on linux\n", + " Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n", + " >>> \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Здесь можно вводить код Python. При этом для каждой инструкции\n", + "интерпретатор выполняет код и выводит результат на экран.\n", + "Интерпретатор Python предоставляет такие возможности как история\n", + "команд и базовое автодополнение команд.\n", + "\n", + "## Консоль IPython\n", + "
\n", + "\n", + "IPython\n", + "— расширенная среда интерпретатора REPL для Python с\n", + "дополнительными функциями для интерактивных и исследовательских\n", + "вычислений. Например, IPython предоставляет улучшенный просмотр\n", + "истории команд (также между сессиями), систему кэшировния ввода и\n", + "вывода, улучшенное автодополнение, более подробные и полезные\n", + "отслеживания исключений и многое другое. Фактически, IPython теперь\n", + "намного больше, чем расширенный интерфейс командной строки Python. \n", + "\n", + "Выполнение команды `ipython` запускает интерпретатор IPython:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Terminal> ipython\n", + " Python 3.8.1 (default, Jan 22 2020, 06:38:00) \n", + " Type 'copyright', 'credits' or 'license' for more information\n", + " IPython 7.12.0 -- An enhanced Interactive Python. Type '?' for help.\n", + " \n", + " In [1]: \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Кэширование ввода и вывода\n", + "\n", + "
\n", + "\n", + "В консоли IPython подсказка ввода обозначается как `In[1]:`, а\n", + "соответствующий вывод обозначается как `Out[1]:`, где число в\n", + "квадратных скобках увеличивается для каждого нового ввода и\n", + "вывода. Эти подсказки ввода и вывода называются *ячейками* в \n", + "IPython. Значения как входных так и выходныех предыдущих ячеек можно\n", + "потом использовать через переменные `In` и `Out`, которые\n", + "автоматически создаются IPtyhon. Переменные `In` и `Out` — это список\n", + "и словарь соответственно, которые могут быть проиндексированы индексом\n", + "ячейки. Например, рассмотрим следующую сессию IPython:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "3*3" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "In[]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "Out[]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "In" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "Out" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Кэширование ввода и вывода часто полезно при интерактивных и\n", + "исследовательских вычислениях, так как результат вычислений может быть\n", + "доступен даже если он не был явно присвоен переменной.\n", + "\n", + "Отметим, что когда ячейка выполнена, значение последнего выражения в\n", + "ячейке ввода по-умолчанию отображается в соответствующей ячейке\n", + "вывода, если выражение не является присваиванием или если значение не\n", + "равно `None`. Вывод можно пресечь посредством ввода точки с запятой в\n", + "конце инструкции:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "1+2" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "1+2;" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "x=1" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "x=2; x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Автодополнение и самоанализ объектов\n", + "\n", + "
\n", + "\n", + "В Ipython нажатие клавиши `TAB` активирует автодополнение, которое\n", + "отображает список символов (переменных, функций, классов и т.д.) с\n", + "именами, которые доступны для дополнения того, что уже было\n", + "набрано. Автодополнение в IPython является контекстным, и оно будет\n", + "искать совпадающие переменные и функции в текущем пространстве имен\n", + "или среди атрибутов и методов класса при вызове после имени экземпляра\n", + "класса. Например, `os.` даст список переменных, функций и классов\n", + "из модуля `os`, а нажатие `TAB` после того, как набрали `os.w` даст\n", + "список символов из модуля `os`, которые начинаются с `w`. Эта функция\n", + "называется самоанализом объекта. Она очень полезна для\n", + "интерактивного изучения свойств объекта Python. \n", + "\n", + "\n", + "### Документация\n", + "\n", + "
\n", + "\n", + "Самоанализ объекта удобен для изучения API модулей и содержащихся в\n", + "них классов и функций, и вместе со строками документации или\n", + "«docstrings», которые обычно представлены в коде Python, он\n", + "предоставляет встроенное динамическое справочное руководство для почти\n", + "всех модулей, которые установлены и могут быть импортированы. Если\n", + "закончить объект Python знаком вопроса и выполнить команду, то будет\n", + "выведена строка документации для объекта. Это аналогично вызову\n", + "Python-функции `help`. Ввод объекта можно закончить двумя знаками\n", + "вопроса. В этом случае IPython пытается отобразить более детальную\n", + "документацию, вколючая (если возможно) исходный код. Например, для\n", + "того чтобы получить описание функции `cos` из модуля `math` можно\n", + "сделать следующее:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import math" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "math.cos?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Строки документации могут быть заданы для модулей, функций, классов и\n", + "их атрибутов и методов. Хорошо документированные модули включают\n", + "документацию своего API в исходный код.\n", + "\n", + "### Взаимодействие с оболочкой системы\n", + "\n", + "
\n", + "\n", + "IPython предоставляет также расширение языка Python, которое делает\n", + "его удобным для взаимодействия с оболочкой системы, в которой он\n", + "запущен. Все, что следует за восклицательным знаком\n", + "выполняется с помощью системной оболочки. Например, в UNIX-подобных\n", + "системах, таких как Linux или Mac OS X, список файлов из текущего\n", + "каталога можно получить следующим образом:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "!ls" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "В Windows эквивалентная команда — `!dir`. Этот метод взаимодействия с\n", + "операционной системой является очень мощной функцией, которая дает\n", + "возможность легкой навигации по файловой системе и использования\n", + "IPython в качестве консольной системной оболочки. Вывод команд,\n", + "следующих за восклицательным знаком, может быть легко записан в\n", + "переменную Python. Например, список файлов, полученный командой `!ls`\n", + "можно сохранить в список следующим образом:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "files = !ls" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "len(files)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "files" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Аналогично, мы можем передать значения переменных Python командам\n", + "оболочки, поставив перед именем переменной знак `$`:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "file = \"test.py\"" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "!ls -l $file" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Такое двухстороннее взаимодействие между консолью IPython и системной\n", + "оболочкой может оказаться очень удобным когда, например, мы\n", + "обрабатываем файлы с данными.\n", + "\n", + "### Расширения IPython\n", + "\n", + "
\n", + "\n", + "IPython предоставляет команды расширения, так называемые *магические*\n", + "команды. Эти команды начинаются со знака `%`. Один знак `%`\n", + "используется для однострочных команд, а два знака `%` используются для\n", + "команд, которые действуют на нескольких ячейках (многострочные\n", + "команды). Чтобы получить полный список доступных команд расширения,\n", + "наберите `%lsmagic`, а документацию для каждой команды можно получить\n", + "заканчивая магическую команду знаком вопроса:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "%lsmagic?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Навигация по файловой системе\n", + "\n", + "
\n", + "\n", + "Кроме взаимодействия с системной оболочкой IPython предоставляет\n", + "команды для навигации по файловой системе. Команды будут знакомы\n", + "пользователям UNIX-подобных систем: `%ls` (список файлов), `%pwd`\n", + "(вернуть текущий рабочий каталог), `%cd` (изменить рабочий каталог),\n", + "`%cp` (копировать файл), `%less` (вывести содержимое файла) и\n", + "`%writefile filename` (записать содержимое ячейки в файл\n", + "`filename`). Отметим, что в IPython автодополнение работает и для имен\n", + "файлов в текущем работчем каталоге.\n", + "\n", + "### Запуск сценариев из консоли IPython\n", + "\n", + "
\n", + "\n", + "Команда `%run` — важное и полезное расширение. С помощью этой команды\n", + "можно выполнять внешние файлы со сценариями Python в интерактивной\n", + "сессии IPython. Оставляя сессию активной между несколькими запусками\n", + "сценария, мы можем анализировать переменные и функции, определенные в\n", + "сценарии, интерактивно после окончания выполнения сценария. Рассмотрим\n", + "файл" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# -*- coding: utf-8 -*-\n", + "def fib(n):\n", + " \"\"\"\n", + " Возвращает список первых n чисел Фибоначи\n", + " \"\"\"\n", + " f0, f1 = 0, 1\n", + " f = [1]*n\n", + " for i in range(1, n):\n", + " f[i] = f0 + f1\n", + " f0, f1 = f1, f[i]\n", + "\n", + " return f\n", + "\n", + "print(fib(10))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Сценарий определеяет функцию, которая генерирует последовательность из $n$\n", + "чисел Фибоначчи, и выводит результат при $n=10$. Его можно запустить в\n", + "системной консоли, используя стандартный интерпретатор Python:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Terminal> python fib.py\n", + " [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Также этот файл со сценарием можно выполнить в интерактивной сессии\n", + "IPython, которая выполнит тот же вывод, а также добавит символы\n", + "определенные в файле в локальное пространство имен, так что функция\n", + "`fib` будет доступна для использования в интерактивной сессий после\n", + "выполнения команды `%run`." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "%run src-intro/fib.py" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "%who" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "fib(6)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "В предыдущем примере мы также использовали команду `%who`, которая\n", + "перечисляет все определенные символы (переменные и функции).\n", + "Команда `%whos` аналогична, но также предоставляет более подробную\n", + "информацию о типе и значении каждого символа, когда это применимо. \n", + "\n", + "### Отладчик\n", + "\n", + "
\n", + "\n", + "IPython включает режим отладки, который может быть вызван после того\n", + "как возникло исключение Python (ошибка). После того, как в консоли\n", + "IPythob было напечатано сообщение об ошибке (Traceback) не\n", + "перехваченного исключения, можно непосредственно перейти в отладчик с\n", + "помощью команды `%debug`. Такая возможность позволяет не перезапускать\n", + "программу с самого начала с помощью отладчика или с использованием\n", + "метода отладки с добавлением операторов печати в код. Если исключение\n", + "было неожиданным и произошло после длительных вычислений, это может\n", + "значительно сэкономить время.\n", + "\n", + "Для того, чтобы увидеть как может работать команда `%debug`,\n", + "рассмотрим следующий некорректный вызов функции `fib`, определенной\n", + "выше. Вызов будет некорректным, так как мы передадим значение типа\n", + "`float` в то время, как функция реализована в предположении, что\n", + "передаваемый аргумент имеет тип `int`.`" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "fib(1.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "В строке с номером 7 код сталкивается с ошибкой типа, и интерпретатор\n", + "Python вызывает исключение типа `TypeError`. IPython перехватывает\n", + "исключение и выводит полезную трассировку вызовов в консоль. Если мы\n", + "не понимаем, почему код в строке 7 содержит ошибку, полезно запустить\n", + "отладчик с помощью команды `%debug`. Тогда мы можем получить доступ к\n", + "локальному пространству имен в источнике исключения, который позволит\n", + "нам изучить более детально, почему возникло исключение." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "%debug" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> **Подсказка.**\n", + ">\n", + "> Наберите знак вопроса в строке отладчика для того, чтобы получить\n", + "> подсказку с перечислением доступных команд.\n", + "> \n", + "> Больше информации об отладчике Python и его возможностях можно\n", + "> получить в документации Python по адресу .\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "### Сброс пространства имен\n", + "\n", + "
\n", + "\n", + "Сброс пространства имен сессии IPython часто полезен для гарантии\n", + "того, что программа запускается в нетронутой среде, не перегруженной\n", + "существующими переменными и функциями. Команда `%reset` предоставляет\n", + "такую возможность (используйте аргумент `-f` для принудительного\n", + "сброса). Использование этой команды часто устраняет необходимость в\n", + "других распространенных циклах выхода-перезапуска консоли. Несмотря на\n", + "то, что после выполнения команды `%reset` необходимо заново\n", + "импортировать модули, важно знать, что даже если модули изменялись с\n", + "момента последнего импорта, новый импорт после команды `%reset` не\n", + "будет импортировать новый модуль, а, скорее всего, включит\n", + "кэшированную версию модуля из предыдущего импорта. Такое поведение не\n", + "желательно при разработке новых модулей Python. В этом случае\n", + "повторный импорт ранее импортированного (и с тех пор обновленного)\n", + "модуля часто может быть достигнут с помощью функции `reload` из\n", + "`IPython.lib.deepreload`. Однако, этот метод не всегда работает, так\n", + "как некоторые библиотеки выполняют код во время импорта, который\n", + "должен выполняться только один раз. В этом случае есть только один\n", + "способ: остановить и заново запустить консоль IPython.\n", + "\n", + "### Расчет времени выполнения и профилирование кода\n", + "\n", + "
\n", + "\n", + "Команды `%timeit` и `%time` предоставляют простые средства сравнения,\n", + "которые полезны при попытках оптимизировать код. Команда `%timeit`\n", + "запускает оператор Python несколько раз и дает оценку времени\n", + "выполнения (используйте `%%timeit`, чтобы сделать \n", + "то же самое для многострочной ячейки). Точное количество раз \n", + "выполнения оператора, определяется эвристически, если явно не\n", + "установлено с помощью флагов `-n` и `-r`. Команда `%timeit` не\n", + "возвращает значение выражения. Если необходим результат выполнения\n", + "вычислений, можно использовать команды `%time` или `%%time` (для\n", + "многострочной ячейки), но эти команды запускают выражение только один\n", + "раз и, следовательно, дают менее точную оценку времени выполнения.\n", + "\n", + "Следующий пример демонстрирует типичное использование команд `%timit`\n", + "и `%time`" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "%timeit fib(100)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "result = %time fib(100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Хотя команды `%timeit` и `%time` полезны для измерения времени\n", + "выполнения вычислений, они не дают никакой подробной информации о том,\n", + "какая часть вычислений занимает больше времени. Такой анализ требует\n", + "более сложного профилировщика кода, такого, например, как `cProfile`,\n", + "предоставляемого стандартной библиотекой Python. Профилировщик Python\n", + "доступен в IPython с помощью команд `%prun` (для операторов) и `%run`\n", + "с аргументом `-p` (для запуска внешних сценариев). Вывод\n", + "профилировщика довольно многословен и может быть настроен с помощью\n", + "опций команд `%prun` и `%run -p` (см. `%prun?`).\n", + "\n", + "В качестве примера рассмотрим функцию, которая моделирует $N$\n", + "случайных ходоков, которые делают по $M$ шагов, а затем вычисляет\n", + "самое дальнее расстояние от начальной точки, достигнутой любым из\n", + "случайных ходоков." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# -*- coding: utf-8 -*-\n", + "import numpy as np\n", + "\n", + "def random_walker_max_distance(M, N):\n", + " trajectories = [np.random.randn(M).cumsum() for _ in range(N)]\n", + " return np.max(np.abs(trajectories))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Вызов этой функции с использованием профилировщика дает генерирует\n", + "следующий вывод, который включает информацию о том, как много раз\n", + "вызывается каждая функция и разбивку общего и совокупного времени,\n", + "потраченного на каждую функцию. По этой информации мы можем сделать\n", + "вывод, что в нашем простом примере вызовы функции `np.random.rand`\n", + "потребляет большую часть времени вычислений." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "%prun random_walker_max_distance(400, 10000)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Интерпретатор и текстовый редактор как среда разработки\n", + "
\n", + "\n", + "В принципе, интерпретаторы Python и IPython и хороший текстовый\n", + "редактор — это все, что нужно для полной среды разработки на\n", + "Python. Эта простая связка, по сути, является предпочтительной\n", + "средой разработки для многих опытных программистов. Однако в следующих\n", + "разделах мы рассмотрим Jupyter Notebook и интегрированную среду\n", + "разработки Spyder. Эти среды предоставляют более широкие возможности,\n", + "которые повышают производительность при работе с интерактивными и\n", + "исследовательскими приложениями. \n", + "\n", + "## Jupyter\n", + "
\n", + "\n", + "Проект\n", + "Jupyter\n", + "Проект Jupyter является побочным продуктом проекта IPython, который\n", + "включает независимые интерфейсы Python — в первую очередь блокноты\n", + "(notebook) — и коммуникационную структуру, которая позволяет отделить\n", + "внешний интерфейс от вычислительных серверных частей, известных как\n", + "ядра. \n", + "\n", + "До создания проекта Jupyter, блокноты и базовая структура приложения\n", + "для них были частью проекта IPython. Однако, поскольку внешний\n", + "интерфейс для блокнотов не зависит от языка — его также можно использовать\n", + "с большим количеством других языков, таких как R и Julia, — он был\n", + "выделен из отдельного проекта, чтобы лучше обслуживать более широкое\n", + "вычислительное сообщество и избегать предполагаемой предвзятости в\n", + "сторону Python. Теперь роль IPython заключается в том, чтобы\n", + "сосредоточиться на приложениях, специфичных для Python, таких как\n", + "интерактивная консоль Python, и предоставить ядро Python для среды\n", + "Jupyter.\n", + "\n", + "В среде Jupyter интерфейс взаимодействует с серверными частями\n", + "(ядрами). Интерфейс может иметь несколько зарегистрированных ядер,\n", + "например, для различных языков программирования, для различных версий\n", + "Python, или различных сред Python. Ядро поддерживает состояние\n", + "интерпретатора и выполняет фактические вычисления, в то время как\n", + "интерфейс управляет тем, как код вводится и организуется, и как\n", + "результаты вычислений визуализируются пользователю.\n", + "\n", + "Здесь мы рассмотрим Jupyter QtConsole и интерфейсы для блокнотов.\n", + "\n", + "\n", + "\n", + "### Jupyter QtConsole\n", + "\n", + "
\n", + "\n", + "Jupyter QtConsole — это расширенное консольное приложение, которое\n", + "может служить заменой стандартной консоли IPython. QtConsole\n", + "запускается передачей аргумента `qtconsole` команде `jupyter`:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Terminal> jupyter qtconsole\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Откроется новое приложение в системной консоли, способное\n", + "отображать мультимедийные объекты, такие как рисунки и\n", + "математические уравнения. Jupyter QtConsole также предоставляет\n", + "механизм на основе меню для отображения результатов автозаполнения, и\n", + "он запрашивает строки документации для функций во всплывающем окне при\n", + "вводе открывающей скобки функции или вызова метода. Скриншот Jupyter\n", + "QtСonsole показан на следующем рисунке:\n", + "\n", + "\n", + "\n", + "![](fig-intro/jupyter_1.png)\n", + "\n", + "\n", + "### Jupyter Notebook\n", + "\n", + "
\n", + "\n", + "Кроме интерактивной консоли Jupyter также предоставляет веб-приложение\n", + "для блокнотов. Блокнот предоставляет много преимуществ по\n", + "сравнению с традиционной средой разработки при работе с анализом\n", + "данных и решением вычислительных задач. В частности, среда блокнота\n", + "позволяет писать и запускать код, отображать выходные данные, \n", + "произведенные кодом, а также документировать и интерпретировать код и\n", + "результаты: все в одном документе. Это означает, что весь рабочий\n", + "процесс анализа записывается в один файл, который впоследствии можно\n", + "сохранить, восстановить и использовать повторно. Напротив, при работе\n", + "с текстовым редактором или IDE код, соответствующие файлы данных и\n", + "рисунки, а также документация распределяются по нескольким файлам в\n", + "файловой системе, и для поддержания такого рабочего процесса требуются\n", + "значительные усилия.\n", + "\n", + "Jupyter Notebook оснащен богатой системой отображения, которая может\n", + "отображать мультимедиа, такие как уравнения, рисунки и видео, как\n", + "встроенные объекты в блокноте. Также возможно создавать элементы\n", + "пользовательского интерфейса с HTML и JavaScript, используя\n", + "систему виджетов Jupyter. Эти виджеты можно использовать в\n", + "интерактивных приложениях, которые связывают веб-приложение с кодом\n", + "Python, который выполняется в ядре IPython (на стороне сервера). Эти и\n", + "многие другие функции Jupyter Notebook делают его отличной средой для\n", + "интерактивных и грамотных вычислений. Для запуска среды Jupyter\n", + "Notebook аргумент `notebook` передается команде `jupyter`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Terminal> jupyter notebook\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Это запускает ядро ноутбука и веб-приложение, которое по умолчанию\n", + "обслуживает веб-сервер через порт 8888 на локальном хосте, доступ к\n", + "которому осуществляется через локальный адрес \n", + "в \n", + "веб-браузере.\n", + "По умолчанию при запуске `jupyter notebook` в браузере открывается\n", + "страница с панелью инструментов. На панели инструментов перечислены\n", + "все блокноты, доступные в каталоге, из которого был запущен\n", + "Jupyter Notebook, а также простой обозреватель каталогов, который\n", + "можно использовать для навигации по подкаталогам относительно места,\n", + "где был запущен сервер, и для открытия блокнотров в нем. На рисунке\n", + "показан снимок экрана веб-браузера и страницы с панелью инструментов\n", + "Jupyter Notebook:\n", + "\n", + "\n", + "\n", + "![](fig-intro/jupyter_2.png)\n", + "\n", + "\n", + "Нажатием кнопки «New» создадим новый блокнот и откроем его на новой\n", + "странице в браузере. Вновь созданный блокнот имеет имя `Untitled` или\n", + "`Untitled1` и т.д. Блокнот можно переименовать нажав на поле с\n", + "заголовком в верхней части страницы. Файлы Jupyter Notebook\n", + "сохраняются в формате JSON со специальным разрешением `ipynb`. Файл\n", + "Jupyter Notebook не является чистым кодом на Python, но при\n", + "необходимости код на Python можно легко выделить из блокнота используя\n", + "либо меню «File ➤ Download as ➤ Python» или с помощью утилиты\n", + "`nbconvert`.\n", + "\n", + "\n", + "\n", + "![](fig-intro/jupyter_3.png)\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "### Jupyter Lab\n", + "\n", + "
\n", + "\n", + "Jupyter Lab — это новая альтернативная среда разработки из проекта\n", + "Jupyter. Она объединяет интерфейс Jupyter Notebook с файловым\n", + "браузером, текстовым редактором, командной оболочкой и консолью\n", + "IPython:\n", + "\n", + "\n", + "\n", + "![](fig-intro/jupyter_4.png)\n", + "\n", + "\n", + "Среда Jupyter Lab объединяет в себе множество преимуществ среды\n", + "для блокнотов и сильные стороны традиционных IDE. Доступ к консолям\n", + "оболочки и текстовым редакторам в одном веб-интерфейсе также удобен\n", + "при работе на сервере Jupyter, работающем в удаленной системе,\n", + "например в вычислительном кластере или в облаке. \n", + "\n", + "### Типы ячеек\n", + "\n", + "
\n", + "\n", + "Основное содержимое блокнота, расположенное под строкой меню и\n", + "панелью инструментов, организовано как ячейки ввода и вывода. Ячейки\n", + "могут быть нескольких типов, тип выбранной ячейки можно изменять\n", + "используя меню в панели инструментов. Наиболее важные типы:\n", + "\n", + "* **Code**: ячейка с кодом может содержать произвольное количество многострочного кода на Python. Нажатие «Shift-Enter» посылает код из ячейки ядру для выполнения в интерпретаторе Python. Результат выполнения возвращается браузеру и отображается в соответствующей ячейке вывода.\n", + "\n", + "* **Markdown**: ячейка такого типа может содержать размеченный текст, который интерпретируется с использованием языка Markdown и HTML.\n", + "\n", + "* **Headings**: ячейка такого типа может использоваться для разбивки блокнота на разделы.\n", + "\n", + "* **Raw**: ячейка такого типа отображает необработанный текст.\n", + "\n", + "### Редактирование ячеек\n", + "\n", + "
\n", + "\n", + "\n", + "\n", + "Используя меню и панель инструментов, ячейки можно добавлять,\n", + "удалять, перемещать вверх и вниз, вырезать и вставлять и т.д. Эти\n", + "функции также связаны с сочетаниями клавиш, которые удобны и\n", + "экономят время при работе с ноутбуками Jupyter. В ноутбуке\n", + "используется двухрежимный интерфейс ввода: режим редактирования и\n", + "командный режим. В режим редактирования можно войти, щелкнув ячейку\n", + "или нажав клавишу ввода на клавиатуре, когда ячейка находится в\n", + "фокусе. Находясь в режиме редактирования, содержимое ячейки ввода\n", + "можно редактировать. Выход из режима редактирования осуществляется\n", + "нажатием клавиши ESC или нажатием Shift-Enter для выполнения ячейки. В\n", + "командном режиме стрелки вверх и вниз можно использовать для\n", + "перемещения фокуса между ячейками, а ряд сочетаний клавиш\n", + "сопоставляется с основными действиями по манипулированию ячейками,\n", + "доступными через панель инструментов и меню. \n", + "\n", + "\n", + "\n", + "
\n", + "\n", + "\n", + "**Таблица 1.** \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
Сочетание клавиш Описание
b Создать ячейку ниже текущей
a Создать ячейку выше текущей
d-d Удалить текущую ячейку
от 1 до 6 Ячейка с заглавием раздела (heading) уровня от 1 до 6
x Вырезать текущую ячейку в буфер обмена
c Скопировать текущую ячейку в буфер обмена
v Вставить ячейку из буфера обмена
m Преобразовать тип ячейки в Markdown
y Преобразовать тип ячейки в Code
Up Выбрать предыдущую ячейку
Down Выбрать следующую ячейку
Enter Войти в режим редактирования ячейки
Escape Выйти из режима редактирования ячейки
Shift-Enter Выполнить ячейку
h Показать окно помощи со списком сочиетаний клавиш
0-0 Перезапустить ядро
i-i Прервать выполнение ячейки
s Сохранить блокнот
\n", + "\n", + "\n", + "Во время выполнения ячейки блокнота номер ячейки обозначается\n", + "звездочкой (`In [*]`), а индикатор в правом верхнем углу страницы\n", + "сигнализирует о том, что ядро IPython занято. Прервать выполнение\n", + "ячейки можно через меню «Kernel ➤ Interrupt» или сочетанием клавиш\n", + "`i-i` в командном режиме (т.е., дважды нажать клавишу `i`). В таблице 1\n", + "представлены наиболее популярные сочетания клавиш командного режима\n", + "Jupyter Notebook.\n", + "\n", + "### Ячейки Markdown\n", + "\n", + "
\n", + "\n", + "Одна из ключевых возможностей Jupyter Notebook заключается в том, что\n", + "ячейки с кодом и ячейки с результатом могут быть дополнены\n", + "документацией, содержащейся в текстовых ячейках. Текстовые ячейки\n", + "имеют тип Markdown. Входной текст преобразуется с использованием языка\n", + "разметки Markdown. Markdown разработан как легкая система набора\n", + "текста, которая позволяет преобразовывать текст с простыми правилами\n", + "разметки в HTML и другие форматы для более удобного\n", + "отображения. Правила разметки разработаны так, чтобы быть удобными для\n", + "пользователя и читаемыми, как в текстовом формате. Например, фрагмент\n", + "текста можно выделить курсивом, окружив его звездочками (`*text*`),\n", + "можно сделать полужирным, окружив двойными звездочками\n", + "(`**text**`). Markdown также позволяет создавать нумерованные и\n", + "маркированные списки, таблицы и гиперссылки. Расширение Markdown,\n", + "поддерживаемое Jupyter, заключается в том, что математические\n", + "выражения можно набирать в LaTeX с помощью библиотеки JavaScript LaTeX\n", + "MathJax.\n", + "\n", + "Ниже приведем краткое описание синтаксиса Markdown.\n", + "\n", + "**Выделение.**\n", + "\n", + "Одинарные звездочки используются для выделения курсивом" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " это *выделенный* текст\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Двойные звездочки используются для выделения полужирным" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " это **очень выделенный** текст\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Код в строке.**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Используйте функцию `printf()` для вывода.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Ссылки.**\n", + "\n", + "Инлайн ссылки" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Это простая [ссылка](http://rukeba.com/) в тексте.\n", + " Это [ссылка](http://rukeba.com/ \"Титул\") с аттрибутом title.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Сноски" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Это [ссылка][1] в справочном стиле.\n", + " ...\n", + " ...\n", + " [1]: http://rukeba.com/ \"Необязательный титул\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Чтобы веб-адрес в тексте стал ссылкой его нужно обрамить `<` и `>`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " По ссылке находится сайт.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Изображения.**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " ![alt-текст](http://example.com/image.jpg \"Необязательный титул\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "или в справочном стиле:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " ![alt-текст][2]\n", + " ...\n", + " ...\n", + " [2]: http://example.com/image.jpg \"Необязательный титул\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Абзац.**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " <пустая строка>\n", + " Текст параграфа. Может быть\n", + " разбит на несколько строк.\n", + " <пустая строка>\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Разрыв строки.**\n", + "\n", + "Что бы вставить перевод строки без начала нового параграфа, в конец\n", + "нужно добавить два или больше пробелов." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Текст параграфа.<пробел><пробел>\n", + " Этот текст будет с новой строки.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Код.**\n", + "\n", + "Отступ в четыре пробела или один таб генерирует блок кода:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " <пробел><пробел><пробел><пробел>print 'Hello, World!'\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Горизонтальная линия.**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " * * *\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "или так:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " ***\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "или так:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " ------\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Таблица.**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " | A | B | C |\n", + " |---|---|---|\n", + " | 1 | 2 | 3 |\n", + " | 4 | 5 | 6 |\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Заголовки.**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " # Заголовок первого уровня H1\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Цитаты.**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " > Это\n", + " > многострочная\n", + " > цитата\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Списки.**\n", + "\n", + "Ненумерованный:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " * красный\n", + " * зеленый\n", + " * синий\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Нумерованный:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " 1. Первый\n", + " 2. Второй\n", + " 3. Третий\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**LaTeX.**\n", + "\n", + "Строчные формулы:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " $\\LaTeX$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Выключеная формула (с новой строки и по-центру):" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " $$\n", + " \\LaTeX\n", + " $$\n" ] }, { @@ -515,202 +1999,141 @@ "cell_type": "markdown", "metadata": {}, "source": [ - " Terminal> python3\n" + " \\begin{env}\n", + " ...\n", + " \\end{env}\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "В результате Python запустится в интерактивном режиме и будет ожидать ввод\n", - "команд пользователя.\n", + "Здесь `env` LaTeX окружение для формул: `equation`, `eqnarray`,\n", + "`align` и т.д.\n", "\n", - "\n", - "\n", - "![](fig-intro/interact_1.png)\n", + "Ячейки типа Markdown могут также содержать код HTML, и интерфейс\n", + "Jupyter Notebook будет отображать его как обработанный HTML.\n", + "\n", + "Больше информации о MathJax и Markdown доступно на страницах проектов:\n", + " и . \n", + "\n", + "## Spyder: Интегрированная среда разработки\n", + "
\n", + "\n", + "Рассмотрим свободную интегрированную среду разработки Spyder, особенно\n", + "хорошо подходит для вычислений и анализа данных с использованием\n", + "Python.\n", + "\n", + "Spyder IDE был специально создан для программирования на Python и, в\n", + "частности, для научных вычислений с использованием Python. Как\n", + "таковой, он обладает функциями, которые полезны для интерактивных и\n", + "исследовательских вычислений: в частности, интеграция с консолью\n", + "IPython непосредственно в IDE. Пользовательский интерфейс Spyder\n", + "состоит из нескольких дополнительных панелей, которые могут быть\n", + "по-разному организованы в приложении.\n", + "\n", + "Самые важные панели:\n", + "\n", + "* Редактор исходного кода\n", + "\n", + "* Консоли интерпретаторов Python и IPython и системной оболочки\n", + "\n", + "* Инспектор объектов для показа документации по объектам Python\n", + "\n", + "* Обозреватель переменных\n", + "\n", + "* Обозреватель файловой\n", + "\n", + "* История команд\n", + "\n", + "* Профилировщик\n", + "\n", + "Каждую панель можно настроить для отображения или скрытия в\n", + "зависимости от предпочтений и потребностей пользователя, используя\n", + "меню «View ➤ Panes». \n", + "\n", + "### Редактор исходного кода\n", + "\n", + "
\n", + "\n", + "Редактор исходного кода в Spyder поддерживает подсветку синтаксиса,\n", + "умное автодополнение, работу с несколькими открытыми файлами\n", + "одновременно, проверку соответствия скобок и др. Дополнительным\n", + "преимуществом использования IDE является то, что код может \n", + "быть запущен из редактора — код целиком (клавиша F5) или выделенный\n", + "код (клавиша F9) — в подключенных консолях Python и IPython.\n", + "\n", + "Кроме того, редактор Spyder имеет очень полезную поддержку статической\n", + "проверки кода с помощью `pylint`, `pyflakes` и `pep8` — внешних\n", + "инструментов, которые анализируют исходный код Python и сообщают об\n", + "ошибках, таких как неопределенные символы, синтаксические ошибки,\n", + "нарушения стиля кодирования и т. д. \n", + "\n", + "> **Подсказка.**\n", + ">\n", + "> Язык Python является универсальным, и эквивалентный исходный код\n", + "> Python может быть написан с использованием самых разных стилей и\n", + "> способов. Однако был предложен стандарт стиля кодирования Python,\n", + "> PEP8, для поощрения единообразного внешнего вида кода Python. \n", + "> Настоятельно рекомендуем изучить стандарт стиля кодирования PEP8 и \n", + "> соответствовать этому в вашем коде. PEP8 описан по адресу\n", + "> .\n", "\n", "\n", - "Если же у вас есть файл с исходным кодом на Python , и вы его хотите запустить, то\n", - "для этого нужно в командной строке вызвать интерпретатор Python и в качестве\n", - "аргумента передать ваш файл. Например, для файла с именем test.py процедура\n", - "запуска будет выглядеть так:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - " Terminal> python test.py\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Откройте Python в интерактивном режиме и наберите в нем следующее:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "print(“Hello, World!”)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "И нажмите ENTER .\n", - "\n", - "В ответ на это интерпретатор выполнит данную строку и отобразит\n", - "строкой ниже результат своей работы.\n", - "\n", - "\n", - "\n", - "![](fig-intro/interact_2.png)\n", "\n", "\n", - "Python можно использовать как калькулятор для различных вычислений, а если\n", - "дополнительно подключить необходимые математические библиотеки, то по своим\n", - "возможностям он становится практически равным таким пакетам как Matlab, Octave и\n", - "т.п.\n", "\n", - "Различные примеры вычислений приведены ниже. Более подробно об\n", - "арифметических операциях будет рассказано далее. \n", + "### Консоли\n", "\n", - "\n", - "\n", - "![](fig-intro/interact_3.png)\n", + "
\n", "\n", + "Интегрированные консоли Python и IPython могут использоваться для\n", + "запуска файла, который редактируется в окне текстового редактора, или\n", + "для запуска кода Python с интерактивным вводом. При выполнении файлов\n", + "исходного кода Python из редактора переменные пространства имен,\n", + "созданные в сценарии, сохраняются в сеансе IPython или Python в\n", + "консоли. Это важная особенность, которая делает Spyder интерактивной\n", + "вычислительной средой, в дополнение к традиционному приложению IDE,\n", + "поскольку она позволяет исследовать значения переменных после\n", + "завершения выполнения сценария. Spyder поддерживает одновременное\n", + "открытие нескольких консолей Python и IPython, и, например, новую\n", + "консоль IPython можно запустить через меню «Consoles ➤ Open an IPython\n", + "console». При запуске сценария из редактора нажатием клавиши F5 или\n", + "кнопки запуска на панели инструментов сценарий по умолчанию\n", + "запускается в самой последней активированной консоли. Это позволяет\n", + "поддерживать разные консоли с независимыми пространствами имен для\n", + "разных сценариев или проектов. \n", "\n", - "Для выхода из интерактивного режима, наберите команду" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "exit()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "и нажмите ENTER .\n", + "### Инспектор объектов\n", "\n", - "В комплекте вместе с интерпретатором Python идет IDLE (интегрированная\n", - "среда разработки). По своей сути она подобна интерпретатору, запущенному\n", - "в интерактивном режиме с расширенным набором возможностей (подсветка синтаксиса,\n", - "просмотр объектов, отладка и т.п.).\n", - "\n", - "Для запуска IDLE в Windows необходимо перейти в папку Python в меню “Пуск” и\n", - "найти там ярлык с именем «IDLE (Python 3 XX-bit)».\n", - "\n", - "\n", - "\n", - "![](fig-intro/interact_4.png)\n", - "\n", - "\n", - "В Linux оболочка IDLE по умолчанию отсутствует, поэтому ее предварительно\n", - "нужно установить. Для этого, если у вас Ubuntu , введите в командной строке (для\n", - "Python 3.4):" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - " Terminal> sudo apt-get install idle-python3\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "В результате IDLE будет установлен на ваш компьютер.\n", - "Для запуска оболочки, введите:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - " Terminal> idle-python3.4\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Ниже представлен внешний вид IDLE в ОС Linux.\n", - "\n", - "\n", - "\n", - "![](fig-intro/interact_5.png)\n", - "\n", - "\n", - "## Пакетный режим работы\n", - "
\n", - "\n", - "Теперь запустим Python в режиме интерпретации файлов с исходным кодом\n", - "(пакетный режим). Создайте файл с именем `test.py`, откройте его с\n", - "помощью любого текстового редактора и введите следующий код:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "a = int(input())\n", - "print(a**2)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Эта программа принимает целое число на вход и выводит его квадрат. Для\n", - "запуска, наберите в командной строке" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - " Terminal> python test.py\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Пример работы программы приведен в окне ниже.\n", - "\n", - "\n", - "\n", - "![](fig-intro/interact_5.png)\n", + "
\n", "\n", + "Инспектор объектов (панель справки) очень помогает при написании кода\n", + "Python. Он может отображать строки форматированного документа для\n", + "объектов, определенных в исходном коде, созданном с помощью редактора,\n", + "и для символов, определенных в библиотечных модулях, установленных в\n", + "системе. Текстовое поле объекта в верхней части панели инспектора\n", + "объектов можно использовать для ввода имени модуля, функции или\n", + "класса, для которого отображается строка документации. Модули и\n", + "символы не нужно импортировать в локальное пространство имен, чтобы\n", + "можно было отображать их строки документов с помощью инспектора\n", + "объектов. Документацию для объекта в редакторе или консоли также можно\n", + "открыть в инспекторе объектов, выбрав объект с помощью курсора и\n", + "используя сочетание клавиш `Ctrl-i` (`Cmd-i` в Mac OS X). Можно даже\n", + "автоматически отображать строки документов для вызываемых объектов,\n", + "когда вводится его открывающая левая скобка. Это дает немедленное\n", + "напоминание об аргументах и ​​их порядке для вызываемого объекта, что\n", + "может значительно повысить производительность. Чтобы активировать эту\n", + "функцию, перейдите на страницу «Help» в окне «Preferences» и\n", + "установите флажки в разделе «Automatic connections». \n", "\n", "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", + "\n", "\n", "\n", "" diff --git a/src-datatype/quadratic.py b/src-datatype/quadratic.py new file mode 100644 index 0000000..505b345 --- /dev/null +++ b/src-datatype/quadratic.py @@ -0,0 +1,49 @@ +# -*- coding: utf-8 -*- +import cmath +import math +import sys + +# Start get_float +def get_float(msg, allow_zero): + x = None + while x is None: + try: + x = float(input(msg)) + if not allow_zero and abs(x) < sys.float_info.epsilon: + print("zero is not allowed") + x = None + + except ValueError as err: + print(err) + return x +# End get_float + +# Start 1st block +print("ax\N{SUPERSCRIPT TWO} + bx + c = 0") +a = get_float("enter a: ", False) +b = get_float("enter b: ", False) +c = get_float("enter c: ", False) +# End 1st block + +# Start 2d block +x1 = None +x2 = None +discriminant = (b ** 2) - (4 * a * c) +if discriminant == 0: + x1 = -(b / (2 * a)) +else: + if discriminant > 0: + root = math.sqrt(discriminant) + else: # discriminant < 0 + root = cmath.sqrt(discriminant) + x1 = (-b + root) / (2 * a) + x2 = (-b - root) / (2 * a) +# End 2d block + +# Start 3d block +equation = ("{0}x\N{SUPERSCRIPT TWO} + {1}x + {2} = 0" + " \N{RIGHTWARDS ARROW} x = {3}").format(a, b, c, x1) +if x2 is not None: + equation += " or x = {0}".format(x2) +print(equation) +# End 3d block diff --git a/src-intro/.ipynb_checkpoints/Untitled-checkpoint.ipynb b/src-intro/.ipynb_checkpoints/Untitled-checkpoint.ipynb new file mode 100644 index 0000000..2fd6442 --- /dev/null +++ b/src-intro/.ipynb_checkpoints/Untitled-checkpoint.ipynb @@ -0,0 +1,6 @@ +{ + "cells": [], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src-intro/Untitled.ipynb b/src-intro/Untitled.ipynb new file mode 100644 index 0000000..d874c4f --- /dev/null +++ b/src-intro/Untitled.ipynb @@ -0,0 +1,49 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Заголовок 1 уровня\n", + "## Заголовок 2 уровня\n", + "### Заголовок 3 уровня" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> Этот текст печатается со сдвигом\n", + "> по отношению к основному тексту." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.8.1" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/src-intro/Untitled.ipynb~ b/src-intro/Untitled.ipynb~ new file mode 100644 index 0000000..fb4970b --- /dev/null +++ b/src-intro/Untitled.ipynb~ @@ -0,0 +1,46 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Заголовок 1 уровня\n", + "## Заголовок 2 уровня\n", + "### Заголовок 3 уровня" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.8.1" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/src-intro/fib.py b/src-intro/fib.py new file mode 100644 index 0000000..193eb3a --- /dev/null +++ b/src-intro/fib.py @@ -0,0 +1,14 @@ +# -*- coding: utf-8 -*- +def fib(n): + """ + Возвращает список первых n чисел Фибоначи + """ + f0, f1 = 0, 1 + f = [1]*n + for i in range(1, n): + f[i] = f0 + f1 + f0, f1 = f1, f[i] + + return f + +print(fib(10)) diff --git a/src-intro/hello.py b/src-intro/hello.py new file mode 100644 index 0000000..7243d25 --- /dev/null +++ b/src-intro/hello.py @@ -0,0 +1 @@ +print("Hello from Python!") diff --git a/src-intro/walkers.py b/src-intro/walkers.py new file mode 100644 index 0000000..390ab71 --- /dev/null +++ b/src-intro/walkers.py @@ -0,0 +1,6 @@ +# -*- coding: utf-8 -*- +import numpy as np + +def random_walker_max_distance(M, N): + trajectories = [np.random.randn(M).cumsum() for _ in range(N)] + return np.max(np.abs(trajectories))