Файл: Понятие модуля Перед тем как приступить к изучению модулей стандартной библиотеки, необходимо определить то, что в Python называется модулем.pdf

Модуль time
Этот модуль дает функции для получения текущего времени и преобразования форматов времени.
Модуль sets
Модуль реализует тип данных для множеств. Следующий пример показывает, как использовать этот модуль. Следует заметить, что в Python 2.4 и старше тип set стал встроенным, и вместо sets.Set можно использовать set
: import sets
A = sets.Set([1, 2, 3])
B = sets.Set([2, 3, 4]) print A | B, A & B, A - B, A ^ B for i in A: if i in B: print i,
В результате будет выведено:
Set([1, 2, 3, 4]) Set([2, 3]) Set([1]) Set([1, 4])
2 3
Модули array и struct
Эти модули реализуют низкоуровневый массив и структуру данных. Основное их назначение - разбор двоичных форматов данных.
Модуль itertools
Этот модуль содержит набор функций для работы с итераторами. Итераторы позволяют работать с данными последовательно, как если бы они получались в цикле.
Альтернативный подход - использование списков для хранения промежуточных результатов - требует подчас большого количества памяти, тогда как использование итераторов позволяет получать значения на момент, когда они действительно требуются для дальнейших вычислений. Итераторы будут рассмотрены более подробно в лекции по функциональному программированию.
Модуль locale
Модуль locale применяется для работы с культурной средой. В конкретной культурной среде могут использоваться свои правила для написания чисел, валют, времени и даты и т.п. Следующий пример выводит дату сначала в культурной среде "C", а затем на русском языке: import time, locale locale.setlocale(locale.LC_ALL, None) print time.strftime("%d %B %Y", time.localtime (time.time())) locale.setlocale(locale.LC_ALL, "ru_RU.KOI8-R") print time.strftime("%d %B %Y", time.localtime (time.time()))
В результате:

18 November 2004 18 Ноября 2004
Модуль gettext
При интернационализации программы важно не только предусмотреть возможность использования нескольких культурных сред, но и перевод сообщений и меню программы на соответствующий язык. Модуль gettext позволяет упростить этот процесс достаточно стандартным способом. Основные сообщения программы пишутся на английском языке. А переводы строк, отмеченных в программе специальным образом, даются в виде отдельных файлов, по одному на каждый язык (или культурную среду). Уточнить нюансы использования gettext можно по документации к Python.
Поддержка цикла разработки
Модули этого раздела помогают поддерживать документацию, производить регрессионное тестирование, отлаживать и профилировать программы на Python, а также обслуживают распространение готовых программ, создавая среду для конфигурирования и установки пакетов.
В качестве иллюстрации можно предположить, что создается модуль для вычисления простых чисел по алгоритму "решето Эратосфена". Модуль будет находиться в файле
Sieve.py и состоять из одной функции primes(N)
, которая в результате своей работы дает все простые (не имеющие натуральных делителей кроме себя и единицы) числа от
2
до
N
: import sets import math
"""Модуль для вычисления простых чисел от 2 до N """ def primes(N):
"""Возвращает все простые от 2 до N""" sieve = sets.Set(range(2, N)) for i in range(2, math.sqrt(N)): if i in sieve: sieve -= sets.Set(range(2*i, N, i)) return sieve
Модуль pdb
Модуль pdb предоставляет функции отладчика с интерфейсом - командной строкой. Сессия отладки вышеприведенного модуля могла бы быть такой:
>>> import pdb
>>> pdb.runcall(Sieve.primes, 100)
> /home/rnd/workup/intuit-python/examples/Sieve.py(15)primes()
-> sieve = sets.Set(range(2, N))
(Pdb) l
10 import sets
11 import math
12 """Модуль для вычисления простых чисел от 2 до N """
13 def primes(N):
14 """Возвращает все простые от 2 до N"""
15 -> sieve = sets.Set(range(2, N))
16 for i in range(2, int(math.sqrt(N))):
17 if i in sieve:
18 sieve -= sets.Set(range(2*i, N, i))
19 return sieve
20

