Учебник Python 3.1. Учебник Python 3. Учебник Python 1 Материал из Викиучебника. Оглавление

• Название: Учебник Python 1 Материал из Викиучебника. Оглавление
• Анкор: Учебник Python 3.1.pdf
• Дата: 05.04.2017
• Размер: 1.85 Mb.
• Имя файла: Учебник Python 3.1.pdf
• Тип: Учебник; #4516
• страница: 4 из 13

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 !
Модель lambda
В связи с неустанными просьбами, в Python были добавлены несколько возможностей, которые были привычны для функциональных языков программирования, таких как Lisp.
Используя зарезервированное слово lambda
, вы можете создать небольшую безымянную функцию. Например, функцию, которая возвращает сумму двух своих аргументов, можно записать так: lambda a, b: a+b
. Формы lambda могут быть использованы в любом месте где требуется объект функции. При этом они синтаксически ограничены одним выражением. Семантически, они лишь «синтаксический сахар» для обычного определения функции. Как и определения вложенных функций, lambda
-формы могут ссылаться на переменные из содержащей их области видимости:
>>>
def
make_incrementor(n):
29

Учебник Python 3.1: Материал из Викиучебника.
return
lambda
x: x + n
>>>
f
=
make_incrementor(
42
)
>>>
f(
0
)
42
>>>
f(
1
)
43
Строки документации
Перечислим некоторые существующие соглашения по содержимому строк документации и их форматированию.
По поводу форматирования строк документации и их содержимого постоянно появляются всё новые соглашения.
Первая строка всегда должна быть сжатой, лаконичной сводкой о назначении объекта.
Для краткости, в ней не обязательно присутствие имени типа или объекта, поскольку они доступны другими способами (исключая случай, когда имя функции оказывается глаголом, описывающим суть операции). Эта строка должна начинаться с прописной буквы и оканчиваться точкой.
Если строке документации (литералу, объекту строки) требуется больше строк
(физических), вторая строка должна быть пустой, визуально отделяя сводку от остального описания. Следующие строки могут быть одним или более абзацем, описывающим соглашения по вызову объекта, сторонние эффекты, и т.д.
Парсер Python не обрабатывает отступы в много-строковых литералах, поэтому инструментам, которые работают над документацией, предлагается, по желанию, делать это самим. Производится это по следующему соглашению. Первая непустая строка после первой строки литерала определяет величину отступа всего литерала документации. (Мы не можем использовать первую строку, поскольку она обычно выравнивается по открывающим кавычкам и её отступ в литерале не явен). Пробельный „эквивалент“ этого отступа затем отрезается от начала всех строк литерала. Строк с меньшим отступом не должно обнаруживаться, но если они встретились, весь их начальный отступ должен быть обрезан. Эквивалентность пробельных замен может быть протестирована развертыванием табуляции (обычно, к 8 пробелам).
Вот пример многострочной документации (док-строки):
>>>
def
my_function():
"""Не делаем ничего, но документируем.
... Нет, правда, эта функция ничего не делает.
... """
pass
>>>
print
(my_function.__doc__)
Не делаем ничего
,
но документируем.
Нет
,
правда
,
эта функция ничего не делает.
Интермеццо: Стиль написания кода
Теперь, когда вам предстоит писать более объёмные и сложные блоки кода на Python, настало время поговорить о стиле написания кода (coding style). Код на большинстве языков программирования может быть записан (или, точнее
30

Учебник Python 3.1: Материал из Викиучебника.
говоря, отформатирован (formatted)) различными способами; некоторые из них более читабельны, некоторые — нет. Стремление к написанию лёгкого для прочтения другими кода всегда считалось хорошим тоном, и выбор правильного стиля для кода крайне ему способствует.
В случае языка Python, в качестве руководства по стилю было создано предложение
PEP8
[28]
, которого придерживаются создатели большинства проектов. В нём учреждается чрезвычайно читабельный и приятный для глаза стиль написания кода. В некоторый момент с ним должен ознакомиться каждый разработчик на Python. Приведём здесь избранные, наиболее важные, пункты:
•
Используйте отступ в 4 пробела, не используйте табуляцию
4 пробела легко опознаются и в случае небольших отступов (хватает места для глубоких вложений) и в случае больших отступов (приятнее читается). Табуляция вносит путаницу и лучше от неё воздержаться.
•
Разделяйте строки так, чтобы их длина не превышала 79-и символов
Это поможет пользователям с небольшими экранами, а пользователям с большими экранами позволит уложить несколько файлов с исходным кодом рядом.
•
Используйте пустые строки для отделения функций, классов, и крупных блоков внутри функций.
•
При возможности располагайте комментарий на отдельной строке.
•
Используйте строки документации (док-строки)
•
Применяйте пробелы вокруг символов операций и после запятых, но не добавляйте их в конструкции со скобками: a = f(1, 2) + g(3, 4)
•
Называйте ваши классы и функции единообразно; соглашение следующее: используйте
CamelCase
[29]
для именования классов и нижний_регистр_с_подчёркиваниями
[30]
для функций и методов. (обращайтесь к разделу
Первый взгляд на классы за дополнительной информации о классах и методах)
•
Не используйте в вашем коде изощрённых кодировок
[31]
, если он рассчитан на использование в интернациональной среде. Стандартный набор ASCII всегда работает на ура
[32]
Структуры данных
Эта глава описывает подробнее некоторые вещи, которые вы уже изучили, а также раскрывает некоторые новые темы.
Подробнее о списках
У типа данных список также имеются не описанные ранее методы. Ниже приведены все методы объекта типа список:
list.append(x)
Добавить элемент к концу списка; эквивалент list[len(list):] = [x]
list.extend(L)
Расширить список за счёт добавления всех элементов переданного списка; эквивалентно list[len(list):] = L
31

