Часто задаваемые вопросы по библиотеке и расширениям

Как найти модуль или приложение для выполнения задачи X?

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

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

Где находится исходный файл math.py (socket.py, regex.py и т. д.)?

Если вы не можете найти исходный файл для модуля, он может быть встроенным или динамически загружаемым модулем, написанным на C, C++ или другом языке компилируемых модулей. В этом случае у вас может не быть исходного файла, или он находится где-то в каталоге C-источника (не в пути Python).

В Python существует (по крайней мере) три типа модулей:

1. модули, написанные на Python (.py);
2. модули, написанные на C и динамически загружаемые (.dll, .pyd, .so, .sl и т. д.);

3. модули, написанные на C и связанные с интерпретатором; чтобы получить список таких модулей, введите:

   import sys
   print(sys.builtin_module_names)
   

Как сделать скрипт Python исполняемым в Unix?

Вам нужно сделать две вещи: разрешения файла скрипта должны быть установлены как исполняемые, и первая строка должна начинаться с #! и далее следовать путь к интерпретатору Python.

Первое делается выполнением chmod +x scriptfile или chmod 755 scriptfile.

Второе можно сделать несколькими способами. Самый простой способ - написать

#!/usr/local/bin/python

в качестве первой строки вашего файла, используя полное имя файла интерпретатора Python на вашей платформе.

Если вы хотите, чтобы скрипт не зависел от расположения интерпретатора Python, вы можете использовать программу env. Почти все варианты Unix поддерживают следующее, предполагая, что интерпретатор Python находится в каталоге в переменной окружения пользователя PATH:

#!/usr/bin/env python

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

Иногда среда пользователя настолько переполнена, что программа /usr/bin/env не работает; или программа env вообще отсутствует. В этом случае вы можете попробовать следующую хитрость (предложенная Алексом Резинским):

#! /bin/sh
""":"
exec python $0 ${1+"$@"}
"""

Незначительным недостатком является то, что это определяет строку документации __doc__ скрипта. Однако вы можете исправить это, добавив

__doc__ = """...Whatever..."""

Есть ли пакет curses/termcap для Python?

Для систем Unix: стандартное распределение исходного кода Python поставляется с модулем curses в подкаталоге Modules, хотя он не компилируется по умолчанию. (Обратите внимание, что это не доступно в дистрибутиве для Windows — модуля curses для Windows нет.)

Модуль curses поддерживает базовые функции curses, а также многие дополнительные функции из ncurses и SYSV curses, такие как цвет, поддержка альтернатного набора символов, области и поддержка мыши. Это означает, что модуль несовместим с операционными системами, в которых есть только BSD curses, но, похоже, в настоящее время нет поддерживаемых ОС, которые попадают в эту категорию.

Есть ли аналог C-функции onexit() в Python?

Модуль atexit предоставляет функцию регистрации, аналогичную C-функции onexit().

Почему мои обработчики сигналов не работают?

Самая распространённая проблема заключается в том, что обработчик сигнала объявлен с неправильным списком аргументов. Он вызывается как

handler(signum, frame)

поэтому его следует объявить с двумя параметрами:

def handler(signum, frame):
    ...

Как протестировать программу или компонент Python?

Python поставляется с двумя фреймворками для тестирования. Модуль doctest находит примеры в строках документации модуля и выполняет их, сравнивая результат с ожидаемым результатом, указанным в строке документации.

Модуль unittest — это более продвинутый фреймворк для тестирования, основанный на фреймворках тестирования Java и Smalltalk.

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

«Глобальная логика» вашей программы может быть такой простой, как

if __name__ == "__main__":
    main_logic()

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

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

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

if __name__ == "__main__":
    self_test()

Даже программы, взаимодействующие со сложными внешними интерфейсами, могут быть протестированы, когда внешние интерфейсы недоступны, с помощью «фиктивных» интерфейсов, реализованных на Python.

Как создать документацию из строк документации?

Модуль pydoc может создавать HTML из строк документации в вашем исходном коде Python. Альтернативный способ создания документации API исключительно из строк документации — epydoc. Sphinx также может включать содержимое строк документации.

Как получить один нажатие клавиши за раз?

Для вариантов Unix существует несколько решений. Это просто сделать с помощью curses, но curses — это довольно большой модуль, требующий изучения.

Как программировать с использованием потоков?

Убедитесь, что вы используете модуль threading, а не модуль _thread. Модуль threading создаёт удобные абстракции поверх низкоуровневых примитивов, предоставляемых модулем _thread.

Ни один из моих потоков, похоже, не выполняется: почему?

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

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