(Pdb) n
> /home/rnd/workup/intuit-python/examples/Sieve.py(16)primes()
-> for i in range(2, int(math.sqrt(N))):
(Pdb) n
> /home/rnd/workup/intuit-python/examples/Sieve.py(17)primes()
-> if i in sieve:
(Pdb) n
> /home/rnd/workup/intuit-python/examples/Sieve.py(18)primes()
-> sieve -= sets.Set(range(2*i, N, i))
(Pdb) n
> /home/rnd/workup/intuit-python/examples/Sieve.py(16)primes()
-> for i in range(2, int(math.sqrt(N))):
(Pdb) p sieve
Set([2, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35,
37, 39,
41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75,
77, 79,
81, 83, 85, 87, 89, 91, 93, 95, 97, 99])
(Pdb) n
> /home/rnd/workup/intuit-python/examples/Sieve.py(17)primes()
-> if i in sieve:
(Pdb) n
> /home/rnd/workup/intuit-python/examples/Sieve.py(18)primes()
-> sieve -= sets.Set(range(2*i, N, i))
(Pdb) n
> /home/rnd/workup/intuit-python/examples/Sieve.py(16)primes()
-> for i in range(2, int(math.sqrt(N))):
(Pdb) p sieve
Set([2, 3, 5, 7, 11, 13, 17, 19, 23, 25, 29, 31, 35, 37, 41, 43, 47, 49,
53, 55, 59, 61, 65, 67, 71, 73, 77, 79, 83, 85, 89, 91, 95, 97])
Модуль profile
С помощью профайлера разработчики программного обеспечения могут узнать, сколько времени занимает исполнение различных функций и методов.
Продолжая пример с решетом Эратосфена, стоит посмотреть, как тратится процессорное время при вызове функции primes()
:
>>> profile.run("Sieve.primes(100000)")
709 function calls in 1.320 CPU seconds
Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function)
1 0.010 0.010 1.320 1.320 :1(?)
1 0.140 0.140 1.310 1.310 Sieve.py:13(primes)
1 0.000 0.000 1.320 1.320 profile:0(Sieve.primes(100000))
0 0.000 0.000 profile:0(profiler)
65 0.000 0.000 0.000 0.000 sets.py:119(__iter__)
314 0.000 0.000 0.000 0.000 sets.py:292(__contains__)
65 0.000 0.000 0.000 0.000 sets.py:339(_binary_sanity_check)
66 0.630 0.010 0.630 0.010 sets.py:356(_update)
66 0.000 0.000 0.630 0.010 sets.py:425(__init__)
65 0.010 0.000 0.540 0.008 sets.py:489(__isub__)
65 0.530 0.008 0.530 0.008 sets.py:495(difference_update)
Здесь ncalls
- количество вызовов функции или метода, tottime
- полное время выполнения кода функции (без времени нахождения в вызываемых функциях), percall
- тоже, в пересчете на один вызов, cumtime
- аккумулированное время нахождения в

функции, вместе со всеми вызываемыми функциями. В последнем столбце приведено имя файла, номер строки с функцией или методом и его имя.
Примечание:
"Странные" имена, например,
__iter__
,
__contains__
и
__isub__
- имена методов, реализующих итерацию по элементам, проверку принадлежности элемента ( in
) и операцию
-=
. Метод
__init__
- конструктор объекта (в данном случае - множества).
Модуль unittest
При разработке программного обеспечения рекомендуется применять так называемые регрессионные испытания. Для каждого модуля составляется набор тестов, по возможности таким образом, чтобы проверялись не только типичные вычисления, но и "крайние", вырожденные случаи, чтобы испытания затронули каждую ветку алгоритма хотя бы один раз. Тест для данного модуля (написанный сразу после того, как определен интерфейс модуля) находится в файле test_Sieve.py
:
# file: test_Sieve.py import Sieve, sets import unittest class TestSieve(unittest.TestCase): def setUp(self): pass def testone(self): primes = Sieve.primes(1) self.assertEqual(primes, sets.Set()) def test100(self): primes = Sieve.primes(100) self.assert_(primes == sets.Set([2, 3, 5, 7, 11, 13, 17, 19, 23,
29, 31, 37, 41, 43, 47,
53, 59, 61, 67, 71, 73, 79, 83, 89, 97])) if __name__ == '__main__': unittest.main()
Тестовый модуль состоит из определения класса, унаследованного от класса unittest.TestCase
, в котором описывается подготовка к испытаниям (метод setUp
) и сами испытания -- методы, начинающиеся на test
. В данном случае таких испытаний всего два: в первом испытывается случай
N=1
, а во втором --
N=100
Запуск тестов производится выполнением функции unittest.main()
. Вот как выглядят успешные испытания:
$ python test_Sieve.py
----------------------------------------------------------------------
Ran 2 tests in 0.002s
OK
В процессе разработки перед каждым выпуском все модули прогоняются через регрессионные испытания, чтобы обнаружить, не были ли внесены ошибки. Однако никакие тесты в общем случае не могут гарантировать безошибочности сложной программы. При дополнении модулей тесты также могут быть дополнены, чтобы отразить изменения в проекте.

