Как в языке python называются указания компьютеру определяющие какие операции

Структура программы на языке Python. Операции, переменные и литералы. Типы данных

С этого видеоурока ученики начнут знакомство с программами на языке Python. Будут рассмотрены составные структурные единицы программ, такие как модули, инструкции и выражения. Также ученики познакомятся с понятием переменной, операции и типизацией данных в языке Python.

В данный момент вы не можете посмотреть или раздать видеоурок ученикам

Чтобы получить доступ к этому и другим видеоурокам комплекта, вам нужно добавить его в личный кабинет.

Получите невероятные возможности

1. Откройте доступ ко всем видеоурокам комплекта.

2. Раздавайте видеоуроки в личные кабинеты ученикам.

3. Смотрите статистику просмотра видеоуроков учениками.
Получить доступ

Конспект урока «Структура программы на языке Python. Операции, переменные и литералы. Типы данных»

· Структура программы на языке Python.

· Операции и переменные.

· Типы данных языка Python.

Итак, рассмотрим, из чего состоят программы на языке Python. Любая программа на языке Python состоит из модулей. Модуль на языке Python представляет собой ряд связанных между собой операций. Модули сохраняются в отдельных файлах с расширением *.py. Сохранённые модули можно использовать в создаваемых программах. Сначала мы будем разрабатывать довольно простые программы, которые практически всегда будут состоять всего из одного модуля.

Модули, в свою очередь, состоят из более простых структурных единиц. В модулях содержится код на языке Python, состоящий из инструкций. Инструкции представляют собой указания компьютеру. Они определяют, какие операции выполнит компьютер с данными. Инструкции в языке Python делятся на простые и составные. Простые инструкции описываются одной строкой кода, составные же – содержат вложенные инструкции.

Инструкции могут содержать выражения. И если инструкции определяют, какие действия будут выполнены над информацией, то выражения в составе инструкций определяют, над какими именно данными будут выполнены действия, описанные в инструкции.

Вместе с языком Python поставляется множество стандартных модулей, которые предоставляют программисту большое количество инструментов и возможностей для написания самых разных программ.

Рассмотрим пример. Находясь в интерактивном режиме среды разработки, создадим новый файл, в котором запишем несколько инструкций. Сохраним его под именем modul_1.py. Запишем в файле инструкцию вывода print (2 * (10 – 4)). Сохраним файл и запустим инструкцию на выполнение. В главном окне среды разработки было выведено значение записанного нами выражения, то есть 12.

В описанном нами примере, файл modul_1.py является модулем, строка, записанная нами в этом файле, является инструкцией, а математическое выражение, записанное в скобках, является выражением.

Рассмотрим, что такое операции. Операциями в языках программирования называются любые действия над операндами. Операндами называются некоторые данные. Для примера рассмотрим операции, используемые в описанном нами математическом выражении. Всего их две: разность и умножение. Операндами для операции разности являются числа: 10 и 4. Операндами для операции умножения являются число 2 и разность чисел 10 и 4. Установив скобки в этом выражении, мы определили порядок выполнения операций. Сначала будет выполнена операция разности, записанная в скобках, после чего её результат будет использован в качестве операнды при выполнении умножения. Приоритет выполнения операций в языке Python соответствует математическому.

Операндами для операций могут быть литералы, выражения и переменные. В описанном нами примере операндами разности являются литералы, то есть числа, которые записаны при написании кода, а для операции умножения – литерал, то есть число 2, а также выражение, то есть разность чисел 10 и 4. Операндами могут быть и переменные. Независимо от языка программирования, переменной называется именованная область оперативной памяти, в которой хранится информация определённого типа. Механизм связи между переменной и данными, которые она содержит, может отличаться в зависимости от языка программирования. Пока просто запомним, что данные, сохранённые в переменной, связаны с некоторым именем и могут быть вызваны по этому имени.

Данные, которые соответствуют переменной в языке Python, могут быть определены с помощью инструкции присваивания. Инструкция присваивания в языке Python записывается с помощью знака равенства, слева от которого находится имя переменной, а справа – её значение. То есть, чтобы переменной а присвоить значение 4, мы должны записать строку кода: а = 4.

Рассмотрим пример. В среде разработки языка Python, в интерактивном режиме, присвоим переменной t значение 15, после чего убедимся, что операция выполнена. Для этого запишем строку кода: t = 15 и нажмём клавишу Enter. Операция присваивания уже была выполнена – убедимся в этом. Для этого запишем инструкцию print (t) для вывода значения переменной t на экран. Таким образом, мы убедились, что переменная t имеет значение 15. Важно запомнить, что переменную стоит называть осмысленно, её имя не должно совпадать со служебными словами языка или содержать служебные символы; имя переменной не может начинаться с цифры.

Рассмотрим, какие типы данных используются в языке программирования Python. Во время написания программ мы будем использовать всего четыре основных типа данных: целые числа – int, вещественные числа – float и символьные строки – str. К целым числам относятся числа без дробной части, например: 0, 7, — 12 и т. д… К вещественным числам относятся числа с дробной частью, например: 3.5, — 6.7 и так далее… К символьным строкам относятся любые последовательности символов. При вводе они заключаются в двойные или одинарные кавычки.

Те из вас, кто до этого использовал другие языки программирования, например Pascal, знают, что прежде чем использовать переменную в программе, её нужно объявить. При этом, за переменной закрепляется ячейка оперативной памяти, а также указывается тип данных, которые будут на ней храниться. Возможно, многие из вас обратили внимание на то, что при написании кода для демонстрации работы оператора присваивания, мы не объявляли переменную Тэ, прежде чем присвоить ей значение. Так происходит потому, что в языке Python переменная объявляется автоматически перед первым использованием. Тогда у многих из вас может возникнуть вопрос: «Как определяется тип переменной? Ведь его мы тоже не указывали». В отличие от всё того же языка Pascal, в языке Python используется динамическая типизация. Что это означает? В языке Python тип переменной определяется автоматически, в зависимости от присвоенного ей значения, а так как значение переменной в ходе исполнения программы может изменяться, то и тип переменной также изменяется вслед за значением.

Как же определить, какой тип имеет переменная на данный момент? Для этого в языке Python есть функция type. Посмотрим, как она работает. В среде разработки языка Python, в интерактивном режиме, сначала присвоим переменной a значение 4, после чего запишем инструкцию type (a). На экран был выведен результат выполнения инструкции. В угловых скобках записано слово type, после которого в одинарных кавычках следует тип переменной – int. Теперь присвоим переменной a значение -5.7. В языке Python дробная часть числа отделяется от целой точкой. Теперь снова запишем инструкцию type (a). Как видим, тип переменной a изменился на float. Теперь присвоим переменной a символьную строку. Для этого, после знака равенства, в двойных или одинарных кавычках запишем любую последовательность символов, например, слово «Привет». Теперь снова запишем инструкцию type (a). Тип переменной a изменился на str. Для того, чтобы задать число с нулевой дробной частью как вещественное, достаточно просто указать его дробную часть равной нулю. Присвоим переменной a значение 4.0, после чего запишем инструкцию type (a). Как видим, тип переменной a стал float. Важно запомнить, что значения строкового типа не могут употребляться в одном выражении со значениями одного из числовых типов, иначе результатом попытки выполнения инструкции будет сообщение об ошибке.

Решим задачу. Написать модуль, в котором переменным a и b присваиваются значения соответственно равные 8.5 и 6, а переменной c – значение суммы a и b. После чего выводятся на экран значения переменной c, разности a и b, их произведения, частного, а также a b .

Создадим файл модуля, после чего сохраним его. Начнём написание инструкций. В начале запишем инструкцию для присваивания переменной a значения 8.5. После этого, запишем инструкцию для присваивания переменной b значения 6, а также инструкцию присваивания переменной c значения суммы a и b. Дальше напишем инструкцию print, после которой будут следовать пустые скобки. Скопируем эту инструкцию четыре раза (по количеству выражений, результаты которых необходимо вывести). В первой инструкции print в скобках запишем c, во второй – a – b, в третьей – a * b, в четвёртой – a / b и в пятой – a ** b.

После того как все инструкции записаны, сохраним модуль и запустим его на выполнение. В главном окне среды разработки в пяти строках было выведено пять чисел – результаты перечисленных операций. Модуль работает правильно. Задача решена.

Обратим внимание на то, как выполняются инструкции присваивания в написанном нами модуле. При выполнении первой инструкции сначала выделяется ячейка оперативной памяти для переменной a, после чего проверяется литерал 8.5. Это вещественное число, поэтому тип переменной становится float. Далее в ячейку оперативной памяти заносится значение литерала 8.5. Вторая инструкция выполняется так же, с той лишь разницей, что литерал 6 является целым числом и тип переменной b будет int. При выполнении третьей инструкции присваивания сначала из оперативной памяти извлекаются значения переменных a и b, после чего вычисляется значение их суммы. Далее для переменной c выделяется ячейка оперативной памяти. Так как результатом операции сложения является вещественное число, тип переменной c становится float. В созданную ячейку оперативной памяти заносится результат суммы, то есть четырнадцать целых пять десятых.

· Программа на языке Python состоит из модулей, которые, в свою очередь, состоят из инструкций, которые могут содержать выражения.

· Операцией называется любое действие над данными.

· Переменной называется именованная область оперативной памяти, содержащая данные определённого типа.

· В языке Python есть три основных типа данных: целые числа – int, вещественные числа – float, а также строки символов – str.

· В языке Python переменные объявляются автоматически при первом использовании.

· Тип данных, хранящихся в переменной, изменяется в ходе исполнения программы в зависимости от того, какое значение присваивается переменной. Этот принцип называется динамической типизацией.

Основы языка программирования Python за 10 минут

На сайте Poromenos’ Stuff была
опубликована статья, в которой, в сжатой форме,
рассказывают об основах языка Python. Я предлагаю вам перевод этой статьи. Перевод не дословный. Я постарался подробнее объяснить некоторые моменты, которые могут быть непонятны.

Если вы собрались изучать язык Python, но не можете найти подходящего руководства, то эта
статья вам очень пригодится! За короткое время, вы сможете познакомиться с
основами языка Python. Хотя эта статья часто опирается
на то, что вы уже имеете опыт программирования, но, я надеюсь, даже новичкам
этот материал будет полезен. Внимательно прочитайте каждый параграф. В связи с
сжатостью материала, некоторые темы рассмотрены поверхностно, но содержат весь
необходимый метриал.

Основные свойства

Python не требует явного объявления переменных, является регистро-зависим (переменная var не эквивалентна переменной Var или VAR — это три разные переменные) объектно-ориентированным языком.

Синтаксис

Во первых стоит отметить интересную особенность Python. Он не содержит операторных скобок (begin..end в pascal или в Си), вместо этого блоки выделяются отступами: пробелами или табуляцией, а вход в блок из операторов осуществляется двоеточием. Однострочные комментарии начинаются со знака фунта «#», многострочные — начинаются и заканчиваются тремя двойными кавычками «»»»».
Чтобы присвоить значение пременной используется знак «=», а для сравнения —
«==». Для увеличения значения переменной, или добавления к строке используется оператор «+=», а для уменьшения — «-=». Все эти операции могут взаимодействовать с большинством типов, в том числе со строками. Например

>>> myvar = 3
>>> myvar += 2
>>> myvar -= 1
«»«Это многострочный комментарий
Строки заключенные в три двойные кавычки игнорируются»»»
>>> mystring = «Hello»
>>> mystring += » world.»
>>> print mystring
Hello world.
# Следующая строка меняет
значения переменных местами. (Всего одна строка!)
>>> myvar, mystring = mystring, myvar

Структуры данных

Python содержит такие структуры данных как списки (lists), кортежи (tuples) и словари (dictionaries). Списки — похожи на одномерные массивы (но вы можете использовать Список включающий списки — многомерный массив), кортежи — неизменяемые списки, словари — тоже списки, но индексы могут быть любого типа, а не только числовыми. «Массивы» в Python могут содержать данные любого типа, то есть в одном массиве может могут находиться числовые, строковые и другие типы данных. Массивы начинаются с индекса 0, а последний элемент можно получить по индексу -1 Вы можете присваивать переменным функции и использовать их соответственно.

>>> sample = [ 1 , [ «another» , «list» ], ( «a» , «tuple» )] #Список состоит из целого числа, другого списка и кортежа
>>> mylist = [ «List item 1» , 2 , 3 . 14 ] #Этот список содержит строку, целое и дробное число
>>> mylist[ 0 ] = «List item 1 again» #Изменяем первый (нулевой) элемент листа mylist
>>> mylist[- 1 ] = 3 . 14 #Изменяем последний элемент листа
>>> mydict = < «Key 1» : «Value 1» , 2 : 3 , «pi» : 3 . 14 >#Создаем словарь, с числовыми и целочисленным индексами
>>> mydict[ «pi» ] = 3 . 15 #Изменяем элемент словаря под индексом «pi».
>>> mytuple = ( 1 , 2 , 3 ) #Задаем кортеж
>>> myfunction = len #Python позволяет таким образом объявлять синонимы функции
>>> print myfunction( list )
3

Вы можете использовать часть массива, задавая первый и последний индекс через двоеточие «:». В таком случае вы получите часть массива, от первого индекса до второго не включительно. Если не указан первый элемент, то отсчет начинается с начала массива, а если не указан последний — то масив считывается до последнего элемента. Отрицательные значения определяют положение элемента с конца. Например:

>>> mylist = [ «List item 1» , 2 , 3 . 14 ]
>>> print mylist[:] #Считываются все элементы массива
[ ‘List item 1’ , 2 , 3 . 1400000000000001 ]
>>> print mylist[ 0 : 2 ] #Считываются нулевой и первый элемент массива.
[ ‘List item 1’ , 2 ]
>>> print mylist[- 3 :- 1 ] #Считываются элементы от нулевого (-3) до второго (-1) (не включительно)
[ ‘List item 1’ , 2 ]
>>> print mylist[ 1 :] #Считываются элементы от первого, до последнего
[ 2 , 3 . 14 ]

