Пособие. Пособие по Python. Название Описание

• Название: Название Описание
• Анкор: Пособие
• Дата: 05.10.2021
• Размер: 0.75 Mb.
• Имя файла: Пособие по Python.pdf
• Тип: Документы; #241608
• страница: 1 из 5

Программирование на Python
Встроенные типы данных следующие:
Название
Описание
None неопределенное значение переменной bool
Булевый тип: True/False int
Целочисленный тип float
Вещественный тип complex
Комплексный тип (для комплексных чисел) str
Строковый тип
Бинарные списки bytes
Список байт bytearray
Байтовые массивы memoryview
Специальные объекты для доступа к внутренним данным объекта через protocol buffer
Множества set
Множество frozenset
Неизменяемое множество
Словари dict
Словарь
• input()
– для ввода данных с клавиатуры;
• print()
– для вывода данных в консоль.
Начнем с первой. Вызвать функцию input можно таким образом: input
() и после ее запуска среда выполнения будет ожидать от нас ввода данных. Введем, допустим, число 5 и нажмем enter. Смотрите, эта функция возвратила нам это число, но в виде строки:
‘5’
В действительности, данная функция всегда возвращает строку, чего бы мы не вводили с клавиатуры. Ну хорошо, а как нам сохранить в переменной введенное значение? Это можно сделать так: a
=
input
()

Теперь, на все введенные данные будет ссылаться переменная a.
Несмотря на то, что input всегда возвращает строки, нам в программах в ряде случаев будет требоваться ввод чисел. И здесь возникает вопрос: как число из строки преобразовать в обычное число, которое можно будет в последствие использовать в арифметических операциях? Это делается с помощью функции int(<аргумент>)
Данная функция пытается переданный аргумент преобразовать в число и вернуть уже числовое значение. Например: int
(
'5'
) вернет число 5, или int
(a) преобразует значение a в числовое. Однако, здесь следует быть осторожным и иметь в виду, что если аргумент не удается преобразовать в число, то возникнет ошибка: int
(
'12dfd'
)
Отлично, с этим разобрались. Теперь мы можем преобразовывать строки в числа, используя такую конструкцию: a
=
int
(
input
())
Здесь сначала сработает input, а затем, введенное строковое значение будет преобразовываться в число и переменная a уже будет ссылаться на числовое значение. Благодаря этому, данную переменную можно в дальнейшем использовать в арифметических операциях, например: a+
2
и так далее (об арифметических операциях речь пойдет на следующем занятии).
По аналогии с int работает функция float(<аргумент>) которая преобразовывает строку в вещественное число. С ее помощью можно выполнять, например, такие преобразования:

float
(
'3'
) float
(
'4.5'
)
Каждый раз мы будем получать вещественные значения. То есть, можно записывать и такую конструкцию: a
=
float
(
input
()) и вводить любые вещественные числа.
В качестве примера рассмотрим простую программу вычисления периметра прямоугольника: w
=
float
(
input
()) h
=
float
(
input
()) p
=
2
*(w+h)
print
(p)
Но здесь есть небольшое неудобство: при вводе значений пользователь не знает, что именно ему вводить. Нужно написать подсказки. Это реализуется так: w
=
float
(
input
(
"Введите ширину: "
)) h
=
float
(
input
(
"Введите длину: "
))
Теперь, он видит сообщение и понимает что нужно вводить с клавиатуры.
О функции print мы уже немного знаем, здесь рассмотрим подробнее различные возможности ее использования. Например, эту функцию можно записывать в таких вариациях:
print
(
1
)
print
(
1
,
2
)
print
(
1
,
2
,
3
)
И так далее, число аргументов может быть произвольным.
Соответственно все эти значения в строчку будут выведены в консоли. Причем, значения разделяются между собой пробелом. Это разделитель, который используется по умолчанию. Если нужно изменить значение этого разделителя, то для этого используется специальный именованный аргумент sep:
print
(
1
,
2
,
3
,
sep
=
","
)
print
(
1
,
2
,
3
,
sep
=
"-"
)
print
(
1
,
2
,
3
,
sep
=
"***"
)

