Наверное любому программисту приходится часто писать конструкции такого вида:

if a == b:
    c = d
else:
    c = e

Как-то разбирая исходники какого-то проекта наткнулся на весьма компактную замену. Вот для сравнения два аналогичных блока кода с использованием логических операций python’а и с использованием конструкции if-else:

# if-else:
if random.random() > 0.5:
    a = 1
else:
    a = 0

# and-or style:
a = random.random() > 0.5 and 1 or 0

На мой взгляд выглядит гораздо лучше и компактнее (да-да, if-else можно записать в 2 строчки вместо 4, но мне так не нравится ^__^) . Другое дело, что некоторым это может показаться противоречиво с некоторыми пунктами дзена python’а (import this), но это спорно :). В общем использую там, где считаю нужным.

Кстати, если кого-то интересует производительность, то она примерно одинакова, далее выложу тесты и объяснение логики для тех, кому интересно.

>>> import timeit
>>> t1 = timeit.Timer('if random.random()>0.5:a=1\nelse:a =0', 'from __main__ import a\nimport random')
>>> t2 = timeit.Timer('a=random.random()>0.5 and 1 or 0', 'from __main__ import a\nimport random')
>>> t1.repeat()
[0.21074632467116317, 0.2097615509806019, 0.20978293771349854]
>>> t2.repeat()
[0.21944338095772764, 0.21785226684687586, 0.21940797240040411]

Тесты привёл, теперь объяснение.

Дело в том, что логические операции and и or в python’е возвращают один из операндов. Операция and возвращает первый операнд, если он приводится к логическому типу False, иначе — второй. Операция or наоборот, возвращает 1й операнд, если он приводится к типу True, иначе — второй. Всё это связано с «ленивостью» (lazy) операций, вычисляется столько аргументов, сколько надо для того, чтобы однозначно определить результат (например, 1 or x всегда даёт True, поэтому x не вычисляется).

Итак, опустим настройку и подключение Hibernate, предположим, что вы это уже сделали :). Быть может, напишу об этом позже. Требуется удалить из таблицы player (которая маппится с классом Player, естественно… или наоборот :) ) некоторые записи. Если мы знаем id игрока, тогда всё элементарно (как и в других случаях)):

Теперь рассмотрим случай, когда надо удалить много записей.

В ORM’е Hibernate несколько способов провернуть это. 1й — очевидный, с помощью createQuery выбрать все нужные записи HQL’ом и в цикле удалять по одной:

players_list = session.createQuery("FROM Player WHERE name = :name")\
    .setParameter("name", "Василий")\
    .list()
for player in players_list:
    session.delete(player)

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

Вот таким способом можно избавиться от всех неугодных нам Василиев ;). Так же есть возможность воспользоваться сырым sql с помощью Session.createSQLQuery().

Ссылки:
Документация по Hibernate.

# -*- coding: utf-8 -*-

import cgi
from os import curdir, sep
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
import subprocess

class MyHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        try:
            if self.path != "/output.exe":
                f = open(curdir+sep+"upload.html")
                self.send_response(200)
                self.send_header("Content-type", "text/html")
                self.end_headers()
                self.wfile.write(f.read())
                f.close()
            else:
                self.send_response(200)
                self.send_header("Content-type", "application/octet-stream")
                self.end_headers()
                self.wfile.write(open(curdir+sep+"output.exe", "rb").read())
        except IOError:
            self.send_error(404,"File Not Found: %s" % self.path)

    def do_POST(self):
        try:
            ctype, pdict = cgi.parse_header(self.headers.getheader("content-type"))
            if ctype == "multipart/form-data":
                query = cgi.parse_multipart(self.rfile, pdict)
            self.send_response(200)
            self.end_headers()
            upfile = query.get("file")

            f = open(curdir+sep+"output.exe", "wb")
            f.write(upfile[0])
            f.close()

            params = " np output.exe"

            p = query.get("encryption")
            if p[0] == "aes":
                params += " sf 1"
            elif p[0] == "rc5":
                params += " sf 2"
            elif p[0] == "xor":
                params += " sf 3"
            else:
                params += " sf 0"

            p = query.get("hw_bind")
            if p[0] == "yes":
                p = query.get("hw_bind_serial")
                assert len(p[0]) == 8
                params += " sn " + p[0]
            else:
                params += " sn 0"

            p = query.get("passwd")
            assert len(p[0]) > 0
            params += " pass " + p[0]

            p = query.get("pack")
            if p[0] == "yes":
                params += " pack 1"
            else:
                params += " pack 0"

            pipe = subprocess.Popen("processor.exe "+params, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            pipe.stdin.close()
            pipe.wait()

            self.wfile.write('<a href="/output.exe">Download results</a>.');
        except :
            pass

if __name__ == "__main__":
    try:
        server = HTTPServer(("", 8080), MyHandler)
        print "started httpserver..."
        server.serve_forever()
    except KeyboardInterrupt:
        print "^C received, shutting down server"
        server.socket.close()

Итак, для начала импортируем из библиотеки BaseHTTPServer два класса: HTTPserver — собственно, сам вёб-сервер и BaseHTTPRequestHandler — класс, который служит для обработки запросов от пользователей.

Объявляем свой класс MyHandler, который наследуется от BaseHTTPRequestHandler. И перегружаем в нём два метода — do_GET и do_POST для обработки данных, переданных методом GET и POST, соответственно.

В первом обработчике проверяем запрос от пользователя (содержится в self.path), если запрашиваемый документ не является /output.exe, то выдаём форму для загрузки файла, иначе — считываем и выдаём output.exe. Так же, перед этим, посылается ответ от сервера с кодом 200, что соответствует успешной обработке запроса от клиента и передаём заголовок, в котором указан тип содержимого (text/html для html-код или application/octet-stream для бинарного файла).

В обработке POST-запроса проверяем какие данные были переданы. Сначала получаем файл и записываем его под именем output.exe. Далее формируем строку параметров на основе переданных от пользователя данных, запускаем хранящуюся на сервере программу для обработки полученных файлов, ждём пока она завершится и выдаём ссылку на скачивание результата.

Далее, в самой программе создаём вёб-сервер, указав при этом порт, на котором он будет работать (в примере это 8080) и класс, который необходимо использовать для обработки запросов от пользователей.

Недостаток заключается в том, что данная реализация не сможет обработать одновременную загрузку файлов от разных пользователей, т.к. в лучшем случае просто один из запросов затрёт файл output.exe, полученный в другом запросе. Но такая задача не стояла. На мой взгляд хороший пример для демонстрации возможностей python’а.

Так же код html-файла upload.html, который должен располагаться в той же директории, что и сервер:

<form action="/" enctype="multipart/form-data" method="post">
<table border="1">
<tbody>
<tr>
<td>Encryption:</td>
<td>
<input checked="checked" name="encryption" type="radio" value="none" />None
<input name="encryption" type="radio" value="aes" />AES
<input name="encryption" type="radio" value="rc5" />RC5
<input name="encryption" type="radio" value="xor" />XOR</td>
</tr>
<tr>
<td>Hardware binding:</td>
<td>
<input checked="checked" name="hw_bind" type="radio" value="no" />No
<input name="hw_bind" type="radio" value="yes" />Yes
<input name="hw_bind_serial" value="media serial number" /></td>
</tr>
<tr>
<td>Password:</td>
<td>
<input name="passwd" type="password" /></td>
</tr>
<tr>
<td>Pack:</td>
<td>
<input checked="checked" name="pack" type="radio" value="no" />No
<input name="pack" type="radio" value="yes" />Yes</td>
</tr>
<tr>
<td colspan="2">
<input name="file" type="file" />
<input type="submit" value="Отправить" /></td>
</tr>
</tbody></table>
</form>

Ссылки к статье:

http://ru.wikipedia.org/wiki/Список_кодов_состояния_HTTP — Список кодов состояния HTTP.

Решений у этого вопроса несколько.
1 — Запускать эти вычисления в отдельном потоке, что меня вполне устроило:

# -*- coding: utf-8 -*-
from Tkinter import *
import threading, time

class AppGUI:
    def __init__(self):
        self.tk = Tk()
        frame = Frame(self.tk)
        frame.pack()
        Button(frame, text="Compute", command=self.computeWithGUIAntifreeze).pack()

        def run(self):
            self.tk.mainloop()

    def computeWithGUIAntifreeze(self):
        """ Метод-прокладка для запуска в новом потоке вычислений """
        threading.Thread(target=self.compute).start()

    def compute(self):
        """" Тут как раз и происходят длительные вычисления """"
        time.sleep(15)

gui = AppGUI()
gui.run()

2 — Использовать время от времени методы:

• Tk.update();
• Tk.update_idletasks() — только обновляет окна, но не вызывает обработку событий, сгенерированных пользователем, в отличие от Tk.update();

Использовать эти методы стоит с осторожностью, дабы не возникло неприятных ситуаций (подробнее в документации). Таково предостережение официальной документации.

Ссылки к посту:
http://www.tcl.tk/man/tcl8.5/TclCmd/update.htm — официальная документация по Tcl/Tk.

Сам класс для перебора паролей ко всему и вся таков:

# -*- coding: utf-8 -*-

EN = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
en = "abcdefghijklmnopqrstuvwxyz"
RU = "АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ"
ru = "абвгдеёжзийклмнопрстуфхцчшщъыьэюя"
digits = "1234567890"
space = " "
p = ",.-!?;:'\"/()"
op = "+-*/:^()<>="
all_spec = "`~!@#$%^&*-_=+\\|/?.>,< '\";:[]{}"

class ABCIterator:
    firstuse_flag = True
    stop = None

    def __init__(self, start="", stop=None, start_len=None, stop_len=None, abc=en+EN+digits+all_spec):
        assert len(abc) > 0
        if start_len is not None:
            assert start_len > 0
            #assert start == ""
            self.current_str = list(abc[0]*start_len)
        else:
            self.current_str = list(filter(lambda x: x in abc, start))
        if stop_len is not None:
            assert (start_len is None) or (start_len <= stop_len)
            assert stop_len > 0
            self.stop = list(abc[0]*(stop_len+1)) # т.к. итератор работает с полуотрезками
        else:
            if stop is not None: self.stop = list(filter(lambda x: x in abc, stop))
        self.abc = list(abc)

    def __iter__(self):
        return self

    def next(self):
        if (self.stop is not None) and (self.stop == self.current_str):
            raise StopIteration
        if self.current_str == []:
            self.current_str.append(self.abc[0])
            self.firstuse_flag = False
            return self.abc[0]
        elif self.firstuse_flag:
            self.firstuse_flag = False
            return "".join(self.current_str)
        offset = 0
        while offset < len(self.current_str):
            if self.current_str[offset] != self.abc[-1]:
                self.current_str[offset] = self.abc[self.abc.index(self.current_str[offset])+1]
                # выпендрёшь для полуотрезка
                if (self.stop is not None) and (self.current_str == self.stop):
                    raise StopIteration
                return "".join(self.current_str)
            self.current_str[offset] = self.abc[0]
            offset += 1
        self.current_str = [self.abc[0]] + self.current_str
        # опять же оно же
        if (self.stop is not None) and (self.current_str == self.stop):
            raise StopIteration
        return "".join(self.current_str)

А таковы мои пояснения к нему:

• firstuse_flag — свойство, которое указывает на то, что итератор используется впервые и не стоит производить итерацию, надо лишь вернуть текущее значени строки. Это нужно для того, чтобы в цикле не «съедалось» первое значение (напр., инициализировали итератор с начальной строкой «aaa», а при 1й же итерации он вернул бы, без этого чудесного свойства, «baa»)
• stop — указывает на значение, на котором пора бы уже остановиться и вызвать исключение StopIteration. Если не задано (имеет значение None), то не пора, итератор будет бесконечным
• __init__(start=», stop=None, start_len=None, stop_len=None, abc=en+EN+digits+all_spec, **kwargs) — в общем то сам конструктор. start — начальное значение, stop — конечное, если не задано или идёт до начального, то итерации происходят бесконечно. Можно так же задать начальную и конечную длину, место конкретных значений с помощью start_len и stop_len. Если задана длина и начальные значения, то приоритет будет иметь длина, что можно легко исправить, если для кого-то это критично. abc — алфавит, над которым будут производиться итерации.
• __iter__() — необходимо для того чтобы класс был полноценным итератором.
• next() — возвращает следующую строку, в общем-то этот метод так же необходим для того чтобы класс был итератором.

Пример использования:

>>> for i in ABCIterator(start_len=1, stop_len=3, abc="abc"):
...     i
...
'a'
'b'
[...]
'bcc'
'ccc'
>>>

Ну, как-то так оно и работает. Если кому-то что-то непонятно, то могу объяснить подробнее. В общем как обычно, всё в комменты ;-). Неплохо было бы ещё реализовать преобразование чисел в строки и наоборот, но это позже… может быть.

