Чаплыгин А. Н.

Учимся программировать вместе с

Питоном (Start with Python)
L1: [Link]
L1: Следующая
>>> help(datetime) документация
Двойной клик по этой кнопке выдаст следующую автоматически
подсказку создается из
The following documentation is automatically generated from the Python исходных файлов
source files. It may be incomplete, incorrect or include features that Python. Он может
are considered implementation detail and may vary between Python быть неполным,
implementations. When in doubt, consult the module reference at the неправильным или
location listed above. включать функции,
которые считаются
>>> import datetime деталями
>>> [Link]() реализации и могут
[Link](2022, 7, 1) различаться в
разных
>>> import time реализациях
>>> [Link](“%I:%M”) Python. Если вы
'11:55' сомневаетесь,
обратитесь к
справочнику
модуля в
указанном выше
месте
import datetime import datetime
print ([Link]()) print([Link]().day)
2022-07-01 print([Link]().month)
print([Link]().year)
1
7
2022
>>> import time import time
>>> [Link]('%I:%M') print ([Link]('%I:%M'))
'04:52' print ([Link]("%A %p"))
>>> [Link]("%A %p") 04:56
'Friday PM' Friday PM

Преобразование типов
>>> int(3.99999) >>> float(32) >>> str(32)
3 32.0 '32'
>>> int(-2.3) >>> float("3.14159") >>> str(3.14149)
-2 3.14159 '3.14149'
>>> str()
''

L1: Встроенные типы данных

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

Узнать тип любого объекта можно с помощью встроенной функции type().

Числовые литералы можно записать в системах счисления с основанием 8, 10 или 16: # В этих
литералах записано число 10
print (10, 012, 0xA, 10L)
Набор операций над числами - достаточно стандартный как по семантике, так и по
обозначениям:
>>> print (1 + 1, 3 - 2, 2*2, 7/4, 5%3)
21412
>>> print (2L ** 1000)
107150860718626732094842504906000181056140481170553360744375038
837035105112493612249319837881569585812759467291755314682518714
528569231404359845775746985748039345677748242309854210746050623
711418779541821530464749835819412673987675591655439460770629145
71196477686542167660429831652624386837205668069376
>>> print (3 < 4 < 6, 3 >= 5, 4 == 4, 4 != 4) # сравнения
True False True False
>>> print (1 << 8, 4 >> 2, ~4) # побитовые сдвиги и инверсия
256 1 -5
>>> for i, j in (0, 0), (0, 1), (1, 0), (1, 1):
... print (i, j, ":", i & j, i | j, i ^ j) # побитовые операции .
00:000
01:011
10:011
11:110
Переменные
>>> message = "Hello world!" >>> print message >>> type(message)
>>> n = 12 Hello world! <type 'str'>
>>> pi = 3.14159 >>> print (n) >>> type(n)
12 <type 'int'>
>>> print (pi) >>> type(pi)
3.14159 <type 'float'>
Как любой другой язык программирования Питон поддерживает концепцию переменных, но с небольшим
отличием. Если в языках C++ или Pascal переменная – это имя ячейки памяти, в которой хранится значение,
то в Питоне переменная – это ссылка на ячейку
памяти.
>>> message = "Hello world!" При этом значение 12 хранится в памяти только
>>> n = 12 один раз – Питон довольно экономно расходует
>>> type(message) память.
<type 'str'>
>>> message = n
>>> print (message)
12
>>> type(message)
<type 'int'> Как видно из примера, переменная message после
присваивания ей значения n поменяла свой тип.
Далеко не каждый язык програм-мирования
«умеет» это делать так просто.

Имена переменных и ключевые слова

Всего в Питоне версии 2.3. зарезервировано 29 ключевых слов:
and del for is raise assert elif from lambda return break else global not try class except if or while continue exec
import pass yield def finally in print
При составлении имен переменных в Питоне можно использовать любые латинские
буквы, цифры и знак _ (знак подчеркивания). Интерпретатор различает большие и маленькие буквы.
L1: Имя может начинаться с латинской >>> import keyword
буквы (любого регистра) или >>> [Link]
подчеркивания, а дальше допустимо ['and', 'assert', 'break', 'class',
'continue', 'def', 'del', 'elif', 'else',
использование цифр. В качестве
'except', 'exec', 'finally', 'for', 'from',
идентификаторов нельзя применять 'global', 'if', 'import', 'in', 'is',
ключевые слова языка и нежелательно 'lambda', 'not', 'or', 'pass', 'print',
переопределять встроенные имена. Список 'raise', 'return', 'try', 'while', 'yield']
ключевых слов можно узнать так:
Имена, начинающиеся с подчеркивания или двух подчеркиваний, имеют особый смысл. Одиночное
подчеркивание говорит программисту о том, что имя имеет местное применение, и не должно
использоваться за пределами модуля. Двойным подчеркиванием в начале и в конце обычно наделяются
специальные имена атрибутов - об этом будет говориться в лекции по объектно-ориентированному
программированию.
В каждой точке программы интерпретатор "видит" три пространства имен: локальное, глобальное и
встроенное. Пространство имен - отображение из имен в объекты. Для понимания того, как Python
находит значение некоторой переменной, необходимо ввести понятие блока кода. В Python блоком кода
является то, что исполняется как единое целое, например, тело определения функции, класса или модуля.
Локальные имена - имена, которым присвоено значение в данном блоке кода. Глобальные имена -
имена, определяемые на уровне блока кода определения модуля или те, которые явно заданы в операторе
global. Встроенные имена - имена из специального словаря __ builtins __.
Так как переменную можно связать с объектом в любом месте блока, важно, чтобы это произошло до ее
использования, иначе будет возбуждено исключение NameError. Связывание имен со значениями
происходит в операторах присваивания, from, import, в формальных аргументах функций, при
определении функции или класса, во втором параметре части except оператора try-except.
Достаточно придерживаться следующих правил:3
1. Всегда следует связывать переменную со значением (текстуально) до ее использования.
2. Необходимо избегать глобальных переменных и передавать все в качестве параметров. Глобальными
на уровне модуля должны остаться только имена константы, имена классов и функций.
 3. Никогда не следует использовать from модуль import * - это может привести к затенению имен из
других модулей, а внутри определения функции просто запрещено.
Предпочтительнее переделать код, нежели использовать глобальную переменную. Конечно, для
программ, состоящих из одного модуля, это не так важно: ведь все определенные на уровне модуля
переменные глобальны. Убрать связь имени с объектом можно с помощью оператора del. В этом случае,
если объект не имеет других ссылок на него, он будет удален. Для управления памятью в Python
используется подсчет ссылок (reference counting), для удаления наборов объектов с зацикленными
ссылками - сборка мусора (garbage collection).

Операторы и операнды
Значения символов +, -, * и / в Питоне такие же, как в математике. Скобки используются для группировки
операций, а двумя звездочками (**) обозначается операция возведения в степень.
Сложение, вычитание, умножение и возведение в степень работают привычным для нас
способом, но действие операции деления несколько отличается.
>>> minute = 59 >>> minute = 59
>>> minute/60 >>> float(minute) / 60
0 0.983333333333
Значение переменной minute равно 59; результат деления 59 на 60 должен быть0.98333, а не 0. Причиной
этого несоответствия является то, что Питон выполняет целочисленное деление. Если один из операндов
принадлежит типу float, то второй автоматически преобразовывается к этому типу, как к более сложному.

Простейшие операции над строками

Конкатенация или сцепление Операция повторения строки >>> str1 = "hello"+" world"*3
строк. (или итерация). >>> print (str1)
>>> str1 = "Hello" >>> str1 = 'Fun'*3 >>> print (str1)
>>> str2 = " world" >>> print (str1) hello world world world
>>> print (str1 + str2 + FunFunFun
"!")
Hello world!
# L1: Набор операций над строками включает конкатенацию " + ", повтор " * ", форматирование " % ".
>>> "A" + "B"4 'AB' >>> "A"*10 'AAAAAAAAAA' >>> "%s %i" % ("abc", 12)
'abc 12'

Композиция
>>> percentage = 100 * 20 / 80; print (percentage) Скомпонованы две команды в одной
25 строк, разделенные точкой с запятой

Глава 3. Функции (стр.34)

Справочная система
Две функции для вызова справки. Выход из справочной системы осуществляется клавишей [Q].
>>> print (str.__doc__)#вызов справки __doc__ это встроенная переменная
str(object='') -> str (начинается и заканчивается парами
str(bytes_or_buffer[, encoding[, errors]]) -> str символов подчеркивания), в которой обычно
хранится минимальная справочная
Create a new string object from the given object. If encoding информация.
or
errors is specified, then the object must expose a data buffer
that will be decoded using the given encoding and error
handler.
Otherwise, returns the result of object.__str__() (if defined)
or repr(object).
encoding defaults to [Link]().
errors defaults to 'strict'.
 >>> help(str) help(). Данная функция в качестве параметра
