dr_domi/python-course-ipynb
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Добавлена глава по типам коллекций

Browse Source
This commit is contained in:
Sergey Lemeshevsky
2020-03-02 12:29:02 +03:00
parent af27efd7f6
commit 2756a9b834
20 changed files with 3162 additions and 950 deletions
Download Patch File Download Diff File Expand all files Collapse all files

926
arithmetic.ipynb
View File

@@ -1,926 +0,0 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!-- dom:TITLE: Арифметические операции -->\n",
"# Арифметические операции\n",
"<!-- dom:AUTHOR: С.В. Лемешевский Email:sergey.lemeshevsky@gmail.com at Институт математики НАН Беларуси -->\n",
"<!-- Author: --> \n",
"**С.В. Лемешевский** (email: `sergey.lemeshevsky@gmail.com`), Институт математики НАН Беларуси\n",
"\n",
"\n",
"Язык Python , благодаря наличию огромного количества библиотек для решения\n",
"разного рода вычислительных задач, является конкурентом таким пакетам как Matlab и\n",
"Octave. Запущенный в интерактивном режиме, он, фактически, превращается в\n",
"мощный калькулятор. В этой главе речь пойдет об арифметических операциях,\n",
"доступных в данном языке.\n",
"\n",
"Как было сказано в предыдущей главе, посвященной типам и модели данных\n",
"Python, в этом языке существует три встроенных числовых типа данных:\n",
"* целые числа (`int`);\n",
"\n",
"* вещественные числа (`float`);\n",
"\n",
"* комплексные числа (`complex`).\n",
"\n",
"Если в качестве операндов некоторого арифметического выражения используются\n",
"только целые числа, то результат тоже будет целое число. Исключением является\n",
"операция деления, результатом которой является вещественное число.\n",
"При совместном использовании целочисленных и вещественных переменных, результат\n",
"будет вещественным.\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"<!-- Common Mako variable and functions -->\n",
"<!-- -*- coding: utf-8 -*- -->\n",
"\n",
"\n",
"\n",
"\n",
"# Арифметические операции с целыми и вещественными числами\n",
"<div id=\"arithmetic:numbers\"></div>\n",
"\n",
"Все эксперименты будем проводить в Python, запущенном в интерактивном\n",
"режиме.\n",
"\n",
"\n",
"**Сложение.** Складывать можно непосредственно сами числа ..."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"3 + 2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"либо переменные, но они должны предварительно быть проинициализированы."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"a = 3\n",
"b = 2\n",
"a + b"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Результат операции сложения можно присвоить другой переменной..."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"a = 3\n",
"b = 2\n",
"c = a + b\n",
"print (c)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"либо ей же самой, в таком случае можно использовать полную или сокращенную\n",
"запись, полная выглядит так:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"a = 3\n",
"b = 2\n",
"a = a + b\n",
"print (a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"сокращенная так:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"a = 3\n",
"b = 2\n",
"a += b\n",
"print (a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Все перечисленные выше варианты использования операции сложения могут быть\n",
"применены для всех нижеследующих операций.\n",
"\n",
"**Вычитание.**"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"4 - 2"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"a = 5\n",
"b = 7\n",
"a - b"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Деление.**"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"9 / 3"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"a = 7\n",
"b = 4\n",
"a / b"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Получение целой части от деления.**"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"9 // 3"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"a = 7\n",
"b = 4\n",
"a // b"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Получение дробной части от деления.**"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"9 % 5"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"a = 7\n",
"b = 4\n",
"a % b"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Возведение в степень.**"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"5**4"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"a = 4\n",
"b = 3\n",
"a**b"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!-- Local Variables: -->\n",
"<!-- doconce-chapter-nickname: \"arithmetic\" -->\n",
"<!-- doconce-section-nickname: \"numbers\" -->\n",
"<!-- End: -->\n",
"# Работа с комплексными числами\n",
"<div id=\"arithmetic:complex\"></div>\n",
"\n",
"Для создания комплексного числа можно использовать функцию `complex(a, b)`, в\n",
"которую, в качестве первого аргумента, передается действительная часть, в качестве\n",
"второго – мнимая. Либо записать число в виде `a+bj`.\n",
"\n",
"Рассмотрим несколько примеров.\n",
"\n",
"Создание комплексного числа."
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"z = 1+2j\n",
"print(z)"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"x = complex(3, 2)\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Комплексные числа можно складывать, вычитать, умножать, делить и возводить в\n",
"степень."
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"x+z"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"x-z"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"x*z"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"x/z"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"x**z"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"x**3"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"У комплексного числа можно извлечь действительную и мнимую части."
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"x = 3+2j\n",
"x.real"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"x.imag"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Для получения комплексносопряженного число необходимо использовать метод\n",
"`conjugate()`."
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"x.conjugate()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!-- Local Variables: -->\n",
"<!-- doconce-chapter-nickname: \"arithmetic\" -->\n",
"<!-- doconce-section-nickname: \"complex\" -->\n",
"<!-- End: -->\n",
"# Битовые операции\n",
"<div id=\"arithmetic:bit\"></div>\n",
"\n",
"В Python доступны битовые операции, их можно производить над целыми числами.\n",
"\n",
"**Побитовое И (AND).**"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"p = 9\n",
"q = 3\n",
"p & q"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Побитовое ИЛИ (OR).**"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"p | q"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Побитовое Исключающее ИЛИ (XOR).**"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"p^q"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Инверсия.**"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"~p"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Сдвиг вправо и влево.**"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"p<<1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!-- Local Variables: -->\n",
"<!-- doconce-chapter-nickname: \"arithmetic\" -->\n",
"<!-- doconce-section-nickname: \"bit\" -->\n",
"<!-- End: -->\n",
"# Представление чисел в других системах счисления\n",
"<div id=\"arithmetic:other\"></div>\n",
"\n",
"В своей повседневной жизни мы используем десятичную систему исчисления, но\n",
"при программирования, очень часто, приходится работать с шестнадцатеричной,\n",
"двоичной и восьмеричной.\n",
"\n",
"**Представление числа в шестнадцатеричной системе.**"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"m = 124504\n",
"hex(m)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Представление числа в восьмеричной системе.**"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"oct(m)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Представление числа в двоичной системе.**"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"bin(m)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!-- Local Variables: -->\n",
"<!-- doconce-chapter-nickname: \"arithmetic\" -->\n",
"<!-- doconce-section-nickname: \"other\" -->\n",
"<!-- End: -->\n",
"# Библиотека (модуль) `math`\n",
"<div id=\"arithmetic:math\"></div>\n",
"\n",
"В стандартную поставку Python входит библиотека math , в которой содержится\n",
"большое количество часто используемых математических функций.\n",
"\n",
"Для работы с данным модулем его предварительно нужно импортировать."
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"import math"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Рассмотрим наиболее часто используемые функции.\n",
"\n",
"**Функция `math.ceil(x)`.**\n",
"\n",
"Возвращает ближайшее целое число большее, чем `x`."
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"math.ceil(3.2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Функция `math.fabs(x)`.**\n",
"\n",
"Возвращает абсолютное значение числа."
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"math.fabs(-7)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Функция `math.factorial(x)`.**\n",
"\n",
"Вычисляет факториал `x`."
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"math.factorial(5)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"** Функция `math.floor(x)`.**\n",
"\n",
"Возвращает ближайшее целое число меньшее, чем `x`."
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"math.floor(3.2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Функция `math.exp(x)`.**\n",
"Вычисляет `e**x`."
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"math.exp(3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Функция `math.log2(x)`.**\n",
"Логарифм по основанию `2`."
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"math.log2(8)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Функция `math.log10(x)`.**\n",
"\n",
"Логарифм по основанию 10."
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"math.log10(1000)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Функция `math.log(x[, base])`.**\n",
"\n",
"По умолчанию вычисляет логарифм по основанию `e`, дополнительно можно указать\n",
"основание логарифма."
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"math.log(5)"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"math.log()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Функция `math.pow(x, y)`.**\n",
"\n",
"Вычисляет значение `x` в степени `y`."
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"math.pow(3 , 4)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Функция `math.sqrt(x)`.**\n",
"\n",
"Корень квадратный от `x`."
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"math.sqrt(25)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Тригонометрические функции, их мы оставим без примера.**\n",
"\n",
"* `math.cos(x)`\n",
"\n",
"* `math.sin(x)`\n",
"\n",
"* `math.tan(x)`\n",
"\n",
"* `math.acos(x)`\n",
"\n",
"* `math.asin(x)`\n",
"\n",
"* `math.atan(x)`\n",
"\n",
"И напоследок пару констант.\n",
"* `math.pi` — число $\\pi$.\n",
"\n",
"* `math.e` — число $e$.\n",
"\n",
"Помимо перечисленных, модуль `math` содержит ещё много различных\n",
"функций, за более подробной информацией можете обратиться eна\n",
"официальный сайт (<https://docs.python.org/3/library/math.html>).\n",
"\n",
"\n",
"<!-- Local Variables: -->\n",
"<!-- doconce-chapter-nickname: \"arithmetic\" -->\n",
"<!-- doconce-section-nickname: \"math\" -->\n",
"<!-- End: -->\n",
"\n",
"\n",
"<!-- Local Variables: -->\n",
"<!-- doconce-chapter-nickname: \"arithmetic\" -->\n",
"<!-- End: -->"
]
}
],
"metadata": {},
"nbformat": 4,
"nbformat_minor": 2
}

