PyDay Talk"Jacobo de Vera | @jovianjake | PyDay Tenerife 2018

Jacobo de Vera | @jovianjake | PyDay Tenerife 2018

Tech Lead en Qnective AG
Encantador de serpientes desde v2.2
Trabajo en remoto desde 2016
Incapaz de soportarun invierno de
verdad desde2016
Apenas sé hablar español técnico
Gran amante de las listas
Como esta
Python
Venga!

from dataclasses import dataclass
@dataclass
class Point:
x: int
y: int
p1 = Point(0, 0)
print(f'{p1}: x={p1.x}, y={p1.y}')
p2 = Point(x=0, y=0)
print(f'{p1} == {p2} -> {p1 == p2}’)
Point(x=0, y=0): x=0, y=0
Point(x=0, y=0) == Point(x=0, y=0) -> True

El dato estructurado
De tuplas a clases
Añadiendo funcionalidad a una clase
Dataclass
Casosmás simples
Comparabilidad
Hashabilidad
Campos
Valores por defecto
Herencia
__slots__
Funciones de apoyo
Proyectos de terceros
Alternativas

El dato estructurado

red = 255, 0, 0
orange = (255, 165, 0)
green = tuple(0, 255, 0)
>>> orange[0]
255
>>> r, g, b = orange
>>> g
165

red = list((255, 0, 0))
orange = [255, 165, 0]

red = dict(red=255, green=0, blue=0)
orange = {'red': 255,
'green': 165,
'blue': 0}
>>> orange[‘blue’]
0

( )
from collections import namedtuple
Colour = namedtuple(
'Colour', 'red green blue')
red = Colour(255, 0, 0)
orange = Colour(red=255,
green=165,
blue=0)
>>> orange.red
255

from typing import NamedTuple
class Colour(NamedTuple):
red: int
green: int
blue: int = 0 # default!
red = Colour(255, 0)
orange = Colour(red=255, green=165)
>>> red.red
255
>>> orange.blue
0

from types import SimpleNamespace
red = SimpleNamespace(red=255, green=0, blue=0)
>>> red.red
255

class Colour:
def __init__(self, red, green, blue=0):
self.red = red
self.green = green
self.blue = blue
>>> red.red
255
>>> orange.blue
0

>>> print(red)
<__main__.Colour object at 0x0000019119B09358>

def __repr__(self):
return (
f"{self.__class__.__name__}("
f"red={self.red}, green={self.green}, "
f"blue={self.blue})")
>>> print(red)
Colour(red=255, green=0, blue=0)

class Colour:
self.red = red
self.green = green
self.blue = blue
def __repr__(self):
return (f"{self.__class__.__name__}("

>>> red1 = Colour(255, 0, 0)
>>> red2 = Colour(255, 0, 0)
>>> red1 == red2
False
>>> red1 == red1
True

def __eq__(self, other):
if other.__class__ is not self.__class__:
return NotImplemented
return (self.red, self.green, self.blue) == (
other.red, other.green, other.blue)
>>> red1 = Colour(255, 0, 0)
>>> red2 = Colour(255, 0, 0)
>>> red1 == red2
True
>>> red1 is red2
False

class Colour:
self.red = red
self.green = green
self.blue = blue
def __repr__(self):
if other.__class__ is not self.__class__:

>>> list(sorted([orange, red]))
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: '<' not supported between instances of
'Colour' and 'Colour'

def __lt__(self, other):
if other.__class__ is self.__class__:
return (self.red, self.green, self.blue) < (
...
[Colour(red=255, green=0, blue=0), Colour(red=255,
green=165, blue=0)]

class Colour:
self.red = red
self.green = green
self.blue = blue
def __repr__(self):
def __ge__(self, other):
return (self.red, self.green, self.blue) >= (
def __gt__(self, other):
return (self.red, self.green, self.blue) > (
def __le__(self, other):
return (self.red, self.green, self.blue) <= (

def __delattr__(self, name):
raise TypeError(f'cannot delete field {name}')
def __setattr__(self, name, value):
raise TypeError(f'cannot assign to field {name}’)
>>> red = Colour(255, 0, 0)
File "<input>", line 4, in __init__
File "<input>", line 48, in __setattr__
TypeError: cannot assign to field red

object.__setattr__(self, "red", red)
object.__setattr__(self, "green", green)
object.__setattr__(self, "blue", blue)
>>> red = Colour(255, 0, 0)
>>> red.blue = 1
File "<input>", line 23, in __setattr__
TypeError: cannot assign to field blue

def __hash__(self):
return hash((self.red, self.green, self.blue))
>>> hash(red)
1738572376461218158
>> set([red])
{Colour(red=255, green=0, blue=0)}

class Colour:
def __repr__(self):
raise TypeError(f'cannot assign to field {name}')
def __hash__(self):

Añade.
Otro.
Campo.

El módulo dataclasses

@dataclass
class Colour:
red: int
green: int
blue: int
orange = Colour(red=255, green=165, blue=0)
red = Colour(255, 0, 0)
>>> red

# Python 3.5
from typing import Optional
def fun(width: float,
name: Optional[str]=None) -> None:
pass
# Python 3.6
temperature: float
temperature = 'cold'
class Measurement:
speed: float
__annotations__

@dataclass
class Colour:
red: int
green: int
blue: int
orange = Colour(red=255, green=165, blue=0)
red = Colour(255, 0, 0)
red2 = Colour(255, 0, 0)
>>> red == red2
True

@dataclass
class Colour:
red: int
green: int
blue: int
red = Colour(255, 0, 0)
>>> red.red = 240
>>> red

@dataclass
class Colour:
red: int
green: int
blue: int
TypeError: '<' not supported between instances of
'Colour' and 'Colour'

@dataclass(order=True)
class Colour:
red: int
green: int
blue: int
[Colour(red=255, green=0, blue=0),
Colour(red=255, green=165, blue=0)]

def dataclass(_cls=None, *, order=False):
def wrap(cls):
return _process_class(cls, order)
# See if we're being called as @dataclass
# or @dataclass().
if _cls is None:
# We're called with parens.
return wrap
# We're called as @dataclass without parens.
return wrap(_cls)

@dataclass(order=True)
class Colour:
red: int
green: int
blue: int
>>> hash(red)
TypeError: unhashable type: 'Colour'

@dataclass(order=True, frozen=True)
class Colour:
red: int
green: int
blue: int
>>> hash(red)
1738572376461218158
>> set([red])
{Colour(red=255, green=0, blue=0)}

class Colour:
red: int
green: int
blue: int
>>> red.red = 240
File "<string>", line 3, in __setattr__
dataclasses.FrozenInstanceError: cannot assign
to field 'red'

Dataclass
class Colour:
red: int
green: int
blue: int
Claseartesanal
• class Colour:
def __repr__(self):
raise TypeError(f'cannot assign to field {name}')
def __hash__(self):

def dataclass(
_cls=None, *,
init=True,
repr=True,
eq=True,
order=False,
unsafe_hash=False,
frozen=False):

Los campos de una dataclass

@dataclass
class Colour:
red: int
green: int
blue: int = 0
>>> red

from typing import List
@dataclass
class Employee:
name: str
surname: str
children: List[str] = []
john = Employee('John', 'Green')
hank = Employee('Hank', 'Green’)
john.children.append('Henry')

File "dataclasses.py", line 966, in dataclass
return wrap(_cls)
File "dataclasses.py", line 958, in wrap
return _process_class(cls, init, repr, eq, order,
unsafe_hash, frozen)
File "dataclasses.py", line 809, in _process_class
for name, type in cls_annotations.items()]
File "dataclasses.py", line 809, in <listcomp>
for name, type in cls_annotations.items()]
File "dataclasses.py", line 702, in _get_field
raise ValueError(f'mutable default
{type(f.default)} for field '
ValueError: mutable default <class 'list'> for field
children is not allowed: use default_factory

from dataclasses import dataclass, field
from typing import List
@dataclass
class Employee:
name: str
surname: str
children: List[str] = field(default_factory=list)
john = Employee('John', 'Green')
hank = Employee('Hank', 'Green')
john.children.append('Henry')
john.children.append('Alice’)
>>> hank.children
[]

__annotations__
dataclasses.Field
__dataclass_fields__

def field(*,
default=MISSING,
default_factory=MISSING,
init=True,
repr=True,
hash=None,
compare=True,
metadata=None):

from typing import ClassVar
@dataclass
class Colour:
MAX: ClassVar[int] = 255
red: int
green: int
blue: int = 0
orange = Colour(255, 165)
>>> red.MAX
255

from dataclasses import dataclass, field, InitVar
@dataclass
class Address:
protocol: InitVar[str]
host: InitVar[str]
url: str = field(init=False)
def __post_init__(self, protocol, host):
self.url = f'{protocol}://{host}/'
addr = Address('http', ‘example.com’)
>>> addr
Address(url='http://google.com/')

@dataclass
class Point1d:
x: float
@dataclass
class Point2d(Point1d):
y: float
@dataclass
class Point3d(Point2d):
z: float
p1 = Point1d(11.1)
p2 = Point2d(22.2, 33.3)
p3 = Point3d(44.4, 55.5, 66.6)
>>> p1, p2, p3
(Point1d(x=11.1), Point2d(x=22.2, y=33.3), Point3d(x=44.4, y=55.5,
z=66.6))

@dataclass
class Colour:
__slots__ = (
'red’,
'green’,
'blue')
red: int
green: int
blue: int
>>> red.check = True
AttributeError: 'Colour' object has no attribute
'check'
Rapidez de acceso
Restricción de creación de campos
Ahorro de espacio
¡Sin valores por defecto!

Funciones de apoyo

fields Lista los campos guardados. Funciona con instancias y
clases.
asdict Convierte un objeto en diccionario de forma recursiva
astuple Convierte un objeto en tupla de forma recursiva
replace Crea una copia (no profunda) de un objeto con algunos
campos cambiados de valor.
is_dataclass Comprueba si un objeto o clase es una dataclass
make_dataclass Crea una nueva clase con dataclass

fields Lista los campos guardados. Funciona con instancias y
clases.
>>> dataclasses.fields(red)
(Field(name='red’,...
Field(name='green',type=<class
'int'>,default=<dataclasses._MISSING_TYPE object at
0x0000028B13380208>,default_factory=<dataclasses._MISSI
NG_TYPE object at
0x0000028B13380208>,init=True,repr=True,hash=None,compa
re=True,metadata=mappingproxy({}),_field_type=_FIELD),
Field(name='blue’,...))

asdict Convierte un objeto en diccionario de forma recursiva
>>> dataclasses.asdict(red)
{'red': 255, 'green': 0, 'blue': 0}

astuple Convierte un objeto en tupla de forma recursiva
>>> dataclasses.astuple(red)
(255, 0, 0)

replace Crea una copia (no profunda) de un objeto con algunos
campos cambiados de valor.
>>> red2 = dataclasses.replace(red, blue=12)
>>> red2

is_dataclass Comprueba si un objeto o clase es una dataclass
>>> dataclasses.is_dataclass(red)
True
>>> dataclasses.is_dataclass(Colour)
True
>>> dataclasses.is_dataclass([])
False

make_dataclass Crea una nueva clase con dataclass
from dataclasses import make_dataclass
Colour = make_dataclass('Colour',
fields=[('red', int), ('green', int),
('blue', int)])
red = Colour(255, 0, 0)
orange = Colour(255, 165, 0)

Proyectos relacionados

dataslots Decorador with_slots, añade slots a una
dataclass.
dataclass-factory Crea instancias de dataclasses a partir de
diccionarios. Inverso a asdict.
strictclasses Decorador que hace que se comprueben tipos
en asignación.
dataclassinspector Intenta mostrar el equivalente al código
generado por una dataclass. Intenta.
fistro Genera instancias de dataclasses con datos
para pruebas. Fixtures.
dataclasses-jsonschema Crea JSON schema a partir de una dataclass.

La alternativa

import attr
@attr.s
class Colour:
red: int = attr.ib()
green: int = attr.ib()
blue: int = attr.ib()
red = Colour(255, 0, 0)
>>> red

Funciona desde Python 2.7
Soporta __slots__
Validadores
Convertidores

La recta final

Todd Ehlers en Flickr
Philippe_ en Flickr
Leo Hidalgo en Flickr
Antonio Trogu en Flickr
Bruce Baugh en Flickr
VivaAntarctica en Flickr
eightydaysjet en Flickr
Farrukh en Flickr
Andy Wilson en Flickr
Valerie Reneé en Flickr
Paul Keller en Flickr
Marc Wesel en Flickr
Matteo Tarenghi en Flickr
JD Hancock en Flickr
Smabs Sputzer (1956-2017) en Flickr
Loco Races en Flickr
Cameron Daigle en Flickr

PyDay Talk"Jacobo de Vera | @jovianjake | PyDay Tenerife 2018

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to PyDay Talk"Jacobo de Vera | @jovianjake | PyDay Tenerife 2018

Similar to PyDay Talk"Jacobo de Vera | @jovianjake | PyDay Tenerife 2018 (11)

Recently uploaded

Recently uploaded (20)

PyDay Talk"Jacobo de Vera | @jovianjake | PyDay Tenerife 2018