Строки

Строки в Python обособляются кавычками двойными «»» или одинарными «’». Внутри двойных ковычек могут присутствовать одинарные или наоборот. К примеру строка «Он сказал ‘привет’!» будет выведена на экран как «Он сказал ‘привет’!». Если нужно использовать строку из несколько строчек, то эту строку надо начинать и заканчивать тремя двойными кавычками «»»»». Вы можете подставить в шаблон строки элементы из кортежа или словаря. Знак процента «%» между строкой и кортежем, заменяет в строке символы «%s» на элемент кортежа. Словари позволяют вставлять в строку элемент под заданным индексом. Для этого надо использовать в строке конструкцию «%(индекс)s». В этом случае вместо «%(индекс)s» будет подставлено значение словаря под заданным индексом.

>>>print «Name: %s\nNumber: %s\nString: %s» % (myclass.name, 3 , 3 * «-» )
Name: Poromenos
Number: 3
String: —
strString = «»«Этот текст расположен
на нескольких строках»»»

Операторы

Операторы while, if, for составляют операторы перемещения. Здесь нет аналога оператора select, так что придется обходиться if. В операторе for происходит сравнение переменной и списка. Чтобы получить список цифр до числа — используйте функцию range(). Вот пример использования операторов

rangelist = range ( 10 ) #Получаем список из десяти цифр (от 0 до 9)
>>> print rangelist
[ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ]
for number in rangelist: #Пока переменная number (которая каждый раз увеличивается на единицу) входит в список…
# Проверяем входит ли переменная
# numbers в кортеж чисел ( 3 , 4 , 7 , 9 )
if number in ( 3 , 4 , 7 , 9 ): #Если переменная number входит в кортеж (3, 4, 7, 9).
# Операция «break» обеспечивает
# выход из цикла в любой момент
break
else :
# «continue» осуществляет «прокрутку»
# цикла. Здесь это не требуется, так как после этой операции
# в любом случае программа переходит опять к обработке цикла
continue
else :
# «else» указывать необязательно. Условие выполняется
# если цикл не был прерван при помощи «break».
pass # Ничего не делать

if rangelist[ 1 ] == 2 :
print «The second item (lists are 0-based) is 2»
elif rangelist[ 1 ] == 3 :
print «The second item (lists are 0-based) is 3»
else :
print «Dunno»

while rangelist[ 1 ] == 1 :
pass

Функции

Для объявления функции служит ключевое слово «def». Аргументы функции задаются в скобках после названия функции. Можно задавать необязательные аргументы, присваивая им значение по умолчанию. Функции могут возвращать кортежи, в таком случае надо писать возвращаемые значения через запятую. Ключевое слово «lambda» служит для объявления элементарных функций .

# arg2 и arg3 — необязательые аргументы, принимают значение объявленное по умолчни,
# если не задать им другое значение при вызове функци.
def myfunction(arg1, arg2 = 100 , arg3 = «test» ):
return arg3, arg2, arg1
#Функция вызывается со значением первого аргумента — «Argument 1», второго — по умолчанию, и третьего — «Named argument» .
>>>ret1, ret2, ret3 = myfunction( «Argument 1» , arg3 = «Named argument» )
# ret1, ret2 и ret3 принимают значения «Named argument», 100, «Argument 1» соответственно
>>> print ret1, ret2, ret3
Named argument 100 Argument 1

# Следующая запись эквивалентна def f(x): return x + 1
functionvar = lambda x: x + 1
>>> print functionvar( 1 )
2

Классы

Язык Python ограничен в множественном наследовании в классах. Внутренние переменные и внутренние методы классов начинаются с двух знаков нижнего подчеркивания «__» (например «__myprivatevar»). Мы можем также присвоить значение переменной класса извне. Пример:

class Myclass:
common = 10
def __init__( self ):
self .myvariable = 3
def myfunction( self , arg1, arg2):
return self .myvariable

# Здесь мы объявили класс Myclass. Функция __init__ вызывается автоматически при инициализации классов.
>>> classinstance = Myclass() # Мы инициализировали класс и переменная myvariable приобрела значение 3 как заявлено в методе инициализации
>>> classinstance.myfunction( 1 , 2 ) #Метод myfunction класса Myclass возвращает значение переменной myvariable
3
# Переменная common объявлена во всех классах
>>> classinstance2 = Myclass()
>>> classinstance.common
10
>>> classinstance2.common
10
# Поэтому, если мы изменим ее значение в классе Myclass изменятся
# и ее значения в объектах, инициализированных классом Myclass
>>> Myclass.common = 30
>>> classinstance.common
30
>>> classinstance2.common
30
# А здесь мы не изменяем переменную класса. Вместо этого
# мы объявляем оную в объекте и присваиваем ей новое значение
>>> classinstance.common = 10
>>> classinstance.common
10
>>> classinstance2.common
30
>>> Myclass.common = 50
# Теперь изменение переменной класса не коснется
# переменных объектов этого класса
>>> classinstance.common
10
>>> classinstance2.common
50

# Следующий класс является наследником класса Myclass
# наследуя его свойства и методы, ктому же класс может
# наследоваться из нескольких классов, в этом случае запись
# такая: class Otherclass(Myclass1, Myclass2, MyclassN)
class Otherclass(Myclass):
def __init__( self , arg1):
self .myvariable = 3
print arg1

>>> classinstance = Otherclass( «hello» )
hello
>>> classinstance.myfunction( 1 , 2 )
3
# Этот класс не имеет совйтсва test, но мы можем
# объявить такую переменную для объекта. Причем
# tэта переменная будет членом только classinstance.
>>> classinstance.test = 10
>>> classinstance.test
10

Исключения

Исключения в Python имеют структуру try—except [exceptionname]:

def somefunction():
try :
# Деление на ноль вызывает ошибку
10 / 0
except ZeroDivisionError :
# Но программа не «Выполняет недопустимую операцию»
# А обрабатывает блок исключения соответствующий ошибке «ZeroDivisionError»
print «Oops, invalid.»

Импорт

Внешние библиотеки можно подключить процедурой «import [libname]», где [libname] — название подключаемой библиотеки. Вы так же можете использовать команду «from [libname] import [funcname]», чтобы вы могли использовать функцию [funcname] из библиотеки [libname]

import random #Импортируем библиотеку «random»
from time import clock #И заодно функцию «clock» из библиотеки «time»

randomint = random .randint( 1 , 100 )
>>> print randomint
64

Работа с файловой системой

Python имеет много встроенных библиотек. В этом примере мы попробуем сохранить в бинарном файле структуру списка, прочитать ее и сохраним строку в текстовом файле. Для преобразования структуры данных мы будем использовать стандартную библиотеку «pickle»

import pickle
mylist = [ «This» , «is» , 4 , 13327 ]
# Откроем файл C:\binary.dat для записи. Символ «r»
# предотвращает замену специальных сиволов (таких как \n, \t, \b и др.).
myfile = file (r «C:\binary.dat» , «w» )
pickle .dump(mylist, myfile)
myfile.close()

myfile = file (r «C:\text.txt» , «w» )
myfile.write( «This is a sample string» )
myfile.close()

myfile = file (r «C:\text.txt» )
>>> print myfile.read()
‘This is a sample string’
myfile.close()

# Открываем файл для чтения
myfile = file (r «C:\binary.dat» )
loadedlist = pickle .load(myfile)
myfile.close()
>>> print loadedlist
[ ‘This’ , ‘is’ , 4 , 13327 ]

Особенности

• Условия могут комбинироваться. 1 < a < 3 выполняется тогда, когда а больше 1, но меньше 3.
• Используйте операцию «del» чтобы очищать переменные или элементы массива.
• Python предлагает большие возможности для работы со списками. Вы можете использовать операторы объявлении структуры списка. Оператор for позволяет задавать элементы списка в определенной последовательности, а if — позволяет выбирать элементы по условию.

>>> lst1 = [ 1 , 2 , 3 ]
>>> lst2 = [ 3 , 4 , 5 ]
>>> print [x * y for x in lst1 for y in lst2]
[ 3 , 4 , 5 , 6 , 8 , 10 , 9 , 12 , 15 ]
>>> print [x for x in lst1 if 4 > x > 1 ]
[ 2 , 3 ]
# Оператор «any» возвращает true, если хотя
# бы одно из условий, входящих в него, выполняется.
>>> any(i % 3 for i in [ 3 , 3 , 4 , 4 , 3 ])
True
# Следующая процедура подсчитывает количество
# подходящих элементов в списке
>>> sum ( 1 for i in [ 3 , 3 , 4 , 4 , 3 ] if i == 3 )
3
>>> del lst1[ 0 ]
>>> print lst1
[ 2 , 3 ]
>>> del lst1

• Глобальные переменные объявляются вне функций и могут быть прочитанны без каких либо объявлений. Но если вам необходимо изменить значение глобальной переменной из функции, то вам необходимо объявить ее в начале функции ключевым словом «global», если вы этого не сделаете, то Python объявит переменную, доступную только для этой функции.

def myfunc():
# Выводит 5
print number

def anotherfunc():
# Это вызывает исключение, поскольку глобальная апеременная
# не была вызванна из функции. Python в этом случае создает
# одноименную переменную внутри этой функции и доступную
# только для операторов этой функции.
print number
number = 3

def yetanotherfunc():
global number
# И только из этой функции значение переменной изменяется.
number = 3

Эпилог

Разумеется в этой статье не описываются все возможности Python. Я надеюсь что эта статья поможет вам, если вы захотите и в дальнейшем изучать этот язык программирования.

Преимущества Python

• Скорость выполнения программ написанных на Python очень высока. Это связанно с тем, что основные библиотеки Python
  написаны на C++ и выполнение задач занимает меньше времени, чем на других языках высокого уровня.
• В связи с этим вы можете писать свои собственные модули для Python на C или C++
• В стандартныx библиотеках Python вы можете найти средства для работы с электронной почтой, протоколами
  Интернета, FTP, HTTP, базами данных, и пр.
• Скрипты, написанные при помощи Python выполняются на большинстве современных ОС. Такая переносимость обеспечивает Python применение в самых различных областях.
• Python подходит для любых решений в области программирования, будь то офисные программы, вэб-приложения, GUI-приложения и т.д.
• Над разработкой Python трудились тысячи энтузиастов со всего мира. Поддержкой современных технологий в стандартных библиотеках мы можем быть обязаны именно тому, что Python был открыт для всех желающих.

10.1. Теория¶

Объектно-ориентированное программирование — методология (парадигма) программирования, основанная на представлении программы в виде совокупности объектов, каждый из которых является экземпляром определенного класса, а классы образуют иерархию наследования. В программе при этом в качестве основных логических конструктивных элементов используются объекты, а не алгоритмы.

До настоящей темы объекты так или иначе использовались в коде, однако сам стиль программирования был императивным (процедурным). Написание программы в исключительно таком стиле вполне возможно, однако с увеличением объема кода и усложнения логики обработки данных, объектно-ориентированный стиль дает значительные преимущества.

10.1.1. Введение ООП¶

10.1.1.1. Проблемы процедурного подхода¶

Написание программы в процедурном стиле в определенный момент приводит к ряду трудноразрешимых проблем.

Предположим, в программе необходимо реализовать работу с некоторым числом окружностей. Минимальные данные, необходимые для создания отдельной окружности, — это координаты ее центра x и y , а также радиус r .

Одним из простых решений является выбор какой-либо структуры данных, например, списка:

circle = [-2, 3, 10] # 'x', 'y' и 'r' 

Данное решение имеет 3 недостатка:

Неочевидность назначения каждого элемента списка.

Разработчик может подразумевать [x, у, r] или [r, x, y] , кроме того, для обращения к параметру окружности необходимо точно знать его индекс. «Сгладить» данную проблему могут помочь именованые константы или использование словаря (Листинг 10.1.1 (а) и (б) соответственно).

Листинг 10.1.1 (а) — Использование именованых констант для доступа к свойствам окружности | скачать ¶

1 2 3 4 5 6 7 8 9 10 11 12 13 14

import math C_X = 0 C_Y = 1 C_R = 2 def get_s(circle): """Вернуть площадь окружности 'circle'.""" return math.pi**2 * circle[C_R] circle = [-2, 3, 10] print(" ".format(get_s(circle))) # 98.70 

Листинг 10.1.1 (б) — Словарь как структура данных для окружности | скачать ¶

1 2 3 4 5 6 7 8 9 10

import math def get_s(circle): """Вернуть площадь окружности 'circle'.""" return math.pi**2 * circle['r'] circle = dict(x=36, y=77, r=8) print(" ".format(get_s(circle))) # 78.96 

Даже ликвидация первого недостатка не помешает выполнить, например,

circle['r'] = -5 

чего не должно быть в принципе. Такая невозможность выполнить встроенную проверку данных является, возможно, самым негативным аспектом исключительно процедурного подхода.

Третья проблема возникает в случае, когда встает необходимость одновременно работать не только с окружностями, но и с другими геометрическими фигурами (в т.ч. одним и тем же образом). Например, для кольца или эллипса, понадобится создать новую структуру данных со схожими характеристиками, во многом дублирующими функциональность окружности (нарисовать себя на экране, передвинуться в точку и т.д.), хотя некоторый код мог бы быть использован повторно.

Для комплексного решения указанных проблем необходим способ, который позволил бы:

• логически «упаковать» данные, предоставив удобный интерфейс доступа (не привязанный к конкретной структуре данных);
• ограничить круг данных и операций, которые могли бы быть изменены;
• повторно использовать написанный код при необходимости.