1907
collections.ipynb Normal file
View File

File diff suppressed because it is too large Load Diff

881
datatype.ipynb
View File

@@ -10,15 +10,13 @@
"<!-- Author: --> \n", "<!-- Author: --> \n",
"**С.В. Лемешевский** (email: `sergey.lemeshevsky@gmail.com`), Институт математики НАН Беларуси\n", "**С.В. Лемешевский** (email: `sergey.lemeshevsky@gmail.com`), Институт математики НАН Беларуси\n",
"\n", "\n",
"Date: **Feb 24, 2020**\n", "Date: **Feb 27, 2020**\n",
"\n", "\n",
"<!-- Common Mako variable and functions -->\n", "<!-- Common Mako variable and functions -->\n",
"<!-- -*- coding: utf-8 -*- -->\n", "<!-- -*- coding: utf-8 -*- -->\n",
"\n", "\n",
"\n", "\n",
"\n", "\n",
"\n",
"\n",
"Здесь разберем как Python работает с переменными и определим, какие\n", "Здесь разберем как Python работает с переменными и определим, какие\n",
"типы данных можно использовать в рамках этого языка. Подробно рассмотрим модель\n", "типы данных можно использовать в рамках этого языка. Подробно рассмотрим модель\n",
"данных Python, а также механизмы создания и изменения значения\n", "данных Python, а также механизмы создания и изменения значения\n",
@@ -1514,7 +1512,7 @@
"Как показано в примере, мы можем также использовать комбинированный\n", "Как показано в примере, мы можем также использовать комбинированный\n",
"оператор присваивания с дублированием. \n", "оператор присваивания с дублированием. \n",
"\n", "\n",
"# Форматирование строк с помощью метода `str.format()`\n", "## Форматирование строк с помощью метода `str.format()`\n",
"<div id=\"datatype:strings:format\"></div>\n", "<div id=\"datatype:strings:format\"></div>\n",
"\n", "\n",
"Метод `str.format()` представляет собой очень мощное и гибкое средство\n", "Метод `str.format()` представляет собой очень мощное и гибкое средство\n",
@@ -1608,6 +1606,8 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"В следующем разделе мы рассмотрим применение функции `str.format()`.\n",
"\n",
"<!-- Local Variables: -->\n", "<!-- Local Variables: -->\n",
"<!-- doconce-chapter-nickname: \"datatype\" -->\n", "<!-- doconce-chapter-nickname: \"datatype\" -->\n",
"<!-- doconce-section-nickname: \"strings\" -->\n", "<!-- doconce-section-nickname: \"strings\" -->\n",
@@ -1615,8 +1615,195 @@
"# Примеры\n", "# Примеры\n",
"<div id=\"datatype:examples\"></div>\n", "<div id=\"datatype:examples\"></div>\n",
"\n", "\n",
"## Печать символов Юникода\n",
"<div id=\"datatype:examples:print-unicode\"></div>\n",
"\n", "\n",
"Рассмотрим небольшой, но достаточно поучительный пример использования\n",
"метода `str.format()`, в котором мы увидим применение спецификаторов\n",
"формата в реальном контексте. Программа, состоящая всего из 25 строк\n",
"выполняемого кода, находится в файле\n",
"[print_unicode.py](src-datatype/print_unicode.py). Она импортирует\n",
"два модуля, `sys` и `unicodedata` и определяет одну функцию –\n",
"`print_unicode_table()`. Рассмотрение примера мы начнем\n",
"с запуска программы, чтобы увидеть, что она делает; затем мы\n",
"рассмотрим программный код в конце программы, где выполняется вся\n",
"фактическая работа; и в заключение рассмотрим функцию, определяемую в\n",
"программе."
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"%run src-datatype/print_unnicode.py Spoked"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"При запуске без аргументов программа выводит таблицу всех символов\n",
"Юникода, начиная с пробела и до символа с наибольшим возможным\n",
"кодом. При запуске с аргументом, как показано в примере, выводятся \n",
"только те строки таблицы, где в названии символов Юникода содержится\n",
"значение строки-аргумента, переведенной в нижний регистр.\n",
"\n", "\n",
"Разберем исходный код программы:"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Start main script\n",
"word = None\n",
"\n",
"if len(sys.argv) > 1:\n",
" if sys.argv[1] in (\"-h\", \"--help\"):\n",
" print(\"usage: {0} [string]\".format(sys.argv[0]))\n",
" word = 0\n",
" else:\n",
" word = sys.argv[1].lower()\n",
"\n",
"if word != 0:\n",
" print_unicode_table(word)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"После инструкций импортирования и определения функции\n",
"`print_unicode_table()` выполнение достигает программного кода,\n",
"показанного выше. Сначала предположим, что пользователь не указал в\n",
"командной строке искомое слово. Если аргумент командной строки\n",
"присутствует и это `-h` или `--help`, программа выводит информацию о\n",
"порядке использования и устанавливает флаг `word` в значение `0`, указывая\n",
"тем самым, что работа завершена. В противном случае в переменную `word`\n",
"записывается копия аргумента, введенного пользователем, с\n",
"преобразованием всех символов в нижний регистр. Если значение `word` не\n",
"равно `0`, программа выводит таблицу.\n",
"\n",
"При выводе информации о порядке использования применяется спецификатор\n",
"формата, который представляет собой простое имя формата, в данном\n",
"случае – порядковый номер позиционного аргумента. Мы могли бы записать\n",
"эту строку, как показано ниже:"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"print(\"usage: {0[0]} [string]\".format(sys.argv))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"При таком подходе первый символ `0` соответствует порядковому номеру\n",
"позиционного аргумента, а `[0]` — это индекс элемента внутри\n",
"аргумента, и такой прием сработает, потому что `sys.argv` является\n",
"списком."
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"def print_unicode_table(word):\n",
" print(\"decimal hex chr {0:^40}\".format(\"name\"))\n",
" print(\"------- ----- --- {0:-<40}\".format(\"\"))\n",
"\n",
" code = ord(\" \")\n",
" end = sys.maxunicode\n",
"\n",
" while code < end:\n",
" c = chr(code)\n",
" name = unicodedata.name(c, \"*** unknown ***\")\n",
" if word is None or word in name.lower():\n",
" print(\"{0:7} {0:5X} {0:^3c} {1}\".format(code, name.title()))\n",
" code += 1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Первый вызов `str.format()` выводит текст `\"name\"`, отцентрированный в\n",
"поле вывода, шириной 40 символов, а второй вызов выводит пустую строку\n",
"в поле шириной 40 символов, используя символ `-` в качестве\n",
"символа-заполнителя, с выравниванием по левому краю. \n",
"\n",
"Как вариант, вторую строку функции можно было записать, как показано ниже:"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"print(\"------- ----- --- {0}\".format(\"-\" * 40))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Здесь мы использовали оператор дублирования строки (`*`), чтобы\n",
"создать необходимую строку, и просто вставили ее в строку формата.\n",
"\n",
"Текущий код символа Юникода сохраняется в переменной `code`, которая\n",
"инициализируется кодом пробела (`0x20`). В переменную end записывается\n",
"максимально возможный код символа Юникода, который может принимать\n",
"разные значения в зависимости от того, какая из кодировок\n",
"использовалась при компиляции Python.\n",
"\n",
"Внутри цикла `while` с помощью функции `chr()` мы получаем символ\n",
"Юникода, соответствующий числовому коду. Функция `unicodedata.name()`\n",
"возвращает название заданного символа Юникода, во втором\n",
"необязательном аргументе передается имя, которое будет использовано в\n",
"случае, когда имя символа не определено. \n",
"\n",
"Если пользователь не указывает аргумент командной строки (`word is None`)\n",
"или аргумент был указан и он входит в состав копии имени символа\n",
"Юникода, в которой все символы приведены к нижнему регистру, то\n",
"выводится соответствующая строка таблицы. \n",
"\n",
"Мы передаем переменную `code` методу `str.format()` один раз, но в\n",
"строке формата она используется трижды. Первый раз – при выводе\n",
"значения `code` как целого числа в поле с шириной 7 символов (по\n",
"умолчанию в качестве символа-заполнителя используется пробел, поэтому\n",
"нет необходимости явно указывать его). Второй раз – при выводе\n",
"значения `code` как целого числа в шестнадцатеричном формате символами\n",
"верхнего регистра в поле шириной 5 символов. И третий раз – при выводе \n",
"символа Юникода, соответствующего значению code, с помощью\n",
"спецификатора формата `c`, отцентрированного в поле с минимальной \n",
"шириной 3 символа. Обратите внимание, что нам не потребовалось\n",
"указывать тип `d` в первом спецификаторе формата, потому что он\n",
"подразумевается по умолчанию для целых чисел. Второй аргумент –\n",
"это имя символа Юникода, которое выводится с помощью метода\n",
"`str.title()`, в результате которого первый символ каждого слова\n",
"преобразуется к верхнему регистру, а остальные символы – к нижнему. \n",
"\n", "\n",
"\n", "\n",
"## `quadratic.py`\n", "## `quadratic.py`\n",
@@ -1658,17 +1845,701 @@
"С коэффициентами $1.5$, $-3$ и $6$ программа выведет (некоторые цифры\n", "С коэффициентами $1.5$, $-3$ и $6$ программа выведет (некоторые цифры\n",
"обрезаны):\n", "обрезаны):\n",
"\n", "\n",
"Теперь обратимся к программному коду, который начинается тремя инструкциями `import`:\n",
"\n",
"Нам необходимы обе математические библиотеки для работы с числами типа\n",
"`float` и `complex`, так как функции, вычисляющие квадратный \n",
"корень из вещественных и комплексных чисел, отличаются. Модуль\n",
"`sys` нам необходим, так как в нем определена константа\n",
"`sys.float_info.epsilon`, которая потребуется нам для сравнения\n",
"вещественных чисел со значением `0`.\n",
"\n",
"Нам также необходима функция, которая будет получать от пользова-\n",
"теля число с плавающей точкой:"
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Start get_float\n",
"def get_float(msg, allow_zero):\n",
" x = None\n",
" while x is None:\n",
" try:\n",
" x = float(input(msg))\n",
" if not allow_zero and abs(x) < sys.float_info.epsilon:\n",
" print(\"zero is not allowed\")\n",
" x = None\n",
"\n",
" except ValueError as err:\n",
" print(err)\n",
" return x"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Эта функция выполняет цикл, пока пользователь не введет допустимое\n",
"число с плавающей точкой (например, `0.5`, `-9`, `21`, `4.92`), и допускает\n",
"ввод значения `0`, только если аргумент `allow_zero` имеет значение `True`.\n",
"Вслед за определением функции `get_float()` выполняется оставшаяся\n",
"часть программного кода. Мы разделим его на три части и начнем со\n",
"взаимодействия с пользователем:"
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Start 1st block\n",
"print(\"ax\\N{SUPERSCRIPT TWO} + bx + c = 0\")\n",
"a = get_float(\"enter a: \", False)\n",
"b = get_float(\"enter b: \", False)\n",
"c = get_float(\"enter c: \", False)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Благодаря функции `get_float()` получить значения коэффициентов `a`,\n",
"`b` и `c` оказалось очень просто. Второй аргумент функции сообщает, когда\n",
"значение `0` является допустимым."
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Start 2d block\n",
"x1 = None\n",
"x2 = None\n",
"discriminant = (b ** 2) - (4 * a * c)\n",
"if discriminant == 0:\n",
" x1 = -(b / (2 * a))\n",
"else:\n",
" if discriminant > 0:\n",
" root = math.sqrt(discriminant)\n",
" else: # discriminant < 0\n",
" root = cmath.sqrt(discriminant)\n",
" x1 = (-b + root) / (2 * a)\n",
" x2 = (-b - root) / (2 * a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Программный код выглядит несколько иначе, чем формула, потому\n",
"что мы начали вычисления с определения значения дискриминанта.\n",
"Если дискриминант равен `0`, мы знаем, что уравнение имеет\n",
"единственное действительное решение и можно сразу же вычислить его. В\n",
"противном случае мы вычисляем действительный или комплексный\n",
"квадратный корень из дискриминанта и находим два корня уравнения."
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# Start 3d block\n",
"equation = (\"{0}x\\N{SUPERSCRIPT TWO} + {1}x + {2} = 0\"\n",
" \" \\N{RIGHTWARDS ARROW} x = {3}\").format(a, b, c, x1)\n",
"if x2 is not None:\n",
" equation += \" or x = {0}\".format(x2)\n",
"print(equation)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Мы не использовали сколько-нибудь сложного форматирования, поскольку\n",
"форматирование, используемое по умолчанию для чисел с плавающей точкой\n",
"в языке Python, прекрасно подходит для этого примера, но мы\n",
"использовали некоторые имена Юникода для вывода пары специальных\n",
"символов.\n",
"\n",
"## `csv2html.py`\n",
"<div id=\"datatype:examples:csv2html\"></div>\n",
"\n",
"Часто бывает необходимо представить данные в формате HTML. В этом\n",
"подразделе мы разработаем программу, которая читает данные из\n",
"файла в простом формате CSV (Comma Separated Value – значения,\n",
"разделенные запятыми) и выводит таблицу HTML, содержащую эти\n",
"данные. В составе Python присутствует мощный и сложный модуль\n",
"для работы с форматом CSV и похожими на него – модуль csv, но здесь\n",
"мы будем выполнять всю обработку вручную.\n",
"\n",
"В формате CSV каждая запись располагается на одной строке, а поля\n",
"внутри записи отделяются друг от друга запятыми. Каждое поле может\n",
"быть либо строкой, либо числом. Строки должны окружаться апострофами\n",
"или кавычками, а числа не должны окружаться кавычками, если они не\n",
"содержат запятые. Внутри строк допускается присутствие запятых, и они\n",
"не должны интерпретироваться как разделители полей. Мы будем исходить\n",
"из предположения, что первая запись в файле содержит имена полей. На\n",
"выходе будет воспроизводиться таблица в формате HTML с выравниванием\n",
"текста по левому краю (по умолчанию для HTML) и с выравниванием чисел\n",
"по правому краю, по одной строке на запись и по одной ячейке на поле.\n",
"\n",
"Ниже приводится маленький фрагмент файла с данными:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" \"COUNTRY\",2000,2001,2002,2003,2004\n",
" \"ANTIGUA AND BARBUDA\",0,0,0,0,0\n",
" \"ARGENTINA\",37,35,33,36,39\n",
" \"BAHAMAS, THE\",1,1,1,1,1\n",
" \"BAHRAIN\",5,6,6,6,6\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Предположим, что данные находятся в файле\n",
"\"sample.csv\": \"src-datatype/sample.csv\" и выполнена комадна"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" Terminal> python csv2html.py < sample.csv > sample.html\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"тогда файл [sample.html](src-datatype/sample.html) должен содержать\n",
"примерно следующее:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" <table border='1'>\n",
" <tr bgcolor='lightgreen'>\n",
" <td>\"Country\"</td>\n",
" <td align='right'>2000</td>\n",
" <td align='right'>2001</td>\n",
" <td align='right'>2002</td>\n",
" <td align='right'>2003</td>\n",
" <td align='right'>2004</td>\n",
" </tr>\n",
" <tr bgcolor='white'>\n",
" <td>\"Antigua and Barbuda\"</td>\n",
" <td align='right'>0</td>\n",
" <td align='right'>0</td>\n",
" <td align='right'>0</td>\n",
" <td align='right'>0</td>\n",
" <td align='right'>0</td>\n",
" </tr>\n",
" <tr bgcolor='lightyellow'>\n",
" <td>\"Argentina\"</td>\n",
" <td align='right'>37</td>\n",
" <td align='right'>35</td>\n",
" <td align='right'>33</td>\n",
" <td align='right'>36</td>\n",
" <td align='right'>39</td>\n",
" </tr>\n",
" <tr bgcolor='white'>\n",
" <td>\"Bahamas, The\"</td>\n",
" <td align='right'>1</td>\n",
" <td align='right'>1</td>\n",
" <td align='right'>1</td>\n",
" <td align='right'>1</td>\n",
" <td align='right'>1</td>\n",
" </tr>\n",
" <tr bgcolor='lightyellow'>\n",
" <td>\"Bahrain\"</td>\n",
" <td align='right'>5</td>\n",
" <td align='right'>6</td>\n",
" <td align='right'>6</td>\n",
" <td align='right'>6</td>\n",
" <td align='right'>6</td>\n",
" </tr>\n",
" </table>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"На рис. показано, как выглядит полученная таблица в веб-броузере.\n",
"\n",
"<!-- dom:FIGURE: [fig-datatype/example_1.png, width=400 frac=1.0] Таблица, произведенная программой csv2html.py, в броузере <div id=\"datatype:examples:fig:1\"></div> -->\n",
"<!-- begin figure -->\n",
"<div id=\"datatype:examples:fig:1\"></div>\n",
"![Таблица, произведенная программой csv2html.py, в броузере](fig-datatype/example_1.png)<!-- end figure -->\n",
"\n",
"\n",
"Теперь, когда мы увидели, как используется программа и что она делает,\n",
"можно приступать к изучению программного кода.\n",
"\n",
"Последняя инструкция в программе – это простой вызов функции:"
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"main()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Хотя в языке Python не требуется явно указывать точку входа в\n",
"программу, как в некоторых других языках программирования, тем не\n",
"менее является распространенной практикой создание в программе на\n",
"языке Python функции с именем `main()`, которая вызывается для\n",
"выполнения обработки. Поскольку функция не может вызываться до того,\n",
"как она будет определена, мы должны вставлять вызов `main()` только\n",
"после того, как данная функция будет определена. Порядок следования\n",
"функций в файле (то есть порядок, в котором они создаются) не \n",
"имеет значения.\n",
"\n",
"В программе `csv2html.py` первой вызываемой функцией является функция\n",
"`main()`, которая в свою очередь вызывает функции `print_start()` и\n",
"`print_line()`. Функция `print_line()` вызывает функции\n",
"`extract_fields()` и `escape_html()`.\n",
"\n",
"Когда интерпретатор Python читает файл, он начинает делать это с\n",
"самого начала. Поэтому сначала будет выполнен импорт (если он есть),\n",
"затем будет создана функция `main()`, а затем будут созданы остальные\n",
"функции – в том порядке, в каком они следуют в файле. Когда\n",
"интерпретатор, наконец, достигнет вызова `main()` в конце файла, все\n",
"функции, которые вызываются функцией `main()` (и все функции, которые\n",
"вызываются этими функциями), будут определены. Выполнение обработки,\n",
"как и следовало ожидать, начинается в точке вызова функции `main()`.\n",
"\n",
"Рассмотрим все функции по порядку, начиная с функции `main()`."
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"def main():\n",
" maxwidth = 100\n",
" print_start()\n",
" count = 0\n",
" while True:\n",
" try:\n",
" line = input()\n",
" if count == 0:\n",
" color = \"lightgreen\"\n",
" elif count % 2:\n",
" color = \"white\"\n",
" else:\n",
" color = \"lightyellow\"\n",
" print_line(line, color, maxwidth)\n",
" count += 1\n",
" except EOFError:\n",
" break\n",
" print_end()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Переменная `maxwidth` используется для хранения числа символов в\n",
"ячейке. Если поле больше, чем это число, часть строки отсекается и на\n",
"место отброшенного текста добавляется многоточие. Программный код\n",
"функций `print_start()`, `print_line()` и `print_end()` будет приведен\n",
"чуть ниже. Цикл while выполняет обход всех входных строк – это могут\n",
"быть строки, вводимые пользователем с клавиатуры, но мы предполагаем,\n",
"что данные будут перенаправлены из файла. Далее выбирается цвет фона и\n",
"вызывается функция `print_line()`, которая выводит строку в виде строки\n",
"таблицы в формате HTML."
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"def print_start():\n",
" print(\"<table border='1'>\")\n",
"\n",
"def print_end():\n",
" print(\"</table>\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Мы могли бы не создавать эти две функции и просто вставить\n",
"соответствующие вызовы `print()` в функцию `main()`. Но мы предпочитаем\n",
"выделять логику, так как это делает реализацию более гибкой, хотя\n",
"в этом маленьком примере гибкость не имеет большого значения."
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"def print_line(line, color, maxwidth):\n",
" print(\"<tr bgcolor='{0}'>\".format(color))\n",
" fields = extract_fields(line)\n",
" for field in fields:\n",
" if not field:\n",
" print(\"<td></td>\")\n",
" else:\n",
" number = field.replace(\",\", \"\")\n",
" try:\n",
" x = float(number)\n",
" print(\"<td align='right'>{0:d}</td>\".format(round(x)))\n",
" except ValueError:\n",
" field = field.title()\n",
" field = field.replace(\" And \", \" and \")\n",
" field = escape_html(field)\n",
" if len(field) <= maxwidth:\n",
" print(\"<td>{0}</td>\".format(field))\n",
" else:\n",
" print(\"<td>{0:.{1}} ...</td>\".format(field, maxwidth))\n",
" print(\"</tr>\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Мы не можем использовать метод `str.split(\",\")` для разбиения каждой\n",
"строки на поля, потому что запятые могут находиться внутри строк в\n",
"кавычках. Поэтому мы возложили эту обязанность на функцию\n",
"`extract_fields()`. Получив список строк полей (в виде строк без\n",
"окружающих их кавычек), мы выполняем обход списка и создаем для \n",
"каждого поля ячейку таблицы.\n",
"\n",
"Если поле пустое, мы выводим пустую ячейку. Если поле было заключено в\n",
"кавычки, это может быть строка или число в кавычках, содержащее\n",
"символы запятой, например `\"1,566\"`. Учитывая такую возможность, мы\n",
"создаем копию поля без запятых и пытаемся преобразовать ее в число\n",
"типа `float`. Если преобразование удалось, мы определяем выравнивание\n",
"в ячейке по правому краю, а значение поля округляется до ближайшего\n",
"целого, которое и выводится. Если преобразование не удалось,\n",
"следовательно, поле содержит строку. В этом случае мы с помощью метода\n",
"`str.title()` изменяем регистр символов и замещаем слово «And» на слово\n",
"«and», устраняя побочный эффект действия метода \n",
"`str.title()`. Затем выполняется экранирование специальных символов\n",
"HTML и выводится либо поле целиком, либо первые `maxwidth` символов\n",
"с добавлением многоточия. Простейшей альтернативой использованию\n",
"вложенного поля замены в строке формата является получение \n",
"среза строки, например:"
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"print(\"<td>{0} ...</td>\".format(field[:maxwidth]))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Еще одно преимущество такого подхода состоит в том, что он требует\n",
"меньшего объема ввода с клавиатуры."
]
},
{
"cell_type": "code",
"execution_count": 63,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"def extract_fields(line):\n",
" fields = []\n",
" field = \"\"\n",
" quote = None\n",
" for c in line:\n",
" if c in \"\\\"'\":\n",
" if quote is None: # начало строки в кавычках\n",
" quote = c\n",
" elif quote == c: # конец строки в кавычках\n",
" quote = None\n",
" else:\n",
" field += c\n",
" # другая кавычка внутри строки в кавычках\n",
" continue\n",
" if quote is None and c == \",\": # end of a field\n",
" fields.append(field)\n",
" field = \"\"\n",
" else:\n",
" field += c\n",
" # добавить символ в поле\n",
" if field:\n",
" fields.append(field) # добавить последнее поле в список\n",
" return fields"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Эта функция читает символы из строки один за другим и накапливает\n",
"список полей, где каждое поле – это строка без окружающих ее\n",
"кавычек. Функция способна обрабатывать поля, не заключенные в кавычки,\n",
"и поля, заключенные в кавычки или в апострофы, корректно обрабатывая\n",
"запятые и кавычки (апострофы в строках, заключенных в кавычки, и\n",
"кавычки в строках, заключенных в апострофы)."
]
},
{
"cell_type": "code",
"execution_count": 64,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"def escape_html(text):\n",
" text = text.replace(\"&\", \"&amp;\")\n",
" text = text.replace(\"<\", \"&lt;\")\n",
" text = text.replace(\">\", \"&gt;\")\n",
" return text"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Эта функция просто замещает каждый специальный символ HTML\n",
"соответствующей ему сущностью языка HTML. В первую очередь, конечно,\n",
"мы должны заменить символ амперсанда и угловые скобки, хотя порядок не\n",
"имеет никакого значения. \n",
"\n",
"<!-- Local Variables: -->\n", "<!-- Local Variables: -->\n",
"<!-- doconce-chapter-nickname: \"datatype\" -->\n", "<!-- doconce-chapter-nickname: \"datatype\" -->\n",
"<!-- doconce-section-nickname: \"examples\" -->\n", "<!-- doconce-section-nickname: \"examples\" -->\n",
"<!-- End: -->\n", "<!-- End: -->\n",
"# Упражнения\n",
"<div id=\"datatype:exercises\"></div>\n",
"\n",
"\n",
"\n",
"<!-- --- begin exercise --- -->\n",
"\n",
"## Изменение вывода символов Юникода\n",
"<div id=\"datatype:exercises:1\"></div>\n",
"\n",
"Измените программу `print_unicode.py` так, чтобы пользователь мог\n",
"вводить в командной строке несколько разных слов и получать\n",
"только те строки из таблицы символов Юникода, в которых содержатся все\n",
"слова, указанные пользователем. Это означает, что мы сможем вводить\n",
"такие команды:"
]
},
{
"cell_type": "code",
"execution_count": 65,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"print_unicode_ans.py greek symbol"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!-- --- begin hint in exercise --- -->\n",
"\n",
"**Подсказка.**\n",
"Один из способов достижения поставленной цели состоит в том,\n",
"чтобы заменить переменную `word` (которая может хранить `0`, `None` \n",
"или строку) списком `words`. Не забудьте изменить информацию о порядке\n",
"использования. В результате изменений не более десяти строк\n",
"программного кода добавится и не более десяти строк изменится.\n",
"\n",
"<!-- --- end hint in exercise --- -->\n",
"Имя файла: `print_unicode_ans.py`.\n",
"\n",
"<!-- --- end exercise --- -->\n",
"\n",
"\n",
"\n",
"\n",
"<!-- --- begin exercise --- -->\n",
"\n",
"## Изменение `quadratic.py`\n",
"<div id=\"datatype:exercises:2\"></div>\n",
"\n",
"Измените программу `quadratic.py` так, чтобы она не выводила\n",
"коэффициенты со значением `0.0`, а отрицательные коэффициенты\n",
"выводились бы как `-n`, а не `+ - n`.\n",
"Имя файла: `quadratic_ans.py`.\n",
"\n",
"<!-- --- end exercise --- -->\n",
"\n",
"\n",
"\n",
"\n",
"<!-- --- begin exercise --- -->\n",
"\n",
"## Использование функции `escape()`\n",
"<div id=\"datatype:exercises:escape\"></div>\n",
"\n",
"Удалите функцию `escape_html()` из программы `cvs2html.py` и\n",
"используйте вместо нее функцию `xml.sax.saxutils.escape()` из модуля \n",
"`xml.sax.saxutils`.\n",
"\n",
"<!-- --- begin hint in exercise --- -->\n",
"\n",
"**Подсказка.**\n",
"Для этого потребуется добавить одну новую строку\n",
"(с инструкцией `import`), удалить пять строк (с ненужной функцией)\n",
"и изменить одну строку (задействовать функцию\n",
"`xml.sax.saxutils.escape()` вместо `escape_html()`).\n",
"\n",
"<!-- --- end hint in exercise --- -->\n",
"Имя файла: `cvs2html_ans1.py`.\n",
"\n",
"<!-- --- end exercise --- -->\n",
"\n",
"\n",
"\n",
"\n",
"<!-- --- begin exercise --- -->\n",
"\n",
"## Добавление обработки параметров командной строки в `csv2html.py`\n",
"<div id=\"datatype:exercises:process_option\"></div>\n",
"\n",
"Измените программу `cvs2html.py` еще раз и добавьте в нее новую\n",
"функцию с именем `process_options()`. Эта функция должна вызываться из\n",
"функции main() и возвращать кортеж с двумя значениями: \n",
"`maxwidth` (типа `int`) и `format` (типа `str`). При вызове функция\n",
"`process_options()` должна устанавливать `maxwidth` в значение по\n",
"умолчанию `100`, а строку `format` – в значение по умолчанию `\".0f\"`,\n",
"которое будет использоваться как спецификатор формата при выводе чисел.\n",
"Если пользователь вводит в командной строке `-h` или `--help`,\n",
"должно выводиться сообщение о порядке использования и возвращаться\n",
"кортеж `(None, None)`. (В этом случае функция `main()` ничего\n",
"делать не должна.) В противном случае функция должна прочитать\n",
"аргументы командной строки и выполнить соответствующие\n",
"присваивания. Например, устанавливать значение переменной `maxwidth`,\n",
"если задан аргумент `maxwidth=n`, и точно так же устанавливать \n",
"значение переменной `format`, если задан аргумент `format=s`. Ниже\n",
"приводится сеанс работы с программой, когда пользователь затребовал\n",
"инструкцию о порядке работы:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" Terminal> csv2html2_ans.py -h\n",
" usage:\n",
" csv2html.py [maxwidth=int] [format=str] < infile.csv > outfile.html\n",
" maxwidth - необязательное целое число. Если задано, определяет\n",
" максимальное число символов для строковых полей. В противном случае\n",
" используется значение по умолчанию 100.\n",
" \n",
" format - формат вывода чисел. Если не задан, по умолчанию используется\n",
" формат \".0f\".\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"А ниже приводится пример командной строки, в которой установ-\n",
"лены оба аргумента:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" Terminal> csv2html2_ans.py maxwidth=20 format=0.2f < mydata.csv > mydata.html\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<!-- --- begin hint in exercise --- -->\n",
"\n",
"**Подсказка.**\n",
"Не забудьте изменить функцию `print_line()` так, чтобы она\n",
"использовала переменную `format` при выводе чисел – для этого вам\n",
"придется передавать функции дополнительный аргумент, добавить одну \n",
"строку и изменить еще одну строку. И это немного затронет функцию\n",
"`main()`. Функция `process_options()` должна содержать порядка\n",
"двадцати пяти строк (включая девять строк с текстом сообщения о\n",
"порядке использования).\n",
"\n",
"<!-- --- end hint in exercise --- -->\n",
"Имя файла: `cvs2html_ans2.py`.\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"<!-- Local Variables: -->\n",
"<!-- doconce-chapter-nickname: \"datatype\" -->\n",
"<!-- doconce-section-nickname: \"exercises\" -->\n",
"<!-- End: -->\n",
"\n", "\n",
"\n", "\n",
"\n", "\n",
"\n", "\n",
"<!-- Local Variables: -->\n", "<!-- Local Variables: -->\n",
"<!-- doconce-chapter-nickname: \"datatype\" -->\n", "<!-- doconce-chapter-nickname: \"datatype\" -->\n",
"<!-- End: -->" "<!-- End: -->\n",
"<!-- --- end exercise --- -->"
] ]
} }
], ],