Кстати, сам Python и его стандартная библиотека имеют тесты для каждого модуля - они находятся в каталоге test в месте, где развернуты файлы поставки
Python, и являются частью пакета test
Модуль pydoc
Успех проекта зависит не только от обеспечения эффективного и качественного кода, но и от качества документации. Утилита pydoc аналогична команде man в Unix:
$ pydoc Sieve
Help on module Sieve:
NAME
Sieve - Модуль для вычисления простых чисел от 2 до N
FILE
Sieve.py
FUNCTIONS primes(N)
Возвращает все простые от 2 до N
Эта страница помощи появилась благодаря тому, что были написаны строки документации - как ко всему модулю, так и к функции primes(N)
Стоит попробовать запустить pydoc следующей командой: pydoc -p 8088
И направить браузер на URL http://127.0.0.1:8088/
- можно получить документацию по модулям Python в виде красивого web-сайта.
Узнать другие возможности pydoc можно, подав команду pydoc pydoc
Пакет docutils
Этот пакет и набор утилит пока что не входит в стандартную поставку Python, однако о нем нужно знать тем, кто хочет быстро готовить документацию (руководства пользователя и т.п.) для своих модулей. Этот пакет использует специальный язык разметки (ReStructuredText), из которого потом легко получается документация в виде
HTML, LaTeX и в других форматах. Текст в формате RST легко читать и в исходном виде. С этим инструментом можно познакомиться на http://docutils.sourceforge.net
Пакет distutils
Данный пакет предоставляет стандартный путь для распространения собственных Python-пакетов. Достаточно написать небольшой конфигурационный файл setup.py
, использующий distutils
, и файл с перечислением файлов проекта
MANIFEST.in
, чтобы пользователи пакета смогли его установить командой python setup.py install
Тонкости работы с distutils можно изучить по документации.
Взаимодействие с операционной системой
Различные операционные системы имеют свои особенности.
Здесь рассматривается основной модуль этой категории, функции которого работают на многих операционных системах.

Модуль os
Разделители каталогов и другие связанные с этим обозначения доступны в виде констант.
Константа
Что обозначает
os.curdir
Текущий каталог os.pardir
Родительский каталог os.sep
Разделитель элементов пути os.altsep
Другой разделитель элементов пути os.pathsep
Разделитель путей в списке путей os.defpath
Список путей по умолчанию os.linesep
Признак окончания строки
Программа на Python работает в операционной системе в виде отдельного процесса. Функции модуля os дают доступ к различным значениям, относящимся к процессу и к среде, в которой он исполняется. Одним из важных объектов, доступных из модуля os
, является словарь переменных окружения environ
. Например, с помощью переменных окружения web-сервер передает некоторые параметры в CGI-сценарий. В следующем примере можно получить переменную окружения
PATH
: import os
PATH = os.environ['PATH']
Большая группа функций посвящена работе с файлами и каталогами. Ниже приводятся только те, которые доступны как в Unix, так и в Windows. access(path, flags)
Проверка доступности файла или каталога с именем path
. Режим запрашиваемого доступа указывается значением flags
, составленных комбинацией (побитовым ИЛИ) флагов os.F_OK
(файл существует), os.R_OK
(из файла можно читать), os.W_OK
(в файл можно писать) и os.X_OK
(файл можно исполнять, каталог можно просматривать). chdir(path)
Делает path текущим рабочим каталогом. getcwd()
Текущий рабочий каталог. chmod(path, mode)
Устанавливает режим доступа к path в значение mode
. Режим доступа можно получить, скомбинировав флаги (см. ниже).
Следует заметить, что chmod()
не дополняет действующий режим, а устанавливает его заново. listdir(dir)
Возвращает список файлов в каталоге dir
. В список не входят специальные значения "."
и ".."
mkdir(path[, mode])
Создает каталог path
. По умолчанию режим mode равен
0777
, то есть:
S_IRWXU|S_IRWXG|S_IRWXO
, если пользоваться константами модуля stat makedirs(path[, mode])
Аналог mkdir()
, создающий все необходимые каталоги, если они не существуют. Возбуждает исключение, когда последний каталог уже существует. remove(path), unlink(path)
Удаляет файл path
. Для удаления каталогов используются rmdir()
и removedirs()
rmdir(path)
Удаляет пустой каталог path removedirs(path)
Удаляет path до первого непустого каталога. В случае если самый последний вложенный подкаталог в указанном пути - не пустой,

