Robustes Python

Vorwort

Diese Arbeit wurde mithilfe von KI übersetzt. Wir freuen uns über dein Feedback und deine Kommentare: [e-mail]

Der bekannte Softwareentwickler und Unternehmer Marc Andreesen hat bekanntlich erklärt, dass "Software die Welt frisst". Das war im Jahr 2011 und hat sich im Laufe der Zeit immer mehr bewahrheitet. Softwaresysteme werden immer komplexer und sind in allen Bereichen des modernen Lebens zu finden. In der Mitte dieser gefräßigen Bestie steht die Sprache Python. Programmierer/innen nennen Python oft als ihre Lieblingssprache, und sie ist überall zu finden: von Webanwendungen über maschinelles Lernen bis hin zu Entwickler-Tools und mehr.

Doch es ist nicht alles Gold, was glänzt. Je komplexer unsere Softwaresysteme werden, desto schwieriger wird es zu verstehen, wie sich unsere mentalen Modelle auf die reale Welt übertragen lassen. Wenn sie nicht kontrolliert werden, blähen sich Softwaresysteme auf und werden brüchig, was ihnen den furchterregenden Namen "Legacy-Code" einbringt. Diese Codebasen werden oft mit Warnungen versehen wie: "Berühre diese Dateien nicht; wir wissen nicht warum, aber es geht kaputt, wenn du es tust" und "Oh, nur So-und-So kennt diesen Code, und er ist vor zwei Jahren für einen hochbezahlten Job im Silicon Valley gegangen." Softwareentwicklung ist ein junges Feld, aber solche Aussagen sollten Entwickler/innen und Unternehmer/innen gleichermaßen erschrecken.

Die Wahrheit ist: Um Systeme zu entwickeln, die lange halten, musst du deine Entscheidungen bewusst treffen. Titus Winters, Tom Manshreck und Hyrum Wright haben es so formuliert: "Softwareentwicklung ist Programmieren im Wandel der Zeit."¹ Dein Code kann sehr lange halten - ich habe schon an Projekten mitgewirkt, deren Code geschrieben wurde, als ich noch in der Grundschule war. Wie lange wird dein Code halten? Hält er länger, als du in deinem jetzigen Job arbeitest (oder wenn du das Projekt nicht mehr betreust)? Wie willst du, dass dein Code in ein paar Jahren ankommt, wenn jemand Kernkomponenten daraus baut? Willst du, dass deine Nachfolger dir für deinen Weitblick danken oder dich für die Komplexität verfluchen, die du in diese Welt hineingebracht hast?

Python ist eine wunderbare Sprache, aber sie macht es gelegentlich schwierig, für die Zukunft zu entwickeln. Einige Befürworter anderer Programmiersprachen haben Python als "nicht produktionstauglich" oder "nur für Prototypen geeignet" verunglimpft, aber die Wahrheit ist, dass viele Entwickler nur an der Oberfläche kratzen, anstatt alle Werkzeuge und Tricks zu lernen, um robustes Python zu schreiben. In diesem Buch lernst du, wie du es besser machen kannst. Du lernst zahlreiche Möglichkeiten kennen, um Python sauber und wartbar zu machen. Deine zukünftigen Maintainer werden gerne mit deinem Code arbeiten, denn er wurde von vornherein so konzipiert, dass er einfach zu warten ist. Lies dieses Buch, blicke in die Zukunft und baue großartige Software, die Bestand hat.

Wer sollte dieses Buch lesen?

