Bild vom Autor | Canva

Als Programmierer verlassen wir uns oft auf verschiedene externe Bibliotheken, um verschiedene Probleme zu lösen. Diese Bibliotheken werden von erfahrenen Entwicklern erstellt und bieten Lösungen, die uns Zeit und Mühe sparen. Aber haben Sie jemals gedacht, „Kann ich auch meine eigenen benutzerdefinierten Bibliotheken erstellen?“ Die Antwort ist ja! Dieser Artikel erläutert die notwendigen Schritte, die Ihnen dabei helfen, dies zu erreichen, egal ob Sie ein professioneller Entwickler sind oder gerade erst anfangen. Vom Schreiben und Strukturieren Ihres Codes bis hin zur Dokumentation und Veröffentlichung deckt dieser Leitfaden alles ab.

Schritt-für-Schritt-Anleitung zum Erstellen einer Bibliothek

Schritt 1: Initialisieren Sie Ihr Projekt

Beginnen Sie mit der Erstellung eines Stammverzeichnisses für Ihr Projekt.

Schritt 2: Erstellen Sie ein Verzeichnis für Ihr Paket

Der nächste Schritt besteht darin, innerhalb des Verzeichnisses Ihres Projekts ein Verzeichnis für Ihr Paket zu erstellen.

multiples_library/
└──multiples/

Schritt 3: Hinzufügen __init.py__

Fügen Sie nun die __init.py__ im Verzeichnis Ihres Pakets. Diese Datei ist der primäre Indikator für Python, dass das Verzeichnis, in dem sie sich befindet, ein Paket ist. Sie enthält Initialisierungscode (sofern vorhanden) und wird automatisch ausgeführt, wenn ein Paket oder eines seiner Module importiert wird.

multiples_library/
└── multiples/
    └──__init__.py

Schritt 4: Module hinzufügen

Jetzt müssen Sie dem Verzeichnis des Pakets Module hinzufügen. Diese Module bestehen normalerweise aus Klassen und Funktionen. Es empfiehlt sich, jedem Modul einen aussagekräftigen Namen zu geben, der seinen Zweck beschreibt.

multiples_library/
│
└── multiples/
    ├── __init__.py
    ├── is_multiple_of_two.py
    └── is_multiple_of_five.py

Schritt 5: In die Module schreiben

In diesem Schritt definieren Sie die Funktionalität jedes Moduls. In meinem Fall beispielsweise:

Modul: multiple_of_two.py

def is_multiple_of_two(quantity):
    """ Verify if a quantity is a a number of of two. """
    return quantity % 2 == 0

Modul: multiple_of_five.py

def is_multiple_of_five(quantity):
    """ Verify if a quantity is a a number of of 5. """
    return quantity % 5 == 0

Schritt 6: setup.py hinzufügen

Der nächste Schritt besteht darin, eine weitere Datei namens setup.py zum Verzeichnis Ihres Pakets hinzuzufügen.

multiples_library/
│
├── multiples/
│   ├── __init__.py
│   ├── is_multiple_of_two.py
│   └── is_multiple_of_five.py
│
└──setup.py

Diese Datei enthält Metadaten zu Ihrem Paket, wie etwa Title, Abhängigkeiten, Autor, Model, Beschreibung und mehr. Sie definiert auch, welche Module enthalten sein sollen, und enthält Anweisungen zum Erstellen und Installieren des Pakets.

from setuptools import setup, find_packages

setup(
    identify="multiples_library",  # Substitute together with your package deal’s identify
    model='0.1.0',
    packages=find_packages(),
    install_requires=(
        # Checklist your dependencies right here
    ),
    creator="Your identify",  
    author_email="Your e-mail",
    description='A library for checking multiples of two and 5.',
    classifiers=(
        'Programming Language :: Python :: 3',
        'License :: OSI Authorised :: MIT License',  # License sort
        'Working System :: OS Unbiased',
    ),
    python_requires=">=3.6",

)

Schritt 7: Checks und andere Dateien hinzufügen (non-obligatory)

Dieser Schritt ist nicht notwendig, aber eine gute Vorgehensweise, wenn Sie eine fehlerfreie und professionelle Bibliothek erstellen möchten. In diesem Schritt ist die Projektstruktur endgültig und sieht ungefähr so ​​aus:

multiples_library/
│
├── multiples/
│   ├── __init__.py
│   ├── is_multiple_of_two.py
│   └── is_multiple_of_five.py
│
│
├── exams/ 
│   ├── __init__.py   
│   ├── test_is_multiple_of_two.py
│   └── test_is_multiple_of_five.py
│
├── docs/
│
├── LICENSE.txt
├── CHANGES.txt
├── README.md
├── setup.py
└── necessities.txt

Nun erkläre ich Ihnen, welchen Zweck die optionalen Dateien und Ordner haben, die im Stammverzeichnis aufgeführt sind:

• Checks/: Enthält Testfälle für Ihre Bibliothek, um sicherzustellen, dass sie sich wie erwartet verhält.
• Dokumente/: Enthält Dokumentation für Ihre Bibliothek.
• LICENSE.txt: Enthält die Lizenzbedingungen, unter denen andere Ihren Code verwenden können.
• ÄNDERUNGEN.txt: Protokolliert Änderungen an der Bibliothek.
• README.md: Enthält die Beschreibung Ihres Pakets und Installationsanweisungen.
• necessities.txt: Listet die externen Abhängigkeiten auf, die Ihre Bibliothek benötigt. Sie können diese Pakete mit einem einzigen Befehl installieren (pip set up -r necessities.txt).

Diese Beschreibungen sind ziemlich unkompliziert und Sie werden den Zweck der optionalen Dateien und Ordner in kürzester Zeit verstehen. Ich möchte jedoch ein wenig auf das optionale Testverzeichnis eingehen, um seine Verwendung zu verdeutlichen.

exams/ Verzeichnis

Es ist wichtig zu beachten, dass Sie ein Testverzeichnis innerhalb Ihres Stammverzeichnisses hinzufügen können, d. h. multiples_libraryoder im Verzeichnis Ihres Pakets, d. h. multiples. Die Entscheidung liegt bei Ihnen. Ich bevorzuge es jedoch, es auf der obersten Ebene im Stammverzeichnis zu belassen, da ich denke, dass dies eine bessere Möglichkeit ist, Ihren Code zu modularisieren.

Mehrere Bibliotheken helfen Ihnen beim Schreiben von Testfällen. Ich werde die bekannteste und meine persönliche Lieblingsbibliothek „unittest“ verwenden.

Unit-Check/s für is_multiple_of_two

Der/die Testfall(e) für dieses Modul ist/sind enthalten im test_is_multiple_of_two.py Datei.

import unittest
import sys
import os

sys.path.insert(0, os.path.abspath(os.path.be a part of(os.path.dirname(__file__), '..')))

from multiples.is_multiple_of_two import is_multiple_of_two


class TestIsMultipleOfTwo(unittest.TestCase):

	def test_is_multiple_of_two(self):
		self.assertTrue(is_multiple_of_two(4))
if __name__ == '__main__': 
      unittest.predominant()

Unit-Check/s für is_multiple_of_five

Der/die Testfall(e) für dieses Modul ist/sind enthalten im test_is_multiple_of_five.py Datei.

import unittest
import sys
import os
sys.path.insert(0, os.path.abspath(os.path.be a part of(os.path.dirname(__file__), '..')))

from multiples.is_multiple_of_five import is_multiple_of_five


class TestIsMultipleOfFive(unittest.TestCase):

	def test_is_multiple_of_five(self):
		self.assertTrue(is_multiple_of_five(75)) 

if __name__ == '__main__':
      unittest.predominant()

Die oben aufgeführten Komponententests sind ziemlich unkompliziert, ich werde jedoch zur weiteren Verdeutlichung zwei Funktionen erläutern.

• self.assertTrue(expression) prüft, ob der Ausdruck „Wahr“ ergibt. Der Check ist nur erfolgreich, wenn das Ergebnis des Ausdrucks „Wahr“ ist.
• unittest.predominant() Funktion wird aufgerufen, um alle in der Datei definierten Testfälle auszuführen.

Schritt 8: Verteilen Sie Ihr Paket mit PyPI

Um Ihre Bibliothek für andere leicht zugänglich zu machen, können Sie sie auf PyPI hochladen. Befolgen Sie diese Schritte, um Ihr Paket zu verteilen:

• Erstellen Sie ein Konto auf PyPI und aktivieren Sie die Zwei-Faktor-Authentifizierung.
• Erstellen Sie ein API-Token indem Sie einen Token-Namen vergeben und den Geltungsbereich auf „Gesamtes Konto“ auswählen. Kopieren Sie ihn dann sorgfältig, da er nur einmal vorkommt.
• Jetzt müssen Sie eine .pypirc-Datei erstellen.
  Für MacOS/Linuxöffnen Sie das Terminal und führen Sie den folgenden Befehl aus:

Für Home windowsöffnen Sie die Eingabeaufforderung und führen Sie den folgenden Befehl aus:

cd %USERPROFILE%
sort NUL > .pypirc

Die Datei wird erstellt und befindet sich unter ~/.pypirc (bei MacOS/Linux) und unter %USERPROFILE%/.pypirc (bei Home windows).

• Bearbeiten .pypirc Datei, indem Sie die folgende Konfiguration kopieren und einfügen:

(distutils)
index-servers =
    pypi

(pypi)
username = __token__
password = pypi-

Ersetzen mit dem tatsächlichen API-Token, das Sie von PyPI generiert haben. Vergessen Sie nicht, das Präfix pypi- einzuschließen.

• Stellen Sie sicher, dass Sie eine Datei „setup.py“ im Stammverzeichnis Ihres Projekts haben. Führen Sie den folgenden Befehl aus, um Verteilungsdateien zu erstellen:

python3 setup.py sdist bdist_wheel

• Twine ist ein Device zum Hochladen von Paketen auf PyPI. Installieren Sie Twine, indem Sie den folgenden Befehl ausführen:
• Laden Sie jetzt Ihr Paket auf PyPI hoch, indem Sie den folgenden Befehl ausführen:

Schritt 9: Installieren und Verwenden der Bibliothek

Sie können die Bibliothek mit dem folgenden Befehl installieren:

pip set up (your-package)

In meinem Fall:

pip set up multiples_library

Nun können Sie die Bibliothek wie folgt verwenden:

from multiples.is_multiple_of_five import is_multiple_of_five
from multiples.is_multiple_of_two import is_multiple_of_two

print(is_multiple_of_five(10))
# Outputs True
print(is_multiple_of_two(11))
# Outputs False

Einpacken

Kurz gesagt, das Erstellen einer Python-Bibliothek ist sehr interessant und ihre Verbreitung macht sie für andere nützlich. Ich habe versucht, alles, was Sie zum Erstellen einer Bibliothek in Python benötigen, so klar wie möglich abzudecken. Wenn Sie jedoch an irgendeinem Punkt nicht weiterkommen oder verwirrt sind, zögern Sie bitte nicht, im Kommentarbereich Fragen zu stellen.

Kanwal Mehreen Kanwal ist Ingenieurin für maschinelles Lernen und technische Autorin mit einer tiefen Leidenschaft für Datenwissenschaft und die Schnittstelle zwischen KI und Medizin. Sie ist Mitautorin des E-Books „Maximizing Productiveness with ChatGPT“. Als Google Era Scholar 2022 für APAC setzt sie sich für Vielfalt und akademische Exzellenz ein. Sie ist außerdem als Teradata Variety in Tech Scholar, Mitacs Globalink Analysis Scholar und Harvard WeCode Scholar anerkannt. Kanwal ist eine leidenschaftliche Verfechterin des Wandels und hat FEMCodes gegründet, um Frauen in MINT-Fächern zu stärken.

Die effektive Verwaltung von Abhängigkeiten, einschließlich Bibliotheken, Funktionen und Paketen, die für die Projektfunktionalität entscheidend sind, wird durch die Verwendung eines Paketmanagers erleichtert. Pip, ein weit verbreiteter Klassiker, ist für viele Entwickler die erste Wahl und ermöglicht die nahtlose Set up von Python-Paketen aus dem Python Bundle Index (PyPI). Conda, das nicht nur als Paketmanager, sondern auch als Umgebungsmanager anerkannt ist, erweitert seine Fähigkeiten auf die Handhabung von Python- und Nicht-Python-Abhängigkeiten und ist damit ein vielseitiges Software. Für unsere Zwecke konzentrieren wir uns darauf, es hauptsächlich für reine Python-Umgebungen zu verwenden.

