В серии: Библиотека alt м. В. Сысоева, И. В. Сысоев

1.6.3 Задания

Задание 1 (Ввод/вывод данных) Здесь собраны задачи по сути учебные, но полезные. Их выполнение позволит вам «набить руку» и выработать необходимые навыки. Задания необходимо выполнить в интерактивном и скриптовом режимах. Выполнять следует все и по порядку. Напишите программу:

1. 
   последовательно запрашивающую ваши фамилию, имя, отчество ивыводящую их одной строкой в последовательности: фамилияимя → отчество; →
   
2. 
   последовательно запрашивающую ваши фамилию, имя, отчество ивыводящую их одной строкой в последовательности: имя → отчество → фамилия;
   
3. 
   преобразующую простую русскую фамилию в мужском роде в женский род (Петров → Петрова; Путин → Путина);
   
4. 
   последовательно введите число, месяц, год рождения; выведите дату своего рождения через точки (01.01.2000), слэши (01/01/2000), пробелы (01 01 2000), тире (01-01-2000).
   

Глава 2
Основные типы данных
В Python имеется множество встроенных типов данных. Все типы делятся на простые и составные. Переменные² простых типов состоят из единственного значения, к ним относятся числа (всего 3 типа: целые, действительные и комплексные) и логические переменные. Переменные составных типов состоят из набора значений и, в свою очередь, делятся на неизменяемые, для которых нельзя изменять значения элементов, добавлять или изымать элементы, и изменяемые, для которых всё это можно делать. К неизменяемым типам относятся строки и кортежи, к изменяемым — списки, словари и множества.
Чтобы получить корректно работающую программу, важно понимать, к какому типу относится переменная. В Python тип переменной не объявляется, а автоматически определяется при присвоении ей значения.

2.1 Числа. Арифметические операции с числами. Модуль math

Числа в Python делятся на:

• 
  целые,
  
• 
  действительные (с плавающей точкой размером в 64 бита),
  
• 
  комплексные (с плавающей точкой размером в 128 бит).
  

Python поддерживает динамическую типизацию, то есть тип переменной определяется только во время исполнения. Переменная может быть переопределена, при этом её тип изменится:
>>> a=2
>>> a
2
>>> a=2.0
>>> a
2.0
>>> a=2+3j
>>> a
(2+3j)
Инструкция a = 2 создаёт числовой объект-переменную с целочисленным значением 2 и присваивает ему имя a. Далее инструкция a = 2.0 создаёт новый числовой объект с действительным значением 2.0 и присваивает уже ему имя a. А объект со значением 2 удаляется из памяти автоматически сборщиком мусора (англ. garbage collector, специальный процесс, периодически освобождающий память, удаляя объекты, которые уже не будут востребованы приложениями), т.к. была потеряна последняя ссылка на этот объект. Затем инструкция a=2+3j создаёт числовой объект с комплексным значением и всё с тем же именем, а объект с действительным значением удаляется.
В интерактивном режиме есть возможность быстро вызвать предыдущую команду сочетанием + p. Поэтому легко можно поправить a=2 на a=2.0.
При операциях с числами существует общее правило: результат будет того же типа, что и операнды, если операнды разных типов, то результат будет приведён к наиболее общему из всех имеющихся. Порядок общности естественный: целые → действительные → комплексные. Следующий пример иллюстрирует это правило:
>>> a=2
>>> b=2+3j
>>> a+b
(4+3j)
Так же полезно запомнить, что для проверки типа любого значения и любой переменной можно использовать функцию type():
>>> a=5
>>> b=17.1
>>> c=4+2j
>>> (a); (b); (c)
< ’int’>
< ’float’>
< ’complex’>
Приведённая программа имеет особенность: в четвёртой строке записано сразу 3 оператора. Так можно делать, но при этом для разделения операторов нужно использовать «;» (после последнего она не обязательна). Пробелы в большинстве случаев необязательны.
Можно явно преобразовывать значение любого типа с помощью соответствующих функций int(), float() или complex():
>>> a=5
>>> (a)
5
>>> (a)
5.0
>>> (a)
(5+0j)
Важно помнить, что комплексное число нельзя преобразовать с помощью функций int() и float() к целому или действительному. Функция int() отбрасывает дробную часть числа, а не округляет его:
>>> a=4.3
>>> (a)
4
>>> b=-4.3
>>> (b)
-4
А теперь про подводные камни и отличие третьего Python от второго при работе в скриптовом (текстовом) режиме. Напишем в текстовом режиме в Python 3.x простую программу, которая должна складывать два введённых числа и выводить результат на экран:
a = (’Введите первое число: ’) b = (’Введите второе число: ’)
(a + b)
Ход работы программы:
Введите первое число: 10
Введите второе число: 4
104
Получили совсем не то, что ожидали. Python версий 2.x поддерживал автоматическое определение типа переменной при вводе с клавиатуры. Однако это часто вызывало различные ошибки или сложности. Поэтому при проектировании версии 3.0 было решено отказаться от автоматического определения типа и всегда считывать данные как строку. Поэтому, если мы хотим действительно сложить два числа, программу придется переписать:
a = ( (’Введите первое число: ’)) b = ( (’Введите второе число: ’))
(a + b)
Вывод программы:
Введите первое число: 10
Введите второе число: 4
14
Python поддерживает все основные арифметические операторы (см. табл. 2.1).
Таблица 2.1. Арифметические операции с числами и встроенные функции c одним и двумя аргументами

