Архив метки: 2.x

Fabric: Модель выполнения

Если Вы читали руководство, то Вы должны быть уже знакомы с тем, как Fabric работает (с одной задачей на одном хосте). Однако, во многих ситуациях Вы можете захотеть выполнить несколько задач и/или на нескольких хостах. Возможно, Вы захотите разделить одну большую задачу на несколько маленьких, или обойти список серверов в поисках тех, на которых надо удалить выбранного пользователя. Все эти сценарии требуют некоторых правил о том, как и когда выполняются задачи.
Этот документ описывает модель выполнения Fabric, включая главный цикл выполнения, определение списка хостов, создание подключений и т.д.

Стратегия выполнения

По умолчанию Fabric работает в одиночном, последовательном режиме выполнения, хотя, начиная с версии 1.3, доступна параллельная модель выполнения (см параллельное выполнение). Поведение по умолчанию заключается в следующем:
  • Создаётся список задач. На данный момент это просто список аргументов, переданных fab'y, сохраняя порядок аргументов
  • Для каждой задачи из разных источников создаётся список хостов (подробнее см «Как создаётся список хостов» ниже)
  • Проходится список задач, каждая задача запускается один раз для каждого хоста в списке
  • Задачи, для которых нет хостов в списке хостов, выполняются только локально и всегда запускаются только один раз
Таким образом, если у нас есть следующий fabfile:
    from fabric.api import run, env

env.hosts = ['host1', 'host2']

def taskA():
run('ls')

def taskB():
run('whoami')
и мы выполняем команду:
 $ fab taskA taskB
мы увидим, что Fabric выполнит следующее:
  • taskA выполняется на host1
  • taskA выполняется на host2
  • taskB выполняется на host1
  • taskB выполняется на host2
Хотя это и упрощённый подход, он позволяет очевидно сопоставить задачи и хосты и (в отличие от инструментов, которые запускают задачу сразу на нескольких узлах) позволяют реализовать логику скрипта, где Вы проверяете результат выполнения предыдущей команды и на основании этого решаете что делать дальше.

Определение задач

Подробнее о том, что такое задачи Fabric и с чем их едят, смотрите «Определение задач«

Определение списка хостов

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

Хосты

Хостами, в данном контексте, называется то, что обычно называется «строками хостов»: строка, которая определяет имя пользователя, имя хоста и номер порта: `username@hostname:port`. Пользователя и порт (и, соответственно, `@` и `:`) могут быть опущены; в таком случае будет использоваться локальное имя пользователя и порт 22. Таким образом, «admin@foo.com:222», «deploy@website» и «nameserver1» могут быть использованы в качестве строк хостов.
Так же поддерживается нотация IPv6, например, «::1», «[::1]:1222», «user@2001:db8::1» или «user@[2001:db8::1]:1222». Квадратные скобки нужны только для того, чтобы отделить адрес от номера порта. Если номер порта не указан, то скобки тоже можно не использовать. Кроме того, если строка хоста задаётся через командную строку, то в некоторых оболочках может потребоваться экранировать эти скобки.
Примечание: Раздел между именем пользователя и именем хоста происходит по последнему найденному знаку @, так что можно вполне использовать email адрес в качестве имени пользователя.
В процессе выполнения Fabric нормализует полученную строку хоста и затем сохраняет каждую часть (имя пользователя / имя хоста / порт) в словаре окружения и для их использования и для того, чтобы задачи по необходимости могли на них сослаться. Более детально смотри в «Словарь окружения«.

Роли

Строка хоста определяют один хост, но иногда бывает полезно объединить хосты в группы. Возможно, у Вас есть несколько Web серверов за балансировщиком нагрузки, и Вы хотите обновить их все; или Вы хотите запустить задачу на «всех клиентских серверах». Роли п

Fabric: Обзор и руководство (Перевод)

Добро пожаловать в Fabric!

Этот документ - быстрый тур по возможностям Fabric и короткое руководство по его использованию. Дополнительная документация может быть найдена тут.

Что такое Fabric?

Как написано в README:

Fabric — это библиотека для Python (2.5 или выше) и инструмент командной строки для использования SSH при развёртывании приложений или выполнении административных задач.