import threading, time

def thread_task(name, n):
    for i in range(n):
        print(name, i)

for i in range(10):
    T = threading.Thread(target=thread_task, args=(str(i), i))
    T.start()

time.sleep(10)  # <---------------------------!

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

Простым решением является добавление небольшой паузы в начале функции run:

def thread_task(name, n):
    time.sleep(0.001)  # <--------------------!
    for i in range(n):
        print(name, i)

for i in range(10):
    T = threading.Thread(target=thread_task, args=(str(i), i))
    T.start()

time.sleep(10)

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

Как распределить работу между несколькими рабочими потоками?

Самый простой способ — использовать модуль concurrent.futures, особенно класс ThreadPoolExecutor.

Или, если вы хотите тонко контролировать алгоритм распределения, вы можете написать свою логику вручную. Используйте модуль queue для создания очереди, содержащей список задач. Класс Queue поддерживает список объектов и имеет метод .put(obj) для добавления элементов в очередь и метод .get() для их возвращения. Класс позаботится о необходимой блокировке, чтобы гарантировать, что каждая задача передаётся ровно один раз.

Вот тривиальный пример:

import threading, queue, time

# The worker thread gets jobs off the queue.  When the queue is empty, it
# assumes there will be no more work and exits.
# (Realistically workers will run until terminated.)
def worker():
    print('Running worker')
    time.sleep(0.1)
    while True:
        try:
            arg = q.get(block=False)
        except queue.Empty:
            print('Worker', threading.current_thread(), end=' ')
            print('queue empty')
            break
        else:
            print('Worker', threading.current_thread(), end=' ')
            print('running with argument', arg)
            time.sleep(0.5)

# Create queue
q = queue.Queue()

# Start a pool of 5 workers
for i in range(5):
    t = threading.Thread(target=worker, name='worker %i' % (i+1))
    t.start()

# Begin adding work to the queue
for i in range(50):
    q.put(i)

# Give threads time to run
print('Main thread sleeping')
time.sleep(5)

При выполнении это даст следующий вывод:

Running worker
Running worker
Running worker
Running worker
Running worker
Main thread sleeping
Worker <Thread(worker 1, started 130283832797456)> running with argument 0
Worker <Thread(worker 2, started 130283824404752)> running with argument 1
Worker <Thread(worker 3, started 130283816012048)> running with argument 2
Worker <Thread(worker 4, started 130283807619344)> running with argument 3
Worker <Thread(worker 5, started 130283799226640)> running with argument 4
Worker <Thread(worker 1, started 130283832797456)> running with argument 5
...

Обратитесь к документации модуля для получения более подробной информации; класс Queue предоставляет функциональный интерфейс.

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

Внутренне используется глобальная блокировка интерпретатора (GIL), чтобы гарантировать, что только один поток работает в виртуальной машине Python одновременно. В целом, Python предлагает переключение между потоками только между инструкциями байткода; частоту переключения можно установить с помощью sys.setswitchinterval(). Следовательно, каждая инструкция байткода, а также весь код реализации на C, достижимый из каждой инструкции, является атомарной с точки зрения программы Python.

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

Например, следующие операции являются атомарными (L, L1, L2 — списки, D, D1, D2 — словари, x, y — объекты, i, j — целые числа):

L.append(x)
L1.extend(L2)
x = L[i]
x = L.pop()
L1[i:j] = L2
L.sort()
x = y
x.field = y
D[x] = y
D1.update(D2)
D.keys()

Эти операции нет:

i = i+1
L.append(L[-1])
L[i] = L[j]
D[x] = D[x] + 1

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

Нельзя ли избавиться от глобальной блокировки интерпретатора?

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

В те далёкие дни Python 1.5 Грег Штайн фактически реализовал полную набор исправлений (патчи «свободных потоков»), которые удалили GIL и заменили его мелкозернистыми блокировками. Адам Олсен недавно провел аналогичный эксперимент в своём проекте python-safethread. К сожалению, оба эксперимента показали резкое падение производительности однопоточных процессов (по крайней мере на 30% медленнее) из-за количества мелкозернистых блокировок, необходимых для компенсации удаления GIL.

Это не означает, что вы не можете эффективно использовать Python на машинах с несколькими процессорами! Вам просто нужно проявить творчество, разбивая работу между несколькими процессами, а не несколькими потоками. Класс ProcessPoolExecutor в новом модуле concurrent.futures обеспечивает лёгкий способ сделать это; модуль multiprocessing предоставляет низкоуровневый API в случае необходимости более точного контроля над диспетчеризацией задач.