BIN
fig-collections/map_1.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 46 KiB

BIN
fig-collections/seq_1.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 14 KiB

BIN
fig-collections/seq_2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 14 KiB

BIN
fig-collections/set_1.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 56 KiB

BIN
fig-collections/set_2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 155 KiB

BIN
fig-datatype/example_1.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 11 KiB

29
intro.ipynb
View File

@@ -10,15 +10,13 @@
"<!-- Author: --> \n", "<!-- Author: --> \n",
"**С.В. Лемешевский** (email: `sergey.lemeshevsky@gmail.com`), Институт математики НАН Беларуси\n", "**С.В. Лемешевский** (email: `sergey.lemeshevsky@gmail.com`), Институт математики НАН Беларуси\n",
"\n", "\n",
"Date: **Feb 22, 2020**\n", "Date: **Feb 26, 2020**\n",
"\n", "\n",
"<!-- Common Mako variable and functions -->\n", "<!-- Common Mako variable and functions -->\n",
"<!-- -*- coding: utf-8 -*- -->\n", "<!-- -*- coding: utf-8 -*- -->\n",
"\n", "\n",
"\n", "\n",
"\n", "\n",
"\n",
"\n",
"# Установка\n", "# Установка\n",
"<div id=\"intro:install\"></div>\n", "<div id=\"intro:install\"></div>\n",
"\n", "\n",
@@ -1462,8 +1460,7 @@
"![](fig-intro/jupyter_1.png)<!-- end figure -->\n", "![](fig-intro/jupyter_1.png)<!-- end figure -->\n",
"\n", "\n",
"\n", "\n",
"### Jupyter Notebook\n", "## Jupyter Notebook\n",
"\n",
"<div id=\"intro:environments:jupyter:notebook\"></div>\n", "<div id=\"intro:environments:jupyter:notebook\"></div>\n",
"\n", "\n",
"Кроме интерактивной консоли Jupyter также предоставляет веб-приложение\n", "Кроме интерактивной консоли Jupyter также предоставляет веб-приложение\n",
@@ -1529,7 +1526,7 @@
"сохраняются в формате JSON со специальным разрешением `ipynb`. Файл\n", "сохраняются в формате JSON со специальным разрешением `ipynb`. Файл\n",
"Jupyter Notebook не является чистым кодом на Python, но при\n", "Jupyter Notebook не является чистым кодом на Python, но при\n",
"необходимости код на Python можно легко выделить из блокнота используя\n", "необходимости код на Python можно легко выделить из блокнота используя\n",
"либо меню «File ➤ Download as ➤ Python» или с помощью утилиты\n", "либо меню **File | Download as | Python** или с помощью утилиты\n",
"`nbconvert`.\n", "`nbconvert`.\n",
"\n", "\n",
"<!-- dom:FIGURE: [fig-intro/jupyter_3.png, width=400 frac=1.0] -->\n", "<!-- dom:FIGURE: [fig-intro/jupyter_3.png, width=400 frac=1.0] -->\n",
@@ -1581,8 +1578,6 @@
"\n", "\n",
"<div id=\"intro:environments:jupyter:edit\"></div>\n", "<div id=\"intro:environments:jupyter:edit\"></div>\n",
"\n", "\n",
"\n",
"\n",
"Используя меню и панель инструментов, ячейки можно добавлять,\n", "Используя меню и панель инструментов, ячейки можно добавлять,\n",
"удалять, перемещать вверх и вниз, вырезать и вставлять и т.д. Эти\n", "удалять, перемещать вверх и вниз, вырезать и вставлять и т.д. Эти\n",
"функции также связаны с сочетаниями клавиш, которые удобны и\n", "функции также связаны с сочетаниями клавиш, которые удобны и\n",
@@ -1599,11 +1594,9 @@
"доступными через панель инструментов и меню. \n", "доступными через панель инструментов и меню. \n",
"\n", "\n",
"\n", "\n",
"<!-- begin table -->\n",
"<div id=\"table:1\"></div>\n",
"\n", "\n",
"## Таблица 1 : Клавиши <div id=\"table:1\"></div>\n",
"\n", "\n",
"**Таблица 1.** \n",
"\n", "\n",
"<table border=\"1\">\n", "<table border=\"1\">\n",
"<thead>\n", "<thead>\n",
@@ -1624,19 +1617,19 @@
"<tr><td align=\"left\"> <code>Enter</code> </td> <td align=\"left\"> Войти в режим редактирования ячейки </td> </tr>\n", "<tr><td align=\"left\"> <code>Enter</code> </td> <td align=\"left\"> Войти в режим редактирования ячейки </td> </tr>\n",
"<tr><td align=\"left\"> <code>Escape</code> </td> <td align=\"left\"> Выйти из режима редактирования ячейки </td> </tr>\n", "<tr><td align=\"left\"> <code>Escape</code> </td> <td align=\"left\"> Выйти из режима редактирования ячейки </td> </tr>\n",
"<tr><td align=\"left\"> <code>Shift-Enter</code> </td> <td align=\"left\"> Выполнить ячейку </td> </tr>\n", "<tr><td align=\"left\"> <code>Shift-Enter</code> </td> <td align=\"left\"> Выполнить ячейку </td> </tr>\n",
"<tr><td align=\"left\"> <code>h</code> </td> <td align=\"left\"> Показать окно помощи со списком сочиетаний клавиш </td> </tr>\n", "<tr><td align=\"left\"> <code>h</code> </td> <td align=\"left\"> Показать окно помощи со списком сочетаний клавиш </td> </tr>\n",
"<tr><td align=\"left\"> <code>0-0</code> </td> <td align=\"left\"> Перезапустить ядро </td> </tr>\n", "<tr><td align=\"left\"> <code>0-0</code> </td> <td align=\"left\"> Перезапустить ядро </td> </tr>\n",
"<tr><td align=\"left\"> <code>i-i</code> </td> <td align=\"left\"> Прервать выполнение ячейки </td> </tr>\n", "<tr><td align=\"left\"> <code>i-i</code> </td> <td align=\"left\"> Прервать выполнение ячейки </td> </tr>\n",
"<tr><td align=\"left\"> <code>s</code> </td> <td align=\"left\"> Сохранить блокнот </td> </tr>\n", "<tr><td align=\"left\"> <code>s</code> </td> <td align=\"left\"> Сохранить блокнот </td> </tr>\n",
"</tbody>\n", "</tbody>\n",
"</table>\n", "</table>\n",
"<!-- end table -->\n", "\n",
"\n", "\n",
"Во время выполнения ячейки блокнота номер ячейки обозначается\n", "Во время выполнения ячейки блокнота номер ячейки обозначается\n",
"звездочкой (`In [*]`), а индикатор в правом верхнем углу страницы\n", "звездочкой (`In [*]`), а индикатор в правом верхнем углу страницы\n",
"сигнализирует о том, что ядро IPython занято. Прервать выполнение\n", "сигнализирует о том, что ядро IPython занято. Прервать выполнение\n",
"ячейки можно через меню «Kernel ➤ Interrupt» или сочетанием клавиш\n", "ячейки можно через меню **Kernel | Interrupt** или сочетанием клавиш\n",
"`i-i` в командном режиме (т.е., дважды нажать клавишу `i`). В таблице 1\n", "`i-i` в командном режиме (т.е., дважды нажать клавишу `i`). В таблице [table:1](#table:1)\n",
"представлены наиболее популярные сочетания клавиш командного режима\n", "представлены наиболее популярные сочетания клавиш командного режима\n",
"Jupyter Notebook.\n", "Jupyter Notebook.\n",
"\n", "\n",
@@ -2050,7 +2043,7 @@
"\n", "\n",
"Каждую панель можно настроить для отображения или скрытия в\n", "Каждую панель можно настроить для отображения или скрытия в\n",
"зависимости от предпочтений и потребностей пользователя, используя\n", "зависимости от предпочтений и потребностей пользователя, используя\n",
"меню «View ➤ Panes». \n", "меню **View | Panes**.\n",
"\n", "\n",
"### Редактор исходного кода\n", "### Редактор исходного кода\n",
"\n", "\n",
@@ -2097,8 +2090,8 @@
"поскольку она позволяет исследовать значения переменных после\n", "поскольку она позволяет исследовать значения переменных после\n",
"завершения выполнения сценария. Spyder поддерживает одновременное\n", "завершения выполнения сценария. Spyder поддерживает одновременное\n",
"открытие нескольких консолей Python и IPython, и, например, новую\n", "открытие нескольких консолей Python и IPython, и, например, новую\n",
"консоль IPython можно запустить через меню «Consoles ➤ Open an IPython\n", "консоль IPython можно запустить через меню **Consoles | Open an IPython\n",
"console». При запуске сценария из редактора нажатием клавиши F5 или\n", "console**. При запуске сценария из редактора нажатием клавиши F5 или\n",
"кнопки запуска на панели инструментов сценарий по умолчанию\n", "кнопки запуска на панели инструментов сценарий по умолчанию\n",
"запускается в самой последней активированной консоли. Это позволяет\n", "запускается в самой последней активированной консоли. Это позволяет\n",
"поддерживать разные консоли с независимыми пространствами имен для\n", "поддерживать разные консоли с независимыми пространствами имен для\n",