Это может быть достигнуто путем создания собственного объекта (типа данных) Окружность , используя объектно-ориентированный стиль программирования.

10.1.1.2. Основные понятия и терминология¶

10.1.1.2.1. Объект и черный ящик¶

Объект — любой материальный предмет, который можно встретить в повседневной жизни: дом, телефон, машина, книга и т.д.

Применительно к программированию, объектом можно считать любое нечто, которое можно представить в программе в виде одного элемента, который имеет какие-либо характеристики и умеет что-либо делать. Это позволяет разделять программу (большую и не очень) на связанные, более мелкие элементы, логически взаимодействующие между собой так, как бы они взаимодействовали и в реальной жизни. Данная идея берет свое начало от концепции черного ящика (Рисунок 10.1.1).

Рисунок 10.1.1 — Модель черного ящика ¶

Черный ящик рассматривается как система, принимающая некую «входную информацию» (данные) и возвращающая «выходную информацию» (результаты работы), при этом происходящие в ходе работы системы процессы наблюдателю неизвестны.

В качестве примера такой системы можно рассмотреть планшетный компьютер. Не являясь специалистом, ответить на вопросы «что находится внутри?» или «как оно работает?» практически невозможно. При этом известно, что нажатие на определенные участки экрана («входная информация») позволит запустить приложение, установить будильник на завтрашнее утро и т.д. («выходная информация»). Более того, можно приобрести новый планшет, и, несмотря на то, что его «начинка» может существенно отличаться, скорее всего проблем с его использованием не возникнет, т.к. аналогичные функции являются стандартными для любых планшетов. Так концепция «черного ящика» разделяет понятия «что объект делает?» и «как он это делает?», предоставляя необходимый уровень детализации для изучения и использования объекта.

Цель объектно-ориентированного подхода — основываясь на модели черного ящика, разбить программу (декомпозировать) на достаточное количество классов и модулей, каждый из которых предназначен для выполнения одной четко очерченной задачи, которую будет выполнять отдельный объект.

Плюсы данного подхода заключаются в том, что декомпозиция позволяет:

• упростить архитектуру приложения (фактически, сделав ее абстракцией реального мира);
• облегчить командную разработку (каждый разработчик занят работой над отдельным объектом кода и при взаимодействии с другими объектами ему нужно знать лишь «что объект делает», без необходимости узнавать «как он это делает»).

Объектно-ориентированное программирование (ООП) — парадигма программирования, предусматривающая написание программ в рамках объектно-ориентированного подхода.

10.1.1.2.2. Класс и объект, поля и методы¶

В ООП центральными являются понятия класса и объекта:

1. Класс (англ. Class): абстракция реального мира (обобщенный шаблон), специальный тип данных; класс описывает свойства и методы, которые могут быть доступны у подобных объектов;
2. Объект (англ. Object) (экземпляр класса, англ. Class Instance): частный случай класса.

Пример разницы между классом и объектом приведена на Рисунке 10.1.2.

Рисунок 10.1.2 — Соотношение класса ( Car ) и конкретных объектов 6 ¶

Каждый класс содержит и описывает поля и методы (Рисунок 10.1.3):

1. Поле (англ. Data Member / Variable / Field): переменная, привязанная к классу;
2. Метод (англ. Method): действие (функция), которую можно проводить над классом.

Рисунок 10.1.3 — Примеры классов с данными и методами 7 ¶

Набор полей и методов определяет интерфейс класса — способ взаимодействия с классом произвольного кода программы. Доступ к полям и методам осуществляется через указание объекта, например, в Python, используя точку:

"Я - экземпляр класса str".count(" ") # 4 

Типичный сценарий написания объектно-ориентированной программы:

1. Создание одного или нескольких классов (или поиск подходящих существующих).
2. Создание произвольного количества экземпляров классов (инстанцирование) — объектов.
3. Изменение полей и вызов методов созданных объектов.

Именно создание экземпляра класса происходит каждый раз при создании списков, словарей и т.д. на основании соответствующего абстрактного типа данных, предусмотренного разработчиками Python.

Как поля так и методы могут иметь разный уровень доступа — область видимости (англ. Scope) (Таблица 10.1.1).

Таблица 10.1.1 — Область видимости полей и методов ¶

Уровень доступа (тип)

Внутри самого класса

Извне (любой код)

Закрытый / приватный (англ. Private)

Защищенный (англ. Protected)

Открытый / публичный (англ. Public)

Хорошо спроектированный класс грамотно определяет уровни доступа к своим полям и методам.

Еще одним понятием, относящимся к классу, является виртуальность метода. Если метод объявлен как виртуальный — он может быть переопределен (изменено поведение метода) в классах-наследниках.

Проектируя класс (впрочем, как и модуль, и функцию) — представляйте, что пользоваться им будете не Вы, а другой разработчик. Это поможет правильно определить набор атрибутов и уровень доступа к ним.

10.1.1.3. Принципы ООП¶

Объектно-ориентированная парадигма программирования включает 3 основных принципа (свойства):

Как язык скрывает детали внутренней реализации объектов и предохраняет целостность данных?
Как язык стимулирует многократное использование кода?
Как язык позволяет трактовать связанные объекты сходным образом?

10.1.1.3.1. Инкапсуляция¶

За счет принципа инкапсуляции язык может скрывать некоторые детали реализации от пользователя объекта (Листинг 10.1.2).

Листинг 10.1.2 — Принцип инкапсуляции на примере класса DatabaseReader() ¶

# Этот класс инкапсулирует детали открытия и закрытия базы данных db_reader = DatabaseReader() db_reader.open("С:/Balance.sqlite") # Сделать что-то с файлом данных. avg_sales = db_reader.get_avg(table="Сотрудник", field="КоличествоПродаж") # . # Закрыть файл db_reader.close() 

Класс DatabaseReader инкапсулирует внутренние детали нахождения, загрузки, манипуляций и закрытия файла данных. Нет необходимости беспокоиться о многочисленных строках кода, которые работают «за кулисами», чтобы использовать класс в своем приложении. Все, что потребуется — это создать экземпляр класса и отправить ему соответствующие сообщения (например, “открыть файл по имени Balance.sqlite , расположенный на диске С:\ ”).

Концепция инкапсуляции вращается вокруг принципа, гласящего, что внутренние данные объекта не должны быть напрямую доступны через экземпляр объекта. Вместо этого данные класса определяются как закрытые. Если вызывающий код желает изменить состояние объекта, то должен делать непрямо через открытые методы. Этот принцип переплетается с идеей защиты данных — «внешний мир» должен попросить о возможности изменения или получения лежащего в основе объекта значения.

10.1.1.3.2. Наследование¶

Наследование — аспект ООП, облегчающий повторное использование кода. Принцип наследования встречается в повседневной жизни — мы группируем объекты по какому-то признаку (форме, дизайну и т.д.).

• диван похож на кресло, но позволяет уместить больше 1 человека;
• оптический привод в компьютере выполняет запись информации на определенный носитель, как и кассетный проигрыватель;
• каждый автомобиль имеет свои «внутренности», однако предоставляет общий интерфейс (руль, педали, определенная коробка передач), и нет необходимости изучать каждый автомобиль отдельно для того, чтобы им пользоваться.

Принцип наследования в языке программирования позволяет строить новые определения классов на основе существующих. Наследование позволяет расширять поведение базового класса (родительского или суперкласса), наследуя его основную функциональность в производном подклассе (дочернем классе или подклассе).

На Рисунке 10.1.4. приведен пример иерархии наследуемых классов.

Рисунок 10.1.4 — Пример иерархии наследуемых классов 8 ¶

Прочесть диаграмму можно следующим образом:

• классы Прямоугольник ( Rectangle ) и Окружность ( Circle ) являются Фигурой ( Shape ) (дочерними классами);
• фигура ( Shape ) имеет следующие характеристики (и ими обладают все дочерние классы!): поля — цвет, толщина линии и методы — отрисовка(), очистка();
• дочерние классы имеют дополнительные характеристики (расширяя унаследованный класс Фигура): например, Rectangle — координаты верхнего левого и нижнего правого углов, а Circle — радиус.

При наличии классов, связанных этой формой наследования, между типами устанавливается отношение “является”.

10.1.1.3.3. Полиморфизм¶

Полиморфизм обозначает способность языка трактовать связанные объекты в сходной манере. В частности, этот принцип ООП позволяет базовому классу определять набор членов, которые доступны всем наследникам.

Когда класс наследуется от базового класса, при определенных условиях он может переопределить методы базового класса. В любом случае, когда производные классы переопределяют члены, определенные в базовом классе, они по существу переопределяют свою реакцию на один и тот же запрос.

На Рисунке 10.1.5 приведена иерархия классов с общим методом draw() .

Рисунок 10.1.5 — Иерархия классов с общим методом draw() 8 ¶

В классе Shape определен метод draw() , отвечающий за отрисовку фигуры. Учитывая, что каждая фигура должна рисовать себя уникальным образом, подклассы (такие как Rectangle и Circle ) должны реализовать этот метод по своему усмотрению так, что вызов draw() на объекте Circle приведет к рисованию круга, а вызов draw() на объекте Rectangle — к рисованию прямоугольника.

Объект Controller содержит список фигур ShapesList , в котором могут содержаться как прямоугольники, так и окружности. Реализовать метод отрисовки всех фигур drawAllShapes() можно 2 способами: в процедурном стиле (Листинг 10.1.3 (а)) и объектно-ориентированном (Листинг 10.1.3 (б)).

Листинг 10.1.3 (а) — Возможный код drawAllShapes() (процедурный подход) ¶

# Предположим, что в процедурном подходе информация о фигуре # хранится в словаре с соответствующими ключами и указанием типа, например, # для прямоугольника def drawAllShapes(): for shape in shapeList: if shape["type"] == "Прямоугольник": draw_rectangle(shape["x1"], shape["y1"], shape["x2"], shape["y2"]) elif shape["type"] == "Окружность": draw_circle(shape["x"], shape["y"], shape["r"]) # И так для каждой новой фигуры # А еще может быть много операций: масштабирование, пермещение. 

Листинг 10.1.3 (б) — Возможный код drawAllShapes() (объектно-ориентированный подход) ¶

def drawAllShapes(): for shape in shapeList: # shape сам решает как себя отрисовать, в зависимости от # своего класса и внутренней реализации shape.draw() # Появление новой фигуры не поменяет (!) этот код 

10.1.2. Поддержка ООП в Python¶

Python — полностью объектно-ориентированный язык, где любое значение является объектом, т.е. экземпляром конкретного класса. Например, число 5 или строка «python» являются объектами, экземплярами классов int и str соответственно.

Python позволяет не только использовать имеющиеся классы, но и создавать собственные, которые могут использоваться как любые встроенные типы данных. Поддержка классов в Python реализована на основе синтаксиса и семантики языков программирования C++ и Modula-3 (один из потомков языка Паскаль).

Большинство классов содержат в себе (инкапсулируют) не только поля (данные), но и методы. В Python традиционно поля и методы вместе называются атрибутами (членами) класса. Доступ к члену класса можно получить через ‘.’ . Например, класс str хранит строки символов Юникода в виде данных и поддерживает методы, такие как str.count() .

Все атрибуты класса являются общедоступными (в терминологии C++, публичными), а все методы виртуальными (переопределяемыми).

10.1.2.1. Определение элементарного класса¶

Python позволяет создавать собственные классы, обладающие произвольной функциональностью.

• для имен классов используйте регистр ВерблюжийРегистр (англ. CamelCase): MyPoint , UserBankAccount ;
• используйте строки документации.

10.1.2.2. Создание и использование класса¶

Создание класса начинается с ключевого слова class и указания имени класса. Пример определения в Python простого класса и его использования приведен в Листинге 10.1.4.

Листинг 10.1.4 — Простой пример класса в Python | скачать ¶

1 2 3 4 5 6 7 8 9 10 11 12

class Point2D: """Точка на плоскости.""" pass if __name__ == "__main__": # Создание объекта (экземпляра класса) p = Point2D() print(p) # print(type(p)) #

10.1.2.3. Инициализация класса¶

При создании экземпляра класса, как правило, требуется проводить его инициализацию (например, устанавливать начальные значения полей), для чего в Python предназначен специальный метод __init__ (Листинг 10.1.5). В ряде языков программирования близкий по смыслу к __init__ метод называется «конструктором» (англ. Constructor).

Листинг 10.1.5 — Инициализация класса | скачать ¶

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

class Point2D: """Точка на плоскости.""" # Инициализирующий метод (специальный метод с __) def __init__(self, x, y): self.x = x # Поля читаются и записываются через 'self' self.y = y # 'self' указывает на текущий экземпляр класса # Обычный метод объекта (метод экземпляра класса) имеет те же правила, # наименования что и обычные функции def distance(self): """Вернуть расстояние до центра координат.""" return (self.x**2 + self.y**2)**0.5 if __name__ == "__main__": # Создание объекта (экземпляра класса) # Передаем параметры, которые теперь требует '__init__()' # Параметр 'self' не передается явно, но содержит ссылку на 'p' p = Point2D(3, 4) # При выводе объекта на экран по умолчанию отображается имя класса print(p) # После инициализации доступны атрибуты 'p.x' и 'p.y', # где хранятся переданные при создании объекта значения print(p.x, p.y) # 3 4 # Вызов обычного метода print("Расстояние до центра координат: ".format(p.distance())) # 5 

В Листинге 10.1.5 объявлены:

• 2 поля x и y ;
• метод инициализации __init__() ;
• метод экземпляра класса distance() .

Первым параметром метода идет параметр self , в котором содержится ссылка на экземпляр, который вызвал данный метод.

