Esta es la sexta colección de consejos y programación de Python de mi feed @pythonetc.
Selecciones anteriores:
Decoradores atípicos
Los decoradores de funciones no están obligados a devolver solo nuevas funciones, pueden devolver cualquier otro valor:
def call(*args, **kwargs): def decorator(func): return func(*args, **kwargs) return decorator @call(15) def sqr_15(x): return x * x assert sqr_15 == 225
Esto puede ser útil para crear clases simples con un solo método redefinible:
from abc import ABCMeta, abstractmethod class BinaryOperation(metaclass=ABCMeta): def __init__(self, left, right): self._left = left self._right = right def __repr__(self): klass = type(self).__name__ left = self._left right = self._right return f'{klass}({left}, {right})' @abstractmethod def do(self): pass @classmethod def make(cls, do_function): return type( do_function.__name__, (BinaryOperation,), dict(do=do_function), ) class Addition(BinaryOperation): def do(self): return self._left + self._right @BinaryOperation.make def Subtraction(self): return self._left - self._right
__length_hint__
PEP 424 permite que los generadores y otros iterables que no tienen un tamaño predeterminado específico devuelvan su longitud aproximada. Por ejemplo, este generador probablemente devolverá unos 50 elementos:
(x for x in range(100) if random() > 0.5)
Si escribe algo iterable y desea devolver una longitud aproximada, defina el método
__length_hint__ . Y si conoce la longitud exacta, use
__len__ . Si usa un objeto iterable y desea saber cuánto puede durar, use
operator.length_hint .
con generador
El operador
in puede usarse con generadores:
x in g . En este caso, Python iterará sobre
g hasta que
x o hasta que
g finalice.
>>> def g(): ... print(1) ... yield 1 ... print(2) ... yield 2 ... print(3) ... yield 3 ... >>> 2 in g() 1 2 True
range() , sin embargo, funciona un poco mejor. Tiene un método mágico anulado
__contains__ , gracias al cual la complejidad computacional de
in es igual a O (1):
In [1]: %timeit 10**20 in range(10**30) 375 ns ± 10.7 ns per loop
Tenga en cuenta que esto no funcionará con la función
xrange() de Python 2.
Operadores + = y +
Python tiene dos operadores diferentes:
+= y
+ . Los métodos
__iadd__ y
__add__ son responsables de su comportamiento, respectivamente.
class A: def __init__(self, x): self.x = x def __iadd__(self, another): self.x += another.x return self def __add__(self, another): return type(self)(self.x + another.x)
Si
__iadd__ no
__iadd__ definido, entonces
a += b funcionará como
a = a + b .
La diferencia semántica entre
+= y
+ es que el primero cambia el objeto y el segundo crea uno nuevo:
>>> a = [1, 2, 3] >>> b = a >>> a += [4] >>> a [1, 2, 3, 4] >>> b [1, 2, 3, 4] >>> a = a + [5] >>> a [1, 2, 3, 4, 5] >>> b [1, 2, 3, 4]
Funcionar como un atributo de una clase.
No puede almacenar una función como un atributo de clase, porque se convertirá automáticamente a un método si se accede a ella a través de una instancia:
>>> class A: ... CALLBACK = lambda x: x ** x ... >>> A.CALLBACK <function A.<lambda> at 0x7f68b01ab6a8> >>> A().CALLBACK <bound method A.<lambda> of <__main__.A object at 0x7f68b01aea20>> >>> A().CALLBACK(4) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: <lambda>() takes 1 positional argument but 2 were given
Puede hacer trampa y envolver la función en un descriptor trivial:
>>> class FunctionHolder: ... def __init__(self, f): ... self._f = f ... def __get__(self, obj, objtype): ... return self._f ... >>> class A: ... CALLBACK = FunctionHolder(lambda x: x ** x) ... >>> A().CALLBACK <function A.<lambda> at 0x7f68b01ab950>
También puede salir de la situación utilizando el método de clase en lugar del atributo.
class A: @classmethod def _get_callback(cls): return lambda x: x ** x