Паттерн фасад (facade) python

Фасад — структурный паттерн проектирования, позволяющий дать интерфейс более высокого уровня к сложной системе.
В отличии от адаптера, используется новый интерфейс.
Большой минус в том, что в данной концепции, фасад может стать godlike, связанным со всей системой.
Иногда фасад превращают в синглтон, т.к. обычно нужен всего 1 фасад.

реализация паттерна
[сode lang=»python»]
# coding: utf-8

class Paper(object):
«»»Бумага»»»
def __init__(self, count):
self._count = count

def get_count(self):
return self._count

def draw(self, text):
if self._count > 0:
self._count -= 1
print text

class Printer(object):
«»»Принтер»»»
def error(self, msg):
print ‘Ошибка: %s’ % msg

def print_(self, paper, text):
if paper.get_count() > 0:
paper.draw(text)
else:
self.error(‘Бумага закончилась’)

class Facade(object):
def __init__(self):
self._printer = Printer()
self._paper = Paper(1)

def write(self, text):
self._printer.print_(self._paper, text)

f = Facade()
f.write(‘Hello world!’) # Hello world!
f.write(‘Hello world!’) # Ошибка: Бумага закончилась
[/code]

паттерн Декоратор (decorator) python

Паттерн Декоратор(decorator) еще один структурный паттерн, который позовляет наделять объекты новыми свойствами и по сути является альтернативой наследованию. В отличии от адаптера не меняет интерфейс!

# coding: utf-8

class Man(object):
    """Человек"""
    def __init__(self, name):
        self._name = name

    def say(self):
        print 'Привет! Меня зовут %s!' % self._name


class Jetpack(object):
    """Реактивный ранец"""
    def __init__(self, man):
        self._man = man

    def __getattr__(self, item):
        return getattr(self._man, item)

    def fly(self):
        # расширяем функциональность объекта добавляя возможность летать
        print '%s летит на реактивном ранце!' % self._man._name


man = Man('Александр')

man_jetpack = Jetpack(man)
man_jetpack.say()  # Привет! Меня зовут Александр!
man_jetpack.fly()  # Виктор летит на реактивном ранце!

Паттерн компоновщик на python

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

Реализация паттерна компоновщик на python

# coding: utf-8


# Класс представляющий одновременно примитивы и контейнеры
class Graphic(object):
    def draw(self):
        raise NotImplementedError()

    def add(self, obj):
        raise NotImplementedError()

    def remove(self, obj):
        raise NotImplementedError()

    def get_child(self, index):
        raise NotImplementedError()


class Line(Graphic):
    def draw(self):
        print 'Линия'


class Rectangle(Graphic):
    def draw(self):
        print 'Прямоугольник'


class Text(Graphic):
    def draw(self):
        print 'Текст'


class Picture(Graphic):
    def __init__(self):
        self._children = []

    def draw(self):
        print 'Изображение'
        # вызываем отрисовку у вложенных объектов
        for obj in self._children:
            obj.draw()

    def add(self, obj):
        if isinstance(obj, Graphic) and not obj in self._children:
            self._children.append(obj)

    def remove(self, obj):
        index = self._children.index(obj)
        del self._children[index]

    def get_child(self, index):
        return self._children[index]


pic = Picture()
pic.add(Line())
pic.add(Rectangle())
pic.add(Text())
pic.draw()
# Изображение
# Линия
# Прямоугольник
# Текст

line = pic.get_child(0)
line.draw() # Линия

Паттерн мост python

Мост — структурный паттерн, основная задача которого отделить абстракцию(например интерфейс) от реализации (например бэкенд).
яркий пример — это интерфейс «пульт» и реализации «телевизор»

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

# coding: utf-8

class TVBase(object):
    """Абстрактный телевизор"""
    def tune_channel(self, channel):
        raise NotImplementedError()


class SonyTV(TVBase):
    """Телевизор Sony"""
    def tune_channel(self, channel):
        print('Sony TV: выбран %d канал' % channel)


class SharpTV(TVBase):
    """Телевизор Sharp"""
    def tune_channel(self, channel):
        print('Sharp TV: выбран %d канал' % channel)


class RemoteControlBase(object):
    """Абстрактный пульт управления"""
    def __init__(self):
        self._tv = self.get_tv()

    def get_tv(self):
        raise NotImplementedError()

    def tune_channel(self, channel):
        self._tv.tune_channel(channel)


class RemoteControl(RemoteControlBase):
    """Пульт управления"""
    def __init__(self):
        super(RemoteControl, self).__init__()
        self._channel = 0  # текущий канал

    def get_tv(self):
        return SharpTV()

    def tune_channel(self, channel):
        super(RemoteControl, self).tune_channel(channel)
        self._channel = channel

    def next_channel(self):
        self._channel += 1
        self.tune_channel(self._channel)

    def previous_channel(self):
        self._channel -= 1
        self.tune_channel(self._channel)