80
src-datatype/csv2html.py Normal file
View File

@@ -0,0 +1,80 @@
# -*- coding: utf-8 -*-
def main():
maxwidth = 100
print_start()
count = 0
while True:
try:
line = input()
if count == 0:
color = "lightgreen"
elif count % 2:
color = "white"
else:
color = "lightyellow"
print_line(line, color, maxwidth)
count += 1
except EOFError:
break
print_end()
def print_start():
print("<table border='1'>")
def print_end():
print("</table>")
def print_line(line, color, maxwidth):
print("<tr bgcolor='{0}'>".format(color))
fields = extract_fields(line)
for field in fields:
if not field:
print("<td></td>")
else:
number = field.replace(",", "")
try:
x = float(number)
print("<td align='right'>{0:d}</td>".format(round(x)))
except ValueError:
field = field.title()
field = field.replace(" And ", " and ")
field = escape_html(field)
if len(field) <= maxwidth:
print("<td>{0}</td>".format(field))
else:
print("<td>{0:.{1}} ...</td>".format(field, maxwidth))
print("</tr>")
def extract_fields(line):
fields = []
field = ""
quote = None
for c in line:
if c in "\"'":
if quote is None: # начало строки в кавычках
quote = c
elif quote == c: # конец строки в кавычках
quote = None
else:
field += c
# другая кавычка внутри строки в кавычках
continue
if quote is None and c == ",": # end of a field
fields.append(field)
field = ""
else:
field += c
# добавить символ в поле
if field:
fields.append(field) # добавить последнее поле в список
return fields
def escape_html(text):
text = text.replace("&", "&amp;")
text = text.replace("<", "&lt;")
text = text.replace(">", "&gt;")
return text
main()