x + y	Сложение — сумма x и y (2 + 3 = 5)
x - y	Вычитание — разность x и y (5 - 2 = 3)
x * y	Умножение — произведение x и y (2 * 3 = 6)
x / y	Деление x на y: 4 / 1.6 = 2.5, 10 / 5 = 2.0, результат всегда типа float
x // y	Деление x на y нацело: 11 // 4 = 2, 11.8 // 4 = 2.0, результат целый, только если оба аргумента целые
x % y	Остаток от деления: 11 % 4 = 3, 11.8 % 4 = 3.8000000000000007 (присутствует ошибка, связанная с неточностью представления данных в компьютере)
x ** y	Возведение x в степень y: (2 ** 3 = 8)
abs(x)	Модуль числа x
round(x)	Округление (round(11.3) = 11)
round(x, n)	Округляет число x до n знаков после запятой: round(12.34567, 3) = 12.346
pow(x, y)	полный аналог записи x ** y
divmod(x, y)	выдаёт два числа: частное и остаток, обращаться следует так: q, r = divmod(x, y)

Отметим, что операции сложения, вычитания, умножения и возведения в степень выдают ответ типа int только если оба аргмента целые, типа float, если один из аргументов действительный, а другой — целый или действительный, и типа complex, если хотя бы один аргумент комплексный. Операция возведения в степень также может выдать комплексный результат при возведении отрицательных чисел в степень кроме случая, когда эта степень целая и нечётная. То есть, эти опраторы в Python подчиняются общеупотребительным правилам преобразования типов.
Оператор деления традиционно является «проблемным»: результат его работы в разных языках программирования определяется разными правилами. Для Python версии 3.x деление «/» всегда действительного типа. В Python версии 2.x деление подчинялось другому правилу: если оба операнда целые — результат будет целый, иначе — действительный. Приведём небольшую программу–пример для иллюстрации работы операторов «/», «//» и «%» на Python 3.4.3:
>>> a = 5; b = 98
>>> c1 = b/a; c2 = b//a; c3 = b%a
>>> c1; c2; c3
19.6
19
3
Таблица 2.2. Встроенные функции c последовательностями или произвольным числом аргументов

max(a,b,...)	Максимальное число из двух или более: max([2, 6, 3]) = 6
min(a,b,...)	Минимальное число из двух или более: min([2, 6, 3]) = 2
max(seq)	Максимальный элемент последовательности: max([2,6,3]) =6
min(seq)	Минимальный элемент последовательности: min([2, 6, 3])=2
sum(seq)	Сумма элементов последовательности, например, кортежа sum((2, 6, 3)) = 11 или списка sum([2, 6, 3]) = 11
sorted(seq)	Отсортированный список: sorted([3, 2, 5, 1, 4]) = [1, 2, 3, 4, 5]

То, что описанные функции являются встроенными, означает, что они доступны без всяких дополнительных действий. Однако встроенных функций немного, гораздо больше функций находится в стандартной библиотеке — наборе модулей, поставляемых всегда вместе с интерпретатором Python. Функции для работы с числами находятся в модулях math для целых и действительных чисел и cmath для комплексных. Сделано это потому, что комплексные числа нужны гораздо реже целых и действительных, а Python часто используется в качестве языка сценариев и в других приложениях, где память нужно экономить. Самые употребительные функции модуля math описаны в таблице 2.3.
Загрузка модулей в Python осуществляется с помощью оператора import. Самый простой способ его использования — загрузить всё содержимое модуля глобально:
math *
t = sin(pi/6)
Таблица 2.3. Наиболее употребительные функции и константы модуля math

trunc(X)	Усечение значения Х до целого
sqrt(X)	Квадратный корень из X
exp(X)	Экспонента числа Х
log(X), log2(X), log10(X)	Натуральный, двоичный и десятичный логариф- мы X
log(X, n)	Логарифм X по основанию n
sin(X), cos(X), tan(X)	Синус, косинус и тангенс X, X указывается в радианах
asin(X), acos(X), atan(X)	Арксинус, арккосинус и арктангенс X
atan2(X, Y)	арктангенс отношения с учётом квадранта
degrees(X)	Конвертирует радианы в градусы
radians(X)	Конвертирует градусы в радианы
sinh(X), cosh(X), tanh(X)	Гиперболические синус, косинус и тангенс X
asinh(X), acosh(X), atanh(X)	Обратный гиперболический синус, косинус и тангенс X
hypot(X, Y)	Гипотенуза треугольника с катетами X и Y
factorial(X)	Факториал числа Х
gamma(X)	Гамма-функция Х
pi	Выдаётся число π
e	Выдаётся число e

v = log(e)
(t, v)
Первую строчку можно прочитать дословно: из модуля math импортируем всё («*» означает всё). Такая запись позволяет в теле программы просто обращаться к функциям, лежащим в math, без сложной записи: math.sin.
Но такой способ подойдёт только для первых двух-трёх занятий, на которых будет использоваться один модуль math. При подключении двух, трёх и более модулей может возникнуть такая ситуация, когда в разных модулях лежат функции с одинаковыми названиями (например, open), но делают они разные действия, да и аргументы вызываются в разном порядке. В такой ситуации, да и просто академически правильнее, писать следующим образом:
math
t = math.sin(math.pi/6) v = math.log(math.e)
(t, v)
Если название модуля слишком длинное, или оно вам не нравится по каким-то другим причинам, то для него можно создать псевдоним с помощью ключевого слова as:
matplotlib.pyplot as plt
plt.plot(x)