то есть, здесь можно прописывать самые разные строки-разделители.
Далее, вы уже заметили, что каждый вызов функции print делает перевод строки. Этот символ автоматически добавляет в конец выводимых данных. Но, мы также можем его изменить. Для этого используется именованный аргумент end:
print
(
1
,
2
,
3
,
sep
=
","
,
end
=
':'
)
print
(
1
,
2
,
3
,
sep
=
"-"
,
end
=
'--end--
\n
'
)
print
(
1
,
2
,
3
,
sep
=
"***"
)
Смотрите, теперь у нас после первой строчки нет перевода строки, а поставлено двоеточие с пробелом, которые мы указали в аргументе end. После второго вывода в конце была добавлена строчка и указан символ ‘\n’ перевода строки.
В качестве примера все это можно использовать для более гибкого вывода значений с помощью print: name
=
"
Федор"
print
(
"
Имя"
,
name
,
sep
=
":"
)
Но это не самый удобный вывод значений. Функция print позволяет делать довольно гибкий форматированный вывод данных с применением спецификаторов. Например: name
=
"
Федор"
;
age
=
18
print
(
"
Имя %s, возраст %d"
%(name
,
age))
В результате, вместо спецификатора %s будет подставлена первая переменная, указанная в скобках, в виде строки, а вместо %d – вторая переменная age в виде целого числа. То есть, для каждого типа данных существует свой спецификатор. Наиболее употребительные, следующие:
•
%d, %i, %u
– для вывода целочисленных значений;
•
%f
– для вывода вещественных значений;
•
%s
– для вывода строк;
•
%% - для вывода символа %
Вот основные возможности функций input и print в Python.
И как уже говорили, в этом языке имеется три базовых типа для представления чисел:
• int
– для целочисленных значений;

• float
– для вещественных;
• complex
– для комплексных.
С этими числами можно выполнять следующие арифметические операции:
Оператор
Описание
Приоритет
+ сложение
2
- вычитание
2
* умножение
3
/, // деление
3
% остаток деления
3
** возведение в степень
4
И введем несколько определений:
Операнд – то, к чему применяется оператор. Например, в
умножении 5 * 2 есть два операнда: левый операнд равен 5, а правый
операнд равен 2. Иногда их называют «аргументами» вместо
«операндов».
Унарным называется оператор, который применяется к одному
операнду.
Например, оператор унарный минус "-" меняет знак числа на противоположный:
#
унарный минус
a
=
1
;
a
=
-a
print
(a)
Обратите внимание как записаны два оператора в одну строчку: они разделены точкой с запятой. Так тоже можно делать. Если каждый оператор начинается с новой строки, то точку с запятой ставить не обязательно, если пишем несколько операторов в одну строчку, то они разделяются точкой с запятой.
Бинарным называется оператор, который применяется к двум
операндам.
Тот же минус существует и в бинарной форме: a
=
1
;
b
=
2
c
=
b-a
#бинарный минус
print
(c)

Раз мы начали говорить об операциях + и -, то продолжим и отметим, что, в общем случае, можно использовать унарный плюс и минус, например: a
=
2
;
print
(+a
,
-a)
Конечно, +a это то же самое, что и a, поэтому, в основном, используется унарный минус. По приоритету унарные операции выше бинарных операций. Например, вот такая запись:
print
(-a+b) означает, что число –a возводится в степень 2, то есть, унарный минус имеет больший приоритет, чем бинарная операция ** возведения в степень.
Если же используются бинарные сложение и вычитание: a
=
2
;
b
=
-
10
print
(a+b)
print
(a-b) то их приоритет становится наименьшим среди всех арифметических операций (они выполняются в последнюю очередь).
Следующая бинарная операция умножение работает так, как мы привыкли ее использовать в математике: a
=
2
;
b
=
-
5.8
;
c
=
2.3
print
( a+b*c )
Здесь сначала выполнится умножение, а затем – сложение. Если необходимо изменить приоритет выполнения операций, то используются круглые скобки:
print
( (a+b)*c )
Далее, деление двух чисел (или переменных) можно выполнить двумя способами. Первый – традиционный, делает деление, привычное в математике, например:
3
/
2
получим ожидаемый результат 1,5. Однако те из вас, кто имеет опыт программирования на таких языках как С++ или Java, знают, что при делении двух целочисленных значений, результат также получался