80
src-datatype/csv2html.py~ Normal file
View File

@@ -0,0 +1,80 @@
# -*- coding: utf-8 -*-
def main():
maxwidth = 100
print_start()
count = 0
while True:
try:
line = input()
if count == 0:
color = "lightgreen"
elif count % 2:
color = "white"
else:
color = "lightyellow"
print_line(line, color, maxwidth)
count += 1
except EOFError:
break
print_end()
def print_start():
print("<table border='1'>")
def print_end():
print("</table>")
def print_line(line, color, maxwidth):
print("<tr bgcolor='{0}'>".format(color))
fields = extract_fields(line)
for field in fields:
if not field:
print("<td></td>")
else:
number = field.replace(",", "")
try:
x = float(number)
print("<td align='right'>{0:d}</td>".format(round(x)))
except ValueError:
field = field.title()
field = field.replace(" And ", " and ")
field = escape_html(field)
if len(field) <= maxwidth:
print("<td>{0}</td>".format(field))
else:
print("<td>{0:.{1}} ...</td>".format(field, maxwidth))
print("</tr>")
def extract_fields(line):
fields = []
field = ""
quote = None
for c in line:
if c in "\"'":
if quote is None: # начало строки в кавычках
quote = c
elif quote == c: # конец строки в кавычках
quote = None
else:
field += c
# другая кавычка внутри строки в кавычках
continue
if quote is None and c == ",": # end of a field
fields.append(field)
field = ""
else:
field += c
# добавить символ в поле
if field:
fields.append(field) # добавить последнее поле в список
return fields
def escape_html(text):
text = text.replace("&", "&amp;")
text = text.replace("<", "&lt;")
text = text.replace(">", "&gt;")
return text
if __name__ == '__main__':
main()