10.1.2.4. Строковое представление класса¶

Еще одним часто используемым специальным методом является специальный метод __str__ , возвращающий строковое представление класса (Листинг 10.1.6).

Листинг 10.1.6 — Метод __str__ | скачать ¶

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

class Point2D: """Точка на плоскости.""" # Инициализирующий метод def __init__(self, x, y): self.x = x self.y = y # Строковое представление класса def __str__(self): """Вернуть строку в виде 'Точка 2D (x, y)'.""" return "Точка 2D (<>, <>)".format(self.x, self.y) def distance(self): """Вернуть расстояние до центра координат.""" return (self.x**2 + self.y**2)**0.5 if __name__ == "__main__": p = Point2D(3, 4) print(p) # Точка 2D (3, 4) 

Если метод __str__ не реализован, осуществляется вывод строкового представления класса по умолчанию (содержит имя класса, см. Листинг 10.1.4).

10.1.2.5. Специальные методы¶

Методы, имена которых обрамляются __ , Python трактует как специальные, например, __init__ (инициализация) или __str__ (строковое представление). Специальные методы, как правило, идут первыми при объявлении класса.

10.1.2.5.1. Определение операторов¶

Специальные методы также могут быть использованы, если необходимо добавить возможность выполнения стандартных операций над классами (например, сложить 2 класса-точки или обратить ее координаты), т.е. определить смысл операторов + и т.д. для создаваемого класса.

Конечно, для этого можно создать дополнительные методы (например, add() ), однако определение действий операторов является более лаконичным способом.

Листинг 10.1.7 содержит пример определения операторов для сложения/разности двух объектов класса Point2D , а также инверсии их координат и равенства/неравенства.

Листинг 10.1.7 — Переопределение операций для класса | скачать ¶

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

class Point2D: """Точка на плоскости.""" def __init__(self, x, y): self.x = x self.y = y def __str__(self): """Вернуть строку в виде 'Точка 2D (x, y)'.""" return "Точка 2D (<>, <>)".format(self.x, self.y) def __add__(self, other): """Создать новый объект как сумму координат 'self' и 'other'.""" # Вместо Point2D можно использовать self.__class__, # что позволит не привязываться к имени класса и быть # валидным для потомков return Point2D(self.x + other.x, self.y + other.y) def __sub__(self, other): """Создать новый объект как разность координат 'self' и 'other'.""" return Point2D(self.x - other.x, self.y - other.y) def __neg__(self): """Вернуть новый объект, инвертировав координаты.""" return Point2D(-self.x, -self.y) def __eq__(self, other): """Вернуть ответ, являются ли точки одинаковыми.""" return self.x == other.x and self.y == other.y def __ne__(self, other): """Вернуть ответ, являются ли точки разными. Используем реализованную операцию ==.""" return not (self == other) def distance(self): """Вернуть расстояние до центра координат.""" return (self.x**2 + self.y**2)**0.5 if __name__ == "__main__": p1 = Point2D(0, 5) p2 = Point2D(-5, 10) # Если Python не найдет в определении класса метода '__add__()', # строка ниже сгенерирует исключение: # 'TypeError: unsupported operand type(s) for +: 'Point2D' and 'Point2D'' print(p1 + p2) # Точка 2D (-5, 15) print(p1 - p2) # Точка 2D (5, -5) print(-p2) # Точка 2D (5, -10) print(p1 == p2, p1 != p2) # False True print("Расстояние до центра координат (p1): ".format(p1.distance())) # 5.00 print("Расстояние до центра координат (p2): ".format(p2.distance())) # 11.18 

В Таблице 10.1.2 приведены некоторые операторы и соответствующие им специальные функции (полный список доступен в справке 9).

Таблица 10.1.2 — Некоторые операторы и соответствующие им специальные функции ¶

Арифметические

Остаток от деления

Возведение в степень

Индексация и срезы

Доступ по индексу

Присвоение по индексу

__setitem__(obj, k, v)

Удаление по индексу

__getitem__(seq, slice(i, j))

__setitem__(seq, slice(i, j), values)

__delitem__(seq, slice(i, j))

Идентификация и сравнение

Проверка на вхождение

Преобразование в логический тип

10.1.2.5.2. Проверка типов¶

Определение операторов предоставляет удобный синтаксис работы с классом, однако в виду того, что точный тип передаваемых аргументов не известен (Python — язык с неявной динамической типизацией), могут возникнуть проблемы при передаче «не ожидаемых» значений (Листинг 10.1.8).

Листинг 10.1.8 — Ошибка при попытке сложить Point2D и int | скачать ¶

if __name__ == "__main__": p1 = Point2D(0, 5) p2 = Point2D(-5, 10) print(p1 + 2) # Ошибка: AttributeError: 'int' object has no attribute 'x' 

Исходя из этого, перед действием рекомендуется проверить, экземпляром какого класса является переданный объект. Выполнить такую проверку можно используя функции type() или isinstance(obj, class) (Листинг 10.1.9).

Листинг 10.1.9 — Изменение действия в зависимости от типа переданного параметра | скачать ¶

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

class Point2D: """Точка на плоскости.""" def __init__(self, x, y): self.x = x self.y = y def __str__(self): """Вернуть строку в виде 'Точка 2D (x, y)'.""" return "Точка 2D (<>, <>)".format(self.x, self.y) def __add__(self, other): """Создать новый объект как сумму координат self и other.""" if isinstance(other, self.__class__): # Точка с точкой # Возвращаем новый объект! return Point2D(self.x + other.x, self.y + other.y) elif isinstance(other, (int, float)): # Точка и число # Добавим к обеим координатам self число other и вернем результат # Возвращаем старый, измененный, объект! self.x += other self.y += other return self else: # В противном случае возбуждаем исключение raise TypeError("Не могу добавить  к ". format(self.__class__, type(other))) if __name__ == "__main__": p1 = Point2D(0, 5) p2 = Point2D(-5, 10) print(p1 + 2) # (2, 7) print(p1 + 5.0) # (7.0, 12.0) # TypeError: Не могу добавить к print(p1 + "я строка") 

Проверка типа (класса) передаваемых аргументов полезна также и в прочих (не специальных) методах, и позволяет обезопасить себя от недопустимых (или нежелательных) операций с классом.

10.1.2.6. Атрибуты объекта и атрибуты класса¶

Реализованные ранее члены класса принадлежат объекту, т.е. получить к ним доступ можно только предварительно создав экземпляр класса (англ. Instance Methods). В ряде случаев существует необходимость иметь поле или метод, доступный через имя самого класса (например, для атрибутов, относящихся ко всему классу целиком, а не конкретному экземпляру).

В Python для этого предназначены:

поля и методы класса (англ. Class Methods):

Методы класса принимают в качестве первого параметра cls (вместо self в обычных методах) — класс, на котором был вызван метод. Данный тип методов может использоваться, когда не требуется привязка к экземпляру объекта, но при этом нужно иметь информацию о классе, на котором он был вызван (например, дополнительные методы инициализации). Поля класса указываются без указания self . Методы класса обозначаются декоратором @classmethod .

Статические методы ничего не знают о классе или об объекте, на котором они вызываются, просто принимая параметры без какого-либо специального аргумента типа self и могут быть вызваны, как через сам класс, так и через его экземпляр. Данный тип методов может использоваться, когда функция логически принадлежит классу, но не использует сам объект или класс при выполнении. Статические методы обозначаются декоратором @staticmethod .

Декораторы не рассматриваются отдельно в настоящем курсе. См.: https://habrahabr.ru/post/141411/.

Пример использования переменных и методов класса, а также статических методов приведен в Листинге 10.1.10:

• переменная класса instances_count : хранение количество созданных точек;
• статический метод sum() : сложение произвольного количество точек;
• метод класса from_string() : создание точки из строки вида ‘x, y’ .

Листинг 10.1.10 — Атрибуты и методы класса | скачать ¶

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111

class Point2D: """Точка на плоскости.""" # Поле класса (доступна без создания экземпляра) # Хранит количество экземпляров класса и является общей (!) # для всех объектов этого класса instances_count = 0 def __init__(self, x, y): self.x = x self.y = y # При инициализации нового класса увеличиваем количество # созданных экземпляров Point2D.instances_count += 1 def __str__(self): """Вернуть строку в виде 'Точка 2D (x, y)'.""" return 'Точка 2D (<>, <>)'.format(self.x, self.y) def __add__(self, other): """Сложить self и other. Параметры: - other (Point2D): вернуть новый объект-сумму; - other (int, float): сдвинуть точку на other по x и y; - other (другой тип): возбудить исключение TypeError. """ if isinstance(other, self.__class__): # Точка с точкой # Возвращаем новый объект! return Point2D(self.x + other.x, self.y + other.y) elif isinstance(other, (int, float)): # Точка и число # Добавим к обеим координатам self число other и вернем результат # Возвращаем старый, измененный, объект! self.x += other self.y += other return self else: # В противном случае сгенерируем исключение raise TypeError("Не могу добавить  к ". format(self.__class__, type(other))) def __sub__(self, other): """Создать новый объект как разность координат self и other.""" return Point2D(self.x - other.x, self.y - other.y) def __neg__(self): """Вернуть новый объект, инвертировав координаты.""" return Point2D(-self.x, -self.y) def __eq__(self, other): """Вернуть ответ, являются ли точки одинаковыми.""" return self.x == other.x and self.y == other.y def __ne__(self, other): """Вернуть ответ, являются ли точки разными. Используем реализованную операцию ==.""" return not (self == other) @staticmethod def sum(*points): """Вернуть сумму точек 'points' как новый объект. Статический метод: принадлежит классу, но ничего о нем не знает. """ assert len(points) > 0, "Количество суммируемых точек = 0!" res = points[0] for point in points[1:]: res += point return res @classmethod def from_string(cls, str_value): """Создать экземпляр класса из строки 'str_value'. Классовый метод, доступен для вызова как: Point2D.from_string(. ) Параметры: - cls: ссылка на класс (Point2D); - str_value: строка вида "float, float". Результат: - Экземпляр класса cls (Point2D). """ values = [float(x) for x in str_value.split(',')] assert len(values) == 2 return cls(*values) if __name__ == "__main__": p1 = Point2D(0, 5) p2 = Point2D(-5, 10) # Создаем 3-ю точку через метод класса p3 = Point2D.from_string("5, 6") print(p1 + p3) # Точка 2D (5.0, 11.0) # Отображаем количество созданных точек через переменную класса print(Point2D.instances_count) # 4 (p1, p2, p3, p1 + p2) # Сложение точек через статический метод p4 = Point2D.sum(p1, p2, p3, Point2D(0, -21)) print(p4) # Точка 2D (0.0, 0.0) 

10.1.3. Инкапсуляция¶

В ряде языков, например, С++, существует четкое разделение членов класса на закрытые, защищенные и публичные.

В Python все члены класса являются общедоступными, хотя существует возможность эмуляции закрытых. Концепция отсутствия закрытых атрибутов в Python описывается фразой одного из разработчиков языка: «Мы все взрослые люди. Если программист хочет выстрелить себе в ногу — нужно предоставить ему возможность это сделать».

Несмотря на это, в Python принята следующая конвенция:

Атрибут, который должен быть не общедоступным (англ. Non-Public) обозначается при помощи ведущего подчеркивания _ :

Пример: _spam для поля или _get_count() для метода. Данный синтаксис указывает на то, что атрибут:

• используется для внутренней реализации класса и не предназначен для использования извне;
• должен быть использован/изменен только если разработчик-пользователь класса абсолютно уверен в этом.

При этом атрибут с _ доступен извне, как и обычный public-атрибут класса.

Пример: __spam для поля или __get_count() для метода. Данный синтаксис указывает на то, что атрибут:

• используется для внутренней реализации класса и не предназначен для использования извне;
• не должен быть использован/изменен разработчиком-пользователем класса.

При этом атрибут с __ оказывается недоступным извне, используя технику сокрытия имен (англ. Name Mangling). Несмотря на это, в отличие от ряда языков (например, Java) такие «закрытые» члены класса также можно изменять, но более сложным способом — их можно увидеть, используя функцию dir() .

10.1.3.1. Свойства¶

Организация доступа к членам класса в Python построена на принципе универсального доступа, гласящем, что «все услуги, предлагаемые модулем должны быть доступны через единую нотацию, которая не раскрывает, реализованы ли они посредством хранения либо вычисления».

В частности, это предполагает:

• предоставлять доступ к переменным напрямую, например, foo.x = 0 , а не foo.set_x(0) ;
• в случае необходимости проверки устанавливаемого значения использовать свойства, которые сохраняют единый синтаксис доступа, установка значения foo.x = 0 приводит к вызову foo.set_x(0) .

Преимуществом данного подхода является возможность использование синтаксиса foo.x += 1 , хотя на самом деле внутри происходит вызов foo.set_x(foo.get_x() + 1) .

Методы вида set_. и get_. называются сеттерами и геттерами (англ. Setter и Getter) и предназначены для «защищенных» установки и чтения значений атрибутов (т.е. прежде чем произойдет изменение атрибута код метода может выполнить какие-либо проверки). Данный подход используется в языках, в которых отсутствуют свойства.

Свойство (англ. Property) — специальный атрибут класса, имитирующий поле (но который при чтении вызывает какой-либо метод).

Вернемся к примеру реализации окружности из начала темы и рассмотрим возможности инкапсуляции для предоставления выборочного доступа к данным извне.

В Листинге 10.1.11 приведен пример простой реализации объекта Circle .

Листинг 10.1.11 — Простая реализация класса окружности | скачать ¶

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