Учебник Python 3.1: Материал из Викиучебника.
list.insert(i, x)
Вставить элемент в указанную позицию. Первый аргумент — это индекс того элемента, перед которым требуется выполнить операцию вставки, поэтому вызов list.insert(0, x)
вставляет элемент в начало списка, а list.insert(len(list), x)
эквивалентно list.append(x)
list.remove(x)
Удалить первый найденный элемент из списка, значение которого — x
. Если элемент не найден, генерируется ошибка.
list.pop([i])
Удалить элемент, находящийся на указанной позиции в списке, и вернуть его. Если индекс не указан, list.pop()
удаляет и возвращает последний элемент списка. (Квадратные скобки вокруг i
в сигнатуре метода означают, что параметр необязателен, а не необходимость набора квадратных скобок в этой позиции. Вы часто будете встречать такую нотацию в
Справочнике по библиотеке
.)
list.index(x)
Вернуть индекс первого найденного в списке элемента, значение которого равно x
. Если элемент не найден, генерируется ошибка.
list.count(x)
Вернуть значение сколько раз, x
встречается в списке.
list.sort()
Сортировать элементы списка, на месте.
list.reverse()
Обратить порядок элементов списка, на месте.
Пример, использующий большинство методов списка:
>>>
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
]
32

Учебник Python 3.1: Материал из Викиучебника.
Использование списка в качестве стека
Методы списков позволяют легко использовать список в качестве стека, где последний добавленный элемент становится первым полученным („первый вошёл - последний вышел“). Чтобы положить элемент на вершину стека, используйте метод append()
. Для получения элемента с вершины стека - метод pop()
без указания явного индекса.
Например:
>>>
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
]
Использование списка в качестве очереди
Вы можете без труда использовать список также и в качестве очереди, где первый добавленный элемент оказывается первым полученным („первый вошёл - первый вышел“).
Чтобы добавить элемент в конец очереди, используйте метод append()
, а чтобы получить элемент из начала очереди - метод pop()
с нулём в качестве индекса. Например:
>>>
queue
=
[
"Eric"
,
"John"
,
"Michael"
]
>>>
queue.append(
"Terry"
)
# Прибыл Terry
>>>
queue.append(
"Graham"
)
# Прибыл Graham
>>>
queue.pop(
0
)
'Eric'
>>>
queue.pop(
0
)
'John'
>>>
queue
[
'Michael'
,
'Terry'
,
'Graham'
]
Списковые сборки
[33]
Использование метода списковой сборки — легкий способ создать список на основе последовательности. В большинстве случаев он применяется для создания списков, в которых каждый элемент является результатом некой операции, произведённой над каждым членом последовательности, или для создания выборок из тех элементов, которые удовлетворяют определённому условию.
Любая списковая сборка состоит из выражения, за которым следует оператор for
, а затем ноль или более операторов for или if
. Результатом станет список, получившийся через
33

Учебник Python 3.1: Материал из Викиучебника.
вычисление выражения в контексте следующих за ним операторов for и/или if
. Если в результате вычисления выражения строится кортеж, его нужно явно обернуть в скобки.
В следующем примере на основе списка чисел создаётся список, где каждое число утроено:
>>>
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'
]
Используя оператор if
, мы можем отфильтровать поток:
>>>
[
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
)]
Вот несколько вложенных циклов for и ещё кое-какое забавное поведение:
>>>
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
]
Списковые сборки могут применяться в сложных выражениях и вложенных функциях
[34]
:
>>>
[
str
(
round
(
355
/
113
,
i))
for
i
in
range
(
1
,
6
)]
[
'3.1'
,
'3.14'
,
'3.142'
,
'3.1416'
,
'3.14159'
]
Вложенные списковые сборки
Если вы в состоянии это переварить: списковые сборки могут быть вложенными. Но как любой мощный инструмент, их следует использовать с осторожностью.
Представьте нижеследующий пример матрицы 3x3 в виде списка, содержащего три других списка, по одному в ряд:
>>>
mat
=
[
... [
1
,
2
,
3
]
,
... [
4
,
5
,
6
]
,
... [
7
,
8
,
9
]
,
... ]
34

