<jupyter_start><jupyter_text>`asyncio` BeispielAb IPython≥7.0 könnt ihr `asyncio` direkt in Jupyter Notebooks verwenden; seht auch [IPython 7.0, Async REPL](https://blog.jupyter.org/ipython-7-0-async-repl-a35ce050f7f7). Wenn ihr die Fehlermeldung `RuntimeError: This event loop is already running` erhaltet, hilft euch vielleicht [nest-asyncio] weiter.Ihr könnt das Paket in eurer Jupyter- oder JupyterHub-Umgebung installieren mit```bash$ pipenv install nest-asyncio```Ihr könnt es dann in euer Notebook importieren und verwenden mit:<jupyter_code>import nest_asyncio

nest_asyncio.apply()<jupyter_output><empty_output><jupyter_text>Einfaches *Hello world*-Beispiel<jupyter_code>import asyncio

async def hello():
  print('Hello')
  await asyncio.sleep(1)
  print('world')

await hello()<jupyter_output>Hello
world<jupyter_text>Ein bisschen näher an einem realen Beispiel<jupyter_code>import asyncio
import random


async def produce(queue, n):
    for x in range(1, n + 1):
        # produce an item
        print('producing {}/{}'.format(x, n))
        # simulate i/o operation using sleep
        await asyncio.sleep(random.random())
        item = str(x)
        # put the item in the queue
        await queue.put(item)

    # indicate the producer is done
    await queue.put(None)


async def consume(queue):
    while True:
        # wait for an item from the producer
        item = await queue.get()
        if item is None:
            # the producer emits None to indicate that it is done
            break

        # process the item
        print('consuming {}'.format(item))
        # simulate i/o operation using sleep
        await asyncio.sleep(random.random())


loop = asyncio.get_event_loop()
queue = asyncio.Queue(loop=loop)
asyncio.ensure_future(produce(queue, 10), loop=loop)
loop.run_until_complete(consume(queue))<jupyter_output>producing 1/10
producing 2/10
consuming 1
producing 3/10
consuming 2
producing 4/10
consuming 3
producing 5/10
consuming 4
producing 6/10
consuming 5
producing 7/10
consuming 6
producing 8/10
consuming 7
producing 9/10
consuming 8
producing 10/10
consuming 9
consuming 10<jupyter_text>Ausnahmebehandlung> **Siehe auch:** [set_exception_handler](https://docs.python.org/3/library/asyncio-eventloop.htmlasyncio.loop.set_exception_handler)<jupyter_code>def main():
    loop = asyncio.get_event_loop()
    # May want to catch other signals too
    signals = (signal.SIGHUP, signal.SIGTERM, signal.SIGINT)
    for s in signals:
        loop.add_signal_handler(
            s, lambda s=s: asyncio.create_task(shutdown(loop, signal=s)))
    loop.set_exception_handler(handle_exception)
    queue = asyncio.Queue()<jupyter_output><empty_output><jupyter_text>Testen mit `pytest`  Beispiel:<jupyter_code>import pytest

@pytest.mark.asyncio
async def test_consume(mock_get, mock_queue, message, create_mock_coro):
    mock_get.side_effect = [message, Exception("break while loop")]

    with pytest.raises(Exception, match="break while loop"):
        await consume(mock_queue)<jupyter_output><empty_output><jupyter_text>Bibliotheken von Drittanbietern* [pytest-asyncio](https://github.com/pytest-dev/pytest-asyncio) hat hilfreiche Dinge wie Test-Fixtures für `event_loop`, `unused_tcp_port`, und `unused_tcp_port_factory`; und die Möglichkeit zum Erstellen eurer eigenen [asynchronen Fixtures](https://github.com/pytest-dev/pytest-asyncio/async-fixtures).* [asynctest](https://asynctest.readthedocs.io/en/latest/index.html) verfügt über hilfreiche Werkzeuge, einschließlich Coroutine-Mocks und [exhaust_callbacks](https://asynctest.readthedocs.io/en/latest/asynctest.helpers.htmlasynctest.helpers.exhaust_callbacks) so dass wir `await task` nicht manuell erstellen müssen.* [aiohttp](https://docs.aiohttp.org/en/stable/) hat ein paar wirklich nette eingebaute Test-Utilities.  Debugging`asyncio` hat bereits einen [debug mode](https://docs.python.org/3.6/library/asyncio-dev.htmldebug-mode-of-asyncio) in der Standardbibliothek. Ihr könnt ihn einfach mit der Umgebungsvariablen `PYTHONASYNCIODEBUG` oder im Code mit `loop.set_debug(True)` aktivieren.  Verwendet den Debug-Modus zum Identifizieren langsamer asynchroner AufrufeDer Debug-Modus von `asyncio` hat einen kleinen eingebauten Profiler. Wenn der Debug-Modus aktiviert ist, protokolliert `asyncio` alle asynchronen Aufrufe, die länger als 100 Millisekunden dauern.  Debugging im Produktivbetrieb mit `aiodebug`[aiodebug](https://github.com/qntln/aiodebug) ist eine kleine Bibliothek zum Überwachen und Testen von Asyncio-Programmen.  Beispiel<jupyter_code>from aiodebug import log_slow_callbacks

def main():
    loop = asyncio.get_event_loop()
    log_slow_callbacks.enable(0.05)<jupyter_output><empty_output><jupyter_text>Logging[aiologger](https://github.com/b2wdigital/aiologger) ermöglicht eine nicht-blockierendes Logging.  Asynchrone Widgets> **Seht auch:** [Asynchronous Widgets](https://ipywidgets.readthedocs.io/en/stable/examples/Widget%20Asynchronous.html)<jupyter_code>def wait_for_change(widget, value):
    future = asyncio.Future()
    def getvalue(change):
        # make the new value available
        future.set_result(change.new)
        widget.unobserve(getvalue, value)
    widget.observe(getvalue, value)
    return future
from ipywidgets import IntSlider
slider = IntSlider()

async def f():
    for i in range(10):
        print('did work %s'%i)
        x = await wait_for_change(slider, 'value')
        print('async function continued with value %s'%x)
asyncio.ensure_future(f())

slider<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.10019823391602091, 'fraction_numerical': 0.013335736168679042, 'mean_word_length': 4.799373040752351, 'pattern_counts': {'":': 0, '<': 27, '<?xml version=': 0, '>': 29, 'https://': 11, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '7', 'dir': 'jupyter-structured-clean-dedup', 'id': '1446', 'license': 'BSD-3-Clause', 'n_tokens_mistral': 1943, 'n_tokens_neox': 1895, 'n_words': 446, 'path': 'docs/refactoring/performance/asyncio-example.ipynb', 'repo_name': 'veit/jupyter-tutorial-de', 'size': '5549'}