возбуждается исключение
OSError rename(src, dst)
Переименовывает файл или каталог src в dst renames(src, dst)
Аналог rename()
, создающий все необходимые каталоги для пути dst и удаляющий пустые каталоги пути src stat(path)
Возвращает информацию о path в виде не менее чем десятиэлементного кортежа. Для доступа к элементам кортежа можно использовать константы из модуля stat
, например stat.ST_MTIME
(время последней модификации файла). utime(path, times)
Устанавливает значения времен последней модификации ( mtime
) и доступа к файлу ( atime
). Если times равен
None
, в качестве времен берется текущее время. В других случаях times рассматривается как двухэлементный кортеж ( atime
, mtime
). Для получения atime и mtime некоторого файла можно использовать stat()
совместно с константами модуля stat
Для работы с процессами модуль os предлагает следующие функции (здесь упомянуты только некоторые, доступные как в Unix, так и в Windows): abort()
Вызывает для текущего процесса сигнал
SIGABRT
system(cmd)
Выполняет командную строку cmd в отдельной оболочке, аналогично вызову system библиотеки языка C. Возвращаемое значение зависит от используемой платформы. times()
Возвращает кортеж из пяти элементов, содержащий время в секундах работы процесса, ОС (по обслуживанию процесса), дочерних процессов,
ОС для дочерних процессов, а также время от фиксированного момента в прошлом (например, от момента запуска системы). getloadavg()
Возвращает кортеж из трех значений, соответствующих занятости процессора за последние 1, 5 и 15 минут.
Модуль stat
В этом модуле описаны константы, которые можно использовать как индексы к кортежам, применяемым функциями os.stat()
и os.chmod()
(а также некоторыми другими). Их можно уточнить в документации по Python.
Модуль tempfile
Программе иногда требуется создать временный файл, который после выполнения некоторых действий больше не нужен. Для этих целей можно использовать функцию
TemporaryFile
, которая возвращает файловый объект, готовый к записи и чтению.
В следующем примере создается временный файл, куда записываются данные и затем читаются: import tempfile f = tempfile.TemporaryFile() f.write("0"*100) # записывается сто символов 0 f.seek(0) # уст. указатель на начало файла print len(f.read()) # читается до конца файла и вычисляется длина
Как и следовало ожидать, в результате будет выведено 100. Временный файл будет удален, как только будут удалены все ссылки на его объект.

Обработка текстов
Модули этой категории будут подробно рассмотрены в отдельной лекции.

Многопоточные вычисления
Модули этой категории станут предметом рассмотрения отдельной лекции.
Хранение данных. Архивация
К этой категории отнесены модули, которые работают с внешними хранилищами данных.
Модуль pickle
Процесс записи объекта в виде последовательности байтов называется
сериализацией. Для того чтобы сохранить объект во внешней памяти или передать его по каналам связи, его нужно вначале сериализовать.
Модуль pickle позволяет сериализовывать объекты и сохранять их в строке или файле. Следующие объекты могут быть сериализованы:
 встроенные типы:
None
, числа, строки (обычные и Unicode).
 списки, кортежи и словари, содержащие только сериализуемые объекты.
 функции, определенные на уровне модуля (сохраняется имя, но не реализация!).
 встроенные функции.
 классы, определенные на уровне модуля.
 объекты классов,
__dict__
или
__setstate__()
которые являются сериализуемыми.
Типичный вариант использования модуля приведен ниже.
Сохранение: import pickle, time mydata = ("abc", 12, [1, 2, 3]) output_file = open("mydata.dat", "w") p = pickle.Pickler(output_file) p.dump(mydata) output_file.close()
Восстановление: import pickle input_file = open("mydata.dat", "r") mydata = pickle.load(input_file) print mydata input_file.close()
Модуль shelve
Для хранения объектов в родном для Python формате можно применять полку
(shelve). По своему интерфейсу полка ничем не отличается от словаря. Следующий пример показывает, как использовать полку: import shelve data = ("abc", 12) # - данные (объект) key = "key" # - ключ (строка) filename = "polka.dat" # - имя файла для хранения полки