Help on class str in module builtins: принимает имя любого объекта (в том числе,
модуля или функции) и выводит справочную
class str(object) информацию о нем.
| str(object='') -> str
| str(bytes_or_buffer[, encoding[, errors]]) -> str
|
| Create a new string object from the given object. If
encoding or
| errors is specified, then the object must expose a data buffer
| that will be decoded using the given encoding and error
handler.
| Otherwise, returns the result of object.__str__() (if defined)
| or repr(object).
| encoding defaults to [Link]().
| errors defaults to 'strict'.

Импорт модулей и математические функции

>>> import math Данная команда импортирует модуль math.Аналогичным способом
>>> подключаются модули (файлы с функциями)

Для начала определим, какие функции и константы определены в модуле math:

>>> dir(math)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2',
'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor',
'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma',
'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh',
'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
>>> print (math.__doc__)
This module provides access to the mathematical functions defined by the C standard.
Примеры применения функции math:
>>> import math >>> import math >>> import math
>>> print >>> height = [Link](45) >>> degrees = 45
([Link]) >>> print (height) >>> angle = degrees * [Link] / 180.0
3.141592653589793 0.8509035245341184 >>> height = [Link](angle)
#Аргумент должен быть в >>> print (height)
радианах, а не в градусах. См. 0.707106781187

Композиция
>>> import math
>>> x = [Link]([Link]([Link](2)/2.0)+[Link]/2)
>>> print (x)
0.70710678118654757
import math x = (-b ± √ (b^2-4ac))/2a.
a = 1 Если дискриминант
b = 0 отрицательный, то возникнет
c = -1
сообщение об ошибке вида:
x1 = (-b + [Link](b**2 - 4*a*c))/(2*a)
ValueError: math domain
x2 = (-b - [Link](b**2 - 4*a*c))/(2*a)
print(x1) error.
print(x2)
1.0
-1.0

Создание функций (стр.40)

Имейте ввиду, что вызывать функцию до ее определения нельзя – это приведет к возникновению
исключения.
def ИМЯ_ФУНКЦИИ(СПИСОК_ПАРАМЕТРОВ): Шаблон для функций
ПОСЛЕДОВАТЕЛЬНОСТЬ_ВЫРАЖЕНИЙ

def printAnything(object): Функция, которой можно передать строку или число.

print (object)
printAnything("Some string")
number = 15
printAnything(number)

Some string
15
import math Функция, у которой аргументом является имя функции,
def printAnything(object): возвращает адрес памяти, где эта функция хранится
print (object)
printAnything(printAnything)

<function printAnything at
0x0000021ED5F00310>
def printHello(): Наверное, вы уже поняли, что сделал Питон, когда мы
print ("Hello!") вызвали функцию runFunction() и передали ей в качестве
def runFunction(function_name): параметра имя функции printHello(): он заменил
function_name()
function_name на значение переданного параметра и вызвал
runFunction(printHello)
таким образом функцию printHello(). Такой гибкостью
Hello! может похвастаться редкий язык программирования. В
языках C++ или Pascal это делается далеко не
тривиальным способом.
import math #Тест «Корни» #Тест «Дистанция»
def printRoots(a,b,c): import math
x1 = (-b + [Link](b**2 -
def distance (x1, y1, x2, y2):
4*a*c))/(2*a)
x2 = (-b - [Link](b**2 - return [Link]((x1-x2)**2 + (y1-y2)**2)
4*a*c))/(2*a) print ('Dist = ',distance (0,0, 1,1))
print('x1 = ',x1) Dist = 1.4142135623730951
print('x2 = ',x2)
printRoots(1,0,-1)
x1 = 1.0
x2 = -1.0

Параметры и аргументы
Параметрами функции называют список переменных, которым присваиваются передаваемые при вызове
этой функции значения. А сами передаваемые значения называют аргументами. В своем теле функция
оперирует параметрами, но не аргументами.
В тестах, что в примерах выше (a, b, c) и (x1, y1, x2, y2) это параметры, а (1,0,-1) и (0,0,
1,1) -аргументы.