Более конкретно: 

  • Инструмент, который позволяет Вам выполнить любую функцию Python при помощи командной строки
  • Библиотека подпрограмм (построенная на более низкоуровневой библиотеке), переназначенная для выполнения команд оболочки через SSH легко и по-питонски.
Обычно, большинство пользователей используют обе эти возможности, применяя Fabric для записи и выполнения функций Python или заданий, чтобы автоматизировать работу с удалённым сервером. Давайте на это посмотрим.

Hello, fab

Это не было бы хорошим руководством без стандартного примера:
def hello():
    print(«Hello world!»)
Если разместить эту функцию в модуле с именем fabfile.py в вашей рабочей директории, то эту функцию hello можно выполнить при помощи инструмента fab (устанавливаемого как часть Fabric) и будет делать именно то, что Вы ожидаете:
$ fab hello
Hello world!

Done.
Вот и всё. Таким образом Вы можете использовать Fabric как (очень) простой способ сборки даже без импорта какого либо из его API.
Примечание: Инструмент fab просто просто импортирует ваш fabfile и выполняет функцию или функции, которые Вы в нём определили. Тут нет никакой магии — всё, что Вы можете сделать в обычном скрипте Python, можно сделать и в fabfile.

Аргументы задачи

Очень часто полезно передать параметры в процессе выполнения в вашу задачу, как Вы это можете сделать и в обычном скрипте Python. Fabric поддерживает эту возможность при помощи такой нотации: :,=,…. Давайте расширим наш первый пример:
def hello(name=»world»):
    print(«Hello %s!» % name)
По умолчанию, если Вы используете команду fab hello — Вы получите тот же результат, что и в раньше; но теперь Вы можете передать и имя, кого приветствовать:
$ fab hello_name=Jeff
Hello Jeff!

Done.
Те, кто уже программируют на Python, могут предположить, что то же самое можно сделать и немного по другому:
$ fab hello:Jeff
Hello Jeff!

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

Локальные команды

В примере выше fab всего лишь экономит Вам несколько строк, начинающихся после `if __name__==»__main__»`. Обычно же используется API Fabric, который содержит функции (или операции) для выполнения команд оболочки, передачи файлов и т.д.
Давайте построим гипотетическое Web приложение fabfile. Этот сценарий делает следующее: Web приложение управляется через Git на удалённом хосте vcshost. На localhost у нас есть локальный клон web-приложения.

Создаём QR коды на Python (Перевод)

Как-то раз я задумался: было бы забавно создать программу при помощи wxPython, которая генерирует QR коды и затем отображает их на экране. Поскольку, как понятно, я хотел написать её на Python, то после недолгих поисков я обнаружил трёх кандидатов на это дело:
Я воспользовался python-qrcode и pyqrnative, так как они прекрасно работают как на Windows, так и на Mac и Linux. Кроме того, они не требуют ничего больше, только Python Imaging Library. Проект pyqrcode требует дополнительных модулей и не работает на Windows, так что я даже не стал с ним заморачиваться. В итоге я взял старый код моего  Photo Viewer и немного его переиначил, чтобы получить генератор QR кодов. Если интересно — давайте поподробнее!

Приступаем

Как я уже упомянул в начале, Вам понадобится Python Imaging Library. Мы будем использовать wxPython для создания GUI, так что без него тоже не обойтись. И кроме того Вам понадобится загрузить python-qrcode и pyqrnative. Основное отличие, которое я обнаружил между ними — python-qrcode гораздо быстрее создаёт изображение и изображение именно привычного нам вида. По каким-то причинам, pyqrnative требует больше времени и создаёт более плотно выглядящие QR коды. Возможно, у каждого из проектов есть опции, меняющие вид кодов, но у обоих проектов отвратительная документация. В итоге пришлось копаться в исходниках больше, чем когда-либо.

Создаём QR коды

Итак, как только мы установили всё, что нам нужно, мы можем запустить следующий код и посмотреть, на что же способен Python:
import os
import wx
 
try:
import qrcode
except ImportError:
qrcode = None
 
try:
import PyQRNative
except ImportError:
PyQRNative = None
 