d = shelve.open(filename) # открытие полки d[key] = data # сохранить данные под ключом key
# (удаляет старое значение, если оно было) data = d[key] # загрузить значение по ключу len(d) # получить количество объектов на полке d.sync() # запись изменений в БД на диске del d[key] # удалить ключ и значение flag = d.has_key(key) # проверка наличия ключа lst = d.keys() # список ключей d.close() # закрытие полки
Модули anydbm и gdbm
Для внешнего хранения данных можно использовать примитивные базы данных, содержащие пары ключ-значение. В Python имеется несколько модулей для работы с такими базами: bsddb
, gdbm
, dbhash и т.п. Модуль anydbm выбирает один из имеющихся хэшей, поэтому его можно применять для чтения ряда форматов ( any
- любой).
Доступ к хэшу из Python мало отличается от доступа к словарю. Разница лишь в том, что хэш еще нужно открыть для создания, чтения или записи, а затем закрыть.
Кроме того, при записи хэш блокируется, чтобы не испортить данные.
Модуль csv
Формат CSV (comma separated values - значения, разделенные запятыми) достаточно популярен для обмена данными между электронными таблицами и базами данных. Следующий ниже пример посвящен записи в CSV-файл и чтению из него: mydata = [(1, 2, 3), (1, 3, 4)] import csv
# Запись в файл: f = file("my.csv", "w") writer = csv.writer(f) for row in mydata: writer.writerow(row) f.close()
# Чтение из файла: reader = csv.reader(file("my.csv")) for row in reader: print row
Платформо-зависимые модули
Эта категория модулей имеет применение только для конкретных операционных систем и семейств операционных систем. Довольно большое число модулей в стандартной поставке Python посвящено трем платформам: Unix, Windows и Macintosh.
При создании переносимых приложений использовать платформо-зависимые модули можно только при условии реализации альтернативных веток алгоритма, либо с отказом от свойств, которые доступны не на всех платформах. Так, под Windows не работает достаточно обычная для Unix функция os.fork()
, поэтому при создании переносимых приложений нужно использовать другие средства для распараллеленных вычислений, например, многопоточность.
В документации по языку обычно отмечено, для каких платформ доступен тот или иной модуль или даже отдельная функция.

Поддержка сети. Протоколы Интернет
Почти все модули из этой категории, обслуживающие клиентскую часть протокола, построены по одному и тому же принципу: из модуля необходим только класс, объект которого содержит информацию о соединении с сервером, а методы реализуют взаимодействие с сервером по соответствующему протоколу. Таким образом, чем сложнее протокол, тем больше методов и других деталей требуется для реализации клиента.
Примеры серверов используются по другому принципу. В модуле с реализацией сервера описан базовый класс, из которого пользователь модуля должен наследовать свой класс, реализующий требуемую функциональность. Правда, иногда замещать нужно всего один или два метода.
Этому вопросу будет посвящена отдельная лекция.
Поддержка Internet. Форматы данных
В стандартной библиотеке Python имеются разноуровневые модули для работы с различными форматами, применяющимися для кодирования данных в сети Интернет и тому подобных приложениях.
Сегодня наиболее мощным инструментом для обработки сообщений в формате
RFC 2822
является пакет email. С его помощью можно как разбирать сообщения в удобном для программной обработки виде, так и формировать сообщение на основе данных о полях и основном содержимом (включая вложения).
Python о себе
Язык Python является рефлективным языком, в котором можно "заглянуть" глубоко в собственные внутренние структуры кода и данных. Модули этой категории дают возможность прикоснуться к внутреннему устройству Python. Более подробно об этом рассказывается в отдельной лекции.
Графический интерфейс
Почти все современные приложения имеют графический интерфейс пользователя. Такие приложения можно создавать и на языке Python. В стандартной поставке имеется модуль Tkinter, который есть не что иное, как интерфейс к языку
Tcl/Tk, на котором можно описывать графический интерфейс.
Следует отметить, что существуют и другие пакеты для программирования графического интерфейса: wxPython (основан на wxWindows), PyGTK и т.д. Среди этих пакетов в основном такие, которые работают на одной платформе (реже - на двух).
Помимо возможностей программного описания графического интерфейса, для
Python есть несколько коммерческих и некоммерческих построителей графического
интерфейса (GUI builders), однако в данном курсе они не рассматриваются.
Заключение
В этой лекции говорилось о встроенных функциях языка Python и модулях его стандартной библиотеки. Некоторые направления будут рассмотрены более подробно в следующих лекциях. Python имеет настолько обширную стандартную библиотеку, что в