Dieses Buch richtet sich an jeden Python-Entwickler, der den Code, an dem er arbeitet, nachhaltig und wartbar weiterentwickeln möchte. Dies ist nicht dein erster Python-Text; ich erwarte, dass du bereits Python geschrieben hast. Du solltest mit dem Kontrollfluss von Python vertraut sein und bereits mit Klassen gearbeitet haben. Wenn du nach einem einführenden Text suchst, empfehle ich dir, zuerst Learning Python von Mark Lutz (O'Reilly) zu lesen.

Obwohl ich viele fortgeschrittene Python-Themen behandeln werde, ist das Ziel dieses Buches nicht, eine Anleitung zur Nutzung aller Python-Funktionen zu geben. Stattdessen dienen die Funktionen als Hintergrund für ein größeres Gespräch über Robustheit und darüber, wie sich deine Entscheidungen auf die Wartbarkeit auswirken. Manchmal werde ich Strategien diskutieren, die du nur selten oder gar nicht verwenden solltest. Das liegt daran, dass ich die ersten Prinzipien der Robustheit veranschaulichen möchte. Es ist wichtiger zu verstehen, warum und wie wir Entscheidungen im Code treffen, als zu wissen, welche Werkzeuge wir in einem optimalen Szenario verwenden. In der Praxis kommt das optimale Szenario nur selten vor. Nutze die Prinzipien in diesem Buch, um deine eigenen Schlüsse aus deiner Codebasis zu ziehen.

Dieses Buch ist kein Nachschlagewerk. Man könnte es ein Diskussionsbuch nennen. Jedes Kapitel sollte ein Ausgangspunkt für Entwickler/innen in deinem Unternehmen sein, um gemeinsam zu diskutieren, wie diese Prinzipien am besten angewendet werden können. Starte einen Buchclub, eine Diskussionsgruppe oder ein "Lunch and Learn", um die Kommunikation zu fördern. Ich habe in jedem Kapitel Diskussionsthemen vorgeschlagen, um die Konversation in Gang zu bringen. Wenn du auf diese Themen stößt, ermutige ich dich, innezuhalten und über deine aktuelle Codebasis nachzudenken. Sprich mit deinen Kolleginnen und Kollegen und nutze diese Themen als Sprungbrett, um den Zustand deines Codes, deiner Prozesse und Arbeitsabläufe zu besprechen. Wenn du dich für ein Nachschlagewerk über die Sprache Python interessierst, empfehle ich dir das Buch Fluent Python von Luciano Ramalho (O'Reilly; eine zweite Auflage ist für Ende 2021 geplant).

Ein System kann auf viele verschiedene Arten robust sein. Es kann sicherheitsgerüstet, skalierbar, fehlertolerant oder weniger fehleranfällig sein. Jede dieser Facetten der Robustheit rechtfertigt ein ganzes Buch; in diesem Buch geht es darum, die Entwickler, die deinen Code übernehmen, daran zu hindern, neue Fehler in dein System einzubauen. Ich zeige dir , wie du mit zukünftigen Entwicklern kommunizierst, wie du ihnen das Leben durch Architekturmuster erleichterst und wie du Fehler in deiner Codebasis abfängst, bevor sie in die Produktion gelangen. Dieses Buch konzentriert sich auf die Robustheit deiner Python-Codebasis und nicht auf die Robustheit deines Systems als Ganzes.

Ich werde eine Fülle von Informationen aus vielen verschiedenen Bereichen der Software abdecken, darunter Softwareentwicklung, Informatik, Testen, funktionale Programmierung und objektorientierte Programmierung (OOP). Ich erwarte nicht, dass du einen Hintergrund in diesen Bereichen hast. Es gibt Abschnitte, in denen ich Dinge auf Anfängerniveau erkläre; dies geschieht oft, um zu dekonstruieren, wie wir über die Grundprinzipien der Sprache denken. Im Großen und Ganzen ist dies ein Text für die Mittelstufe.

Ideale Leser sind:

• Entwickler, die in einer großen Codebasis arbeiten und nach besseren Möglichkeiten suchen, mit ihren Kollegen zu kommunizieren

• Hauptverantwortliche für die Pflege der Codebasis, die nach Möglichkeiten suchen, die Belastung für zukünftige Betreuer zu verringern

• Autodidaktische Entwickler, die Python sehr gut schreiben können, aber besser verstehen müssen, warum wir die Dinge tun, die wir tun

• Absolventen der Softwareentwicklung, die noch einmal praktische Tipps für die Entwicklung brauchen

• Erfahrene Entwickler, die nach einer Möglichkeit suchen, ihre Designprinzipien mit den ersten Prinzipien der Robustheit zu verbinden

Dieses Buch konzentriert sich auf das Schreiben von Software im Laufe der Zeit. Wenn ein großer Teil deines Codes ein Prototyp, ein Wegwerfprogramm oder auf andere Weise wegwerfbar ist, werden die Ratschläge in diesem Buch am Ende mehr Arbeit verursachen, als für dein Projekt notwendig ist. Das Gleiche gilt, wenn dein Projekt klein ist - sagen wir, weniger als hundert Zeilen Python. Code wartbar zu machen, erhöht die Komplexität, daran besteht kein Zweifel. Ich werde dich jedoch dabei unterstützen, diese Komplexität zu minimieren. Wenn dein Code länger als ein paar Wochen lebt oder zu einer beträchtlichen Größe heranwächst, musst du dir Gedanken über die Nachhaltigkeit deiner Codebasis machen.

Über dieses Buch

Dieses Buch deckt ein breites Spektrum an Wissen in vielen Kapiteln ab. Es ist in vier Teile gegliedert:

Teil I, "Deinen Code mit Typen kommentieren"

Wir beginnen mit den Typen in Python. Typen sind grundlegend für die Sprache, werden aber nicht oft im Detail untersucht. Die Typen, die du wählst, sind wichtig, denn sie vermitteln eine ganz bestimmte Absicht. Wir werden uns mit Typ-Annotationen beschäftigen und damit, was bestimmte Annotationen dem Entwickler mitteilen. Außerdem werden wir uns mit Typprüfungen beschäftigen und wie diese helfen, Fehler frühzeitig zu erkennen.

Teil II, "Deine eigenen Typen definieren"

Nachdem wir uns damit beschäftigt haben, wie man über Pythons Typen nachdenkt, werden wir uns darauf konzentrieren, wie du deine eigenen Typen erstellst. Wir werden Enumerationen, Datenklassen und Klassen im Detail durchgehen. Wir werden untersuchen, wie bestimmte Design-Entscheidungen beim Entwurf eines Typs die Robustheit deines Codes erhöhen oder verringern können.

Teil III, "Erweiterbares Python"

Nachdem wir gelernt haben, wie du deine Absichten besser ausdrücken kannst, werden wir uns darauf konzentrieren, wie du es Entwicklern ermöglichen kannst, deinen Code mühelos zu ändern und mit Vertrauen auf deinem starken Fundament aufzubauen. Wir werden uns mit Erweiterbarkeit, Abhängigkeiten und Architekturmustern beschäftigen, die es dir ermöglichen, dein System mit minimalen Auswirkungen zu verändern.

Teil IV, "Aufbau eines Sicherheitsnetzes"

Schließlich werden wir untersuchen, wie du ein Sicherheitsnetz aufbaust, damit du deine zukünftigen Mitarbeiter sanft auffangen kannst, wenn sie stürzen. Ihr Selbstvertrauen wird wachsen, weil sie wissen, dass sie ein starkes, robustes System haben, das sie ohne Angst an ihren Anwendungsfall anpassen können. Zum Schluss stellen wir dir eine Reihe von Werkzeugen für die statische Analyse und das Testen vor, die dir dabei helfen, fehlerhaftes Verhalten zu erkennen.

Jedes Kapitel ist größtenteils in sich abgeschlossen, mit Verweisen auf andere Kapitel, wo dies möglich ist. Du kannst das Buch von vorne bis hinten lesen oder zwischen den Kapiteln hin- und herspringen, die dir gefallen. Kapitel, die in jedem Teil gruppiert sind, stehen in Beziehung zueinander, aber es gibt weniger Beziehungen zwischen den Buchteilen.

Alle Codebeispiele wurden mit Python 3.9.0 ausgeführt. Ich werde versuchen, dich darauf hinzuweisen, wenn du eine bestimmte Python-Version oder eine neuere benötigst, um die Beispiele auszuführen (z. B. Python 3.7 für die Verwendung von Datenklassen).

In diesem Buch werde ich den Großteil meiner Arbeit auf der Kommandozeile erledigen. Ich habe alle Befehle von einem Ubuntu-Betriebssystem aus ausgeführt, aber die meisten Tools sollten genauso gut auf Mac- oder Windows-Systemen funktionieren. In einigen Fällen werde ich zeigen, wie bestimmte Tools mit integrierten Entwicklungsumgebungen (IDEs) wie Visual Studio Code (VS Code) zusammenarbeiten. Die meisten IDEs nutzen die Kommandozeilenoptionen unter der Haube; das meiste, was du auf der Kommandozeile lernst, lässt sich direkt auf die IDE-Optionen übertragen.

In diesem Buch werden viele verschiedene Techniken vorgestellt, die die Robustheit deines Codes verbessern können. Allerdings gibt es in der Softwareentwicklung keine Patentrezepte. Kompromisse sind das Herzstück einer soliden Entwicklung, und die Methoden, die ich vorstelle, sind da keine Ausnahme. Wenn ich diese Themen bespreche, werde ich die Vor- und Nachteile transparent darlegen. Du kennst dich mit deinen Systemen besser aus als ich und kannst am besten entscheiden, welches Werkzeug für welche Aufgabe geeignet ist. Alles, was ich tue, ist, deinen Werkzeugkasten aufzufüllen.

In diesem Buch verwendete Konventionen

In diesem Buch werden die folgenden typografischen Konventionen verwendet:

Kursiv

Weist auf neue Begriffe, URLs, E-Mail-Adressen, Dateinamen und Dateierweiterungen hin.

Constant width

Wird für Programmlistings sowie innerhalb von Absätzen verwendet, um auf Programmelemente wie Variablen- oder Funktionsnamen, Datenbanken, Datentypen, Umgebungsvariablen, Anweisungen und Schlüsselwörter hinzuweisen.

Constant width bold

Zeigt Befehle oder anderen Text an, der vom Benutzer wörtlich eingegeben werden muss.

Constant width italic

Zeigt Text an, der durch vom Benutzer eingegebene Werte oder durch kontextabhängige Werte ersetzt werden soll.

Tipp

Dieses Element steht für einen Tipp oder eine Anregung.

Hinweis

Dieses Element steht für einen allgemeinen Hinweis.

Warnung

Dieses Element weist auf eine Warnung oder einen Warnhinweis hin.

Code-Beispiele verwenden

Zusätzliches Material (Code-Beispiele, Übungen usw.) steht unter https://github.com/pviafore/RobustPython zum Download bereit .

Wenn du eine technische Frage oder ein Problem mit den Codebeispielen hast, sende bitte eine E-Mail an [e-mail].

Dieses Buch soll dir helfen, deine Arbeit zu erledigen. Wenn in diesem Buch Beispielcode angeboten wird, darfst du ihn in deinen Programmen und deiner Dokumentation verwenden. Du musst uns nicht um Erlaubnis fragen, es sei denn, du reproduzierst einen großen Teil des Codes. Wenn du zum Beispiel ein Programm schreibst, das mehrere Teile des Codes aus diesem Buch verwendet, brauchst du keine Erlaubnis. Der Verkauf oder die Verbreitung von Beispielen aus O'Reilly-Büchern erfordert jedoch eine Genehmigung. Die Beantwortung einer Frage mit einem Zitat aus diesem Buch und einem Beispielcode erfordert keine Genehmigung. Wenn du einen großen Teil des Beispielcodes aus diesem Buch in die Dokumentation deines Produkts aufnimmst, ist eine Genehmigung erforderlich.

Wir freuen uns über eine Namensnennung, verlangen sie aber in der Regel nicht. Eine Quellenangabe umfasst normalerweise den Titel, den Autor, den Verlag und die ISBN. Zum Beispiel: "Robust Python von Patrick Viafore (O'Reilly). Copyright 2021 Kudzera, LLC, 978-1-098-10066-7."

Wenn du der Meinung bist, dass die Verwendung von Code-Beispielen nicht unter die Fair-Use-Regelung oder die oben genannte Erlaubnis fällt, kannst du uns gerne unter [e-mail] kontaktieren .

O'Reilly Online Learning

Hinweis

Seit mehr als 40 Jahren bietet O'Reilly Media Schulungen, Wissen und Einblicke in Technologie und Wirtschaft, um Unternehmen zum Erfolg zu verhelfen.

Unser einzigartiges Netzwerk von Experten und Innovatoren teilt sein Wissen und seine Erfahrung durch Bücher, Artikel und unsere Online-Lernplattform. Die Online-Lernplattform von O'Reilly bietet dir On-Demand-Zugang zu Live-Trainingskursen, vertiefenden Lernpfaden, interaktiven Programmierumgebungen und einer umfangreichen Sammlung von Texten und Videos von O'Reilly und über zweihundert anderen Verlagen. Weitere Informationen erhältst du unter http://oreilly.com.

Wie du uns kontaktierst

Bitte richte Kommentare und Fragen zu diesem Buch an den Verlag:

• O'Reilly Media, Inc.
• 1005 Gravenstein Highway Nord
• Sebastopol, CA 95472
• 800-998-9938 (in den Vereinigten Staaten oder Kanada)
• 707-829-0515 (international oder lokal)
• 707-829-0104 (Fax)

Wir haben eine Webseite für dieses Buch, auf der wir Errata, Beispiele und zusätzliche Informationen auflisten. Du kannst diese Seite unter https://oreil.ly/robust-python aufrufen .

Schreib eine E-Mail an [e-mail], um Kommentare oder technische Fragen zu diesem Buch zu stellen.

Neuigkeiten und Informationen über unsere Bücher und Kurse findest du unter http://oreilly.com.

Finde uns auf Facebook: http://facebook.com/oreilly

Folge uns auf Twitter: http://twitter.com/oreillymedia

Schau uns auf YouTube: http://youtube.com/oreillymedia

Danksagungen

Ich möchte mich bei meiner unglaublichen Frau Kendall bedanken. Sie ist meine Stütze und mein Resonanzboden, und ich bin dankbar für alles, was sie getan hat, um sicherzustellen, dass ich die Zeit und den Raum hatte, dieses Buch zu schreiben.

Kein Buch wird für sich allein geschrieben, und dieses Buch ist da keine Ausnahme. Ich stehe auf den Schultern von Giganten in der Softwarebranche und ich schätze alle, die vor mir da waren.

Ich möchte mich auch bei allen bedanken, die bei der Durchsicht dieses Buches mitgewirkt haben, um sicherzustellen, dass meine Botschaften konsistent und meine Beispiele klar sind. Ich danke Bruce G., David K., David P. und Don P. für ihr frühes Feedback und ihre Hilfe bei der Festlegung der Richtung dieses Buches. Ich danke meinen technischen Prüfern Charles Givre, Drew Winstel, Jennifer Wilcox, Jordan Goldmeier, Nathan Stocks und Jess Males für ihr wertvolles Feedback, vor allem dort, wo Dinge nur in meinem Kopf, nicht aber auf dem Papier Sinn machten. Zu guter Letzt möchte ich mich bei allen bedanken, die den ersten Entwurf gelesen haben und so freundlich waren, mir ihre Meinung zu mailen, besonders bei Daniel C. und Francesco.

Ich möchte mich bei allen bedanken, die mir geholfen haben, meinen letzten Entwurf in etwas Produktionsfähiges zu verwandeln. Danke an Justin Billing, der als Lektor tief in die Materie eingetaucht ist und mir geholfen hat, meine Ideen besser zu präsentieren. Vielen Dank an Shannon Turlington für das Korrekturlesen; das Buch ist durch dich viel besser geworden. Ein großes Dankeschön geht an Ellen Troutman-Zaig, die einen fantastischen Index erstellt hat, der mich umgehauen hat.

Und schließlich könnte ich das nicht ohne das fabelhafte Team von O'Reilly machen. Danke an Amanda Quinn, die mir bei der Antragstellung geholfen und mich dabei unterstützt hat, den Fokus für das Buch zu entwickeln. Danke an Kristen Brown, die mir die Produktionsphase unglaublich leicht gemacht hat. Danke an Kate Dullea, die meine Skizzen in MS Paint-Qualität in saubere, scharfe Illustrationen umgewandelt hat. Außerdem möchte ich meiner Entwicklungslektorin Sarah Grey ein großes Dankeschön aussprechen. Ich habe mich auf unsere wöchentlichen Treffen gefreut, und sie hat mir fantastisch dabei geholfen, ein Buch für ein breites Publikum zu schreiben, ohne dass ich mich in technische Details vertiefen musste.

¹ Titus Winters, Tom Manshreck, und Hyrum Wright. Softwareentwicklung bei Google: Lessons Learned from Programming over Time. Sebastopol, CA: O'Reilly Media, Inc., 2020.