########################################################################
class QRPanel(wx.Panel):
""""""
 
#----------------------------------------------------------------------
def __init__(self, parent):
"""Constructor"""
wx.Panel.__init__(self, parent=parent)
self.photo_max_size = 240
sp = wx.StandardPaths.Get()
self.defaultLocation = sp.GetDocumentsDir()
 
img = wx.EmptyImage(240,240)
self.imageCtrl = wx.StaticBitmap(self, wx.ID_ANY,
wx.BitmapFromImage(img))
 
qrDataLbl = wx.StaticText(self, label="Текст для перевода в QR код:")
self.qrDataTxt = wx.TextCtrl(self, value="http://www.mousevspython.com", size=(200,-1))
instructions = "Имя файла с QR кодом"
instructLbl = wx.StaticText(self, label=instructions)
self.qrPhotoTxt = wx.TextCtrl(self, size=(200,-1))
browseBtn = wx.Button(self, label='Изменить место для сохранения')
browseBtn.Bind(wx.EVT_BUTTON, self.onBrowse)
defLbl = "Сохраняется по умолчанию в: " + self.defaultLocation
self.defaultLocationLbl = wx.StaticText(self, label=defLbl)
 
qrcodeBtn = wx.Button(self, label="Создать QR при помощи qrcode")
qrcodeBtn.Bind(wx.EVT_BUTTON, self.onUseQrcode)
pyQRNativeBtn = wx.Button(self, label="Создать QR при помощи PyQRNative")
pyQRNativeBtn.Bind(wx.EVT_BUTTON, self.onUsePyQR)
 
# компоновщик
self.mainSizer = wx.BoxSizer(wx.VERTICAL)
qrDataSizer = wx.BoxSizer(wx.HORIZONTAL)
locationSizer = wx.BoxSizer(wx.HORIZONTAL)
qrBtnSizer = wx.BoxSizer(wx.VERTICAL)
 
qrDataSizer.Add(qrDataLbl, 0, wx.ALL, 5)
qrDataSizer.Add(self.qrDataTxt, 1, wx.ALL|wx.EXPAND, 5)
self.mainSizer.Add(wx.StaticLine(self, wx.ID_ANY),
0, wx.ALL|wx.EXPAND, 5)
self.mainSizer.Add(qrDataSizer, 0, wx.EXPAND)
self.mainSizer.Add(self.imageCtrl, 0, wx.ALL, 5)
locationSizer.Add(instructLbl, 0, wx.ALL, 5)
locationSizer.Add(self.qrPhotoTxt, 0, wx.ALL, 5)
locationSizer.Add(browseBtn, 0, wx.ALL, 5)
self.mainSizer.Add(locationSizer, 0, wx.ALL, 5)
self.mainSizer.Add(self.defaultLocationLbl, 0, wx.ALL, 5)
 
qrBtnSizer.Add(qrcodeBtn, 0, wx.ALL, 5)
qrBtnSizer.Add(pyQRNativeBtn, 0, wx.ALL, 5)
self.mainSizer.Add(qrBtnSizer, 0, wx.ALL|wx.CENTER, 10)
 
self.SetSizer(self.mainSizer)
self.Layout()
 
#----------------------------------------------------------------------
def onBrowse(self, event):
""""""
dlg = wx.DirDialog(self, "Выберите папку:",
style=wx.DD_DEFAULT_STYLE)
if dlg.ShowModal() == wx.ID_OK:
path = dlg.GetPath()
self.defaultLocation = path
self.defaultLocationLbl.SetLabel("Сохраняем в: %s" % path)
dlg.Destroy()
 
#----------------------------------------------------------------------
def onUseQrcode(self, event):
"""

https://github.com/lincolnloop/python-qrcode

"
""
qr = qrcode.QRCode(version=1, box_size=10, border=4)
qr.add_data(self.qrDataTxt.GetValue())
qr.make(fit=True)
x = qr.make_image()
 
qr_file = os.path.join(self.defaultLocation, self.qrPhotoTxt.GetValue() + ".jpg")
img_file = open(qr_file, 'wb')
x.save(img_file, 'JPEG')
img_file.close()
self.showQRCode(qr_file)
 
#----------------------------------------------------------------------
def onUsePyQR(self, event):
"""