33
src-datatype/print_unicode.py Normal file
View File

@@ -0,0 +1,33 @@
# -*- coding: utf-8 -*-
import sys
import unicodedata
def print_unicode_table(word):
print("decimal hex chr {0:^40}".format("name"))
print("------- ----- --- {0:-<40}".format(""))
code = ord(" ")
end = sys.maxunicode
while code < end:
c = chr(code)
name = unicodedata.name(c, "*** unknown ***")
if word is None or word in name.lower():
print("{0:7} {0:5X} {0:^3c} {1}".format(code, name.title()))
code += 1
# End print_unicode_table
# Start main script
word = None
if len(sys.argv) > 1:
if sys.argv[1] in ("-h", "--help"):
print("usage: {0} [string]".format(sys.argv[0]))
word = 0
else:
word = sys.argv[1].lower()
if word != 0:
print_unicode_table(word)
#End main script

30
src-datatype/print_unicode.py~ Normal file
View File

@@ -0,0 +1,30 @@
# -*- coding: utf-8 -*-
import sys
import unicodedata
def print_unicode_table(word):
print("decimal hex chr {0:^40}".format("name"))
print("------- ----- --- {0:-<40}".format(""))
code = ord(" ")
end = sys.maxunicode
while code < end:
c = chr(code)
name = unicodedata.name(c, "*** unknown ***")
if word is None or word in name.lower():
print("{0:7} {0:5X} {0:^3c} {1}".format(code, name.title()))
code += 1
word = None
if len(sys.argv) > 1:
if sys.argv[1] in ("-h", "--help"):
print("usage: {0} [string]".format(sys.argv[0]))
word = 0
else:
word = sys.argv[1].lower()
if word != 0:
print_unicode_table(word)