Целенаправленное использование C-расширений также поможет; если вы используете C-расширение для выполнения ресурсоёмкой задачи, расширение может освободить GIL во время выполнения кода на C и позволить другим потокам выполнить некоторую работу. Некоторые модули стандартной библиотеки, такие как zlib и hashlib, уже делают это.

Было предложено, что GIL должен быть блокировкой на уровне состояния интерпретатора, а не глобальной; тогда интерпретаторы не смогут обмениваться объектами. К сожалению, это вряд ли произойдёт. Это потребовало бы огромных усилий, так как многие реализации объектов в настоящее время имеют глобальное состояние. Например, небольшие целые числа и короткие строки кэшируются; эти кэши должны быть перемещены в состояние интерпретатора. Другие типы объектов имеют свой собственный список свободных объектов; эти списки свободных объектов должны быть перемещены в состояние интерпретатора. И так далее.

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

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

Как удалить файл? (И другие вопросы о файлах…)

Используйте os.remove(filename) или os.unlink(filename); для документации см. модуль os. Эти две функции идентичны; unlink() — просто имя системного вызова Unix для этой функции.

Для удаления каталога используйте os.rmdir(); для создания каталога используйте os.mkdir(). os.makedirs(path) создаст все промежуточные каталоги в path, которые не существуют. os.removedirs(path) удалит промежуточные каталоги, если они пустые; если вы хотите удалить всю древовидную структуру каталога и её содержимое, используйте shutil.rmtree().

Для переименования файла используйте os.rename(old_path, new_path).

Для обрезки файла откройте его с помощью f = open(filename, "rb+"), и используйте f.truncate(offset); смещение по умолчанию — текущая позиция поиска. Также есть os.ftruncate(fd, offset) для файлов, открытых с помощью os.open(), где fd — дескриптор файла (маленькое целое число).

Модуль shutil также содержит ряд функций для работы с файлами, включая copyfile(), copytree() и rmtree().

Как скопировать файл?

Модуль shutil содержит функцию copyfile(). Обратите внимание, что на томах Windows NTFS он не копирует альтернативные потоки данных (alternate data streams) ни ресурсные вилки (resource forks) на томах macOS HFS+, хотя оба сейчас редко используются. Он также не копирует разрешения и метаданные файла, хотя использование shutil.copy2() вместо этого сохранит большинство (хотя и не все) из них.

Как читать (или записывать) двоичные данные?

Для чтения или записи сложных двоичных форматов данных лучше всего использовать модуль struct. Он позволяет преобразовывать строку, содержащую двоичные данные (обычно числа), в объекты Python и наоборот.

Например, следующий код считывает два целых числа с размером 2 байта и одно целое число с размером 4 байта в формате big-endian из файла:

import struct

with open(filename, "rb") as f:
    s = f.read(8)
    x, y, z = struct.unpack(">hhl", s)

Символ ‘>’ в строке формата указывает на формат big-endian; символ ‘h’ считывает одно «короткое целое число» (2 байта), а ‘l’ — одно «длинное целое число» (4 байта) из строки.

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

Не могу использовать os.read() для канала, созданного с помощью os.popen(); почему?

os.read() — это функция низкого уровня, которая принимает дескриптор файла, небольшое целое число, представляющее открытый файл. os.popen() создаёт объект файла высокого уровня, такого же типа, как и тот, который возвращает встроенная функция open(). Таким образом, для чтения n байтов из канала p, созданного с помощью os.popen(), вам нужно использовать p.read(n).

Как получить доступ к последовательному (RS232) порту?

Для Win32, OSX, Linux, BSD, Jython, IronPython:

https://pypi.org/project/pyserial/

Для Unix см. сообщение в Usenet от Митча Чапмана:

https://groups.google.com/groups?selm=34A04430.CF9@ohioee.com

Почему закрытие sys.stdout (stdin, stderr) не приводит к его реальному закрытию?

Объекты файлов Python — это абстракционный слой высокого уровня над дескрипторами файлов C низкого уровня.

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

Но stdin, stdout и stderr обрабатываются Python особым образом, из-за их особого статуса в C. Выполнение sys.stdout.close() помечает объект файла на уровне Python как закрытым, но не закрывает связанный с ним дескриптор файла C.

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

os.close(stdin.fileno())
os.close(stdout.fileno())
os.close(stderr.fileno())

Или вы можете использовать числовые константы 0, 1 и 2 соответственно.

Какие инструменты WWW доступны для Python?

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

Резюме доступных фреймворков поддерживается Полом Бодди на https://wiki.python.org/moin/WebProgramming.