Учебник Python 3.1: Материал из Викиучебника.
Чтобы поменять строки и столбцы местами, можно использовать такую списковую сборку:
>>>
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
()
В реальных случаях лучше использовать встроенные функции вместо сложных выражений.
В нашем случае поможет функция zip()
:
>>>
list
(
zip
(*mat))
[(
1
,
4
,
7
)
,
(
2
,
5
,
8
)
,
(
3
,
6
,
9
)]
В разделе
Распаковка списков параметров описано предназначение звёздочки в этих строках.
Другой пример использования вложенных списковых сборок - произведение матрицы a на матрицу b:
c
=
[[
sum
(x*y
for
x
,
y
in
zip
(i
,
j))
for
j
in
zip
(*b)]
for
i
in
a]
Это можно сделать эффективнее и прозрачнее, но на данном примере видна мощь инструмента.
Получение единичной матрицы порядка n:
a
=
[[
0
]*i+[
1
]+[
0
]*(n-i-
1
)
for
i
in
range
(n)]
Оператор
del
Существует способ удалить элемент, указывая его индекс, а не его значение: оператор del
. В отличие от метода pop()
, он не возвращает значения. Оператор del может также использоваться для удаления срезов из списка или полной очистки списка (что мы делали ранее через присваивание пустого списка срезу). Например:
>>>
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 может быть также использован для удаления переменных полностью:
>>>
del
a
Ссылка на имя a
в дальнейшем вызовет ошибку (по крайней мере до тех пор, пока с ним не будет связано другое значение). Позже мы с вами узнаем другие способы использования del
35

Учебник Python 3.1: Материал из Викиучебника.
Кортежи и последовательности
Мы видели, что списки и строки поддерживают много привычных свойств, таких как индексирование и операция получения срезов. Существует два подвида типов данныхпоследовательность (sequence) (см.
—
Справочник по библиотеке
Последовательности
), и поскольку Python — развивающийся язык, со временем могут быть добавлены другие последовательные типы данных. Итак, существует также и другой, достойный рассмотрения, стандартный последовательный тип данных: кортеж.
Кортеж состоит из некоторого числа значений разделённых запятыми, например:
>>>
t
=
12345
,
54321
,
'hello!'
>>>
t[
0
]
12345
>>>
t
(
12345
,
54321
,
'hello!'
)
>>>
# Кортежи могут быть вложенными:
... u
=
t
,
(
1
,
2
,
3
,
4
,
5
)
>>>
u
((
12345
,
54321
,
'hello!'
)
,
(
1
,
2
,
3
,
4
,
5
))
Как видите, кортежи на выводе всегда заключены в скобки, таким образом вложенные кортежи интерпретируются корректно; они могут быть введены и с обрамляющими скобками и без, тем не менее в любом случае скобки чаще всего необходимы (если кортеж
— часть более крупного выражения).
Кортежи можно использовать в различных целях. Например:
(x, y)
пары координат, записи о рабочих из базы данных, и так далее. Кортежи, как и строки, неизменяемы: невозможно присвоить что-либо индивидуальным элементам кортежа (однако, вы можете симулировать большинство схожих эффектов за счёт операций срезов и конкатенации).
Также можно создать кортежи, содержащие изменяемые объекты, такие как списки.
Определённая проблема состоит в конструировании кортежей, состоящих из нуля или одного элемента: в синтаксисе языка есть дополнительные хитрости, позволяющие достигнуть этого. Пустые кортежи формируются за счёт пустой пары скобок; кортеж с одним элементом конструируется за счёт запятой, следующей за числом (единственное значение не обязательно заключать в скобки). Необычно, но эффективно. Например:
>>>
empty
=
()
>>>
singleton
=
'hello'
,
# <-- обратите внимание на замыкающую запятую
>>>
len
(empty)
0
>>>
len
(singleton)
1
>>>
singleton
(
'hello'
,
)
Выражение t = 12345, 54321, 'hello!'
является примером упаковки кортежей (tuple packing): значения
12345
,
54321
и 'hello!'
упаковываются в кортеж вместе. Обратная операция также возможна:
>>>
x
,
y
,
z
=
t
Такое действие называется, довольно удачно, распаковкой последовательности (sequence unpacking). Для распаковки на левой стороне требуется список переменных с количеством элементов равным длине последовательности. Обратите внимание, что множественное
36