Локальные переменные
def printRoots(a, b, c):
D = b**2 - 4 * a * c
В теле функции определено три переменные: D, x1
import math и x2. Такие переменные называют локальными, т.к. к ним можно
x1 = (-b + [Link](D)) / 2 * a
x2 = (-b - [Link](D)) / 2 * a
обратиться только в самом
print 'x1 =', x1, '\nx2 =', x2 теле функции. После завершения работы функции они стираются из
памяти.
def printRoots(a, b, c): def printRoots(a, b, c):
D = b**2 - 4 * a * c D = b**2 - 4 * a * c
import math import math
print ("In function D = ", D) print ("In function D=", D, "Adress:", id(D), D)
x1 = (-b + [Link](D)) / 2 * x1 = (-b + [Link](D)) / 2 * a
a x2 = (-b - [Link](D)) / 2 * a
x2 = (-b - [Link](D)) / 2 * print ("x1 =", x1, "\nx2 =", x2)
a D = 'test'
print ("x1 =", x1, "\nx2 =", print ("Before function call D=", D, "Adress:", id(D), D)
x2) printRoots(1.0, 0, -1.0)
D = 'test' print ("After function call D=", D, "Adress:", id(D), D)
print ("Before function call D = Before function call D= test Adress: 2227572429936 test
", D) In function D= 4.0 Adress: 2227601433136 4.0
printRoots(1.0, 0, -1.0) x1 = 1.0
print ("After function call D = ", x2 = -1.0
D) After function call D= test Adress: 2227572429936 test
Before function call D = test
 In function D = 4.0
x1 = 1.0
x2 = -1.0
After function call D = test
D в основной программе и D в теле функции printRoots() – это две разные переменные.
Проверить это можно, немного модифицировав нашу программу. Воспользуемся функцией id(). Она
возвращает адрес объекта в памяти. Измененная программа будет выглядеть приблизительно так:

from math import sqrt #[Link]

r, x, y = map(float, input('Введите R, X, Y: ').split()) #10 1 1
if (0 < x < r and 0 < y < r) or (-r < x < 0 and -r < y < 0) or \
(-r < x < 0 and 0 < y < r and sqrt((-r - x)**2+(r - y)**2) > r) or \
(0 < x < r and -r < y < 0 and sqrt((r - x)**2 + (-r - y)**2) > r):
print('Точка внутри области')
else:
print('Точка вне области')

Функции, возвращающие результат

>>> def getSum(x,y): def PrintRoots(a, b, c):
... z = x + y D = b**2 - 4 * a * c
... return z import math
... x1 = (-b + [Link](D)) / 2 * a
>>> print x2 = (-b - [Link](D)) / 2 * a
(getSum(1,3)) return x1, x2 #результат выполнения в нескольких переменных
4 print (PrintRoots(1.0, 0, -1.0))
(1.0, -1.0)
# таким же образом значения возвращают и встроенные функции Питона
# Кстати, в Паскале и C++ вернуть из функции сразу несколько значений # с
помощью стандартных средств невозможно. Это еще одно удобство,
# предоставляемое Питоном.

Логические выражения, условия и рекурсия (стр.49)

Обратите внимание, что приоритет операций сравнения меньше приоритета арифметических операций, но
больше, чем у операции присваивания.
>>> x = 2 + 2 >>> print y >>> type(y)
>>> y = x == 5 False <type 'bool'>

Логические операторы
Для объединения простых выражений в более сложные используются логические операторы: and, or и not.
Где оператор not унарный, т.е. он работает только с одним операндом.

Выполнение по условию и «пустота»

def PrintRoots(a, b, c): Обратите внимание на то, что инструкция
D = b**2 - 4 * a * c возвращает не пару значений (0, 0), т.к. с
if D < 0: точки зрения математики, это неверно: корни
return None, None
неопределённы и функция должна вернуть
import math
x1 = (-b + [Link](D)) / 2 * a пустоту. Для этих целей и предусмотрена
x2 = (-b - [Link](D)) / 2 * a встроенная константа None.
return x1, x2
print PrintRoots(3, 2, 1)
(None, None)

Ввод данных с клавиатуры

Самая простая из них –input(). Вызов этой функции останавливает выполнение программы и заставляет
компьютер дождаться, пока пользователь не введет данные с клавиатуры. Завершение ввода осуществляется
нажатием клавиши [Enter]8: сразу после нажатия этой клавиши, функция input() завершается и возвращает
значение введенное с клавиатуры:
print('Как вас зовут?') a = input() #12 a = int(input()) #12
name = input() #счит.строку в name b = input() #23 b = int(input()) #23
print('Здравствуйте, ' + name + s = a + b s = a + b
'!') print(s) print(s)
Здравствуйте, 1234! 1223 #строка 35 #числа
a = float(input("введите первое число: ")) #15.5
b = float(input("введите второе число: ")) #12.3
c = a + b
print("сумма", a, "и", b, "равна", c)
сумма 15.5 и 12.3 равна 27.8
import math
def PrintRoots(a, b, c):
D = b**2 - 4 * a * c
if D < 0:
return None, None
import math
x1 = (-b + [Link](D)) / 2 * a
x2 = (-b - [Link](D)) / 2 * a
return x1, x2

a, b, c = map(float, input('Введите через пробелы A B C ').split())

print(PrintRoots(a, b, c))

Введите через пробелы A B C 1 0 -1

(1.0, -1.0)

§5.6. Альтернативные ветки программы (Chained conditionals)

if ЛОГИЧЕСКОЕ_УСЛОВИЕ_1: Работает эта конструкция следующим образом. Сначала
ПОСЛЕДОВАТЕЛЬНОСТЬ_ВЫРАЖЕНИЙ_1 проверяется первое условие и, если оно истинно, то
elif ЛОГИЧЕСКОЕ_УСЛОВИЕ_2: выполняется первая последовательность выражения. После
ПОСЛЕДОВАТЕЛЬНОСТЬ_ВЫРАЖЕНИЙ_2
этого поток выполнения переходит строке, которая следует
elif ЛОГИЧЕСКОЕ_УСЛОВИЕ_3:
ПОСЛЕДОВАТЕЛЬНОСТЬ_ВЫРАЖЕНИЙ_3 после условного оператора (т.е. за последовательностью
... выражений N). Если первое условие равно False, то
else: проверяется второе условие (следующее после elif), и в
ПОСЛЕДОВАТЕЛЬНОСТЬ_ВЫРАЖЕНИЙ_N случае его истинности выполняется последовательность 2, а
затем снова поток выполнения переходит к строке,
(Chained conditionals – это цепочки следующей за оператором условия. Аналогично
условий.) проверяются все остальные условия. До ветки программы
else поток выполнения доходит только в том случае, если не
выполняется ни одно из условий.
def Compare(x, y): def f1():
if (x > y): pass # эта функция ничего не делает (pass)
return 1 choice = input('Input your choice,please (1 or 2)')
elif (x == y): if choice == "1":
return 0 function1()
else: elif choice == "2":
return -1 function2()
else:
x,y=map(float,input('comp ’).split()) print ("Invalid choice!")
print(Compare(x, y)) print "Thank you."
a = 10 a = 10 # elif - это сокращенный else if.
if a < 0: s = -1 if a < 0: s = -1
elif a == 0: s = 0 else:
else: s = 1 if a == 0: s = 0
print(s) else: s = 1
1 print(s)
1

§5.8. Вложенные условные операторы (Nested conditionals)

if x < -5: def Compare(x):
print ("x is NOT between -5 and 5") if -5 <= x < 5: # после упрощения
else: print ("x is between -5 and 5")
if x < 5: else:
 print ("x is between -5 and 5") print ("x is NOT between -5 and 5")
else: return 0
print ("x is NOT between -5 and 5")
x=float(input("comp "))
Compare(x)
comp 6
x is NOT between -5 and 5

§5.9. Рекурсия
Рекурсивными функциями являются функции, получаемые в результате конечного числа применений
самих себя для целочисленных значений аргумента (параметра). Важно заметить то, что такие функции
применимы лишь к целочисленным значениям, но не к дробным.
>>> def fact(n): def fact(n):
... if n == 0: if type(n) != type(1) or n < 0: # Проверка корректности n
... return 1 return None
... return fact(n- if n == 1 or n == 0:
1)*n return 1
... return fact(n-1)*n
>>> fact(3)
6
Ряд этих чисел def fibonacci(n):
if type(n) != type(1) or n < 0: # Проверка корректности n
образуется следующими
return None
значениями 0, 1, 1, 2, 3, if n == 0:
5, 8, 13, 21, 34, 55 и так return 0
далее – каждое if n == 1 or n == 2:
последующее число ряда return 1
return fibonacci(n-1) + fibonacci(n-2)
получается сложением
двух предыдущих.
Особенностью ряда чисел Фибоначчи является то, что по мере роста номера числа в последовательности,
отношение предшествующего члена к последующему приближается к значению – 0.61812 (древние греки
называли это число ≪золотым сечением≫), а последующего к предыдущему – к 1.618.

Глава 6. Циклы (64)

§6.1. Оператор цикла while
Такие циклы называются циклами с предусловием. Их характерная черта заключается в том, что Условие
повторения цикла проверяется до выполнения его тела. Оператор while говорит интерпретатору Python:
"пока верно условие цикла, выполнять тело цикла ".
while УСЛОВИЕ_ПОВТОРЕНИЯ_ЦИКЛА: correct_choice = False
ТЕЛО_ЦИКЛА while not correct_choice:
choice = input("Enter, please (1 or 2):")
if choice == "1" or choice == "2":
correct_choice = True
else:
print ("Invalid choice! Try again, please.")
print ("Thank you.")
n = int(input("Input n, n = int(input("Input n, please:"))
please:")) sum = 0
sum = i = 0 i = 1
while i <= n: while i <= n:
sum += i**3 sum = sum + i**3 #или короче: sum += i**3
i += 1 i = i + 1 # Аналогично: i += 1
print ("sum = ", sum) print ("sum = ", sum)
Input n, please:4
sum = 100
L1: Для большей гибкости при организации циклов применяются операторы break (прервать) и continue
(продолжить). Первый позволяет прервать цикл, а второй - продолжить цикл, перейдя к следующей
итерации (если, конечно, выполняется условие цикла).
f = open("[Link]", "r") L1: Следующий пример читает строки из файла и выводит те, у
while 1:
которых длина больше 5:
s = [Link]()
if not s: В этом примере организован бесконечный цикл, который
break прерывается только при получении из файла пустой строки
 if len(s) > 5: (s ), что обозначает конец файла.
print (s) В языке Python логическое значение несет каждый объект: нули,
[Link]()
пустые строки и последовательности, специальный объект None
и логический литерал False имеют значение "ложь", а прочие
объекты значение "истина". Для обозначения истины обычно
используется 1 или True.

s = "abcdefghijklmnop" # L1: s = "abcdefghijklmnop" # L1: s = "abcdefghijklmnop" # L1:

while s != "": while s != "": while s != "":
print s print (s) print (s)
s = s[1:-1] s = s[1:] s = s[:-1]
abcdefghijklmnop abcdefghijklmnop abcdefghijklmnop
bcdefghijklmno bcdefghijklmnop abcdefghijklmno
cdefghijklmn cdefghijklmnop abcdefghijklmn
defghijklm defghijklmnop abcdefghijklm
efghijkl efghijklmnop abcdefghijkl
fghijk fghijklmnop abcdefghijk
ghij ghijklmnop abcdefghij
hi hijklmnop abcdefghi
ijklmnop abcdefgh
jklmnop abcdefg
klmnop abcdef
lmnop abcde
mnop abcd
nop abc
op ab
p a

§6.4. Альтернативная ветка цикла while (67)

while УСЛОВИЕ_ПОВТОРЕНИЯ_ЦИКЛА: i = 0
ТЕЛО_ЦИКЛА while i < 3:
else: print i
АЛЬТЕРНАТИВНАЯ_ВЕТКА_ЦИКЛА i += 1
#Надо сказать, что другие языки else:
программирования легко обходятся без print "end of loop"
альтернативных веток в операторах 0
цикла – это приятная, но необязательная 1
2
возможность
end of loop

§6.5. Табулирование функций

import math import math
x = 1.0 x = 1.0
while x < 10.0: while x < 100.0:
print (x, "\t", [Link](x)) print (x, "\t", [Link](x)/[Link](2))
x += 1.0 # "\t" обозначает знак x *= 2.0
табуляции. 1.0 0.0 # Благодаря символу табуляции позиция
1.0 0.0 2.0 1.0 # второй колонки не зависит от ширины
2.0 0.6931471805599453 4.0 2.0 # первой – это хорошо видно на
3.0 1.0986122886681098 8.0 3.0 # последних трех значениях.
4.0 1.3862943611198906 16.0 4.0
5.0 1.6094379124341003 32.0 5.0
6.0 1.791759469228055 64.0 6.0
7.0 1.9459101490553132 #При необходимости вычисления логарифма по
8.0 2.0794415416798357 основанию 2 log 2 x=ln x/ln 2
9.0 2.1972245773362196

§6.6. Специальные и экранируемые символы

Последовательность Назначение
\t Табуляция
\n
 \r Перевод на новую строку
Возврат ≪каретки≫ (курсора) в начало строки

>>> print "Main \\template/" ставится так называемый экранирующий символ: еще одна
Main \template/ косая черта "\".
>>> print "I said: \"Hello world\"" Попробуем экранировать кавычки:
I said: "Hello world"
>>> print 'I said: "Hello world"' Еще один вариант решения проблемы – использование
I said: "Hello world" одинарных кавычек:
print ("Значение переменной n должно быть целым положительным" \
+ " числом,\nпопробуйте еще раз.")
Значение переменной n должно быть целым положительным числом,
попробуйте еще раз.

def fibonacciWithWhileLoop(n):
#"""Функция вычисления чисел Фибоначчи с использованием
#оператора цикла while."""
fn = fn1 = fn2 = 1
i = 3
while i <= n:
fn = fn1 + fn2
fn2 = fn1
fn1 = fn
i += 1
return fn
n=int(input('Число n '))
print(fibonacciWithWhileLoop(n))
Число n 5
5

§6.8. Вложенные операторы цикла и двумерные таблицы

i = 1 for i in range(1, 10): # L1:
while i <= 10: for j in range(1, 10):
j = 1 print ("%3i" % (i*j), end="")
while j <= 10: print()
print (i * j, "\t", end='') 1 2 3 4 5 6 7 8 9
j += 1 2 4 6 8 10 12 14 16 18
print () 3 6 9 12 15 18 21 24 27
i += 1 4 8 12 16 20 24 28 32 36
1 2 3 4 5 6 7 8 9 10 5 10 15 20 25 30 35 40 45
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30 6 12 18 24 30 36 42 48 54
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50 7 14 21 28 35 42 49 56 63
6
7
12
14
18
21
24
28
30
35
36
42
42
49
48
56
54
63
60
70
8 16 24 32 40 48 56 64 72
8
9
16
18
24
27
32
36
40
45
48
54
56
63
64
72
72
81
80
90
9 18 27 36 45 54 63 72 81
10 20 30 40 50 60 70 80 90 100

Вывод в строку из разных print(). Функция print() имеет такие ключевые параметры:
sep= – когда выводится более значений, каким символом или строкой их отделить
(стандартно пробелом, т.е. строкой ' '),
end= – какой символ или строка выводить после вывода (всех) значений
(стандартно переходом на новую строку, т.е. строкой '\n'),
file= – в какой файл выводить значения
(стандартно на экран, т.е. [Link]),
flush= – если поток (сохранен в буфере) немедленно вывести в файл
(стандартно нет, т.е. False).
В вашем случае хотите после вывода значения остаться в той же строке, значит, вы не хотите стандартного
окончания переходом на новую строку (end='\n'), но окончить чем-то другим (пробелом, запятой, и тд.) тоже
нет.
Потому окончите вывод пустой строкой (''):
print('a', end='')
print('b', end='')
print('c')

§6.9. Классификация операторов цикла (74)

Первый тип циклов - циклы с предусловием while, Условие повторения цикла проверяется до выполнения
его тела. Цикла с постусловием в Python нет, т.к. он легко заменяется циклом с предусловием – достаточно
на первой итерации сделать истинным условие повторения цикла.
Второй тип циклов – цикл перебора элементов множества. Такие циклы базируются на концепции
итераторов, о которой мы еще поговорим немного позже. Такой цикл в Питоне выглядит следующим
образом:
for i in range(0,10): Немного позже мы к нему еще вернемся и узнаем на что он способен – по
ТЕЛО_ЦИКЛА гибкости он превосходит обычные арифметические циклы, например, в С типа
for (i = 0; i <= 9; i += 1)
for i in range(1, 10): L1: Здесь циклы for являются вложенными. Функция range() порождает
# L1:
for j in range(1, 10): список целых чисел из полуоткрытого интервала [1, 10). Перед каждой
print ("%3i" % (i*j), итерацией счетчик цикла получает очередное значение из этого списка.
end="") Полуоткрытые диапазоны общеприняты в Python. Считается, что их
print() использование более удобно и вызывает меньше программистских ошибок.
1 2 3 4 5 6 7 8 9
2 4 6 8 10 12 14 16 18 Например, range(len(s)) порождает список индексов для списка s (в Python-
3 6 9 12 15 18 21 24 27 последовательности первый элемент имеет индекс 0 ). Для красивого вывода
4 8 12 16 20 24 28 32 36
5 10 15 20 25 30 35 40 45 таблицы умножения применена операция форматирования % (для целых
6
7
12
14
18
21
24
28
30
35
36
42
42
49
48
56
54
63
чисел тот же символ используется для обозначения операции взятия остатка
8 16 24 32 40 48 56 64 72 от деления). Строка форматирования (задается слева) строится почти как
9 18 27 36 45 54 63 72 81 строка форматирования для printf из C.
Для обратного отсчета может использоваться ключевое слово downto.

§6.10. Управляющие структуры

Настало время оглянуться назад. В первой главе речь шла о том, что высокоуровневые
программы строятся на нескольких видах конструкций. Давайте вспомним их и сопоставим каждую из них
со знаниями приобретенными в пройденных главах. Итак, в высокоуровневые программы строятся на
основе следующих типов операций:
• Ввод данных (пока мы умеем вводить данные только с клавиатуры с помощью
функций input и raw_input);
• Вывод данных (данные мы выводили на экран; вывод производится с помощью
команды print);
• Выполнение некоторых операций над числами, строками или другими объектами
(большинство выражений, в том числе, с использованием функций относятся как раз
к этим операциям);
• Выбор ветви выполнения программы на основе принятого решения (условный
оператор if);
• Повторение группы операций чаще всего с изменением одного или нескольких
параметров (операторы цикла while и for).
Кроме того, в третьей главе мы разобрались с функциями, предоставляющими нам
множество преимуществ, в том числе:
• Любой часто повторяемой последовательности операций мы можем назначить имя и
по нему вызывать ее на выполнение;
• Использование функций упрощает понимание программы и процесс ее отладки: мы
можем отладить каждую функцию по отдельности с предельными значениями
параметров, а затем собрать их в единую систему, устойчивую к ошибкам при вводе
данных пользователем и другим непредвиденным ситуациям;
• Функции позволяют избежать дублирование кода, поэтому изменение хорошо
спроектированной программы требует не так много усилий;
• Хорошо продуманные функции могут использоваться в других проектах, что
повышает нашу производительность и позволяет в полной мере насладиться
процессом решения текущей задачи;
• И, наконец, с помощью рекурсивных функций можно элегантно решать довольно
сложные задачи, и программа при этом будет занимать всего несколько строк.
Итак, первая ступень пройдена: теперь мы владеем вопросами, на основе которых
строится подавляющее большинство приложений – программ, позволяющих решать
повседневные задачи (иногда их называют прикладными программами). В следующих главах мы
продолжим изучать новые возможности Питона и концепции программирования, но самое трудное уже
позади.
Глава 7. Строки (76)
§7.1. Оператор индексирования
Оператор индексирования позволяет получить любой одиночный символ из строки. У него довольно
простой синтаксис, а индекс, указываемый в квадратных скобках, представляет собой порядковый номер
символа в строке, при этом считаются не с нуля:
СТРОКА[ИНДЕКС] >>> 'Hello!'[0] >>> 'Hello!'[1]
'H' 'e'

§7.2. Длина строки и отрицательные индексы

>>> len('Hello >>> a = Функции len() выглядит громоздко, поэтому предусмотрен
world!') 'Hello!'
более короткий вариант записи:
12 >>> a[len(a)-1] >>> a[-1]
'!' '!'
>>> a[-5]
'e'
Таким образом, мы можем индексировать строку с обоих ее концов – это очень удобно.

§7.3. Перебор и цикл for

string = "hello" string = "hello" string = "hello"
i = 0 i = len(string)-1 i = -1
while i < len(string): while i >= 0: while i > -len(string)-1:
letter=string[i] letter=string[i] letter=string[i]
print (letter) print (letter) print (letter)
i = i + 1 i = i – 1 i = i – 1
h o o
e l l
l l l
l e e
o h h
Выполняя упражнение, вы, вероятно, заметили, что в циклах с индексами нетрудно
запутаться. Поэтому в Питоне есть более удобный способ перебора элементов строк (и не
только): цикл for. Наша программа будет выглядеть так:

for letter in string:

print letter
Данный цикл не завершается до тех пор, пока каждый элемент строки string не будет
поочередно присвоен переменной letter, начиная с первого. Такой подход избавляет
программиста от необходимости думать над условием завершения цикла, что позволяет ему
сосредоточиться на решаемой задаче.

§7.4. Срезы строк (78)

В Питоне можно обращаться не только к одиночным символам, но и к целым подстрокам – срезам (по-
английски, slices).
>>> s = "Peter, Paul, and В общем виде: string[n:m], где n указывает индекс начала среза, а m –
Mary" индекс конца среза. При этом начальный и конечный индексы
>>> print (s[0:5])
Peter
разделяются двоеточием. Обратите также внимание, что символ с
>>> print (s[7:11]) индексом m в срез не включается.
Paul Существуют также сокращенные формы оператора построения среза.
>>> print (s[17:21]) Если не указать
Mary начальный или конечный индекс среза то будет подразумеваться
>>> print (s[:5])
начало или конец строки
Peter
>>> print (s[17:])
соответственно:
Mary
print (s[:])
Peter, Paul, and Mary
 >>> print s[::2] Для оператора индексирования можно указать еще и шаг выбора
Ptr al n ay элементов в срез. Получился срез состоящий из элементов с четными
индексами (еслиучитывать, что нумерация начинается с нуля)!

s = "Peter,Paul,Mary" s = "Peter,Paul,Mary" s = "Peter,Paul,Mary"

print(s[:(len(s)-4)]) print(s[::3]) print(s[4:(len(s)-5):2])
Peter,Paul, PePla rPu
#Все символы кроме #Символы с индексами #Все символы строки с четными
последних четырех кратными трем индексами за исключением первых
четырех и последних пяти.

§7.5. Сравнение строк

Заглавная буква считается большей, чем любая строчная.

§7.6. Строки нельзя изменить

Cтроки в Питоне не могут быть изменены частично – строковый тип эту операцию не предусматривает.
Лучшее, что можно сделать – это создать новую строку, которая является измененным оригиналом:
greeting = "Hello, world!" greeting = "Hello, world!"
greeting[0] = 'J' # ERROR! newGreeting = 'J' + greeting[1:]
print (greeting) #не правильно print (newGreeting) # правильно
S = "Hello, world!" Напишите программу, заменяющую 5-й (если
nS = S[:5] + ‘!’ + S[6:] начинать считать по-человечески, т.е. с единицы)
print (nS)
Hello! world!
символ строки Hello, world! на восклицательный
знак.

§7.7. Функция find (80)

def find(str, ch): Возвращает индекс первого вхождения символа в строке. Если
index = 0 символ не найден, то функция возвращает -1.
while index < len(str):
if str[index] == ch:
return index
index = index + 1
return -1
print(find("abcdrfg", "d"))
3
def cena(rub, kop=0): # L1: # L1: В этом примере определена функция двух аргументов (из
return "%3i руб. %2i коп."% (rub, которых второй имеет значение по умолчанию - 0 ). Вариантов
kop) вызова этой функции с конкретными параметрами также
print (cena(8, 50))
print (cena(7)) несколько. Стоит только заметить, что при вызове функции
print (cena(rub=23, kop=70)) сначала должны идти позиционные параметры, а затем,
8 руб. 50 коп. именованные. Аргументы со значениями по умолчанию
7 руб. 0 коп. должны следовать после обычных аргументов. Оператор return
23 руб. 70 коп. возвращает значение функции. Из функции можно возвратить
только один объект , но он может быть кортежем из
нескольких объектов. После оператора def имя cena
оказывается связанным с функциональным объектом

§7.8. Циклы и счётчики (81)

fruit = "banana" def count(str, ch): def count(str, ch):
count = 0 i = cnt = 0 cnt = 0
for char in fruit: while i < len(str): for ch1 in str :
if char == 'a': if str[i] == ch: if (ch == ch1):
count = count+1 cnt += 1 cnt += 1
print (count) i = i + 1 return cnt
return cnt print
print (count("abcdaba", (count("abcdaba","a"))
"a")) 3
3
§7.9. Модуль string
import string Модуль string содержит полезные функции, заметно упрощающие работу со
строками. Как обычно, необходимо сначала импортировать модуль до его
использования:

string = "banana" string = "test test test Во-первых, может искать подстроки, не
print test"
только символы
([Link]("na")) print ([Link]('test'))
2 print ([Link]('test')) Также имеется возможность задать
print дополнительный аргумент, который будет
([Link]('test',3)) определять индекс с которого надо
0 начинать:
15

[Link]
Другие функции и методы строк
При вызове методов необходимо помнить, что строки в Python относятся к категории неизменяемых
последовательностей, то есть все функции и методы могут лишь создавать новую строку. Поэтому все
строковые методы возвращают новую строку, которую потом следует присвоить переменной.
Таблица "Функции и методы строк"
Функция или метод Назначение

S = 'str'; S = "str"; S = '''str'''; S =

Литералы строк
"""str"""

S = "s\np\ta\nbbb" Экранированные последовательности

S = r"C:\temp\new" Неформатированные строки (подавляют экранирование)

S = b"byte" Строка байтов

S1 + S2 Конкатенация (сложение строк)

S1 * 3 Повторение строки

S[i] Обращение по индексу

S[i:j:step] Извлечение среза

len(S) Длина строки

[Link](str, [start],[end]) Поиск подстроки в строке. Возвращает номер первого вхождения или -1

[Link](str, [start],[end]) Поиск подстроки в строке. Возвращает номер последнего вхождения или -1

[Link](str, [start],[end]) Поиск подстроки в строке. Возвращает номер первого вхождения или вызывает V

[Link](str, [start],[end]) Поиск подстроки в строке. Возвращает номер последнего вхождения или вызывае

[Link](шаблон, замена[, maxcount]) Замена шаблона на замену. maxcount ограничивает количество замен

[Link](символ) Разбиение строки по разделителю

[Link]() Состоит ли строка из цифр

[Link]() Состоит ли строка из букв

[Link]() Состоит ли строка из цифр или букв

[Link]() Состоит ли строка из символов в нижнем регистре

[Link]() Состоит ли строка из символов в верхнем регистре

 Состоит ли строка из неотображаемых символов (пробел, символ перевода страни
[Link]() строка" ('\n'), "перевод каретки" ('\r'), "горизонтальная табуляция" ('\t') и "вертикал
табуляция" ('\v'))

[Link]() Начинаются ли слова в строке с заглавной буквы

[Link]() Преобразование строки к верхнему регистру

[Link]() Преобразование строки к нижнему регистру

[Link](str) Начинается ли строка S с шаблона str

[Link](str) Заканчивается ли строка S шаблоном str

[Link](список) Сборка строки из списка с разделителем S

ord(символ) Символ в его код ASCII

chr(число) Код ASCII в символ

[Link]() Переводит первый символ строки в верхний регистр, а все остальные в нижний

[Link](width, [fill]) Возвращает отцентрованную строку, по краям которой стоит символ fill (пробел п

Возвращает количество непересекающихся вхождений подстроки в диапазоне [на

[Link](str, [start],[end])
и длина строки по умолчанию)

Возвращает копию строки, в которой все символы табуляции заменяются одним и

[Link]([tabsize]) несколькими пробелами, в зависимости от текущего столбца. Если TabSize не ука
табуляции полагается равным 8 пробелам

[Link]([chars]) Удаление пробельных символов в начале строки

[Link]([chars]) Удаление пробельных символов в конце строки

[Link]([chars]) Удаление пробельных символов в начале и в конце строки

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

[Link](шаблон) шаблона. Если шаблон не найден, возвращается кортеж, содержащий саму строку
пустых строки

Возвращает кортеж, содержащий часть перед последним шаблоном, сам шаблон,

[Link](sep) шаблона. Если шаблон не найден, возвращается кортеж, содержащий две пустых
саму строку

[Link]() Переводит символы нижнего регистра в верхний, а верхнего – в нижний

[Link]() Первую букву каждого слова переводит в верхний регистр, а все остальные в ниж

[Link](width) Делает длину строки не меньшей width, по необходимости заполняя первые симв

Делает длину строки не меньшей width, по необходимости заполняя последние си

[Link](width, fillchar=" ")
символом fillchar

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

[Link](width, fillchar=" ")
fillchar

[Link](*args, **kwargs) Форматирование строки

Глава 8. Списки (84)

Список – это упорядоченное множество значений, идентифицируемых индексом. Во многом списки схожи
со строками, которые, по сути, являются упорядоченными множествами символов. Отличие списков и строк
заключается в том, что элементы списка могут быть любого типа. Упорядоченные множества называют
последовательностями.
L1: В "чистом" Python нет массивов с произвольным типом lst1 = [1, 2, 3,]
элемента. Вместо них используются списки. Их можно задать с lst2 = [x**2 for x in range(10) i
помощью литералов, записываемых в квадратных скобках, lst3 = list("abcde")
или посредством списковых включений. Варианты задания print ('list1=',lst1)
списка приведены ниже: print ('list2=',lst2)
print ('list3=',lst3)
list1= [1, 2, 3]
list2= [1, 9, 25, 49, 81]
list3= ['a', 'b', 'c', 'd', 'e']
Последовательности
Ниже обобщены основные методы последовательностей. Следует напомнить, что последовательности бывают н
изменчивыми. У последних методов чуть больше.
Неизменчивый тип данных (число, строка, кортеж и т.п.).
Изменчивый тип данных

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

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

Взятие элемента по индексу и срезы >>> s = [0, 1, 2, 3, 4]

Здесь же следует сказать несколько слов об индексировании >>> print (s[0], s[-1], s[3])
последовательностей и выделении подстрок (и вообще – под 0 4 3
последовательностей) по индексам. Для получения отдельного >>> s[2] = -2
элемента последовательности используются квадратные скобки, >>> print s
[0, 1, -2, 3, 4]
в которых стоит выражение, дающее индекс. Индексы
>>> del s[2]
последовательностей в Python начинаются с нуля.
>>> print s
Отрицательные индексы служат для отсчета элементов с конца [0, 1, 3, 4]
последовательности ( -1 - последний элемент). Пример
проясняет дело:
Примечание: Удалять элементы можно только из изменчивых
последовательностей и желательно не делать этого внутри
цикла по последовательности.
Несколько интереснее обстоят дела со срезами. Дело в том, что в Python при взятии среза последовательности п
элементы, а промежутки между ними. Поначалу это кажется необычным, тем не менее, очень удобно для указан
срезов. Перед нулевым (по индексу) элементом последовательности промежуток имеет номер 0, после него - 1 и
значения отсчитывают промежутки с конца строки. Для записи срезов используется следующий синтаксис:
последовательность[нач:кон:шаг]
где нач - промежуток начала среза, кон - конца среза, шаг - шаг.
По умолчанию нач=0, кон=len(последовательность), шаг=1, если шаг не указан, второе двоеточие можно опусти
А теперь пример работы со срезами: А теперь пример работы со >>> s = range(10)
срезами: >>> s
Как видно из этого примера, с помощью срезов удобно задавать [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
любую подстроку, даже если она нулевой длины, как для >>> s[0:3]
удаления элементов, так и для вставки в строго определенное [0, 1, 2]
место. >>> s[-1:]
[9]
>>> s[::3]
[0, 3, 6, 9]
>>> s[0:0] = [-1, -1, -1]
>>> s
[-1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7,
>>> del s[:3]
>>> s
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

§8.1. Создание списков

>>> [10, 20, 30, 40] Существует насколько способов создания списков.
[10, 20, 30, 40] них: перечислить элементы списка через запятую в
>>> ["one", "two", "three"]
скобках,
['one', 'two', 'three']
>>> ["hello", 5, 2.0, [10, 20]] Элементы списков вовсе не обязательно должны бы
['hello', 5, 2.0, [10, 20]] Следующий список содержит строку, целое и дробн
список. Список, являющийся элементом другого сп
вложенным.
>>> range(1,5) Питон предоставляет возможность быстрого создан
[1, 2, 3, 4] значений, без необходимости их перечислять. Функ
>>> range(10)
два целых аргумента и возвращает список, который
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
числа в промежутке между заданными значениями,
for i in range(3, 6): включая первое и исключая второе.
print(i,' ', end='')
3 4 5
Если же range() вызвана с тремя аргументами, то пос
range(1, 10, 2)
интерпретируется как размер шага. Т.е. В результир
[1, 3, 5, 7, 9]
значения будут идти не подряд, а через промежутки
my_list = ['один', 'два', 'три', 'четыре', 'пять'] list_of_ints = list(range(3))
my_list_len = len(my_list) print(list_of_ints)
for i in range(0, my_list_len): [0, 1, 2]
print(my_list[i])
один
два
три
четыре
пять

§8.2. Списки и индексы

numbers = [17, 123, 537] >>> list = ['a', 'b', 'c', 'd', 'e', 'f']
empty = [] >>> list[1:3]
print numbers, empty ['b', 'c']
[17, 123, 537] [] >>> list[:4]
['a', 'b', 'c', 'd']
>>> numbers[0] >>> list[3:]
17 ['d', 'e', 'f']
>>> numbers[-1] >>> list[:]
537 ['a', 'b', 'c', 'd', 'e', 'f']
>>> numbers[1] = 5 Элементы списков (в отличие от символов строк)
>>> numbers
могут меняться.
[17, 5, 537]
>>> numbers[1:] = [6, 7]
>>> numbers
[17, 6, 7]
>>> numbers[0], numbers[2] = 1, 2
>>> numbers
[1, 6, 2]
§8.3. Длина списка (86)
mylist = ['one', 'two', 'three', 'four'] Функция len(mylist)) – длина списка
i = 0
while i < len(mylist):
Если список содержит в качестве элемента другой
if i< (len(mylist)-1): список, то этот вложенный список будет считаться
print(mylist[i],',', end='') как один элемент:
else:
print (mylist[i], end='') mylist = [[1, 'one'], [2, 'two'], [3,
i += 1 'three'], 'four', 5]
one ,two ,three ,four print (len(mylist))
print (len(mylist[0]), ' ', end='')
print (len(mylist[1]), ' ', end='')
print (len(mylist[2]))
5
2 2 2

§8.4. Принадлежность списку

list = [[1, 'one'], [2, Принадлежность элемента последовательности проверяется с
'two'], помощью логического оператора in – с ним мы уже сталкивались в
[3,'three'], 'four',
5] §7.10. Этот оператор замечательно работает и со списками. Как
print('four' in list) видите, в качестве первого операнда оператора in может выступать и
print([1, 'one'] in list) список, и если такой список является элементом второго операнда,
print(6 in list) что результатом выражения станет ≪истина≫ (True).
True
True
False

§8.5. Списки и цикл for

for ПАРАМЕТР_ЦИКЛА in ПОСЛЕДОВАТЕЛЬНОСТЬ: В §7.3 мы уже разобрались, как работает цикл
ТЕЛО_ЦИКЛА for. Со списками он работает также, как и со
for fruit in fruits: строками. Обобщенный синтаксис конструкции
print (fruit) такой:
i = 0 Эквивалентно предыдущей конструкции
while i < len(ПОСЛЕДОВАТЕЛЬНОСТЬ):
ПАРАМЕТР_ЦИКЛА = ПОСЛЕДОВАТЕЛЬНОСТЬ[i]
ТЕЛО_ЦИКЛА
i += 1
for fruit in ["banana","apple","quince"]: for number in range(20):
print ("I like to eat " + fruit + "s!") if number % 2 == 0:
print(number,’ ‘, end='')
I like to eat bananas!
0 2 4 6 8 10 12 14 16 18
I like to eat apples!
I like to eat quinces!

§8.6. Операции над списками

>>> a = [1, 2, 3] >>> [0] * 4
>>> b = [4, 5, 6] [0, 0, 0, 0]
>>> c = a + b >>> [1, 2, 3] * 3
>>> print c [1, 2, 3, 1, 2, 3, 1, 2, 3]
[1, 2, 3, 4, 5, 6]

Глава 9. Кортежи (Тип tuple)(89)

Кортеж, который полностью аналогичен списку за исключением того, что его элементы изменять не
допускается. Но если мы попробуем изменить значение одного из элементов, мы получим ошибку.
>>> tuple = ('a', 'b', 'c', 'd', 'e')
>>> t1 = ('a',)
>>> tuple[0] Операции над кортежами такие же, как и над строками.
'a' Оператор индексирования выбирает элемент из кортежа
>>> tuple[1:3]
('b', 'c')
>>> tuple = ('A',) + tuple[1:] Хотя мы не можем менять элементы кортежа, мы можем
>>> tuple заменить его другим кортежем:
('A', 'b', 'c', 'd', 'e')
# L1: Для представления константной p = (1.2, 3.4, 0.9) # точка в трехмерном
пространстве
последовательности (разнородных) объектов
for s in "one", "two", "three": # цикл по
используется тип кортеж. Литерал кортежа знач.кортежа
обычно записывается в круглых скобках, но print s
можно, если не возникают неоднозначности, one_item = (1,)
писать и без них. Примеры записи кортежей: empty = ()
p1 = 1, 3, 9 # без скобок
p2 = 3, 8, 5, # запятая в конце игнорируется
Использовать синтаксис кортежей можно и в a = 1, 3, 9 # без скобок
b = 3, 8, 5, # запятая в конце игнорируется
левой части оператора присваивания. В этом
a, b = b, a
случае на основе вычисленных справа print (a)
значений формируется кортеж и связывается print (b)
один в один с именами в левой части. (3, 8, 5)
Поэтому обмен значениями записывается (1, 3, 9)
очень изящно:

§9.2. Применение кортежи

При реализации многих алгоритмов возникает необходимость поменять местами значения двух
переменных. В Питоне же имеется форма задания кортежа, которая лаконично решает эту задачу:
>>> a, b = b, Слева кортеж переменных, справа кортеж значений. Каждое значение соответствует
a
своей переменной.
Любая в Питоне функция может возвращать кортеж в качестве результата.

§9.4. Случайные числа

import random В Питоне есть встроенная модуль, который позволяет генерировать
for k in range(0,10):
псевдослучайные числа. Они не истинно случайны, с
for m in range(0,2):
for i in range(1): математической точки зрения, но для наших целей вполне подойдут.
x = [Link]() Чтобы получить случайное число между 0.0 и верхней границей
print (x, "\t", end='') high, просто умножьте x на high.
print ()
0.23953460418943107
0.5415465099710097
0.49506285500539615
0.9324659279435141
0.8576674283146908
0.9285230327290197
0.880932880231142
0.45066732725114056
0.46506991628733474
0.6608486358058879
0.8415924173656739
0.2549732018668637
0.9829544091423222
0.7671488264164276
0.6936455188019173
0.08187733623633797
0.9548996926739971
0.5478077613633483
0.15957001589349573
0.8664711710162215
import random Первым шагом является создание списка случайных величин.
def randomList(n):
randomList принимает
for i in range(n):
s[i] = [Link]() целое число в качестве параметра и возвращает список случайных
return s чисел заданной длины.
n=8 Она начинает выполнятся со списком из n нулей. При каждом
s = [0] * n проходе через цикл она
randomList(8)
for i in range(n):
заменяет один из элементов случайным числом. Возвращаемое
print (s[i]) значение является ссылкой на
0.3176103869949476 полный список
0.8109384774433751
0.27845357046218766
0.8261011767665148
0.34484868954790704
0.9467326845546593
0.41217053722514563
0.8498540012362222

§9.6. Паттерны программирования(92)

import random Гистограмма попадания для
def inBuck(listLow, listHigh, listCnt): выборки случайных чисел
for i in range(num):
if listLow[i] < rr < listHigh[i]:
listCnt[i] += 1
#------------------------
num = 8
buckLow = [0] * num # Созд.списка Low
buckHigh = [0] * num # Созд.списка High
buckCnt = [0] * num # Созд.списка Cnt
buckWidth = 1.0 / num
low = high = numCnt = 0
for i in range(num):
low = high
buckLow[i] = low
high += buckWidth
buckHigh[i] = high
print (buckLow)
print (buckHigh)
for i in range(10000):
rr = [Link]()
inBuck(buckLow, buckHigh, buckCnt)
print (buckCnt)
for i in range(num):
numCnt += buckCnt[i]
print (numCnt)
[0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875]
[0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0]
[1236, 1270, 1243, 1266, 1191, 1294, 1220, 1280]
10000

Глава 10. Словари(97) Тип dict

Строки, списки и кортежи используют в качестве индексов целые числа. Если же мы попытаемся
использовать в качестве индексов значения изменяемых типов
данных, то интерпретатор выведет ошибку.
Словари схожи со списками за исключением того, что в них могут использоваться в качестве индекса
значение любого неизменяемого типа (например, str, float, tuple).
L1: Словарь (хэш, d = {1: 'one', 2: 'two', 3: 'three', 4: One (1)
'four'} {1: 'one', 2:
ассоциативный массив) - это d0 = {0: 'zero'}
изменчивая структура 'two', 3: 'three',
print (d[1]) # берется значение по
данных для хранения пар ключу (1) 4: 'four'} (2)
ключ-значение, где значение d[0] = 0 # присваивается значение по ключу 1 one (3)
однозначно определяется del d[0] # удаляется пара ключ-значение с 2 two
данным ключом 3 three
ключом. В качестве ключа print (d) #(2)
может выступать 4 four
for key, val in [Link](): # цикл по всему
1 one
неизменчивый тип данных словарю
2 two
(число, строка, кортеж и print (key, val) #(3)
for key in [Link](): # цикл по ключам 3 three
т.п.). Порядок пар ключ- словаря 4 four
значение произволен. Ниже print (key, d[key]) #(4) One (4)
приведен литерал для for val in [Link](): # цикл по значениям two
словаря и пример работы со словаря three
словарем: print (val) #(5) four
[Link](d0) # пополняется словарь из
другого 5 (6)
print (len(d)) # количество пар в
словаре (6)
§10.1. Создание словаря
Для примера мы создадим англо-испанский словарь, индексами в котором будут
служить строковые значения.
Один из способов создать словарь – начать с пустого словаря и добавлять элементы. Пустой словарь
обозначается фигурными скобками {}:
>>> eng2sp = {} Элементы словаря выводятся через запятую; каждый элемент
>>> eng2sp['one'] = 'uno' содержит индекс и
>>> eng2sp['two'] = 'dos'
>>> print (eng2sp) значение, разделенные двоеточием. В словаре индексы называют
{'one': 'uno', 'two': 'dos'} ключами, а элементы
называют парами ключ-значение.
>>> eng2sp = {'one': 'uno', 'two': 'dos', 'three': 'tres'}
Другой способ создать словарь – предоставить список пар ключ-значение, используя тот же синтаксис что и
в предыдущем выводе.
>>> print eng2sp >>> print eng2sp['two']
{'one': 'uno', 'three': 'tres', 'two': 'dos'
'dos'}

§10.2. Операции над словарями

>>> inventory = {'apples': 430, 'bananas': >>> del inventory['pears'] #Удалить
312, 'oranges': 525, >>> print inventory
'pears': 217} {'oranges': 525, 'apples': 430, 'bananas': 312}
>>> print inventory
{'oranges': 525, 'apples': 430, 'pears': 217, 'bananas':
312}
>>> inventory['pears']= 0 #Добавить >>> len(inventory) #Найти длину
>>> print inventory 4
{'oranges': 525, 'apples': 430, 'pears': 0, 'bananas': 312}

§10.3. Методы словарей

>>> [Link]() #Список ключей >>> [Link]() #Список значений
['one', 'three', 'two'] ['uno', 'tres', 'dos']
>>> [Link]() #Список кортежей ключ-значение >>> eng2sp.has_key('one') #Пров.наличия
[('one','uno'), ('three', 'tres'), ('two', 'dos')] 1
>>> eng2sp.has_key('deux')
0

§10.4. Использование псевдонимов и копирование

§10.5. Разряженные матрицы(99)
>>> matrix1 = [ [0,0,0,1,0], matrix2 = {(0,3): 1, (2, 1): 2, (4, 3): 3}
[0,0,0,0,0],
[0,2,0,0,0],
[0,0,0,0,0],
[0,0,0,3,0] ]
>>> matrix1[0][3] >>> [Link]((0,3), 0)
1 1
>>> matrix2[0,3]
1

§10.7. Тип «длинное целое число»

Питон предоставляет тип названный long int, который может хранить целые числа любого размера. Есть два
пути создать значение типа long int. Первый – написать целое число с заглавной L в конце.
>>> type(1L) >>> long(1)
<type 'long int'> 1L
>>> long(3.9)
3L
>>> long('57')
57L
§10.8. Подсчет букв
letterCounts = {}
for letter in "Mississippi":
letterCounts[letter] = [Link] (letter, 0) + 1
print(letterCounts)
letterItems = sorted([Link]())
print (letterItems)
dictLetter = dict(letterItems)
print (dictLetter)
{'M': 1, 'i': 4, 's': 4, 'p': 2}
[('M', 1), ('i', 4), ('p', 2), ('s', 4)]
{'M': 1, 'i': 4, 'p': 2, 's': 4}

L1: Исключения
try: L1: В современных программах передача управления происходит не
res = int(open('[Link]').read()) всегда так гладко, как в описанных выше конструкциях. Для
/ обработки особых ситуаций (таких как деление на ноль или
int(open('[Link]').read())
print (res) попытка чтения из несуществующего файла) применяется
except IOError: механизм исключений. Лучше всего пояснить синтаксис
print ("Ошибка ввода-вывода") оператора try-except следующим примером:
except ZeroDivisionError:
print ("Деление на 0")
except KeyboardInterrupt:
print ("Прерывание с
клавиатуры")
except:
print ("Ошибка")
4.0 #a=4. c=1
Деление на 0 #a=4. c=0
Ошибка #a=4. c=f
В этом примере берутся числа из двух файлов и делятся одно на другое. В результате этих нехитрых
действий может возникнуть несколько исключительных ситуаций, некоторые из них отмечены в частях
except (здесь использованы стандартные встроенные исключения Python). Последняя часть except в этом
примере улавливает все другие исключения, которые не были пойманы выше. Например, если хотя бы в
одном из файлов находится нечисловое значение, функция int() возбудит исключение ValueError. Его-то
и сможет отловить последняя часть except. Разумеется, выполнение части try в случае возникновения
ошибки уже не продолжается после выполнения одной из частей except.

if dict.has_key(key): #вместо этого try: #пишут так

value = dict[key] value = dict[key]
else: except:
value = default_value value = default_value
В отличие от других языков программирования, в Python исключения нередко служат для упрощения
алгоритмов. Записывая оператор try-except, программист может думать так: "попробую, а если сорвется -
выполнится код в except ". Особенно часто это используется для выражений, в которых значение
получается по ключу из отображения:
Примечание: Пример уже несколько устаревшей идиомы value = [Link](key, default_value).
языка Python иллюстрирует только дух этого подхода: в
современном Python лучше записать так
Исключения можно возбуждать и из программы. Для этого class MyError(Exception):
pass
служит оператор raise. Заодно следующий пример
try:
показывает канонический способ определения собственного ...
исключения: raise MyError, "my error 1"
Кстати, все исключения выстроены в иерархию классов, ...
поэтому ZeroDivisionError может быть поймана как except MyError, x:
print ("Ошибка:", x)
ArithmeticError, если соответствующая часть except будет
идти раньше.
L1: Тип file
Объекты этого типа предназначены для работы с внешними данными. В простом случае - это файл на
диске. Файловые объекты должны поддерживать основные методы: read(), write(), readline(), readlines(),
seek(), tell(), close() и т.п.
Следующий пример показывает f1 = open("[Link]", "r")
копирование файла: f2 = open("[Link]", "w")
for line in [Link]():
[Link](line)
[Link]()
[Link]()
Стоит заметить, что кроме собственно import urllib
файлов в Python используются и файл- f1 =
подобные объекты. В очень многих [Link]("[Link]
функциях просто неважно, передан ли ей
объект типа file или другого типа, если он
имеет все те же методы (и в том же смысле).
Например, копирование содержимого по
ссылке (URL) в файл [Link] можно
достигнуть, если заменить первую строку на

L1: Выражения
В современных языках программирования принято производить большую часть обработки данных в
выражениях. Синтаксис выражений у многих языков программирования примерно одинаков. Синтаксис
выражений Python не удивит программиста чем-то новым. (Разве что цепочечные сравнения могут приятно
порадовать.) Приоритет операций показан в нижеследующей таблице (в порядке уменьшения). Для унарных
операций x обозначает операнд. Ассоциативность операций в Python - слева-направо, за исключением
операции возведения в степень ( ** ), которая ассоциативна справа налево.
Таким образом, порядок вычислений операндов определяется такими правилами:
1. Операнд слева вычисляется раньше операнда справа во всех бинарных операциях, кроме возведения в
степень.
2. Цепочка сравнений вида a < b < c ... y < z фактически равносильна: (а < b) and (b < c) and ... and (y < z).
3. Перед фактическим выполнением операции вычисляются нужные для нее операнды. В большинстве
бинарных операций предварительно вычисляются оба операнда (сначала левый), но операции or и and, а
также цепочки сравнений вычисляют такое количество операндов, которое достаточно для получения
результата. В невычисленной части выражения в таком случае могут даже быть неопределенные имена.
Это важно учитывать, если используются функции с побочными эффектами.
4. Аргументы функций, выражения для списков, кортежей, словарей и т.п. вычисляются слева-направо, в
порядке следования в выражении. В случае неясности приоритетов желательно применять скобки.
Несмотря на то, что одни и те же символы могут использоваться для разных операций, приоритеты
операций не меняются. Так, % имеет тот же приоритет, что и *, а потому в следующем примере скобки
просто необходимы, чтобы операция умножения произошла перед операцией форматирования:
print "%i" % (i*j)
Выражения могут фигурировать во многих операторах Python и даже как самостоятельный оператор. У
выражения всегда есть результат, хотя в некоторых случаях (когда выражение вычисляется ради
побочных эффектов) этот результат может быть "ничем" - None.
Очень часто выражения стоят в правой части оператора присваивания или расширенного присваивания. В
Python (в отличие, скажем, от C) нет операции присваивания, поэтому синтаксически перед знаком =
могут стоять только идентификатор, индекс, срез, доступ к атрибуту или кортеж (список) из
перечисленного. (Подробности в документации).

L1: Стиль программирования

Стиль программирования - дополнительные ограничения, накладываемые на структуру и вид
программного кода группой совместно работающих программистов с целью получения удобных для
применения, легко читаемых и эффективных программ.
Основные ограничения на вид программы дает синтаксис языка программирования, и его нарушения
вызывают синтаксические ошибки. Нарушение стиля не приводит к синтаксическим ошибкам, однако как
отдельные программисты, так и целые коллективы сознательно ограничивают себя в средствах
выражения ради упрощения совместной разработки, отладки и сопровождения программного продукта.
Стиль программирования затрагивает практически все аспекты написания кода:
 именование объектов в зависимости от типа, назначения, области видимости;
 оформление функций, методов, классов, модулей и их документирование в коде программы;
 декомпозиция программы на модули с определенными характеристиками;
 способ включения отладочной информации;
 применение тех или иных функций (методов) в зависимости от предполагаемого уровня совместимости
разрабатываемой программы с различными компьютерными платформами;
 ограничение используемых функций из соображений безопасности.
Для языка Python Гвидо ван Россум разработал официальный стиль. С оригинальным текстом «Python
Style Guide», с недавних пор включенным в состав Python Enhancement Proposals можно ознакомиться
здесь. Наиболее существенные положения этого стиля перечислены ниже. В случае сомнений хорошим
образцом стиля являются модули стандартной библиотеки.
 Рекомендуется использовать отступы в 4 пробела.
 Длина физической строки не должна превышать 79 символов.
 Длинные логические строки лучше разбивать неявно (внутри скобок), но и явные методы вполне
уместны. Отступы строк продолжения рекомендуется выравнивать по скобкам или по первому операнду
в предыдущей строке. Текстовый редактор Emacs в режиме python-mode и некоторые интегрированные
оболочки (IDE) автоматически делают необходимые отступы в Pythonпрограммах:
 def draw(figure, color="White", border_color="Black",
 size=5):
 if color == border_color or \
 size == 0:
 raise "Bad figure"
 else:
 _draw(size, size, (color, border_color))

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

Несколько рекомендаций касаются написания комментариев.

 Комментарии должны точно отражать актуальное состояние кода. (Поддержание актуальных
комментариев должно быть приоритетной задачей!) После коротких комментариев можно не ставить
точку, тогда как длинные лучше писать по правилам написания текста. Автор Python обращается к
неанглоязычным программистам с просьбой писать комментарии на английском, если есть хотя бы
небольшая вероятность того, что код будут читать специалисты, говорящие на других языках.
 Комментарии к фрагменту кода следует писать с тем же отступом, что и комментируемый код. После " #
" должен идти одиночный пробел. Абзацы можно отделять строкой с " # " на том же уровне. Блочный
комментарий можно отделить пустыми строками от окружающего кода.
 Комментарии, относящиеся к конкретной строке, не следует использовать часто. Символ " # " должен
отстоять от комментируемого оператора как минимум на два пробела.
 Хороший комментарий не перефразирует программу, а содержит дополнительную информацию о
действии программы в терминах предметной области.

Все модули, классы, функции и методы, предназначенные для использования за пределами модуля,
должны иметь строки документации, описывающие способ их применения, входные и выходные
параметры.
 Строка документации для отдельной программы должна объяснять используемые ею ключи,
назначение аргументов и переменных среды и другую подобную информацию.
 Для строк документации рекомендуется везде использовать утроенные кавычки ( """ ).
 Однострочная документация пишется в императиве, как команда: "делай это", "возвращай то".
 Многострочная документация содержит расширенное описание модуля, функции, класса. Она будет
смотреться лучше, если текст будет написан с тем же отступом, что и начало строки документации.
 Документация для модуля должна перечислять экспортируемые функции, классы, исключения и другие
объекты, по одной строке на объект.
 Строка документации для функции или метода должна кратко описывать действия функции, ее входные
параметры и возвращаемое значение, побочные эффекты и возможные исключения (если таковые есть).
Должны быть обозначены необязательные аргументы и аргументы, не являющиеся частью интерфейса.
 Документация для класса должна перечислять общедоступные методы и атрибуты, содержать
рекомендации по применению класса в качестве базового для других классов. Если класс является
подклассом, необходимо указать, какие методы полностью заменяют, перегружают, а какие используют,
но расширяют соответствующие методы надкласса. Необходимо указать и другие изменения по
сравнению с надклассом.
 Контроль версий повышает качество процесса создания программного обеспечения. Для этих целей
часто используются RCS или CVS. "Python Style Guide" рекомендует записывать $Revision: 1.31 $ в
переменную с именем __version__, а другие данные заключать в комментарии " # ".

Сегодня сосуществуют несколько более или менее широко распространенных правил именования
объектов. Программисты вольны выбрать тот, который принят в их организации или конкретном проекте.
Автор Python рекомендует придерживаться нижеследующих правил для именования различных
объектов, с тем чтобы это было понятно любому программисту, использующему Python.
 Имена модулей лучше давать строчными буквами, например, shelve, string, либо делать первые
буквы слов прописными, StringIO, UserDict. Имена написанных на C модулей расширения
обычно начинаются с подчеркивания " _ ", а соответствующие им высокоуровневые обертки - с
прописных букв: _tkinter и Tkinter.
 Ключевые слова нельзя использовать в качестве имен, однако, если все-таки необходимо
воспользоваться этим именем, стоит добавить одиночное подчеркивание в конце имени. Например:
class_.
 Классы обычно называют, выделяя первые буквы слов прописными, как в Tag или HTTPServer. 
Имена исключений обычно содержат в своем составе слово "error" (или "warning"). Встроенные модули
пишут это слово со строчной буквы (как [Link] ) (но могут писать и с прописной):
[Link].
 Функции, экспортируемые модулем, могут именоваться по-разному. Можно давать с прописных букв
имена наиболее важных функций, а вспомогательные писать строчными.
 Имена глобальных переменных (если таковые используются) лучше начинать с подчеркивания, чтобы
они не импортировались из модуля оператором fromimport со звездочкой.
 Имена методов записываются по тем же правилам, что и имена функций.
 Имена констант (имен, которые не должны переопределяться) лучше записывать прописными буквами,
например: RED, GREEN, BLUE.
 При работе с языком Python необходимо учитывать, что интерпретатор считает некоторые классы имен
специальными (обычно такие имена начинаются с подчеркивания).