Кэмерон Лэрд поддерживает полезный набор страниц о веб-технологиях Python по адресу https://web.archive.org/web/20210224183619/http://phaseit.net/claird/comp.lang.python/web_python.

Как можно имитировать отправку формы CGI (METHOD=POST)?

Мне нужно получить веб-страницы, которые являются результатом отправки формы POST. Существует ли готовый код, который позволит мне сделать это легко?

Да. Вот простой пример, который использует urllib.request:

#!/usr/local/bin/python

import urllib.request

# build the query string
qs = "First=Josephine&MI=Q&Last=Public"

# connect and send the server a path
req = urllib.request.urlopen('http://www.some-server.out-there'
                             '/cgi-bin/some-cgi-script', data=qs)
with req:
    msg, hdrs = req.read(), req.info()

Обратите внимание, что в общем случае для операций POST с кодировкой процентов строки запроса должны быть приведены к канонической форме с помощью urllib.parse.urlencode(). Например, для отправки name=Guy Steele, Jr.:

>>> import urllib.parse
>>> urllib.parse.urlencode({'name': 'Guy Steele, Jr.'})
'name=Guy+Steele%2C+Jr.'

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

Вы можете найти набор полезных ссылок на странице вики «Веб-программирование» Web Programming wiki page.

Как отправить электронное письмо из скрипта Python?

Используйте стандартный модуль библиотеки smtplib.

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

import sys, smtplib

fromaddr = input("From: ")
toaddrs  = input("To: ").split(',')
print("Enter message, end with ^D:")
msg = ''
while True:
    line = sys.stdin.readline()
    if not line:
        break
    msg += line

# The actual mail send
server = smtplib.SMTP('localhost')
server.sendmail(fromaddr, toaddrs, msg)
server.quit()

Альтернативный вариант только для Unix использует sendmail. Расположение программы sendmail варьируется в зависимости от системы; иногда это /usr/lib/sendmail, а иногда /usr/sbin/sendmail. Справочная страница sendmail поможет вам. Вот пример кода:

import os

SENDMAIL = "/usr/sbin/sendmail"  # sendmail location
p = os.popen("%s -t -i" % SENDMAIL, "w")
p.write("To: receiver@example.com\n")
p.write("Subject: test\n")
p.write("\n")  # blank line separating headers from body
p.write("Some text\n")
p.write("some more text\n")
sts = p.close()
if sts != 0:
    print("Sendmail exit status", sts)

Как избежать блокировки в методе connect() сокета?

Модуль select обычно используется для асинхронного ввода-вывода сокетов.

Чтобы предотвратить блокировку TCP-соединения, можно установить сокет в режим «неблокирующего» режима. Затем, когда вы выполните socket.connect(), вы либо подключитесь немедленно (маловероятно), либо получите исключение, содержащее номер ошибки как .errno. errno.EINPROGRESS указывает, что соединение в процессе, но еще не завершено. Разные операционные системы будут возвращать разные значения, поэтому вам нужно будет проверить, что возвращается на вашей системе.

Вы можете использовать метод socket.connect_ex() чтобы избежать создания исключения. Он просто вернет значение errno. Для опроса можно вызвать socket.connect_ex() снова позже — 0 или errno.EISCONN указывают, что вы подключены — или вы можете передать этот сокет в select.select() для проверки возможности записи.

Существуют ли интерфейсы к пакетам баз данных в Python?

Да.

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

Поддержка большинства реляционных баз данных доступна. Подробную информацию см. на странице вики «Программирование баз данных» DatabaseProgramming wiki page.

Как реализовать персистентные объекты в Python?

Модуль библиотеки pickle решает эту задачу очень общим образом (хотя вы по-прежнему не можете хранить такие вещи, как открытые файлы, сокеты или окна), а модуль библиотеки shelve использует pickle и (g)dbm для создания персистентных отображений, содержащих произвольные объекты Python.

Как сгенерировать случайные числа в Python?

Стандартный модуль random реализует генератор случайных чисел. Использование простое:

import random
random.random()

Возвращает случайное число с плавающей запятой в диапазоне [0, 1).

В этом модуле также есть много других специализированных генераторов, таких как:

• randrange(a, b) выбирает целое число в диапазоне [a, b).
• uniform(a, b) выбирает число с плавающей точкой в диапазоне [a, b).
• normalvariate(mean, sdev) выбирает образец нормального (гауссовского) распределения.

Некоторые функции более высокого уровня работают непосредственно со строками, например:

• choice(S) выбирает случайный элемент из заданной последовательности.
• shuffle(L) перемешивает список на месте, т. е. случайным образом переупорядочивает его.

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