import math class Circle: """Окружность.""" def __init__(self, x=0, y=0, r=0): self.x = x self.y = y self.r = r def length(self): """Вернуть длину окружности.""" return 2 * math.pi * self.r def square(self): """Вернуть площадь окружности.""" return math.pi * self.r**2 def __str__(self): return "Окружность ( ; ) радиус= ".format(self) if __name__ == "__main__": c = Circle(3, 4, 1) print(c) # Окружность (3; 4) радиус=1 print(c.length(), c.square()) # 6.283185307179586 3.141592653589793 

В приведенной реализации все атрибуты общедоступны и имеется проблема возможности указания напрямую отрицательного радиуса. Один из вариантов — добавить сеттеры и геттеры для радиуса, а сам радиус обозначить как не общедоступный атрибут (Листинг 10.1.12).

Листинг 10.1.12 — Использование сеттера и геттера для «защиты» атрибута радиуса | скачать ¶

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

import math class Circle: """Окружность.""" def __init__(self, x=0, y=0, r=0): self.x = x self.y = y # Радиус self._r устанавливается через метод-сеттер set_r(), # который проверяет устанавливаемое значение self.set_r(r)  def length(self): """Вернуть длину окружности.""" return 2 * math.pi * self._r  def square(self): """Вернуть площадь окружности.""" return math.pi * self._r**2  def get_r(self):  """Вернуть радиус."""  return self._r  def set_r(self, r):  """Установить радиус в значение 'r'."""  # Устаналиваем только положительный радиус  assert r > 0, "Радиус должен быть положительным!"  self._r = r  def __str__(self): return "Окружность ( ; ) радиус= ".format(self)  if __name__ == "__main__": c = Circle(3, 4, 1) print(c) # Окружность (3; 4) радиус=1 print(c.length(), c.square()) # 6.283185307179586 3.141592653589793 c.set_r(-1) # AssertionError: Радиус должен быть положительным! 

Теперь предполагается, что пользователь класса будет вызывать методы set_r() и get_r() для установки и получения значения радиуса соответственно. Данный подход обычно используется в языках, где отсутствует поддержка свойств по умолчанию (например, С++), для Python же такое решение громоздко и не соответствует принципу универсального доступа.

Используя свойства, аналогичная функциональность будет выглядеть более лаконично (Листинг 10.1.13).

Листинг 10.1.13 — Использование свойств для ограничения доступа к радиусу | скачать ¶

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

import math class Circle: """Окружность.""" def __init__(self, x=0, y=0, r=0): self.x = x self.y = y self.r = r  def length(self): """Вернуть длину окружности.""" return 2 * math.pi * self.r  def square(self): """Вернуть площадь окружности.""" return math.pi * self.r**2  @property  def r(self):  # Определение свойства 'r': возвращает 'self._r' и позволяет работать с  # радиусом извне, как с обычным атрибутом  return self._r  @r.setter  def r(self, r):  """Установить радиус окружности в 'r'.   Метод может быть опущен, свойство 'r' долно быть доступно только для чтения.  """  assert r > 0, "Радиус должен быть положительным!"  self._r = r  def __str__(self): return "Окружность ( ; ) радиус= ".format(self)  if __name__ == "__main__": c = Circle(3, 4, 1) c.r *= 5 # Увеличили радиус в 5 раз  print(c) # Окружность (3; 4) радиус=5 print(c.length(), c.square()) # 6.283185307179586 3.141592653589793 c.r = -1 # AssertionError: Радиус должен быть положительным! 

Свойство определяется при помощи декораторов:

• @property : определяет метод получения значения;
• @r.setter : определяет метод установки значения свойства r .

Имя свойства r определяется в наименовании обоих методов и декораторе @r.setter . Если необходимо реализовать свойство «только для чтения», второй метод может быть опущен.

10.1.4. Наследование и полиморфизм¶

В Python все классы наследуются от класса object , обладающего некоторыми атрибутами по умолчанию (например, __init__ , __doc__ , __str__ и т.д.).

Дочерние классы могут изменять поведение атрибутов класса-родителя, переопределив (англ. Override) их. При этом, обычно, дочерний класс дополняет родительский метод, добавив свой код после кода родителя (используя функцию super() , предоставляющую ссылку на родительский класс).

Каждый класс также может получить информацию о своих «родителях» через метод __bases__() или isinstance() .

Полиморфизм позволяет интерпретировать любой объект, как экземпляр не только текущего класса, но и любого из его базовых классов. В компилируемых языках программирования полиморфизм достигается за счет создания виртуальных методов, которые в отличие от невиртуальных можно перегрузить в классе-потомке. В Python все методы являются виртуальными и, соответственно, доступными для перезагрузки.

Повторное использование кода существует в двух видах:

1. Наследование (отношение «является»);
2. Модель включения/делегации (отношение «имеет»).

10.1.4.1. Отношение: «является»¶

Предположим, существует телефонная компания, хранящая данные о своих клиентах.

Для простого учета используется класс Customer (Клиент), содержащий атрибуты:

• поле name : имя клиента (чтение/запись);
• свойство balance : баланс счета клиента (только чтение);
• метод record_payment() : выполняет пополнение баланса;
• метод record_call() : выполняет обработку звонка клиента в зависимости от:

• типа звонка: «городской» (5 руб./мин.) и «мобильный» (1 руб./мин.);
• количества минут разговора.

Код класса приведен в Листинге 10.1.14.

Листинг 10.1.14 — Класс, представляющий клиента телефонной компании | скачать ¶

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

class Customer: """Клиент телефонной компании.""" def __init__(self, name, balance=0): self.name = name self._balance = balance def __str__(self): return "Клиент \"<>\". Баланс: <> руб.".format(self.name, self.balance) @property def balance(self): """Вернуть баланс клиента. Свойство 'balance' доступно только для чтения: давать доступ на изменение его напрямую было бы неправильно.""" return self._balance def record_payment(self, amount_paid): """Пополнить баланс клиента на 'amount_paid' руб.""" assert amount_paid > 0, "Сумма пополнения должна быть > 0!" self._balance += amount_paid def record_call(self, call_type, minutes): """Списать стоимость звонка с баланса клиента. Параметры: - call_type (str): тип звонка: "Г": городской; "М": мобильный; - minutes (float): количество минут разговора. """ # В реальности, эти значения могут читаться из базы данных if call_type == "Г": self._balance -= minutes * 5 elif call_type == "М": self._balance -= minutes * 1 if __name__ == "__main__": ivan = Customer("Иван Петров") elena = Customer("Елена Миронова", 100) ivan.record_call("Г", 20) ivan.record_call("М", 5) elena.record_call("М", 10) ivan.record_payment(155) # Пополнили телефон на 155 руб. print(ivan) # Клиент "Иван Петров". Баланс: 50 руб. print(elena) # Клиент "Елена Миронова". Баланс: 90 руб. 

Расширим возможности компании, добавив наличие у клиента тарифного плана, в каждом из которых есть тип звонка («городской» и «мобильный»):

• Повременный : «городской» (5 руб./мин.) и «мобильный» (1 руб./мин.);
• После10МинутВ2РазаДешевле : после 10 минут звонка на городской номер каждая вторая минута бесплатно; в остальном как Повременный ;
• ПлатиМеньшеДо5Минут : до 5 минут разговора в 2 раза дешевле тарифа Повременный , после — в 2 раза дороже.

Одним из вариантов реализации может быть добавление строкового поля call_plan и расширение существующего условия списывания средств в методе record_call() (Листинг 10.1.15).

Листинг 10.1.15 — Добавление учета тарифного плана в метод record_call | скачать ¶

--- /home/yuri/DATA/Проекты/PythonCourse/python-book-sphinx/docs/source/code/10_01_14.py +++ /home/yuri/DATA/Проекты/PythonCourse/python-book-sphinx/docs/source/code/10_01_15.py @@ -1,12 +1,14 @@ class Customer: """Клиент телефонной компании.""" - def __init__(self, name, balance=0): + def __init__(self, name, balance=0, call_plan="Повременный"): self.name = name self._balance = balance + self.call_plan = call_plan # "Повременный" по умолчанию def __str__(self): - return "Клиент \"<>\". Баланс: <> руб.".format(self.name, self.balance) + return "Клиент \"<>\". Баланс: <> руб. Тариф: \"<>\"". \ + format(self.name, self.balance, self.call_plan) @property def balance(self): @@ -32,22 +34,54 @@ - minutes (float): количество минут разговора. """ # В реальности, эти значения могут читаться из базы данных - if call_type == "Г": - self._balance -= minutes * 5 - elif call_type == "М": - self._balance -= minutes * 1 + if self.call_plan == "Повременный": + # Фиксированная стоимость минуты в зависимости от типа звонка + if call_type == "Г": + self._balance -= minutes * 5 + elif call_type == "М": + self._balance -= minutes * 1 + elif self.call_plan == "После10В2РазаДешевле": + # После 10 минут звонка на городской номер + # каждая вторая минута бесплатно + if call_type == "Г": + if minutes > 10: + bonus_minutes = (minutes - 10) // 2 + else: + bonus_minutes = 0 + self._balance -= (minutes - bonus_minutes) * 5 + elif call_type == "М": + self._balance -= minutes * 1 + + elif self.call_plan == "ПлатиМеньшеДо5Минут": + # До 5 минут разговора в 2 раза дешевле тарифа 'Повременный', + # после - в 2 раза дороже + LIMIT_CHEAP = 5 + if minutes > LIMIT_CHEAP: + cheap_minutes = LIMIT_CHEAP + expensive_minutes = minutes - LIMIT_CHEAP + else: + cheap_minutes = minutes + expensive_minutes = 0 + + if call_type == "Г": + self._balance -= cheap_minutes * 2.5 + expensive_minutes * 10 + elif call_type == "М": + self._balance -= cheap_minutes * 0.5 + expensive_minutes * 2 if __name__ == "__main__": - ivan = Customer("Иван Петров") - elena = Customer("Елена Миронова", 100) + ivan = Customer("Иван Петров", 100) + elena = Customer("Елена Миронова", 100, call_plan="После10В2РазаДешевле") + ekaterina = Customer("Екатерина Ефимова", 100, call_plan="После10В2РазаДешевле") + sergey = Customer("Сергей Васильев", 100, call_plan="ПлатиМеньшеДо5Минут") ivan.record_call("Г", 20) - ivan.record_call("М", 5) - elena.record_call("М", 10) + elena.record_call("Г", 20) + ekaterina.record_call("М", 20) + sergey.record_call("Г", 20) - ivan.record_payment(155) # Пополнили телефон на 155 руб. - - print(ivan) # Клиент "Иван Петров". Баланс: 50 руб. - print(elena) # Клиент "Елена Миронова". Баланс: 90 руб. + print(ivan) # "Иван Петров". Баланс: 0 руб. Тариф: "Повременный" + print(elena) # "Елена Миронова". Баланс: 25 руб. Тариф: "После10В2РазаДешевле" + print(ekaterina) # "Екатерина Ефимова". Баланс: 80 руб. Тариф: "После10В2РазаДешевле" + print(sergey) # "Сергей Васильев". Баланс: -62.5 руб. Тариф: "ПлатиМеньшеДо5Минут" 

Данное решение является неудовлетворительным по нескольким причинам:

1. Резко увеличивается размер условного блока (в т.ч. его вложенность), что приведет к трудностям его поддержки.
2. При появлении новых тарифных планов необходимо будет редактировать уже существующий код, что может привести к ошибкам, в частности, затронув функциональность существующих планов.

Более эффективным в данном случае будет использование принципов наследования и полиморфизма. Унаследовав класс Customer , можно изменить только метод расчета (засчет полиморфизма — переопределить работу метода), а далее использовать новый класс, если клиент использует новый тарифный план (Листинг 10.1.16).

Листинг 10.1.16 — Добавление тарифного плана через наследование класса Customer | скачать ¶

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105

class Customer: """Клиент телефонной компании. Расходы данного клиента ведутся на повременной основе.""" def __init__(self, name, balance=0): self.name = name self._balance = balance def __str__(self): return "Клиент \"<>\". Баланс: <> руб.".format(self.name, self.balance) @property def balance(self): """Вернуть баланс клиента. Свойство 'balance' доступно только для чтения: давать доступ на изменение его напрямую было бы неправильно.""" return self._balance def record_payment(self, amount_paid): """Пополнить баланс клиента на 'amount_paid' руб.""" assert amount_paid > 0, "Сумма пополнения должна быть > 0!" self._balance += amount_paid def record_call(self, call_type, minutes): """Списать стоимость звонка с баланса клиента. Параметры: - call_type (str): тип звонка: "Г": городской; "М": мобильный; - minutes (int): количество минут разговора. """ if call_type == "Г": self._balance -= minutes * 5 elif call_type == "М": self._balance -= minutes * 1 class CustomerFree2ndMinuteAfter10(Customer): """Клиент телефонной компании (потомок Customer). После 10 минут звонка на городской номер каждая вторая минута бесплатно; в остальном как "Повременный". Все атрибуты, что предоставляет Customer, доступны и здесь, достаточно изменить только те, которые должны работать по-другому.""" def record_call(self, call_type, minutes): # Данный метод переопределяет соответствующий метод родителя # Определяем количество бесплатных минут if call_type == "Г" and minutes > 10: bonus_minutes = (minutes - 10) // 2 else: bonus_minutes = 0 # Вызываем родительский метод расчета super().record_call(call_type, minutes - bonus_minutes) class CustomerTwiceCheaperFirst5Minutes(Customer): """Клиент телефонной компании (потомок Customer). До 5 минут разговора в 2 раза дешевле тарифа "Повременный", после - в 2 раза дороже. Все атрибуты, что предоставляет Customer, доступны и здесь, достаточно изменить только те, которые должны работать по-другому.""" def record_call(self, call_type, minutes): # Данный метод переопределяет соответствующий метод родителя LIMIT_CHEAP = 5 if minutes > LIMIT_CHEAP: cheap_minutes = LIMIT_CHEAP expensive_minutes = minutes - LIMIT_CHEAP else: cheap_minutes = minutes expensive_minutes = 0 # Вызываем родительский метод расчета super().record_call(call_type, cheap_minutes / 2 + expensive_minutes * 2) if __name__ == "__main__": ivan = Customer("Иван Петров", 100) # Елена, Екатерина и Сергей теперь экземпляры других классов elena = CustomerFree2ndMinuteAfter10("Елена Миронова", 100) ekaterina = CustomerFree2ndMinuteAfter10("Екатерина Ефимова", 100) sergey = CustomerTwiceCheaperFirst5Minutes("Сергей Васильев", 100) ivan.record_call("Г", 20) elena.record_call("Г", 20) ekaterina.record_call("М", 20) sergey.record_call("Г", 20) print(ivan) # "Иван Петров". Баланс: 0 руб. Тариф: "Повременный" print(elena) # "Елена Миронова". Баланс: 25 руб. Тариф: "После10В2РазаДешевле" print(ekaterina) # "Екатерина Ефимова". Баланс: 80 руб. Тариф: "После10В2РазаДешевле" print(sergey) # "Сергей Васильев". Баланс: -62.5 руб. Тариф: "ПлатиМеньшеДо5Минут" 