http://code.google.com/p/pyqrnative/

"
""
qr = PyQRNative.QRCode(20, PyQRNative.QRErrorCorrectLevel.L)
qr.addData(self.qrDataTxt.GetValue())
qr.make()
im = qr.makeImage()
 
qr_file = os.path.join(self.defaultLocation, self.qrPhotoTxt.GetValue() + ".jpg")
img_file = open(qr_file, 'wb')
im.save(img_file, 'JPEG')
img_file.close()
self.showQRCode(qr_file)
 
#----------------------------------------------------------------------
def showQRCode(self, filepath):
""""""
img = wx.Image(filepath, wx.BITMAP_TYPE_ANY)
# масштабируем изображение
W = img.GetWidth()
H = img.GetHeight()
if W > H:
NewW = self.photo_max_size
NewH = self.photo_max_size * H / W
else:
NewH = self.photo_max_size
NewW = self.photo_max_size * W / H
img = img.Scale(NewW,NewH)
 
self.imageCtrl.SetBitmap(wx.BitmapFromImage(img))
self.Refresh()
 
 
########################################################################
class QRFrame(wx.Frame):
""""""
 
#----------------------------------------------------------------------
def __init__(self):
"""Constructor"""
wx.Frame.__init__(self, None, title="QR Code Viewer", size=(550,500))
panel = QRPanel(self)
 
if __name__ == "__main__":
app = wx.App(False)
frame = QRFrame()
frame.Show()
app.MainLoop()
Код для изменения и отображения картинки разъяснён в одной из предыдущих статей (не переведена), так что единственное, что может вызвать у Вас непонимание — два метода создания кодов: onUseQrcode и onUsePyQR. Я всего лишь взял примеры с их сайтов и немного поменял их, чтобы сгенерировать изображение с кодом. Они достаточно самоочевидны, но почти не документированны, так что я не смогу сказать Вам, что же тут происходит. И, хотя оба проекта страдают на момент написания от отсутствия документации, код, тем не менее работает:
Как можно видеть — вполне стандартный код. А этот, созданный PyQRNative, выглядит гораздо более «плотным»:
Оба кода были корректно распознаны моим телефоном на  Android. Так что если Вам надо создать для вашего проекта QR код — я надеюсь, эта статья Вам поможет!

Обновление от 21/05/2012

Один из моих читателей (Mike Farmer) сообщил мне недавно, что в PyQRNative “первый аргумент — размер контейнера, а второй — избыточность / коррекция ошибок”. У меня были такие подозрения по поводу второго аргумента, но я не знаю, что делают эти уровни коррекции ошибок. К счастью, Mr. Farmer объяснил это мне: Если уровень коррекции ошибок низкий, то смазывание кода или его намокание приведёт его в нечитабельное состоянии. Если же Вы будете использовать более высокий уровень коррекции, то за счёт добавления / дублирования данных внутри кода, он сможет пережить даже потоки слёз. Более того, при высоком уровне коррекции ошибок Вы можете даже наложить на код дополнительное изображение, и он  это переживёт. В любом случае, если Вы изменяете первый параметр, Вы можете изменить размер кода. Зачем? Ну, чем больше информации Вы хотите засунуть в код, тем больше он должен быть. Mr. Farmer предложил забавный тестовый код, который позволяет вычислить минимальный возможный для вашей информации размер кода:

import PyQRNative
 
def makeQR(data_string,path,level=1):
quality={1: PyQRNative.QRErrorCorrectLevel.L,
2: PyQRNative.QRErrorCorrectLevel.M,
3: PyQRNative.QRErrorCorrectLevel.Q,
4: PyQRNative.QRErrorCorrectLevel.H}
size=3
while 1:
try:
q = PyQRNative.QRCode(size,quality[level])
q.addData(data_string)
q.make()
im=q.makeImage()
im.save(path,format="png")
break
except TypeError:
size+=1

Исходник

Автор: Ishayahu Lastov

Python 101: Перемещение файлов между серверами (Перевод)