remote_control = RemoteControl()
remote_control.tune_channel(5)  # Sharp TV: выбран 5 канал
remote_control.next_channel() # Sharp TV: выбран 6 канал

Реализация паттерна Адаптер на python

Адаптер — это один из структурных паттернов, из названия которого исходит его и назначения. По сути это типичный переходник для разных интерфейсов или данных.
1. Адаптер имеет интерфейс, который совместим с одним из объектов.
2. Поэтому этот объект может свободно вызывать методы адаптера.
3. Адаптер получает эти вызовы и перенаправляет их второму объекту, но уже в том формате и последовательности, которые понятны второму объекту.

Вырожденная форма адаптера — двухсторонний адаптер.
Нефизические примеры из жизни — это например система СМЭВ, которая предоставляет сервисы для получения/ обмена информацией.
Однако для работы вашего приложения со СМЭВ нужны адаптеры на вашей стороне, которые могут воспринимать данные, полученные со стороны СМЭВ, переводя их в объекты, понятные вашей системе.

Существуют адаптеры класса и адаптеры объекта.

пример адаптера на python для круглых отверстий и кольев квадратного сечения

# coding=utf-8
import math


class Hole(object):
    """
    Абстрактная дырка в вашем коде
    """
    def __init__(self, r):
        # задаем радиус дыры
        self.r = r

    def put(self, obj):
        # пытаемся поместить
        try:
            # чтобы влезло, нужно,
            # чтобы радиус дырки позволял
            if self.r >= obj.r:
                print u'Лезет!'
            else:
                print u'Не лезет'
        except AttributeError:
            print (u'Переданный объект не умеет вычислять радиус дырки,' 
                   u' в которую он влезет! Напишите Адаптер на python!')


class Square(object):
    """
    Абстрактный квадратный кол, который позволит
    закрыть абстрактную дырку в коде
    """
    def __init__(self, x, h):
        # зададим параметры дрына
        self.x = x
        self.h = h


class SquareHoleAdapter(object):
    def __init__(self, sq_obj):
        self.sq_obj = sq_obj

    @property
    def r(self):
        # половина диагонали квадрата будет как раз влезать
        # в дырку радиусом с полученное значение
        return math.sqrt(2*(self.sq_obj.x**2))/2


h1 = Hole(5)
h2 = Hole(2)
s1 = Square(5, 7)
s2 = Square(3, 3)
sa = SquareHoleAdapter(s2)

h1.put(s1)
>>> Переданный объект не умеет вычислять радиус дырки, в которую он влезет! Напишите Адаптер на python!

h1.put(sa)
>>> Лезет!

h2.put(sa)
>>> Не лезет

Как вывести информацию о переменных функции? количество, названия, значения?

Еще один интересный вопрос на аттестацию по знанию внутреннего устройства функций.

def foo(a,b,c):
     x=1
     return x*a*b*c
 
# Вывести названия переменных, которые используются в функции
print foo.func_code.co_varnames
('a', 'b', 'c', 'x')
# Вывести значения, которые определены
print foo.func_code.co_consts
(None, 1)
# Вывести количество принимаемых аргументов функции
print foo.func_code.co_argcount
3

Пример реализации Singleton python

Пример порождающего паттерна singletoon на python

Основная мысль:
1. Гарантирует, что у класса есть только один экземпляр!
2. Предоставляет глобальную точку доступа (в отличии от переменных, их можно переписывать)

По сути нужно перекрыть метод, который создает объект __new__

class Singleton(object):

    def __new__(cls):
        # Перекрываем создание объекта класса
        if not hasattr(cls, 'instance'):
            cls.instance = super(Singleton, cls).__new__(cls)
        return cls.instance


s = Singleton()
print id(s)
print s

b = Singleton()
print id(b)
print b

print (s is b)

# Вывод:
# 140425907838864
# <__main__.Singleton object at 0x7fb7745a9f90>
# 140425907838864
# <__main__.Singleton object at 0x7fb7745a9f90>
# True

Как написать генератор на python

Одна из задач на собеседование:
«Написать функцию генератор значений от 0 до 2»

def generator():
    num = 0
    while num <= 2:
        yield num
        num += 1


mygen = generator()
for i in mygen:
    print i

Yield это ключевое слово, которое используется примерно как return — отличие в том, что функция вернёт генератор.

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

Довольно частая задача с подсчетом самых часто встречаемых значений в строке/списке для джуниор-разработчика превращается в костылинг и велосипединг.
Нам поможет collections!

from collections import Counter

x = [1, 3, 4, 5, 6, 7, 0, 1, 3]
a = 'python attestation'

print Counter(a).most_common()
print Counter(x).most_common()

В данном случае вывод такой:

[('t', 5), ('a', 2), ('o', 2), ('n', 2), (' ', 1), ('e', 1), ('i', 1), ('h', 1), ('p', 1), ('s', 1), ('y', 1)]
[(1, 2), (3, 2), (0, 1), (4, 1), (5, 1), (6, 1), (7, 1)]