Pip und Conda sind zuverlässige Instruments, die von der Entwickler-Group häufig verwendet und geschätzt werden. Mit der Ausweitung von Projekten wird es jedoch immer schwieriger, die Organisation bei einer wachsenden Anzahl von Abhängigkeiten aufrechtzuerhalten. In diesem Zusammenhang erweist sich Poetry als moderne und organisierte Lösung für die Abhängigkeitsverwaltung.

Poetry, das auf Pip aufbaut, führt einen zeitgemäßen Ansatz zur Verwaltung von Abhängigkeiten ein. Es geht über eine einfache Fusion von Pip und einer virtuellen Umgebung hinaus und dient als umfassendes Software, das Abhängigkeitsmanagement, Projektpaketierung und Construct-Prozesse umfasst. Der Vergleich mit Conda ist nuanciert; Poetry zielt darauf ab, die Paketierung und Verteilung von Python-Projekten zu vereinfachen und bietet einen eigenen Satz an Funktionen.

Pip und Conda bleiben wertvolle Optionen für die Verwaltung von Abhängigkeiten, da Conda vielseitig mit unterschiedlichen Abhängigkeiten umgehen kann. Poetry hingegen bietet eine moderne und umfassende Lösung, die die Verwaltung von Python-Projekten und deren Abhängigkeiten vereinfacht. Die Wahl des geeigneten Instruments hängt von den spezifischen Anforderungen des Projekts und den Vorlieben des Entwicklers ab.

Paketverwaltung

Poetry verwendet eine pyproject.toml-Datei, um die Konfiguration für Ihr Projekt anzugeben, begleitet von einer automatisch generierten Sperrdatei. Die pyproject.toml-Datei sieht folgendermaßen aus:

(instrument.poetry.dependencies)
python = "^3.8"
pandas = "^1.5"
numpy = "^1.24.3"

(instrument.poetry.dev.dependencies)
pytest = "^7.3.2"
precomit = "^3.3.3"

Wie andere Abhängigkeitsmanager verfolgt Poetry die Paketversionen in der aktuellen Umgebung sorgfältig über eine Sperrdatei. Diese Sperrdatei enthält Projektmetadaten, Paketversionsparameter und mehr und stellt so die Konsistenz zwischen verschiedenen Umgebungen sicher. Entwickler können Abhängigkeiten in den Toml-Dateien clever in dev- und prod-basierte Kategorien aufteilen, wodurch Bereitstellungsumgebungen optimiert und das Konfliktrisiko, insbesondere auf verschiedenen Betriebssystemen, verringert wird.

Die Datei pyproject.toml von Poetry wurde entwickelt, um bestimmte Einschränkungen zu beheben, die in den Dateien necessities.txt von Pip und atmosphere.yaml von Conda zu finden sind. Im Gegensatz zu Pip und Conda, die oft lange Abhängigkeitslisten ohne Metadaten in einer separaten Datei erstellen, zielt Poetry auf eine besser organisierte und prägnantere Darstellung ab.

Zwar fehlt Pip und Conda standardmäßig eine Sperrfunktion, es ist jedoch wichtig zu beachten, dass neuere Versionen Optionen zum Generieren von Sperrdateien über installierte Bibliotheken wie Pip-Instruments und Conda-Lock bieten. Diese Funktion stellt sicher, dass verschiedene Benutzer die in der Datei necessities.txt angegebenen beabsichtigten Bibliotheksversionen installieren können, was die Reproduzierbarkeit fördert.

Poetry erweist sich als moderne und organisierte Lösung für die Python-Abhängigkeitsverwaltung und bietet im Vergleich zu herkömmlichen Instruments wie Pip und Conda eine verbesserte Organisation, Versionskontrolle und Flexibilität.

Aktualisieren, Installieren und Entfernen von Abhängigkeiten

Mit Poetry ist das Aktualisieren von Bibliotheken einfach und berücksichtigt andere Abhängigkeiten, um sicherzustellen, dass sie entsprechend auf dem neuesten Stand sind. Poetry verfügt über einen Massenaktualisierungsbefehl, der Ihre Abhängigkeiten (gemäß Ihrer Toml-Datei) aktualisiert, während alle Abhängigkeiten weiterhin miteinander kompatibel bleiben und die Paketversionsparameter in der Sperrdatei beibehalten werden. Dadurch wird gleichzeitig Ihre Sperrdatei aktualisiert.