В Листинге 10.1.16 был переопределен, метод расчет стоимости звонка record_call() .

За счет свойств наследования и полиморфизма при необходимости добавления нового тарифа в данном случае достаточно объявить новый класс (например, VipClient , в т.ч. унаследовать его не только от Customer , но и других классов) и реализовать только необходимые методы относительно родителя.

С дочерним классом возможно проводить следующие операции:

• добавлять собственные поля и методы; при этом данные изменения не коснутся родительского класса;
• заменять/дополнять реализацию уже существующих родительских атрибутов, переопределяя их.

10.1.4.2. Отношение: «имеет»¶

Другим возможным вариантом решения системы тарифов (и более логичным при решении данной проблемы) будет реализация тарификации по модели «включения/делегации».

Пусть существует 2 общих класса:

• поле name : наименование тарифа (чтение/запись);
• метод record_call() : выполняет обработку звонка клиента в зависимости от:

• типа звонка: «городской» (5 руб./мин.) и «мобильный» (1 руб./мин.);
• количества минут разговора.

Наследники CallPlan (прочие тарифы) будут иметь изменять необходимые атрибуты.

Customer (Клиент): хранит информацию о пользователе и ссылку на тариф:

• поле name : имя клиента (чтение/запись);
• поле call_plan : тариф — ссылка на объекта класса Тариф (чтение/запись);
• свойство balance : баланс счета клиента (только чтение);
• метод record_payment() : выполняет пополнение баланса;
• метод record_call() : выполняет обработку звонка клиента на основании тарифа call_plan .

Алгоритм подсчета стоимости звонка для класса Customer изменится следующим образом:

• расчет стоимости делегируется объекту call_plan ;
• результат (стоимость звонка по тарифу) вычитается из баланса клиента.

В Листинге 10.1.17 (а-в) приведены модули и код соответствующих классов.

Листинг 10.1.17 (а) — Включение/делегация классов в Python: класс CallPlan | скачать ¶

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79

class CallPlan: """Абстрактный класс для всех тарифных планов.""" def __init__(self): self.name = "Абстрактный тариф" def record_call(self, call_type, minutes): """Списать стоимость звонка с баланса клиента. Параметры: - call_type (str): тип звонка: "Г": городской; "М": мобильный; - minutes (float): количество минут разговора. """ # Делегируем расчет стоимости отдельному методу # Так, наследнику достаточно будет переопределить каждый из них, # не меняя общую логику ниже if call_type == "Г": return self.record_call_g(minutes) elif call_type == "М": return self.record_call_m(minutes) else: return 0 def record_call_g(self, minutes): """Вернуть стоимость звонка на городской номер для 'minutes' минут.""" raise NotImplementedError # Должны реализовать дочерние классы def record_call_m(self, minutes): """Вернуть стоимость звонка на мобильный номер для 'minutes' минут.""" raise NotImplementedError # Должны реализовать дочерние классы class CallPlanSimple(CallPlan): def __init__(self): self.name = "Повременный" def record_call_g(self, minutes): return minutes * 5 def record_call_m(self, minutes): return minutes * 1 class CallPlanFree2ndMinuteAfter10(CallPlanSimple): def __init__(self): self.name = "После10В2РазаДешевле" def record_call_g(self, minutes): if minutes > 10: bonus_minutes = (minutes - 10) // 2 else: bonus_minutes = 0 # Вызываем родительский метод расчета return super().record_call_g(minutes - bonus_minutes) class CallPlanTwiceCheaperFirst5Minutes(CallPlanSimple): def __init__(self): self.name = "ПлатиМеньшеДо5Минут" def record_call(self, call_type, minutes): LIMIT_CHEAP = 5 if minutes > LIMIT_CHEAP: cheap_minutes = LIMIT_CHEAP expensive_minutes = minutes - LIMIT_CHEAP else: cheap_minutes = minutes expensive_minutes = 0 # Вызываем родительский метод расчета return super().record_call(call_type, cheap_minutes / 2 + expensive_minutes * 2) 

Листинг 10.1.17 (б) — Включение/делегация классов в Python: класс Customer | скачать ¶

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

from call_plan import CallPlanSimple class Customer: """Клиент телефонной компании.""" def __init__(self, name, balance=0, call_plan=None): self.name = name self._balance = balance self.call_plan = call_plan # Если тарифный план не был указан, используем CallPlanSimple() if self.call_plan is None: self.call_plan = CallPlanSimple() def __str__(self): return "Клиент \"<>\". Баланс: <> руб. Тариф: \"<>\"". \ format(self.name, self.balance, self.call_plan.name) @property def balance(self): """Вернуть баланс клиента. Свойство 'balance' доступно только для чтения: давать доступ на изменение его напрямую было бы неправильно.""" return self._balance def record_payment(self, amount_paid): """Пополнить баланс клиента на 'amount_paid' руб.""" assert amount_paid > 0, "Сумма пополнения должна быть > 0!" self._balance += amount_paid def record_call(self, call_type, minutes): """Списать стоимость звонка с баланса клиента. Параметры: - call_type (str): тип звонка: "Г": городской; "М": мобильный; - minutes (int): количество минут разговора. """ # Делегируем определение стоимости звонка классу call_plan costs = self.call_plan.record_call(call_type, minutes) self._balance -= costs 

Листинг 10.1.17 (в) — Включение/делегация классов в Python: основной модуль | скачать ¶

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

from customer import Customer from call_plan import CallPlanFree2ndMinuteAfter10, CallPlanTwiceCheaperFirst5Minutes if __name__ == "__main__": ivan = Customer("Иван Петров", 100) # 1. Используется тариф по умолчанию ivan.record_call("Г", 20) print(ivan) # Клиент "Иван Петров". Баланс: 0 руб. Тариф: "Повременный" ivan.record_payment(100 - ivan.balance) # Пополнили телефон до 100 руб. # 2. Меняем тариф на CallPlanFree2ndMinuteAfter10 ivan.call_plan = CallPlanFree2ndMinuteAfter10() ivan.record_call("Г", 20) print(ivan) # Клиент "Иван Петров". Баланс: 25 руб. Тариф: "После10В2РазаДешевле" ivan.record_payment(100 - ivan.balance) # Пополнили телефон до 100 руб. # 3. Меняем тариф на CallPlanTwiceCheaperFirst5Minutes ivan.call_plan = CallPlanTwiceCheaperFirst5Minutes() ivan.record_call("Г", 20) print(ivan) # Клиент "Иван Петров". Баланс: -62.5 руб. Тариф: "ПлатиМеньшеДо5Минут" 

Данный пример может быть расширен, например, добавлением журнала звонков, смены тарифа и т.д.

Засчет наследования и полиморфизма также легко осуществляются групповые операции с классами. В Листинге 10.1.18 приведен пример сравнения затрат по тарифам между собой.

Листинг 10.1.18 — Сравнение затрат по тарифам | скачать ¶

from customer import Customer from call_plan import CallPlanSimple, \ CallPlanFree2ndMinuteAfter10, \ CallPlanTwiceCheaperFirst5Minutes if __name__ == "__main__": call_plans = (CallPlanSimple(), CallPlanFree2ndMinuteAfter10(), CallPlanTwiceCheaperFirst5Minutes()) minutes = tuple(range(0, 26, 5)) # 0, 5, 10, 15, 20, 25 мин. # Сравним стоимости звонков для тарифов for call_type in ("Г", "М"): print(" ".format(call_type), end="") # Заголовок - минуты for minute in minutes: print("8d> мин.".format(minute), end="") print() # Подсчет стоимости for call_plan in call_plans: print(" ".format(call_plan.name), end="") for minute in minutes: print("8.2f> руб.".format(call_plan.record_call(call_type, minute)), end="") print() print() # ------------- # Пример вывода: # Г 0 мин. 5 мин. 10 мин. 15 мин. 20 мин. 25 мин. # Повременный 0.00 руб. 25.00 руб. 50.00 руб. 75.00 руб. 100.00 руб. 125.00 руб. # После10В2РазаДешевле 0.00 руб. 25.00 руб. 50.00 руб. 65.00 руб. 75.00 руб. 90.00 руб. # ПлатиМеньшеДо5Минут 0.00 руб. 12.50 руб. 62.50 руб. 112.50 руб. 162.50 руб. 212.50 руб. # М 0 мин. 5 мин. 10 мин. 15 мин. 20 мин. 25 мин. # Повременный 0.00 руб. 5.00 руб. 10.00 руб. 15.00 руб. 20.00 руб. 25.00 руб. # После10В2РазаДешевле 0.00 руб. 5.00 руб. 10.00 руб. 15.00 руб. 20.00 руб. 25.00 руб. # ПлатиМеньшеДо5Минут 0.00 руб. 2.50 руб. 12.50 руб. 22.50 руб. 32.50 руб. 42.50 руб. 

10.1.5. Дополнительные аспекты ООП¶

10.1.5.1. Проектирование иерархии классов и класс object ¶

Объектно-ориентированная парадигма программирования (и, в частности, принцип наследования) подразумевает построение иерархии классов, которая бы в совокупности наиболее эффективным образом решала поставленную задачу.

Одной из наиболее популярных в мире профессиональных нотаций (системы условных обозначений) моделирования в объектно-ориентированном стиле является язык UML (англ. Unified Modeling Language). На Рисунке 10.1.4 приведен пример изображения иерархии классов в данной нотации.

Рисунок 10.1.6 — Диаграмма классов UML ¶

Язык UML позволяет детально смоделировать иерархию классов перед реализацией. В то же время, использование UML для малых проектов может оказаться избыточным, и достаточно простой схемы.

В Python все классы наследуются от класса object , так, для классов из Листинга 10.1.16 иерархия будет выглядеть следующим образом:

object -> Customer -> CustomerFree2ndMinuteAfter10 -> CallPlanTwiceCheaperFirst5Minutes

Встроенные классы Python также имеют свою иерархию, например, для типа bool она выглядит как:

object -> int -> bool

10.1.5.2. Множественное наследование¶

Python поддерживает концепцию множественного наследования, т.е. позволяет создать класс, имеющий нескольких родителей. В данном случае список наследуемых классов перечисляется при объявлении класса (Листинг 10.1.19).

Листинг 10.1.19 — Множественное наследование в Python | скачать ¶

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

class Student: def pass_exam(self): print("Я сдал экзамен!") class Worker: def work(self): print("Работаю. ") class FootballPlayer: def score(self): print("Забил гол!") class StudentWorkerAndFootballPlayer(Student, Worker, FootballPlayer): pass if __name__ == "__main__": s = StudentWorkerAndFootballPlayer() s.pass_exam() # Я сдал экзамен! s.work() # Работаю. s.score() # Забил гол! 

Множественное наследование часто критикуется 10 и зачастую считается признаком неверного анализа и проектирования, поэтому его использование рекомендуется в случае крайней необходимости и оправданности такого решения.

10.1.5.3. Класс как структура данных¶

В ряде случаев бывает полезным иметь структуру, похожую на структуру из языка Си (или запись из Паскаля), позволяющую логически сгруппировать данные. Для этого можно использовать словарь или класс с пустой реализацией (Листинг 10.1.20).

Листинг 10.1.20 — Использование класса в Python как структуры в Си | скачать ¶

class FootballPlayer: pass if __name__ == "__main__": r9 = FootballPlayer() # При присвоении значения несуществующему полю класса Python дополняет класс # Синтаксис похож на словарь, где ключ указывается не в скобках [], а через точку r9.name = "Роналдо" r9.birthday = "18/09/1976" r9.position = "Нападающий" r9.height = 1.83 r9.wc_goals = 15 print(r9.name, r9.birthday, r9.position, r9.height, r9.wc_goals) 

10.1.6. Преимущества и недостатки ООП¶

Объектно-ориентированное программирование как другие парадигмы имеет свои преимущества и недостатки 11.

Преимущества

1. Улучшение производительности разработки ПО.

ООП способствует модульности, расширяемости и повторному использованию кода (за счет аспекта наследования и полиморфизма).

Благодаря модульности, расширяемости и повторному использованию кода его легче поддерживать.
Повторное использование кода позволяет выполнять разработку быстрее, в т.ч. в смежных проектах.

Повторное использование кода также позволяет снизить издержки и сосредоточиться на объектно-ориентированном анализе и проектировании, снижающем общую стоимость ПО.

Ускорение разработки и снижение затрат позволяет уделить больше времени и ресурсов на тестирование ПО.

Недостатки

1. Крутая кривая обучения.

