with open('f') as f:
    with open('g') as g:
        with open('h') as h:
            pass

o = open
with o('f') as f, o('g') as g, o('h') as h:
    pass

with nested(o('f'), o('g'), o('h')) as (f, g, h):
    pass

with ExitStack() as stack:
    f = stack.enter_context(o('f'))
    g = stack.enter_context(o('g'))
    other = [
        stack.enter_context(o(filename))
        for filename in filenames
    ]

In [1]: class A:
   ...:     def __init__(self, x):
   ...:         self._x = x
   ...:
   ...:     def __repr__(self):
   ...:         class_name = type(self).__name__
   ...:         x = self._x
   ...:         return f'{class_name}({x!r})'
   ...:

In [2]: A(1)
Out[2]: A(1)

In [3]: A(2)
Out[3]: A(2)

In [4]: A(3)
Out[4]: A(3)

In [5]: [x for x in gc.get_objects() if isinstance(x, A)]
Out[5]: [A(1), A(2), A(3)]

try:
    1 / 0
except ZeroDivisionError:
    raise ValueError('Zero!')

(most recent call last):
  File "test.py", line 2, in <module>
    1 / 0
ZeroDivisionError: division by zero

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "test.py", line 4, in <module>
    raise ValueError('Zero!')
ValueError: Zero!

division_error = None

try:
    1 / 0
except ZeroDivisionError as e:
    division_error = e

raise ValueError('Zero!') from division_error

(most recent call last):
  File "test.py", line 4, in <module>
    1 / 0
ZeroDivisionError: division by zero

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "test.py", line 8, in <module>
    raise ValueError('Zero!') from division_error
ValueError: Zero!

int('୧৬𝟙༣')

1613

# Пример 1
int('෯')
# Вывод:
9

# Пример 2
'٢'.isdecimal()
# Вывод:
True

# Пример 3
import re
bool(re.match(r'\d', '౫'))
# Вывод:
True

>>> bool(datetime(2018, 1, 1).time())
False
>>> bool(datetime(2018, 1, 1, 13, 12, 11).time())
True

def create(created_time=None) -> None:
    if not created_time:
        created_time = datetime.now().time()

def create(created_time=None) -> None:
    if created_time is None:
        created_time = datetime.now().time()

async with aiofiles.open('filename', mode='r') as f:
    contents = await f.read()

>>> int("10")
10
>>> int("10", 2)
2
>>> def base2(x):
...     return int(x, 2)
...
>>> base2("10")
2

base2 = partial(int, base=2)

>>> map(partial(int, base=2), ["1", "10", "100"])
[1, 2, 4]

>>> map(lambda x: int(x, base=2), ["1", "10", "100"])
[1, 2, 4]

package_broken = any(
    part.is_broken() for part in package.get_parts()
)
package_ok = all(
    part.ok() for part in package.get_parts()
)

class Task:
    _task_id = 0

    def __init__(self):
        self._id = self._task_id
        type(self)._task_id += 1

class Task:
    _task_id = 0

    def __init__(self, task_id):
        self._id = task_id

    @classmethod
    def create(cls):
        obj = cls(cls._task_id)
        cls._task_id += 1
        return obj

from contextlib import contextmanager

QUIT_MESSAGE = 'Bye'

def print_quit_mesage():
    global QUIT_MESSAGE
    print(QUIT_MESSAGE)

@contextmanager
def global_variable_changed(name, value):
    orig_value = globals()[name]
    globals()[name] = value
    yield
    globals()[name] = orig_value

with global_variable_changed(
    'QUIT_MESSAGE',
    'Tschüss'
):
    print_quit_mesage()

>>> dict(a=1, b=2)
{'a': 1, 'b': 2}
>>> {'a': 1, 'b': 2}
{'a': 1, 'b': 2}

>>> dict(a=1)
{'a': 1}
>>> dict(1='a')
  File "<stdin>", line 1
SyntaxError: keyword can't be an expression

>>> {'a': 1, 'a': 1}
{'a': 1}
>>> dict(a=1, a=1)
  File "<stdin>", line 1
SyntaxError: keyword argument repeated

>>> d = dict(b=2)
>>> dict(a=1, **d)
{'a': 1, 'b': 2}

>>> dict(b=3, **d)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: type object got multiple values for keyword argument

{**{'a': 1}, 'b': 2, **{'c': 3}}
# Результат: {'a': 1, 'b': 2, 'c': 3}

[1, 2, *[3, 4]]
# Результат: [1, 2, 3, 4]

{**{'a': 1, 'b': 1}, 'a': 2, **{'b': 3}}
# Результат: {'a': 2, 'b': 3}

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):
        print('slow')

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

import asyncio
from contextlib import asynccontextmanager

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

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

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

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):
            self._number.inc()


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

>>> d = dict(a=1, b=2, c=3)
>>> assert d['a'] == 1
>>> assert d['c'] == 3

>>> assert d == dict(a=1, b=ANY, c=3)

>>> class AnyClass:
...     def __eq__(self, another):
...         return True
... 
>>> ANY = AnyClass()

In : eng = ['one', 'two', 'three']
In : ger = ['eins', 'zwei', 'drei']
In : for e, g in zip(eng, ger):
    ...:     print('{e} = {g}'.format(e=e, g=g))
    ...:

one = eins  
two = zwei  
three = drei

In : list(zip(*zip(eng, ger)))
Out: [('one', 'two', 'three'), ('eins', 'zwei', 'drei')]

flatten = lambda lst: [x for sub in lst for x in (flatten(sub) if isinstance(sub, list) else [sub])]

memoize = lambda f: (lambda *args, _cache={}, **kwargs: _cache.setdefault((args, tuple(kwargs.items())), f(*args, **kwargs)))

chunked = lambda lst, n: [lst[i:i+n] for i in range(0, len(lst), n)]

uniq = lambda seq: list(dict.fromkeys(seq))

deep_get = lambda d, *keys: __import__('functools').reduce(lambda a, k: a.get(k) if isinstance(a, dict) else None, keys, d)

pretty_json = lambda obj: __import__('json').dumps(obj, ensure_ascii=False, indent=2)

tail = lambda f, n=10: list(__import__('collections').deque(open(f), maxlen=n))

sh = lambda cmd: __import__('subprocess').run(cmd, shell=True, check=True, capture_output=True).stdout.decode().strip()

path_join = lambda *p: __import__('os').path.join(*p)

group_by = lambda seq, key: {k: [d for d in seq if d.get(key) == k] for k in set(d.get(key) for d in seq)}