Die Set up könnte nicht einfacher sein. Um Abhängigkeiten mit Poetry zu installieren, können Sie die Poetry-Add-Funktion verwenden, mit der Sie entweder die Model angeben, eine Logik verwenden können, um Versionsparameter anzugeben (größer als, kleiner als) oder Flags wie @newest verwenden können, wodurch die neueste Model des Pakets von PyPI installiert wird. Sie können sogar mehrere Pakete in derselben Add-Funktion gruppieren. Jedes neu installierte Paket wird automatisch aufgelöst, um die richtigen Abhängigkeiten beizubehalten.

$poetry add requests pandas@newest

Lassen Sie uns wie bei den klassischen Abhängigkeitsmanagern testen, was passiert, wenn wir versuchen, eine ältere, inkompatible Model zu installieren. Von Pip installierte Pakete geben Fehler und Konflikte aus, installieren das Paket aber letztendlich trotzdem, was zu einer nicht optimalen Entwicklung führen kann. Conda verfügt zwar über einen Solver für Kompatibilitätsfehler und benachrichtigt den Benutzer, wechselt jedoch sofort in den Suchmodus, um das Kompatibilitätsproblem zu lösen, und gibt einen sekundären Fehler aus, wenn keine Lösung gefunden werden kann.

(test-env) consumer:~$ pip set up "numpy<1.18.5"
Gathering numpy<1.18.5
  Downloading numpy-1.18.4-cp38-cp38-manylinux1_x86_64.whl (20.7 MB)
     |████████████████████████████████| 20.7 MB 10.9 MB/s
Putting in collected packages: numpy
  Making an attempt uninstall: numpy
    Discovered present set up: numpy 1.22.3
    Uninstalling numpy-1.22.3:
      Efficiently uninstalled numpy-1.22.3
ERROR: pip's dependency resolver doesn't at the moment bear in mind all of the packages which can be put in. This behaviour is the supply of the next dependency conflicts.
pandas 1.4.2 requires numpy>=1.18.5; platform_machine != "aarch64" and platform_machine != "arm64" and python_version < "3.10", however you've got numpy 1.18.4 which is incompatible.
Efficiently put in numpy-1.18.4

(test-env) consumer:~$ pip record
Bundle         Model
--------------- -------
numpy           1.18.4
pandas          1.4.2
pip             21.1.1
python-dateutil 2.8.2
pytz            2022.1
six             1.16.0

Poetry reagiert sofort auf Abhängigkeitskompatibilitätsfehler, um Konflikte schnell und frühzeitig zu erkennen. Es weigert sich, die Set up fortzusetzen, sodass der Benutzer nun selbst dafür verantwortlich ist, entweder eine andere Model des neuen oder des vorhandenen Pakets zu finden. Wir sind der Meinung, dass dies im Gegensatz zu Condas sofortiger Aktion mehr Kontrolle ermöglicht.

consumer:~$ poetry add "numpy<1.18.5"

Updating dependencies
Resolving dependencies... (53.1s)
  SolverProblemError

  As a result of pandas (1.4.2) depends upon numpy (>=1.18.5)
   and no variations of pandas match >1.4.2,<2.0.0, pandas (>=1.4.2,<2.0.0) requires numpy (>=1.18.5).
  So, as a result of dependency-manager-test depends upon each pandas (^1.4.2) and numpy (<1.18.5), model fixing failed.
  ...
consumer:~$ poetry present
numpy           1.22.3 NumPy is the elemental package deal for array computing with Python.
pandas          1.4.2  Highly effective information buildings for information evaluation, time sequence, and statistics
python-dateutil 2.8.2  Extensions to the usual Python datetime module
pytz            2022.1 World timezone definitions, trendy and historic
six             1.16.0 Python 2 and three compatibility utilities

Zu guter Letzt gibt es noch die Deinstallation von Paketen durch Poetry. Manche Pakete erfordern mehr Abhängigkeiten, die installiert werden. Bei Pip wird durch das Entfernen eines Pakets nur das definierte Paket deinstalliert und sonst nichts. Conda entfernt einige Pakete, aber nicht alle Abhängigkeiten. Poetry hingegen entfernt das Paket und alle seine Abhängigkeiten, damit Ihre Liste der Abhängigkeiten übersichtlich bleibt.

Ist Poetry mit vorhandenen Pip- oder Conda-Projekten kompatibel?