Если Вам часто приходится заниматься системным администрированием, тогда Вы знаете, что иногда Вам нужен скрипт, который бы перемещал файлы с одного сервера на другой. Я не системный администратор, но мне часто приходится сталкиваться с такой задачей. У Python есть сторонний пакет для этой цели. Мы посмотрим на paramiko, который зависит от PyCrypto (скачать PyCrypto можно с PyPI).

Пишем код

Предположим, что у Вас уже всё установлено, так что мы можем приступать к работе. Вот код, основанный на том, что я сам использую на работе. Давайте посмотрим на него:
import paramiko
 
########################################################################
class SSHConnection(object):
""""""
 
#----------------------------------------------------------------------
def __init__(self, host, username, password, port=22):
"""Инициализируем и настраиваем соединение"""
self.sftp = None
self.sftp_open = False
 
# открываем поток SSH Transport
self.transport = paramiko.Transport((host, port))
 
self.transport.connect(username=username, password=password)
 
#----------------------------------------------------------------------
def _openSFTPConnection(self):
"""
Открываем SFTP соединение, если этого ещё не сделано
"
""
if not self.sftp_open:
self.sftp = paramiko.SFTPClient.from_transport(self.transport)
self.sftp_open = True
 
#----------------------------------------------------------------------
def get(self, remote_path, local_path=None):
"""
Копируем файл с удалённого хоста к нам
"
""
self._openSFTPConnection()
self.sftp.get(remote_path, local_path)
 
#----------------------------------------------------------------------
def put(self, local_path, remote_path=None):
"""
Копируем файл от нас на удалённый хост
"
""
self._openSFTPConnection()
self.sftp.put(local_path, remote_path)
 
#----------------------------------------------------------------------
def close(self):
"""
Закрываем SFTP и ssh соединения
"
""
if self.sftp_open:
self.sftp.close()
self.sftp_open = False
self.transport.close()
 
if __name__ == "__main__":
host = "myserver"
username = "mike"
pw = "dingbat!"
 
origin = '/home/mld/projects/ssh/random_file.txt'
dst = '/home/mdriscoll/random_file.txt'
 
ssh = SSHConnection(host, username, pw)
ssh.put(origin, dst)
ssh.close()
Достаточно просто, правда? В методе  __init__ нашего класса мы всего лишь задаём параметры соединения. В нашем случае нам надо указать хост, логин и пароль. После чего мы открываем потоковый объект SSH Transport. Затем мы вызываем наш метод put для отправки файла на удалённый сервер. С обратной задачей нам поможет справиться метод get. И, наконец, мы вызываем наш метод close, чтобы закрыть соединение. Можно заметить, что в наших методах put и get мы используем частный метод для проверки наличия соединения, чтобы открыть его в случае, если оно было по какой-то причине закрыто.

Итог

Paramiko реально облегчает нашу работу. Я очень рекомендую прочитать статью Jesse’а на эту тему (ссылка ниже), так как там всё это описывается более подробно. Мы интересно, как ещё можно решить эту задачу при помощи ssh и scp, так что я буду рад вашим комментариям. Сам я слышал хорошие отзывы о Fabric.

Дополнительное чтение

Автор: Ishayahu Lastov

Хватит использовать “print” для отладки: пятиминутное введение в модуль logging Python’а (Перевод)

  • Это руководство короткое
  • Для поиска ошибок в коде Вы можете использовать print для просмотра значений переменных
  • НЕ делайте этого. Используйте модуль logging
Модуль logging предпочтительнее, так как:
  • Легко можно поместить указатель времени в каждое сообщение
  • Вы можете использовать разные уровни срочности ваших сообщений и фильтровать их по этому уровню
  • Когда Вы захотите позже найти / изменить лог-сообщения Вы не перепутаете их с другим выводом команды print
  • Если Вы хотите вывести лог в файл, то очень легко будет игнорировать вывод лог-сообщений
Использование pirnt подходит для тех программистов, у которых достаточно времени. Но лучше использовать logging. Кроме того, научитесь использовать отладчик Python для отладки ошибок и Pylint для предотвращения появления ошибок и для того, чтобы сделать код более читаемым.
Для того, чтобы отобразить лог-сообщения на экране, используйте такой код:

import logging
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
logging.debug('This is a log message.')

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

import logging
logging.basicConfig(filename='log_filename.txt',level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
logging.debug('This is a log message.')

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

import logging
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)

formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
fh = logging.FileHandler('log_filename.txt')
fh.setLevel(logging.DEBUG)
fh.setFormatter(formatter)
logger.addHandler(fh)
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
ch.setFormatter(formatter)
logger.addHandler(ch)
logger.debug('This is a test log message.')

Убедитесь, что переменная logging глобальная, так что её смогут видеть все функции (использовать в них gloval logger не нужно, так как эта переменная только для чтения, не для записи и изменения).

Уровни логирования, от более срочных до менее срочных:
  1. CRITICAL
  2. ERROR
  3. WARNING
  4. INFO
  5. DEBUG
Вызов setLevel() устанавливает минимальный уровень логирования, нужный Вам. Например, если Вы используете fh.setLevel(logging.ERROR), тогда будут сообщения  с уровнем WARNING, INFO и DEBUG не будут записываться в файл (так как fh - обработчик лог-файла в нашем примере, в отличие от ch, который обрабатывает логи для отображения на экране).
Для записи сообщен
ий разного уровня используйте
:
  1. logger.critical('This is a critical message.')
  2. logger.error('This is an error message.')
  3. logger.warning('This is a warning message.')
  4. logger.info('This is an informative message.')
  5. logger.debug('This is a low-level debug message.')
На самом деле Вы можете делать гораздо больше, но это всё, что Вам надо знать, чтобы больше не использовать print для отладки программ.
Кроме того, функция pprint.pprint() хороша для вывода словарей и списков, особенно вложенных. Попробуйте и увидите.

Последний совет: Вы можете использовать команду tail -f logfile.txt чтобы посмотреть файл, куда будет записываться информация. Опция -f означает “follow (следовать)”. Просто оставьте окно терминала открытым с запущенной командой, и в нем автоматически будет появляться записываемый в файл текст. Этот способ избавит Вас от необходимости открывать текстовый редактор.
Команда tail присутствует на Mac OS X и Linux / *nix. На Windows Вы можете использовать для её получения проект Cygwin.

Автор: Ishayahu Lastov

Руководство по анализу производительности скриптов на Python (Перевод)

Поскольку не каждая программа на Python требует тщательного анализа производительности, отрадно знать, что когда такая необходимость возникает у Вас всё же есть отличные инструменты для этой цели.
Анализ производительности программы состоит в поиске ответа на четыре вопроса:
  1. Как быстро выполняется программа?
  2. Какое место определяет скорость её выполнения?
  3. Как много используется памяти?
  4. Где утечки памяти?
Посмотрим, что же у нас есть для ответа на эти вопросы.

Грубая оценка времени выполнения

Давайте начнём  простого и быстрого способа оценки времени выполнения нашего кода: старой доброй утилиты UNIX time:
$ time python yourprogram.py

real 0m1.028s
user 0m0.001s
sys 0m0.003s

Объяснение этого результата можно найти в этой статье. В кратце:

  • real — время от запуска программы до её завершения
  • user — время процессора, затраченное вне ядра
  • sys — время процессора, затраченное в ядре
Таким образом, сложив user и sys, Вы можете оценить сколько процессорного времени потребовалось вашей программе вне зависимости от загрузки системы.
Если эта сумма сильно больше чем реально затраченное время, тогда можно предположить, что проблемы с производительностью вашей программы связаны с ожиданием ввода / вывода.

Более точная оценка времени с использованием менеджера контекста

Вот маленький модуль, который окажет нам бесценную пользу в измерении времени выполнения:
timer.py
import time

class Timer(object):
def __init__(self, verbose=False):
self.verbose = verbose

def __enter__(self):
self.start = time.time()
return self

def __exit__(self, *args):
self.end = time.time()
self.secs = self.end - self.start
self.msecs = self.secs * 1000 # millisecs
if self.verbose:
print 'elapsed time: %f ms' % self.msecs