Мышление в ООП-стиле требует определенных навыков, а переход от императивного стиля на взаимодействие объектов может потребовать времени.

Как правило, ООП приводит появлению большего количества кода, нежели в императивном программировании.

ООП-программы чаще выполняются медленнее, т.к. содержат больше кода для выполнения.

Ряд задач могут лучше решаться в императивном, логическом или функциональном стиле, где использование ООП не даст выигрыша.

Sebesta, W.S Concepts of Programming languages. 10E; ISBN 978-0133943023.

Саммерфилд М. Программирование на Python 3. Подробное руководство. — М.: Символ-Плюс, 2009. — 608 с.: ISBN: 978-5-93286-161-5.

Лучано Рамальо. Python. К вершинам мастерства. — М.: ДМК Пресс , 2016. — 768 с.: ISBN: 978-5-97060-384-0, 978-1-491-94600-8.

Python/Учебник Python 3.1

Python — мощный и простой для изучения язык программирования. В нём предоставлены проработанные высокоуровневые структуры данных и простой, но эффективный подход к объектно-ориентированному программированию. Сочетание изящного синтаксиса и динамической типизации, совмещённых с интерпретируемой сущностью, делает Python идеальным языком для написания сценариев и ускоренной разработки приложений в различных сферах и на большинстве платформ.

Интерпретатор Python и разрастающаяся стандартная библиотека находятся в свободном доступе в виде исходников и бинарных файлов для всех основных платформ на официальном сайте Python http://www.python.org и могут распространяться без ограничений. Кроме этого на сайте содержатся дистрибутивы и ссылки на многочисленные модули третьих сторон для языка Python, различные программы и инструменты, а также дополнительная документация.

Интерпретатор Python может быть легко расширен с помощью новых функций и типов данных, написанных на C/C++ (или других языках, к которым можно получить доступ из C). Также Python можно применять как язык расширений для настраиваемых приложений.

Этот учебник неформально представляет читателю основные концепции и возможности языка и системы Python. Полезно держать интерпретатор Python под рукой для получения практического опыта, но при этом все примеры самодостаточны, так что учебник вполне возможно читать вне сети.

Описание стандартных объектов и модулей вы можете найти в справочнике по библиотеке Python. Руководство по языку даёт более формальное описание языка. Перед написанием расширений на C/C++ ознакомьтесь с руководством по расширению и встраиванию в интерпретатор и справочником по Python/C API. Существует также несколько книг, в которых подробно рассмотрен язык Python.

Этот учебник не претендует на звание всеобъемлющего и не описывает каждую особенность Python: он даже не описывает все его часто используемые особенности. Вместо этого он знакомит читателя с наиболее заслуживающими внимания из них и даёт вам представление о стиле и привкусе языка. После прочтения учебника вы сможете писать и читать программы и модули, написанные на Python, и будете готовы узнать больше о различных модулях библиотеки Python, описанных в справочнике по библиотеке Python.

Кроме того, будет нелишним полистать Глоссарий.

Разжигая ваш аппетит ! править

Если вы много работаете за компьютером — то периодически обнаруживаете задачи, которые хотели бы автоматизировать. Например, вы были бы не против ускорить операцию поиска и замены большого количества текстовых файлов, или как-то своеобразно переименовать и отсортировать набор фотографий. Возможно, вам хотелось бы написать небольшую базу данных на заказ, специализированное GUI-приложение или простую игру.

Если вы профессиональный разработчик программных продуктов — вероятно, вы привыкли работать с несколькими библиотеками на C/C++/Java, но находите обычный цикл написания/компиляции/тестирования/перекомпиляции кода чересчур медленным. Возможно, вы пишете набор тестов для такой библиотеки и процесс написания тестирующего кода воспринимается утомительным. Или же вы написали программу, которая должна использовать специальный язык для расширений и не хотите проектировать и разрабатывать полностью новый язык для вашего приложения.

Python — язык, который вам подойдёт.

Вы можете написать шелл-сценарий для Unix или использовать пакетные файлы Windows для некоторых из этих задач, но шелл-сценарии хороши лишь для перемещения файлов и замены текстовых данных — они вряд ли подойдут для написания приложений, снабженных графическим интерфейсом, или для игр. Вы можете написать программу на C/C++/Java, но разработка может занять довольно много времени — даже на то, чтобы получить первый рабочий набросок, его требуется немало. Python — проще в использовании, доступен на операционных системах Windows, Mac OS X и Unix, и поможет сделать работу намного быстрее.

Даже учитывая лёгкость использования, Python — полноценный язык программирования, предлагающий много больше возможностей для структурирования и поддержки крупных программ, чем могут позволить себе шелл-сценарии или пакетные файлы. С другой стороны, Python также предоставляет намного больше информации для отладки ошибок чем C и, будучи сверх-высокоуровневым-языком, имеет встроенные высокоуровневые типы данных — такие, как гибкие массивы и словари. Благодаря наличию обобщённых типов данных Python применим для более широкого круга приложений, чем Awk или даже Perl, и при этом очень многие вещи остаются в языке Python как минимум настолько же простыми, насколько просты в упомянутых языках.

Python позволяет вам разделить вашу программу на модули, которые могут быть заново использованы в других программах на Python. Он поставляется вместе с внушительной коллекцией стандартных модулей, которые вы можете использовать в качестве фундамента ваших программ; или в качестве примеров для того, чтобы начать изучение Python. Многие из этих модулей предоставляют различную полезную функциональность: например, ввод-вывод для файлов, системные вызовы, сокеты, и даже инструменты для создания графического пользовательского интерфейса — например, Tk.

Python — интерпретируемый язык, и это может сохранить вам немало времени при разработке — в компиляции и связывании нет необходимости. Интерпретатор может использоваться в интерактивном режиме, что позволяет легко экспериментировать с возможностями языка, писать программы-однодневки или проверять функции во время разработки программ методом снизу-вверх. И, кроме всего прочего — это удобный настольный калькулятор.

Python даёт возможность писать компактные и удобочитаемые программы. Программы, написанные на Python, отличаются большей краткостью, чем эквиваленты на C, C++ или Java по нескольким причинам:

• высокоуровневые типы данных позволяют вам выражать сложные операции в одной инструкции;
• группировка инструкций выполняется отступами, а не операторными скобками;
• нет необходимости в описании переменных или аргументов.

Python расширяем: если вы знаете, как программировать на C, то вам легко будет добавить к интерпретатору новую встроенную функцию или модуль, либо для выполнения критических операции на максимальной скорости, либо для связывания программы на Python с библиотеками, которые могут быть доступны только в бинарной форме (например, зависящие от поставщика графические библиотеки). Как только вы приобретете соответствующий опыт, вы сможете привязать интерпретатор Python к приложению, написанному на C, чтобы использовать его как язык расширений или командный язык этого приложения.

Кстати, язык назван в честь шоу «Летающий цирк Монти Пайтона» на BBC и не имеет ничего общего с рептилиями. Ссылки на скетчи Монти Пайтона в документации не только позволены, но и приветствуются!

Теперь, когда ваш интерес к Python полностью пробужден, вам наверняка захочется изучить его более детально. В связи с тем, что лучший способ выучить язык — использовать его, автор приглашает вас использовать интерпретатор Python в процессе чтения.

В следующей главе описана механика использования интерпретатора. Это довольно приземленная информация, но она необходима для работы с примерами, которые будут представлены позже.

Остальная часть учебника описывает различные возможности языка и системы Python за счёт примеров — начиная с простых выражений, операторов и типов данных, рассматривая функции и модули, и заканчивая прикосновением к таким продвинутым концепциям как исключения и определённые пользователем [1] классы.

Использование интерпретатора Python править

Запуск интерпретатора править

Интерпретатор Python после установки располагается, обычно, по пути /usr/local/bin/python3.1 — на тех компьютерах, где этот путь доступен. Добавление каталога /usr/local/bin к пути поиска Unix-шелла (переменная PATH) позволит запустить интерпретатор набором команды

прямо из шелла [2] . Поскольку выбор каталога, в котором будет обитать интерпретатор, осуществляется при его установке, то возможны и другие варианты — посоветуйтесь с вашим Python-гуру или системным администратором. (Например, путь /usr/local/python тоже популярен в качестве альтернативного расположения.)

На машинах с ОС Windows, инсталляция Python обычно осуществляется в каталог C:\Python31, но и он может быть изменён во время установки. Чтобы добавить этот каталог к вашему пути поиска, вы можете набрать в окне DOS следующую команду, в ответ на приглашение:

При наборе символа конца файла (Ctrl-D в Unix, Ctrl-Z в Windows) в ответ на основное приглашение интерпретатора, последний будет вынужден закончить работу с нулевым статусом выхода. Если это не сработает — вы можете выйти из интерпретатора путём ввода следующих команд:

import sys; sys.exit() 

Особенности редактирования строк в интерпретаторе не оказываются обычно чересчур сложными. Те, кто установил интерпретатор на машину Unix, потенциально имеют поддержку библиотеки GNU readline, обеспечивающей усовершенствованное интерактивное редактирование и сохранение истории. Самый быстрый, наверное, способ проверить, поддерживается ли расширенное редактирование командной строки, заключается в нажатии Ctrl-P в ответ на первое полученное приглашение Python. Если вы услышите сигнал — значит вам доступно редактирование командной строки — тогда обратитесь к Приложению об Интерактивном редактировании входных данных за описанием клавиш. Если на ваш взгляд ничего не произошло или отобразился символ ^P — редактирование командной строки недоступно — удалять символы из текущей строки возможно будет лишь использованием клавиши Backspace.

Интерпретатор ведёт себя сходно шеллу Unix: если он вызван, когда стандартный ввод привязан к устройству tty — он считывает и выполняет команды в режиме диалога; будучи вызванным с именем файла в качестве параметра или с файлом, назначенным на стандартный ввод — он читает и выполняет сценарий из этого файла.

Другой способ запустить интерпретатор — директива python -c команда [arg] . — при её использовании поочередно выполняются инструкции(-ция) из команды (как при использовании опции -c Unix-шелла). В связи с тем, что инструкции Python часто содержат пробелы или другие специальные для шелла символы, рекомендуется заключать команды полностью в одинарные кавычки.

Некоторые модули Python оказываются полезными при использовании их в качестве сценариев. Они могут быть запущены в этом виде командой python -m модуль [arg] . — таким образом исполняется исходный файл модуля (как произошло бы, если бы вы ввели его полное имя в командной строке).

Обратите внимание на различие между командами python file и python . В последнем случае запросы на ввод из программы, такие как вызов sys.stdin.read() , удовлетворяются из самого файла. Поскольку файл уже был прочитан до конца ещё до начала выполнения программы — символ конца файла будет обнаружен программой незамедлительно. В большинстве случаев (это, чаще всего, и есть те ситуации, которых вы ожидали) вызовы удовлетворяются независимо от того, файл или устройство привязаны к стандартному вводу интерпретатора Python.

$ python3.1 Python 3.1a1 (py3k, Sep 12 2007, 12:21:02) [GCC 3.4.6 20060404 (Red Hat 3.4.6-8)] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> 

>>> the_world_is_flat = 1 >>> if the_world_is_flat: . print("Be careful not to fall off!") . Be careful not to fall off! 

if os.path.isfile('.pythonrc.py'): exec(open('.pythonrc.py').read()) 

import os filename = os.environ.get('PYTHONSTARTUP') if filename and os.path.isfile(filename): exec(open(filename).read()) 

# это первый комментарий SPAM = 1 # а это второй комментарий # . и наконец третий! STRING = "# Это не комментарий." 

>>> 2+2 4 >>> # Это комментарий . 2+2 4 >>> 2+2 # а вот комментарий на одной строке с кодом 4 >>> (50-5*6)/4 5.0 >>> 8/5 # При делении целых чисел дробные части не теряются 1.6000000000000001 

>>> print(8/5) 1.6 

>>> # Деление целых чисел возвращает округлённое к минимальному значение: . 7//3 2 >>> 7//-3 -2 

>>> width = 20 >>> height = 5*9 >>> width * height 900 

>>> x = y = z = 0 # Нулевые x, y и z >>> x 0 >>> y 0 >>> z 0 

>>> # попытка получить доступ к неопределённой переменной . n Traceback (most recent call last): File "", line 1, in module> NameError: name 'n' is not defined 

>>> 3 * 3.75 / 1.5 7.5 >>> 7.0 / 2 3.5 

>>> 1j * 1J (-1+0j) >>> 1j * complex(0, 1) (-1+0j) >>> 3+1j*3 (3+3j) >>> (3+1j)*3 (9+3j) >>> (1+2j)/(1+1j) (1.5+0.5j) 

>>> a=1.5+0.5j >>> a.real 1.5 >>> a.imag 0.5 