1
src-datatype/quadratic.py
View File

@@ -18,6 +18,7 @@ def get_float(msg, allow_zero):
return x return x
# End get_float # End get_float
# Start 1st block # Start 1st block
print("ax\N{SUPERSCRIPT TWO} + bx + c = 0") print("ax\N{SUPERSCRIPT TWO} + bx + c = 0")
a = get_float("enter a: ", False) a = get_float("enter a: ", False)

49
src-datatype/quadratic.py~ Normal file
View File

@@ -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

5
src-datatype/sample.csv Normal file
View File

@@ -0,0 +1,5 @@
"COUNTRY",2000,2001,2002,2003,2004
"ANTIGUA AND BARBUDA",0,0,0,0,0
"ARGENTINA",37,35,33,36,39
"BAHAMAS, THE",1,1,1,1,1
"BAHRAIN",5,6,6,6,6
1 COUNTRY 2000 2001 2002 2003 2004
2 ANTIGUA AND BARBUDA 0 0 0 0 0
3 ARGENTINA 37 35 33 36 39
4 BAHAMAS, THE 1 1 1 1 1
5 BAHRAIN 5 6 6 6 6

5
src-datatype/sample.csv~ Normal file
View File

@@ -0,0 +1,5 @@
"COUNTRY",2000,2001,2002,2003,2004
"ANTIGUA AND BARBUDA",0,0,0,0,0
"ARGENTINA",37,35,33,36,39
"BAHAMAS, THE",1,1,1,1,1
"BAHRAIN",5,6,6,6,6