По сути получается некая прослойка между консолью и функциями самого языка программирования. В C++ пришлось наверное помучиться над этим (хотя ничего сложного, главное — знания), в python’е всё как всегда ;-).

Если мы хотим работать в интерактивном режиме — то просто выполняем скрипт, если хотим обработать скрипты — передаём их имена в параметрах программы. Например:

На сегодня, пожалуй, хватит с меня постов, подожду пока эти оценят ;-).

Для реализации поставленной задачи опять прибегнем к ксору aka XOR, исключающее или, почти шифр Вернама. Почти — потому что длина ключа у нас по сути не равна длине сообщения. Алгоритм будет таков:

1. Дано начальное значение ikey. В общем то это и будет на самом деле ключ, который используется в шифровании и расшифровке, просто он будет «спрятан» в сгенерированных ключах.
2. Генерируем 10 случайных строк по длине равных ключу ikey.
3. Для каждой строки из предыдущего пункта выполняем: xor(A, ikey) + A. Полученные строки и будут нашими ключами.

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

Реализацию ксора в python нашёл на просторах инета (выглядит довольно красиво, я пока так не умею :-)), остальное писал сам. Вот исходник:

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

Ссылки к статье:
http://code.activestate.com/recipes/496970/ — «Recipe 496970: xor for strings».