>>> a=3.0+4.0j >>> float(a) Traceback (most recent call last): File "", line 1, in ? TypeError: can`t convert complex to float; use abs(z) >>> a.real 3.0 >>> a.imag 4.0 >>> abs(a) # sqrt(a.real**2 + a.imag**2) 5.0 >>> 

>>> tax = 12.5 / 100 >>> price = 100.50 >>> price * tax 12.5625 >>> price + _ 113.0625 >>> round(_, 2) 113.06 >>> 

>>> 'spam eggs' 'spam eggs' >>> 'doesn\'t' "doesn't" >>> "doesn't" "doesn't" >>> '"Yes," he said.' '"Yes," he said.' >>> "\"Yes,\" he said." '"Yes," he said.' >>> '"Isn\'t," she said.' '"Isn\'t," she said.' 

hello = "This is a rather long string containing\n\ several lines of text just as you would do in C.\n\ Note that whitespace at the beginning of the line is\ significant." print(hello) 

This is a rather long string containing several lines of text just as you would do in C. Note that whitespace at the beginning of the line is significant.

hello = r"This is a rather long string containing\n\ several lines of text much as you would do in C." print(hello) 

This is a rather long string containing\n\ several lines of text much as you would do in C.

print(""" Usage: thingy [OPTIONS] -h Display this usage message -H hostname Hostname to connect to """) 

Usage: thingy [OPTIONS] -h Display this usage message -H hostname Hostname to connect to

>>> word = 'Help' + 'A' >>> word 'HelpA' >>> ' + word*5 + '>' '' 

>>> 'str' 'ing' # 'string' >>> 'str'.strip() + 'ing' # 'string' >>> 'str'.strip() 'ing' # File "", line 1, in ? 'str'.strip() 'ing' ^ SyntaxError: invalid syntax 

>>> word[4] 'A' >>> word[0:2] 'He' >>> word[2:4] 'lp' 

>>> word[:2] # Первые два символа 'He' >>> word[2:] # Всё, исключая первые два символа 'lpA' 

>>> word[0] = 'x' Traceback (most recent call last): File "", line 1, in ? TypeError: 'str' object doesn't support item assignment >>> word[:1] = 'Splat' Traceback (most recent call last): File "", line 1, in ? TypeError: 'str' object doesn't support slice assignment 

>>> 'x' + word[1:] 'xelpA' >>> 'Splat' + word[4] 'SplatA' 

>>> word[:2] + word[2:] 'HelpA' >>> word[:3] + word[3:] 'HelpA' 

>>> word[1:100] 'elpA' >>> word[10:] '' >>> word[2:1] '' 

>>> word[-1] # Последний символ 'A' >>> word[-2] # Предпоследний символ 'p' >>> word[-2:] # Последние два символа 'pA' >>> word[:-2] # Всё, кроме последних двух символов 'Hel' 

>>> word[-0] # (поскольку -0 равен 0) 'H' 

>>> word[-100:] 'HelpA' >>> word[-10] # ошибка Traceback (most recent call last): File "", line 1, in ? IndexError: string index out of range 

+---+---+---+---+---+ | H | e | l | p | A | +---+---+---+---+---+ 0 1 2 3 4 5 -5 -4 -3 -2 -1

>>> s = 'supercalifragilisticexpialidocious' >>> len(s) 34 

>>> 'Hello\u0020World !' 'Hello World !' 

>>> a = ['spam', 'eggs', 100, 1234] >>> a ['spam', 'eggs', 100, 1234] 

>>> a[0] 'spam' >>> a[3] 1234 >>> a[-2] 100 >>> a[1:-1] ['eggs', 100] >>> a[:2] + ['bacon', 2*2] ['spam', 'eggs', 'bacon', 4] >>> 3*a[:3] + ['Boo!'] ['spam', 'eggs', 100, 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boo!'] 

>>> a ['spam', 'eggs', 100, 1234] >>> a[2] = a[2] + 23 >>> a ['spam', 'eggs', 123, 1234] 

>>> # Заменим некоторые элементы: . a[0:2] = [1, 12] >>> a [1, 12, 123, 1234] >>> # Удалим немного: . a[0:2] = [] >>> a [123, 1234] >>> # Вставим пару: . a[1:1] = ['bletch', 'xyzzy'] >>> a [123, 'bletch', 'xyzzy', 1234] >>> # Вставим (копию) самого себя в начало >>> a[:0] = a >>> a [123, 'bletch', 'xyzzy', 1234, 123, 'bletch', 'xyzzy', 1234] >>> # Очистка списка: замена всех значений пустым списком >>> a[:] = [] >>> a [] 

>>> a = ['a', 'b', 'c', 'd'] >>> len(a) 4 

>>> q = [2, 3] >>> p = [1, q, 4] >>> len(p) 3 >>> p[1] [2, 3] >>> p[1][0] 2 

>>> p[1].append('xtra') >>> p [1, [2, 3, 'xtra'], 4] 

>>> q [2, 3, 'xtra'] 

>>> # Ряд Фибоначчи: . # сумма двух элементов определяет следущий элемент . a, b = 0, 1 >>> while b  10: . print(b) . a, b = b, a+b . 1 1 2 3 5 8 

>>> i = 256*256 >>> print('Значением i является', i) Значением i является 65536 

>>> a, b = 0, 1 >>> while b  1000: . print(b, end=' ') . a, b = b, a+b . 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 

>>> x = int(input("Введите, пожалуйста, целое число: ")) Введите, пожалуйста, целое число: 42 >>> if x  0: . x = 0 . print('Отрицательное значение, изменено на ноль') . elif x == 0: . print('Ноль') . elif x == 1: . print('Один') . else: . print('Больше') . 

>>> # Измерим несколько строк: . a = ['cat', 'window', 'defenestrate'] >>> for x in a: . print(x, len(x)) . cat 3 window 6 defenestrate 12 

>>> for x in a[:]: # создать срез-копию всего списка . if len(x) > 6: a.insert(0, x) . >>> a ['defenestrate', 'cat', 'window', 'defenestrate'] 

>>> for i in range(5): . print(i) . 0 1 2 3 4 

range(5, 10) от 5 до 9 range(0, 10, 3) 0, 3, 6, 9 range(-10, -100, -30) -10, -40, -70 

>>> a = ['Mary', 'had', 'a', 'little', 'lamb'] >>> for i in range(len(a)): . print(i, a[i]) . 0 Mary 1 had 2 a 3 little 4 lamb 

>>> print(range(10)) range(0, 10) 

>>> list(range(5)) [0, 1, 2, 3, 4] 

>>> for n in range(2, 10): . for x in range(2, int(n ** 0.5) + 1): . if n % x == 0: . print(n, 'равно', x, '*', n//x) . break . else: . print(n, '- простое число') . 2 - простое число 3 - простое число 4 равно 2 * 2 5 - простое число 6 равно 2 * 3 7 - простое число 8 равно 2 * 4 9 равно 3 * 3 

>>> while True: . pass # Ожидание прерывания c клавиатуры (Ctrl+C) в режиме занятости . 

>>> class ParserError(Exception): . pass . >>> try: . import audioop . except ImportError: . pass . 

>>> def initlog(*args): . raise NotImplementedError # Открыть файл для логгинга, если он ещё не открыт . if not logfp: . raise NotImplementedError # Настроить заглушку для логгинга . raise NotImplementedError('Обработчик инициализации лога вызовов') . 

>>> def fib(n): # вывести числа Фибоначчи меньшие (вплоть до) n . """Выводит ряд Фибоначчи, ограниченный числом n.""" . a, b = 0, 1 . while b  n: . print(b, end=' ') . a, b = b, a+b . >>> # Теперь вызовем определенную нами функцию: . fib(2000) 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 

>>> fib function fib at 10042ed0> >>> f = fib >>> f(100) 1 1 2 3 5 8 13 21 34 55 89 

>>> fib(0) >>> print(fib(0)) None 

>>> def fib2(n): # вернуть числа Фибоначчи меньшие (вплоть до) n . """Возвращает список чисел ряда Фибоначчи, ограниченный n.""" . result = [] . a, b = 0, 1 . while b  n: . result.append(b) # см. ниже . a, b = b, a+b . return result . >>> f100 = fib2(100) # вызываем >>> f100 # выводим результат [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] 

def ask_ok(prompt, retries=4, complaint='Yes or no, please!'): while True: ok = input(prompt) if ok in ('y', 'yeah', 'yes', 'yep'): return True if ok in ('n', 'no', 'nop', 'nope'): return False retries = retries - 1 if retries  0: raise IOError('refusenik user') print(complaint) 

i = 5 def f(arg=i): print(arg) i = 6 f() 

def f(a, L=[]): L.append(a) return L print(f(1)) print(f(2)) print(f(3)) 

[1] [1, 2] [1, 2, 3] 

def f(a, L=None): if L is None: L = [] L.append(a) return L 

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'): print("-- This parrot wouldn't", action, end=' ') print("if you put", voltage, "volts through it.") print("-- Lovely plumage, the", type) print("-- It's", state, "!") 

parrot(1000) parrot(action='VOOOOOM', voltage=1000000) parrot('a thousand', state='pushing up the daisies') parrot('a million', 'bereft of life', 'jump') 

parrot() # пропущен требуемый аргумент parrot(voltage=5.0, 'dead') # позиционный параметр вслед за именованным parrot(110, voltage=220) # повторное значение параметра parrot(actor='John Cleese') # неизвестное имя параметра 

>>> def function(a): . pass . >>> function(0, a=0) Traceback (most recent call last): File "", line 1, in ? TypeError: function() got multiple values for keyword argument 'a' 

def cheeseshop(kind, *arguments, **keywords): print("-- Do you have any", kind, "?") print("-- I'm sorry, we're all out of", kind) for arg in arguments: print(arg) print("-" * 40) keys = sorted(keywords.keys()) for kw in keys: print(kw, ":", keywords[kw]) 

cheeseshop('Limburger', "It's very runny, sir.", "It's really very, VERY runny, sir.", client="John Cleese", shopkeeper="Michael Palin", sketch="Cheese Shop Sketch") 

def write_multiple_items(file, separator, *args): file.write(separator.join(args)) 

>>> def concat(*args, sep="/"): . return sep.join(args) . >>> concat("earth", "mars", "venus") 'earth/mars/venus' >>> concat("earth", "mars", "venus", sep=".") 'earth.mars.venus' 

>>> list(range(3, 6)) # обычный вызов с отдельными параметрами [3, 4, 5] >>> args = [3, 6] >>> list(range(*args)) # вызов с распакованными из списка параметрами [3, 4, 5] 

>>> def parrot(voltage, state='a stiff', action='voom'): . print("-- This parrot wouldn't", action, end=' ') . print("if you put", voltage, "volts through it.", end=' ') . print("It's", state, "!") . >>> d = "voltage": "four million", "state": "bleedin' demised", "action": "VOOM"> >>> parrot(**d) -- This parrot wouldn't VOOM if you put four million volts through it. It's bleedin' demised ! 

>>> def make_incrementor(n): . return lambda x: x + n . >>> f = make_incrementor(42) >>> f(0) 42 >>> f(1) 43 

>>> def my_function(): . """Не делаем ничего, но документируем. . . Нет, правда, эта функция ничего не делает. . """ . pass . >>> print(my_function.__doc__) Не делаем ничего, но документируем. Нет, правда, эта функция ничего не делает. 

>>> a = [66.25, 333, 333, 1, 1234.5] >>> print(a.count(333), a.count(66.25), a.count('x')) 2 1 0 >>> a.insert(2, -1) >>> a.append(333) >>> a [66.25, 333, -1, 333, 1, 1234.5, 333] >>> a.index(333) 1 >>> a.remove(333) >>> a [66.25, -1, 333, 1, 1234.5, 333] >>> a.reverse() >>> a [333, 1234.5, 1, 333, -1, 66.25] >>> a.sort() >>> a [-1, 1, 66.25, 333, 333, 1234.5] 

>>> stack = [3, 4, 5] >>> stack.append(6) >>> stack.append(7) >>> stack [3, 4, 5, 6, 7] >>> stack.pop() 7 >>> stack [3, 4, 5, 6] >>> stack.pop() 6 >>> stack.pop() 5 >>> stack [3, 4] 

>>> queue = ["Eric", "John", "Michael"] >>> queue.append("Terry") # Прибыл Terry >>> queue.append("Graham") # Прибыл Graham >>> queue.pop(0) 'Eric' >>> queue.pop(0) 'John' >>> queue ['Michael', 'Terry', 'Graham'] 

>>> vec = [2, 4, 6] >>> [3*x for x in vec] [6, 12, 18] 

>>> [[x, x**2] for x in vec] [[2, 4], [4, 16], [6, 36]] 

>>> freshfruit = [' banana', ' loganberry ', 'passion fruit '] >>> [weapon.strip() for weapon in freshfruit] ['banana', 'loganberry', 'passion fruit'] 

>>> [3*x for x in vec if x > 3] [12, 18] >>> [3*x for x in vec if x  2] [] 

>>> [x, x**2 for x in vec] # ошибка - для кортежей необходимы скобки File "", line 1, in ? [x, x**2 for x in vec] ^ SyntaxError: invalid syntax >>> [(x, x**2) for x in vec] [(2, 4), (4, 16), (6, 36)] 

>>> vec1 = [2, 4, 6] >>> vec2 = [4, 3, -9] >>> [x*y for x in vec1 for y in vec2] [8, 6, -18, 16, 12, -36, 24, 18, -54] >>> [x+y for x in vec1 for y in vec2] [6, 5, -7, 8, 7, -5, 10, 9, -3] >>> [vec1[i]*vec2[i] for i in range(len(vec1))] [8, 12, -54] 

>>> [str(round(355/113, i)) for i in range(1, 6)] ['3.1', '3.14', '3.142', '3.1416', '3.14159'] 

>>> mat = [ . [1, 2, 3], . [4, 5, 6], . [7, 8, 9], . ] 

>>> print([[row[i] for row in mat] for i in [0, 1, 2]]) [[1, 4, 7], [2, 5, 8], [3, 6, 9]] 

for i in [0, 1, 2]: for row in mat: print(row[i], end="") print() 

>>> list(zip(*mat)) [(1, 4, 7), (2, 5, 8), (3, 6, 9)] 

c=[[sum(x*y for x,y in zip(i,j)) for j in zip(*b)] for i in a] 

a=[[0]*i+[1]+[0]*(n-i-1) for i in range(n)] 

>>> a = [-1, 1, 66.25, 333, 333, 1234.5] >>> del a[0] >>> a [1, 66.25, 333, 333, 1234.5] >>> del a[2:4] >>> a [1, 66.25, 1234.5] >>> del a[:] >>> a [] 

>>> del a