Tips and tricks from my Telegram-channel @pythonetc, January 2019


It is new selection of tips and tricks about Python and programming from my Telegram-channel @pythonetc.

Previous publications:

Two implicit class methods

To create a class method, you should use the @classmethod decorator. This method can be called from the class directly, not from its instances, and accepts the class as a first argument (usually called cls, not self).

However, there are two implicit class methods in Python data model: __new__ and __init_subclass__. They work exactly as though they are decorated with @classmethod except they aren’t. (__new__ creates new instances of a class, __init_subclass__ is a hook that is called when a derived class is created.)

class Foo:
    def __new__(cls, *args, **kwargs):
        return super().__new__(
            cls, *args, **kwargs

Foo()  # 

Asynchronous context managers

If you want a context manager to suspend coroutine on entering or exiting context, you should use asynchronous context managers. Instead of calling m.__enter__() and m.__exit__() Python does await m.__aenter__() and await m.__aexit__() respectively.

Asynchronous context managers should be used with async with syntax:

import asyncio

class Slow:
    def __init__(self, delay):
        self._delay = delay

    async def __aenter__(self):
        await asyncio.sleep(self._delay / 2)

    async def __aexit__(self, *exception):
        await asyncio.sleep(self._delay / 2)

async def main():
    async with Slow(1):

loop = asyncio.get_event_loop()

Defining asynchronous context manager

Since Python 3.7, contextlib provides the asynccontextmanager decorator which allow you to define asynchronous context manager in the exact same manner as contextmanager does:

import asyncio
from contextlib import asynccontextmanager

async def slow(delay):
    half = delay / 2
    await asyncio.sleep(half)
    await asyncio.sleep(half)

async def main():
    async with slow(1):

loop = asyncio.get_event_loop()

For older versions, you could use @asyncio_extras.async_contextmanager.

Unary plus operator

There is no ++ operator in Python, x += 1 is used instead. However, even ++x is still a valid syntax (but x++ is not).

The catch is Python has unary plus operator, and ++x is actually x.__pos__().__pos__(). We can abuse this fact and make ++ work as increment (not recommended though):

class Number:
    def __init__(self, value):
        self._value = value

    def __pos__(self):
        return self._Incrementer(self)

    def inc(self):
        self._value += 1

    def __str__(self):
        return str(self._value)

    class _Incrementer:
        def __init__(self, number):
            self._number = number

        def __pos__(self):

x = Number(4)
print(x)  # 4
print(x)  # 5

The MagicMock object

The MagicMock object allows you to get any attribute from it or call any method. New mock will be returned upon such access. What is more, you get the same mock object if access the same attribute (or call the same method):

>>> from unittest.mock import MagicMock
>>> m = MagicMock()
>>> a = m.a
>>> b = m.b
>>> a is m.a
>>> m.x() is m.x()
>>> m.x()

This obviously will work with sequential attribute access of any deep. Method arguments are ignored though:

>>> m.a.b.c.d

>>> m.a.b.c.d

>>> m.x().y().z()

>>> m.x(1).y(1).z(1)

Once you set a value for any attribute, it doesn’t return mock anymore:

>>> m.a.b.c.d = 42
>>> m.a.b.c.d
>>> m.x.return_value.y.return_value = 13
>>> m.x().y()

However, it doesn’t work with m[1][2]. The reason is, the item access is not treated specially by MagicMock, it’s merely a method call:

>>> m[1][2] = 3
>>> m[1][2]

>>> m.__getitem__.return_value.__getitem__.return_value = 50
>>> m[1][2]