Решение оказалось в одну строчку :). Есть в python’е (да и не только в нём) такая функция с неприличным именем, как eval. Она пытается преобразовать полученное в качестве параметра выражение в некий результат. Например:

Как вы уже наверное догадались, при наличии такой функции задача сводится к тривиальной. В моей задачке был объект db, методы которого и надо было вызывать для демонстрации функций программы. Вот два варианта их вызова:

При исполнении программы вводим «db.method1(params)». Функция input([prompt]) эквивалентна вызову eval(raw_input([prompt])). Чтобы не писать каждый раз «db.», можно упростить ввод пользователя:

Теперь достаточно писать просто «method1(params)».

Так же у функции eval есть ещё 2 необязательных параметра eval(expression[, globals[, locals]]), через них можно передавать устанавливать значения глобальных и локальных переменных. Официальная документация находится тут.

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

S/KEY был разработан для аутентификации на на unix-подобных ОС, в частности, на «глупых» терминалах или на публичных компьютерах с низким уровнем доверия, где использовать долгосрочные пароли нецелесообразно. Как-то так =).

Начнём с описания протокола. Сам протокол предназначен для аутентификации пользователей с использованием одноразовых паролей. Распишем всё по шагам:

1. Для инициализации программы надо взять случайное число w, которое может быть задано как пользователем, так и компьютером. Если это число станет известным злоумышленнику, то протокол будет скомпроментирован.
2. H — односторонняя функция, но т.к. односторонних функций не существует (по крайней мере обычные смертные о них точно не знают ;-) ), то возьмём какую-нибудь функцию, которая претендует на роль односторонней. Говоря простым языком, H — хеш-функция. Возьмём и пременим её n раз. Сначала к w, потом к H(w), H(H(w)), …, H(…H(w)…).
3. Начальное секретное число w уничтожается, дабы не досталось вражине.
4. Выводим пользователю сгенерированные n-1 хешей, пользователь запоминает, или, если он не мнемоник, сохраняет их у себя в укромном месте.
5. Сохраняем на сервере ключ под номером n для данного пользователя, все остальные уничтожаем.

Теперь при попытки войти пользователь передаёт своё имя и в качестве пароля последний ключ из своего списка (ключ, который был сгенерирован на шаге n-1). Сервер получает этот ключ, находит запись о ключе для данного имени пользователя, и сравнивает результат хеширования полученного пароля с найденым у себя в базе ключом, если результат операции совпадает с введённым паролем, то допускает пользователя к своему сверхсекретному сервису (для условности обозначим его xxx ;-) ). Но это ещё не всё, ведь протокол использует одноразовые пароли, поэтому на сервере при удачной попытке входа хранящееся значение ключа заменяется на полученное в начале от пользователя (т.е. праобраз хеша), а пользователь вычёркивает из своего списка последний ключ. Т.о., при первом входе пользователь передают ключ с номером n — 1, на сервере хранится ключ с номером n, при втором n — 2 и n — 1 соответственно, и т.д..

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

Недостатки: при перехвате начального секретного ключа w можно самому сгенерировать такую последовательность; пользователя придётся инициировать заново после того, как он «израсходует» все свои ключи.

А вот и обещанная реализация:

from md5 import md5
import sys, os

def skey_register():
    name = raw_input("Enter your name: ")
    if os.path.exists(name):
        print "Error, user always exists."
        sys.exit(-1)
    r = raw_input("Enter random sequence R: ")
    for i in range(100):
            r = md5(r).hexdigest()
            print i, r
    key = md5(r).hexdigest()
    try:
        f = open(name, "w")
    except:
        print "Error, can't open file %s for write!" % name
        sys.exit(-1)
    f.write(key)
    f.close()