целочисленным. Но в Python это не так! Его арифметические операции работают в соответствии с классическими правилами математики и деление здесь – это всегда полноценное деление двух значений, какими бы они ни были.
Однако, если все же требуется выполнить целочисленное деление (то есть, с отбрасыванием дробной части), то используется такой оператор:
3
//
2
И, как видите, теперь результат 1, а не 1,5. Причем, это целочисленное деление будет выполняться и с вещественными числами:
3.2
//
2
Вот такие два оператора деления существуют в Python.
Если же хотим вычислить остаток от целочисленного деления, то используется оператор: x % y
С положительными целыми числами он работает также как и во многих других языках программирования. Например,
4
%
5
# 0
7
%
5
# 2
и так далее, мы будем получать числа от 0 до 4. Но с отрицательными числами вычисления будут отличаться от того же языка С++.
Например,
-
9
%
5
# (в С++ это -4, а в Python – это 1)
Почему так? Дело в том, что когда то давно инженеры фирмы Intell неверно математически реализовали данную операцию. И язык С++ как наследник этой интеловской архитектуры реализует данную операцию путем вынесения знака «-» за скобки и вычисления обычного остатка от деления. Язык же Python делает это так, как принято в математике. Сначала находится ближайшее наименьшее число кратное 5. Это число -10 (для числа -9) и остаток берется как разность между этими числами:

то есть, остатки всегда будут положительными в диапазоне от 0 до 4, как это и должно быть по математике.
Все рассмотренные операторы (*, /, //, %) имеют одинаковый приоритет и выполняются слева-направо. То есть, если записать a/b*c
Следующая операция – возведение в степень. В самом простом варианте она записывается так: x
=
2
;
y
=
5
;
x**y здесь x, y могут быть и дробными числами. Например: x
=
1.96
;
y
=
0.5
;
x**y
Это будет соответствовать извлечению квадратного корня из 1,96.
Если запишем такую конструкцию:
27
**(
1
/
3
) то получим кубический корень из 27. Причем, обратите внимание, круглые скобки у степени здесь обязательны, т.к. приоритет операции
** выше, чем у деления. Если записать вот так:
27
**
1
/
3

Вот на это следует обращать внимание. И еще один нюанс. Операция возведения в степень выполняется справа-налево. То есть, если записать вот такую строчку:
2
**
3
**
2
Сначала (справа) вычисляется 3**2 = 9, а затем, 2**9 = 512. Все остальные арифметические операции работают слева-направо.
Используя оператор присваивания совместно с арифметическими операторами, можно выполнять некоторые полезные арифметические преобразования переменных. Например, очень часто требуется увеличить или уменьшить некую переменную на определенное число.
Это можно сделать вот так: i
=
5
;
j
=
3
i
=
i+
1
j
=
j-
2
print
(i
,
j)
Но, можно и короче, вот так: i
=
5
;
j
=
3
i +
=
1
j -
=
2
print
(i
,
j)
Они довольно часто используются в программировании. Также, помимо сложения и вычитания, можно записывать и такие выражения: i *
=
3
j /
=
4
print
(i
,
j) a
=
5
;
b
=
10
a **
=
2
b //
=
3
print
(a
,
b)
То есть, здесь до оператора присваивания можно записывать любую арифметическую операцию.
Все рассмотренные арифметические операции можно выполнять и с комплексными числами:

a
=
1
+ 2j b
=
2
- 3j
print
(a+b)
print
(a-b)
print
(a*b)
print
(a/b)
print
(a**b)
Кроме операции целочисленного деления // и вычисления остатка от деления %. Дополнительно у объектов комплексных чисел есть свойства: a
=
1
+ 2j b
=
2
- 3j
print
(a.real)
print
(b.imag) для взятия действительной и мнимой части. И полезный метод: sa
=
a.conjugate()
;
print
(sa) для получения комплексно-сопряженного числа.
В языке Python имеются встроенные функции для работы с числами.
Наиболее полезные, следующие:
Название
Описание abs(x) вычисляет модуль числа x round(x) округляет x до ближайшего целого min(x1, x2,…,x_n) находит минимальное, среди указанных чисел max(x1, x2,…,x_n) находит максимальное, среди указанных чисел pow(x, y) возводит x в степень y
Также в языке Python имеется стандартная библиотека math, которая содержит большое количество стандартных математических функций.
Чтобы ей воспользоваться, необходимо вначале программы подключить эту библиотеку. Делается это с помощью ключевого слова import, за которым указывается имя библиотеки:
import
math
После этого становятся доступными следующие полезные функции:

Название
Описание math.ceil(x) возвращает ближайшее наибольшее целое для x math.floor(x) возвращает ближайшее наименьшее целое для x math.fabs(x) возвращает модуль числа x math.factorial(x) вычисляет факториал x! math.exp(x) вычисляет e**x math.log2(x) вычисляет логарифм по основанию 2 math.log10(x) вычисляет логарифм по основанию 10 math.log(x,
[base]) вычисляет логарифм по указанному основанию base (по умолчанию base = e – натуральный логарифм) math.pow(x, y) возводит число x в степень y math.sqrt(x) вычисляет квадратный корень из x
Тригонометрические функции math.cos(x) вычисляет косинус x math.sin(x) вычисляет синус x math.tan(x) вычисляет тангенс x math.acos(x) вычисляет арккосинус x math.asin(x) вычисляет арксинус x math.atan(x) вычисляет арктангенс x
Математические константы math.pi число пи math.e число e
Помимо этих есть и другие математические функции. При необходимости, о них можно почитать в официальной документации языка Python.
Применение этих функций вполне очевидно, например, их можно вызвать вот так:
import
math a
=
2.4
b
=
math
.cos(a)
print
(b)
print
( math
.floor(
1.7
) )
print
( math
.ceil(
1.7
) )
print
( math
.sqrt(
2.56
) )

И так далее. Вот так работают арифметические операции в Python и вот такие математические функции имеются в стандартной библиотеке math.
Представьте, что вам нужно вычислить модуль числа, хранящегося в переменной x. Как это сделать? Очевидно, нужно реализовать такой алгоритм.
И в этом алгоритме есть вот такое ветвление программы: при x<0 меняется знак на противоположный, а при других x это не делается. В результате получаем модуль числа в переменной x.
Так вот, чтобы реализовать проверку таких условий в Python имеется один условный оператор if, который в самом простом случае имеет такой синтаксис: if(<условное выражение>) : оператор или так: if <условное выражение> : оператор
Если условное выражение истинно, то выполняется оператор, записанный в if. Иначе этот оператор не выполняется. Используя

оператор ветвления, запишем программу для вычисления модуля числа: x
=
-
5
if
(x
<
0
) : x
=
-x
print
(x)
Здесь операция изменения знака переменной x будет выполняться только для отрицательных величин, а положительные просто выводятся в консоль, минуя эту операцию.
Какие операторы сравнения существуют в Python и как они работают?
Многие из них нам известны из школьного курса математики, это: a > b
Истинно, если a больше b a < b
Истинно, если a меньше b a >= b
Истинно, если a больше или равно b a <= b
Истинно, если a меньше или равно b a == b
Истинно, если a равно b (обратите внимание, для сравнения используется двойной знак равенства) a != b
Истинно, если a не равно b
Все эти операторы при сравнении возвращают булевое значение: True
– истина или False – ложь. Например:
print
(
2
>
1
)
print
(
2
==
1
)
print
(
2
!=
1
)
Результат сравнения можно присвоить переменной, как и любое значение: result
=
7
>
5
print
(result)
Сравнение строк
Как вы видите, сравнение двух числовых значений выполняется вполне очевидным образом. Но можно ли, например, сравнивать строки между собой? Оказывается да, можно. Чтобы определить, что одна строка больше другой, Python использует «алфавитный» или
«лексикографический» порядок. Другими словами, строки сравниваются посимвольно. Например:

print
(
'Я'
>
'А'
)
print
(
'Кот'
>
'Код'
)
print
(
'Сонный'
>
'Сон'
)
Алгоритм сравнения двух строк довольно прост:
1.
Сначала сравниваются первые символы строк.
2.
Если первый символ первой строки больше (меньше), чем первый символ второй, то первая строка больше (меньше) второй.
3.
Если первые символы равны, то таким же образом сравниваются уже вторые символы строк.
Сравнение продолжается, пока не закончится одна из строк. Если обе строки заканчиваются одновременно, и все их соответствующие символы равны между собой, то строки считаются равными. Иначе, большей считается более длинная строка.
В примерах выше сравнение 'Я' > 'А' завершится на первом шаге, тогда как строки "Кот" и "Код" будут сравниваться посимвольно:
1.
К равна К.
2. о равна о.
3. т больше чем д.
На этом сравнение заканчивается. Первая строка больше.