Ja, Poetry ist mit bestehenden Projekten kompatibel, die von Pip oder Conda verwaltet werden. Initialisieren Sie Ihren Code einfach mit dem Poetry.toml-Format von Poetry und führen Sie ihn aus, um die Bibliothek der Pakete und ihre Abhängigkeiten abzurufen. Dies ermöglicht einen nahtlosen Übergang.

Wenn Sie ein bestehendes Projekt haben, das Pip oder Conda verwendet, können Sie es ohne große Schwierigkeiten zu Poetry migrieren. Poetry verwendet seine eigene pyproject.toml-Datei, um Projektabhängigkeiten und -einstellungen zu verwalten. Um Poetry in Ihrem Projekt zu verwenden, können Sie diese Schritte ausführen:

1. Installieren Sie Poetry entweder durch Curling und Piping oder mit Pip

curl -sSL https://uncooked.githubusercontent.com/python-poetry/poetry/grasp/get-poetry.py | python -

2. Navigieren Sie zum Stammverzeichnis Ihres bestehenden Projekts.

3. Initialisieren Sie Poetry in Ihrem Projektverzeichnis:

Dieser Befehl führt Sie durch eine Reihe von Eingabeaufforderungen, um die Erstkonfiguration für Ihr Projekt einzurichten.

4. Sobald die Initialisierung abgeschlossen ist, erstellt Poetry die Datei pyproject.toml in Ihrem Projektmanager. Öffnen Sie die toml-Datei, um die Abhängigkeiten Ihres Projekts hinzuzufügen oder zu ändern

5. Um die vorhandenen Abhängigkeiten in Ihrem Projekt zu installieren,

Dadurch wird eine virtuelle Umgebung erstellt und die Projektabhängigkeiten darin installiert.

6. Sie können jetzt den Befehl „Poetry run“ verwenden, um die Skripte Ihres Projekts auszuführen, ähnlich wie Sie Python- oder Conda-Befehle verwenden würden.

poetry run python my_script.py

Poetry verwaltet die virtuelle Umgebung und die Abhängigkeitsauflösung für Ihr Projekt und macht es mit vorhandenen Pip- oder Conda-Projekten kompatibel. Es vereinfacht die Verwaltung von Abhängigkeiten und ermöglicht konsistente Paketinstallationen in verschiedenen Umgebungen.

Hinweis: Es empfiehlt sich immer, Ihr Projekt zu sichern, bevor Sie wesentliche Änderungen an der Konfiguration oder den Instruments zur Abhängigkeitsverwaltung vornehmen.

Abschließende Gedanken

Um jedes Mal die richtigen Ergebnisse zu erzielen, müssen Sie sicherstellen, dass sich die richtigen Versionen der Pakete in Ihrer Codeumgebung befinden. Kleine Änderungen am Backend Ihres Codes können das Ergebnis verändern. Genauso wichtig ist es jedoch, diese Pakete und Bibliotheken auf dem neuesten Stand zu halten, um die Innovationen nutzen zu können, die jeder Patch dem nächsten bietet.

Um diese Abhängigkeiten in Ihrem Code zu verwalten, ist Poetry ein großartiges Software für diejenigen, die an komplexeren und vielfältigeren Projekten mit einer höheren Anzahl von Abhängigkeiten arbeiten. Pip und Conda sind zwar immer noch brauchbare Optionen, eignen sich jedoch eher für kleinere, weniger komplexe Umgebungen. Nicht jeder wird Poetry verwenden, aber da es Pip schon ewig gibt, kann es sich aufgrund der Benutzerfreundlichkeit lohnen, einfach Pip zu verwenden.

Wenn Sie jedoch bei Ihrem Projekt und Ihrer Arbeitsbelastung Wert auf Organisation legen und bereit sind, neue Instruments zur Verbesserung Ihres Prozesses zu erkunden, sollten Sie Poetry in Betracht ziehen. Die erweiterte Funktionalität von Pip zu Poetry macht wirklich einen Unterschied. Wir empfehlen Ihnen, Poetry selbst auszuprobieren.

Authentic. Mit Genehmigung erneut veröffentlicht.

Kevin Vu verwaltet Weblog von Exxact Corp und arbeitet mit vielen seiner talentierten Autoren zusammen, die über verschiedene Aspekte des Deep Studying schreiben.