Для того, чтобы его использовать, мы должны обернуть тот кусок кода, время выполнения которого Вы хотите замерить в полученный менеджер контекста. Он запускает измерение времени в начале выполнения блока кода и завершает после выполнения. Вот пример использования этого модуля:
from timer import Timer
from redis import Redis
rdb = Redis()

with Timer() as t:
rdb.lpush("foo", "bar")
print "=> elasped lpush: %s s" % t.secs

with Timer as t:
rdb.lpop("foo")
print "=> elasped lpop: %s s" % t.secs
Я обычно сохраняю вывод в файл для того, чтобы отслеживать изменения производительности с ростом программы.

Построчный тайминг и частота выполнения с
помощью profiler

У Robert Kern есть замечательный проект под названием line_profiler, которым я часто пользуюсь для того, чтобы понять, как быстро выполняется каждая строчка моего кода. Чтобы его использовать — Вам надо сперва установить его при помощи pip:
$ pip install line_profiler

После установки можно использовать модуль “line_profiler” или скрипт “kernprof.py”.

Чтобы использовать этот инструмент для начала Вам надо изменить свой код, обернув функцию, производительность которой Вы хотите измерить, в декоратор @profile. Не беспокойтесь, для этого Вам не надо будет ничего импортировать. Скрипт kernprof.py автоматически добавит всё, что нужно в ваш скрипт в процессе выполнения.
primes.py
@profile
def primes(n):
if n==2:
return [2]
elif n<2:
return []
s=range(3,n+1,2)
mroot = n ** 0.5
half=(n+1)/2-1
i=0
m=3
while m <= mroot:
if s[i]:
j=(m*m-3)/2
s[j]=0
while j<half:
s[j]=0
j+=m
i=i+1
m=2*i+3
re turn [2]+[x for x in s if x]
primes(100)
После того, как Вы настроили свой скрипт — используйте usekernprof.py для его запуска.
$ kernprof.py -l -v fib.py
Опция -l указывает kernprof'у добавить декоратор @profile во встроенную область видимости вашего скрипта, а -v указывает kernprof указать информацию о тайминге после выполнения скрипта. Вывод должен выглядеть так:
Wrote profile results to primes.py.lprof
Timer unit: 1e-06 s

File: primes.py
Function: primes at line 2
Total time: 0.00019 s

Line # Hits Time Per Hit % Time Line Contents
==============================================================
2 @profile
3 def primes(n):
4 1 2 2.0 1.1 if n==2:
5 return [2]
6 1 1 1.0 0.5 elif n<2:
7 return []
8 1 4 4.0 2.1 s=range(3,n+1,2)
9 1 10 10.0 5.3 mroot = n ** 0.5
10 1 2 2.0 1.1 half=(n+1)/2-1
11 1 1 1.0 0.5 i=0
12 1 1 1.0 0.5 m=3
13 5 7 1.4 3.7 while m <= mroot:
14 4 4 1.0 2.1 if s[i]:
15 3 4 1.3 2.1 j=(m*m-3)/2
16 3 4 1.3 2.1 s[j]=0
17 31 31 1.0 16.3 while j 18 28 28 1.0 14.7 s[j]=0
19 28 29 1.0 15.3 j+=m
20 4 4 1.0 2.1 i=i+1
21 4 4 1.0 2.1 m=2*i+3
22 50 54 1.1 28.4 return [2]+[x for x in s if x]

Ищите строки с большим значением hits или time. Это те места, где скрипт можно оптимизировать.

Какое количество памяти мы используем?

Теперь, узнав время выполнения нашего кода, давайте посмотрим на объем используемой им памяти. К счастью для нас, Fabian Pedregosa сделал хороший профилировщик памяти.
Для начала установим его при помощи pip:
$ pip install -U memory_profiler
$ pip install psutil
(Установка пакета psutil сильно ускорит работу memory_profiler).
Как и line_profiler, memory_profiler требует декорирования интересующей вас функции при помощи декоратора @profile:
@profile
def primes(n):
...
...
Для того, чтобы посмотреть сколько памяти использует ваша функция запустите скрипт так:
$ python -m memory_profiler primes.py
Вот пример вывода отчёта после завершения работы скрипта:
Filename: primes.py

