Презентация на тему Этот classный питон

по Python и Frontend разработке

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

(wikipedia)
Наследование, инкапсуляция, полиморфизм
Объект содержит данные и функции работающие с ними

SomeClass(object):
pass

должен иметь self в качестве первого аргумента
Ну почти каждый
class

SomeClass(object):

def __init__(self):
self.var = 1

def func(self):
print self.var

y):
self.x = x

self.y = y

class Vector3D(Vector2D):
def __init__(self, x, y, z):
super(Vector3D, self).__init__(x, y)
self.z = z

сам по себе
Может быть наследован любым классом

class ConsoleMixin(object):

def print_to_console(self, message):
print message

def read_from_console(self, message=''):
return raw_input(message)

def confirm(self, message):
self.print_to_console(message)
while True:
answer = self.read_from_console('yes/no: ').lower()
if answer == 'yes':
return True
if answer == 'no':
return False

run(self):
self.print_to_console('Calculating PI')

pi = 0
denominator = 1

step = 0
sign = 1
while True:
pi += sign * (4.0 / denominator)
denominator += 2
sign *= -1

step += 1
if step % 10000 == 0:
self.print_to_console('PI is %s' % pi)
self.print_to_console('On iteration %s' % step)
if not self.confirm('Would you like to continue?'):
break

утка и крякает как утка, то это, наверное, и

есть утка

def run_program(program):
try:
program.run()
except AttributeError:
print 'Not a program'

def run_program(program):
if hasattr(program, 'run'):
program.run()
else:
print 'Not a program'

y):
self.transformation = [x, y]

def update(self):
print 'Object is in %s' % self.transformation

class Player(Node3D):
pass

class Werewolf(Player):
def __init__(self, x, y):
super(Werewolf, self).__init__(x, y)
self.transformation = False

def begin_transform(self):
self.transformation = True

w = Werewolf(1, 2)
w.update() # Object is in False

y):
self.__transformation = [x, y]

def update(self):
print 'Object is in %s' % self.__transformation

class Player(Node3D):
pass

class Werewolf(Player):
def __init__(self, x, y):
super(Werewolf, self).__init__(x, y)
self.transformation = False

def begin_transform(self):
self.transformation = True

w = Werewolf(1, 2)
w.update() # Object is in [1, 2]

возможно
w = Werewolf(1, 2)
w.__transformation # AttributeError
w._Node3D__transformation # [1, 2]

datetime import datetime

def some_hard_calculations():
before = datetime.now()

pass
dt = datetime.now() - before
logger.info('Cool calculations completed in %s second(s)', dt.total_seconds())

написать один раз и использовать где нужно
@measure
def some_hard_calculations():

pass

= measure(some_hard_calculations)
@measure
def some_hard_calculations():
pass

должен отдавать функцию
IDE постарается поставить скобки в return, не

поддавайтесь!

def measure(func):
def wrapper(*args, **kwargs):
before = datetime.now()
func(*args, **kwargs)
dt = datetime.now() - before
logger.info('Cool calculations completed in %s second(s)', dt.total_seconds())
return wrapper

@measure
def some_hard_calculations():
pass

декоратор?
Нет проблем: создадим функцию, которая вернет декорирующую функцию
def measure(name):

def create_wrapper(func):
def wrapper(*args, **kwargs):
before = datetime.now()
func(*args, **kwargs)
dt = datetime.now() - before
logger.info('%s: Cool calculations completed in %s second(s)', name, dt.total_seconds())
return wrapper
return create_wrapper

@measure('Very Hard Calculations')
def some_hard_calculations():
pass

себя как функция?
class MyFunc(object):
def __call__(self):

print 'Hello World!'

my_func = MyFunc()
my_func() # Hello World!

__init__(self, name):
self.name = name

def __call__(self, func):
def wrapper(*args, **kwargs):
before = datetime.now()
func(*args, **kwargs)
self.post_measure(datetime.now() - before)
return wrapper

def post_measure(self, dt):
logger.info('%s: Cool calculations completed in %s second(s)', self.name, dt.total_seconds())


@measure('Very Hard Calculations')
def some_hard_calculations():
pass

This is extremely long running procedure, use carefully!

"""
pass

print some_hard_calculations.__doc__ # as expected

@measure('profile')
def some_hard_calculations():
"""
This is extremely long running procedure, use carefully!
"""
pass

print some_hard_calculations.__doc__ # None (!!!)

def __init__(self, name):
self.name =

name

def __call__(self, func):
@wraps(func)
def wrapper(*args, **kwargs):
before = datetime.now()
func(*args, **kwargs)
self.post_measure(datetime.now() - before)
return wrapper

def post_measure(self, dt):
logger.info('%s: Cool calculations completed in %s second(s)', self.name, dt.total_seconds())


@measure('profile')
def some_hard_calculations():
"""
This is extremely long running procedure, use carefully!
"""
pass

print some_hard_calculations.__doc__ # as expected

def wrapper(*args, **kwargs):
logger.debug('Executing function %s',

func.__name__)
func(*args, **kwargs)
return wrapper


@measure('profile')
@log_execution
def some_hard_calculations():
"""
This is extremely long running procedure, use carefully!
"""
pass

тоже можно создать
class Message(object):
def message(self):

return 'Hello World'

AnotherMessage = Message
print AnotherMessage().message()

Message = type('Message', (), {
'message': lambda self: 'Hello World'
})

print Message().message()

нужно указать метакласс

добавить
Можно валидировать
Можно программировать декларативно
Django ORM
Django Forms

duck-typing и mixin
Попробуем сделать так чтобы у класса Vector

были обязательные методы dot, length

class Structure(object):
def __init__(self, **kwargs):
for field, value in kwargs.items():
setattr(self, field, value)

class Vector(Structure):
pass

ClassMethodsValidator(object):
REQUIRED_METHODS = ()


class VectorValidator(ClassMethodsValidator):
REQUIRED_METHODS =

('dot', 'length')

name, bases, args):
for base in

bases:
if not issubclass(base, ClassMethodsValidator):
continue
for required in base.REQUIRED_METHODS:
if required not in args:
raise TypeError('The method "%s" is required' % required)

return type.__new__(cls, name, bases, args)

__init__(self, **kwargs):
for field, value in

kwargs.items():
setattr(self, field, value)

__metaclass__ = ClassMethodsValidatorMetaclass


class VectorValidator(ClassMethodsValidator):
REQUIRED_METHODS = ('dot', 'length')


class Vector(Structure, VectorValidator):
def dot(self, v):
return self.x * v.x + self.y * v.y

def length(self):
return math.sqrt(self.dot(self))

бы один из методов
__get__
__set__
__delete__
Что происходит при вызове obj.attr
obj.__dict__[‘attr’]
type(obj).__dict__[‘attr’]
Поиск по

базовым классам
Что будет если в цепочке вверху попадется дескриптор?
Будет вызван один из его методов
Только new-style классы

def __init__(self, default):
self.value =

default

def __get__(self, instance, owner):
return self.value

def __set__(self, instance, value):
self.value = value


class Vector2Di(object):
x = value(1)
y = value(1)

default, type):
self.value = default

self.type = type

def __get__(self, instance, owner):
return self.value

def __set__(self, instance, value):
if not isinstance(value, self.type):
raise AttributeError('%s is not of type %s' % (value, self.type.__name__))
self.value = value


class Vector2Di(object):
x = field(1, int)
y = field(1, int)

a = Vector2Di()

a.x = 0.2 # AttributeError