42
src-datatype/sample.html Normal file
View File

@@ -0,0 +1,42 @@
<table border='1'>
<tr bgcolor='lightgreen'>
<td>"Country"</td>
<td align='right'>2000</td>
<td align='right'>2001</td>
<td align='right'>2002</td>
<td align='right'>2003</td>
<td align='right'>2004</td>
</tr>
<tr bgcolor='white'>
<td>"Antigua and Barbuda"</td>
<td align='right'>0</td>
<td align='right'>0</td>
<td align='right'>0</td>
<td align='right'>0</td>
<td align='right'>0</td>
</tr>
<tr bgcolor='lightyellow'>
<td>"Argentina"</td>
<td align='right'>37</td>
<td align='right'>35</td>
<td align='right'>33</td>
<td align='right'>36</td>
<td align='right'>39</td>
</tr>
<tr bgcolor='white'>
<td>"Bahamas, The"</td>
<td align='right'>1</td>
<td align='right'>1</td>
<td align='right'>1</td>
<td align='right'>1</td>
<td align='right'>1</td>
</tr>
<tr bgcolor='lightyellow'>
<td>"Bahrain"</td>
<td align='right'>5</td>
<td align='right'>6</td>
<td align='right'>6</td>
<td align='right'>6</td>
<td align='right'>6</td>
</tr>
</table>

42
src-datatype/sample.html~ Normal file
View File

@@ -0,0 +1,42 @@
<table border='1'>
<tr bgcolor='lightgreen'>
<td>"Country"</td>
<td align='right'>2000</td>
<td align='right'>2001</td>
<td align='right'>2002</td>
<td align='right'>2003</td>
<td align='right'>2004</td>
</tr>
<tr bgcolor='white'>
<td>"Antigua and Barbuda"</td>
<td align='right'>0</td>
<td align='right'>0</td>
<td align='right'>0</td>
<td align='right'>0</td>
<td align='right'>0</td>
</tr>
<tr bgcolor='lightyellow'>
<td>"Argentina"</td>
<td align='right'>37</td>
<td align='right'>35</td>
<td align='right'>33</td>
<td align='right'>36</td>
<td align='right'>39</td>
</tr>
<tr bgcolor='white'>
<td>"Bahamas, The"</td>
<td align='right'>1</td>
<td align='right'>1</td>
<td align='right'>1</td>
<td align='right'>1</td>
<td align='right'>1</td>
</tr>
<tr bgcolor='lightyellow'>
<td>"Bahrain"</td>
<td align='right'>5</td>
<td align='right'>6</td>
<td align='right'>6</td>
<td align='right'>6</td>
<td align='right'>6</td>
</tr>
</table>