Line # Mem usage Increment Line Contents
==============================================
2 @profile
3 7.9219 MB 0.0000 MB def primes(n):
4 7.9219 MB 0.0000 MB if n==2:
5 return [2]
6 7.9219 MB 0.0000 MB elif n<2:
7 return []
8 7.9219 MB 0.0000 MB s=range(3,n+1,2)
9 7.9258 MB 0.0039 MB mroot = n ** 0.5
10 7.9258 MB 0.0000 MB half=(n+1)/2-1
11 7.9258 MB 0.0000 MB i=0
12 7.9258 MB 0.0000 MB m=3
13 7.9297 MB 0.0039 MB while m <= mroot:
14 7.9297 MB 0.0000 MB if s[i]:
15 7.9297 MB 0.0000 MB j=(m*m-3)/2
16 7.9258 MB -0.0039 MB s[j]=0
17 7.9297 MB 0.0039 MB while j 18 7.9297 MB 0.0000 MB s[j]=0
19 7.9297 MB 0.0000 MB j+=m
20 7.9297 MB 0.0000 MB i=i+1
21 7.9297 MB 0.0000 MB m=2*i+3
22 7.9297 MB 0.0000 MB return [2]+[x for x in s if x]

Куда утекает память?

Интерпретатор сPython использует счётчик ссылок
для управления памятью. То есть каждый объект содержит счётчик, который увеличивается на 1, когда ссылка на этот объект сохраняется где-то, и уменьшается при удалении этой ссылки. Когда счётчик становится равным нулю интерпретатор cPython знает, что объект больше не используется и можно освободить занимаемую им память.
Утечки памяти могут возникать в вашей программе если где-то сохраняется ссылка на какой-то уже не используемый объект.
Самый быстрый способ поиска таких утечек памяти — использовать восхитительный инструмент objgraph написанный Marius Gedminas. Этот инструмент помогает увидеть количество объектов в памяти и обнаружить разные места в коде, которые содержат ссылки на эти объекты.
Для начала установите objgraph:
pip install objgraph
После этого вставьте в ваш код выражения для вызова отладчика:
import pdb; pdb.set_trace()

Статистика использования объектов

В процессе выполнения Вы можете посмотреть на 20 наиболее используемых объектов в вашей программе:
(pdb) import objgraph
(pdb) objgraph.show_most_common_types()

MyBigFatObject 20000
tuple 16938
function 4310
dict 2790
wrapper_descriptor 1181
builtin_function_or_method 934
weakref 764
list 634
method_descriptor 507
getset_descriptor 451
type 439

Какие объекты были добавлены и удалены?

Для того, чтобы посмотреть, какие объекты были удалены или добавлены между двумя точками сделайте так:
(pdb) import objgraph
(pdb) objgraph.show_growth()
.
.
.
(pdb) objgraph.show_growth() # this only shows objects that has been added or deleted since last show_growth() call

traceback 4 +2
KeyboardInterrupt 1 +1
frame 24 +1
list 667 +1
tuple 16969 +1

Что ссылается на этот «утёкший объект»?

Давайте для примера возьмём простой скрипт:
x = [1]
y = [x, [x], {"a":x}]
import pdb; pdb.set_trace()
Чтобы увидеть, что ссылается на переменную x, вызовите функцию objgraph.show_backref():
(pdb) import objgraph
(pdb) objgraph.show_backref([x], filename="/tmp/backrefs.png")
На выводе Вы получите PNG изображение, сохранённое в/tmp/backrefs.png:
back refrences
Квадрат внизу с красными буквами это и есть интересующий нас объект. Мы можем увидеть, что на него ссылается x один раз и список y три раза. Если x is вызывает утечки памяти, можно воспользоваться этим методом чтобы найти эти забытые ссылки.
Ещё раз: objgraph позволяет нам:
  • посмотреть N популярных объектов в памяти вашей программы
  • посмотреть какие объекты были удалены и добавлены за какой-то период времени
  • посмотреть все ссылки на заданный объект в нашем скрипте

Эффективность против точности

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

Источник

Автор: Ishayahu Lastov