def skey_login():
    name = raw_input("Enter your name: ")
    try:
        f = open(name, "r")
    except:
        print "Error, can't open file %s!" % name
        sys.exit(-1)
    passwd = f.read()
    f.close()
    upasswd = raw_input("Enter password: ")
    new_upasswd = md5(upasswd).hexdigest()
    if new_upasswd != passwd:
        print "Invalid password!"
    else:
        print "Login successful!"
        f = open(name, "w")
        f.write(upasswd)
        f.close()

if __name__ == "__main__":
    while True:
        action = raw_input("Enter action ((r)egister, (l)ogin or (q)uit): ")
        if action == "r":
            skey_register()
        elif action == "l":
            skey_login()
        elif action == "q":
            sys.exit(0)

На мой взгяд код достаточно примитивен, поэтому комментировать не буду, если у кого вопросы — на форум ;-). В качестве хеш-функции была выбрана md5.

Ссылки к статье:
http://en.wikipedia.org/wiki/Skey — Skey на английской википедии.

Начнём с функции масштабирования.

import Image

def create_thumbnails(img, size):
    thumbnails = []
    for s in size:
        if img.size[0] == img.size[1]:
                thumbnails.append(img.resize((s, s), Image.ANTIALIAS))
        elif img.size[0] > img.size[1]:
            ratio = float(img.size[0]) / s
            thumbnails.append(img.resize((s, int(img.size[1]/ratio)), Image.ANTIALIAS))
        else:
            ratio = float(img.size[1]) / s
            thumbnails.append(img.resize((int(img.size[0]/ratio), s), Image.ANTIALIAS))
    return thumbnails

if __name__ == "__main__":
    img = Image.open("1.jpg")
    thumbs = create_thumbnails(img, (1000, ))
    thumbs.extend(create_thumbnails(img, (500, 250, 100)))

    c = 0
    for t in thumbs:
        t.save("%dt.jpg" % c)
        c += 1

UPD: Как оказалось, код выше — велосипед :). Всё делается проще. Вместо вычисления соотношений пишем просто img.thumbnail((100, 100), Image.ANTIALIAS), остально за Вас всё сделает питон… Эхх, никакой свободы мысли ;).

Функция Image.open(), как Вы догадались, открывает изображение для дальнейших манипуляций с ним. Наша функция принимает полученный в результате открытия объект и список размеров (поэтому, если мы передаём один размер, то надо указать в параметрах, например, (100, ), а не просто (100)), по которым потом и будем масштабировать. Масштабирование происходит по большей стороне с сохранением пропорций. Возваращает функция так же список полученных превьюшек.

img.resize() — вторым параметром указывается метод преобразования, с Image.ANTIALIAS получается наиболее лучший вариант, так же можно указать Image.NEAREST, Image.BILINEAR, Image.BICUBIC вместо ANTIALIAS, первым — список из ширины и высоты нового изображения.

Теперь перейдём к водяным знакам. Для начала создадим какой-нибудь рисунок или надпись с прозрачным фоном и сохраним в формате png — это и будет наш водяной знак. Можно накладывать его разным способами, мы реализуем клонирование с заданным интервалом. Итак, вот как это примерно будет выглядеть:

import Image, ImageEnhance

def add_watermark(image, watermark, opacity=1, wm_interval=0):
    assert opacity >= 0 and opacity <= 1
    if opacity < 1:
        if watermark.mode != 'RGBA':
            self.watermark = watermark.convert('RGBA')
        else:
            watermark = watermark.copy()
        alpha = watermark.split()[3]
        alpha = ImageEnhance.Brightness(alpha).enhance(opacity)
        watermark.putalpha(alpha)

    layer = Image.new('RGBA', image.size, (0,0,0,0))
    for y in range(0, image.size[1], watermark.size[1]+wm_interval):
        for x in range(0, image.size[0], watermark.size[0]+wm_interval):
            layer.paste(watermark, (x, y))
    return Image.composite(layer,  image,  layer)

if __name__ == "__main__":
    img = Image.open("1.jpg")
    wm = Image.open("wm.png")
    add_watermark(img, wm, 0.5, 50).save("wm_1.jpg")

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

Ссылки к статье:
http://code.activestate.com/recipes/362879/ - Watermark with PIL.
- Resize an image (Python).