10 Dimensionen der statischen Python-Analyse

Artikel von

17. Juli 2024

0 Min. Lesezeit

Die statische Python-Analyse, auch „Linting“ genannt, ist ein wichtiger Bestandteil der Softwareentwicklung. Dabei wird Ihr Python-Code untersucht, ohne ihn auszuführen, um potenzielle Fehler, Programmierfehler, stilistische Probleme oder Abweichungen von vordefinierten Codierungsstandards zu erkennen. Außerdem lassen sich so Schwachstellen früh im Entwicklungsprozess identifizieren und die Wahrscheinlichkeit verringern, dass unsicherer Code in die Produktion gelangt. So können beispielsweise unsichere Programmierpraktiken wie hartcodierte Zugangsdaten, häufige Fehler, die zu SQL-Injection-Angriffen führen können, oder potenzielle Probleme bei der Datenbereinigung erkannt werden.

Für die statische Analyse bietet Python verschiedene Bibliotheken und Tools wie Pylint, Pyflakes und Flake8. Pylint kann beispielsweise dabei helfen, Codierungsstandards durchzusetzen, Fehler zu erkennen und die Codekomplexität zu untersuchen. Hier sehen Sie ein einfaches Codebeispiel für die Verwendung von Pylint:

1# test.py
2
3def add(x, y):
4    return x + y
5
6add(1, '2')

Bei der Ausführung von Pylint für diesen Code erhalten Sie:

$ pylint test.py
************* Module test
test.py:5:4: E1136: Value '2' is unsubscriptable (unsubscriptable-object)

--------------------------------------------------
Your code has been rated at -10.00/10

Pylint hat einen Fehler erkannt, als wir versucht haben, eine Ganzzahl und eine Zeichenfolge zu addieren. Das ist in Python keine gültige Operation.

1. Typprüfung in der statischen Python-Analyse

Python ist eine vielseitige, dynamische Programmiersprache. Ihre Flexibilität ist einer der Gründe, warum sie bei Entwicklern so beliebt ist. Diese Dynamik kann jedoch manchmal zu schwer auffindbaren Fehlern führen, insbesondere bei Typfehlern. Hier kommt die statische Python-Analyse ins Spiel.

Bevor wir uns mit der Typprüfung befassen, sehen wir uns an, was dynamische Typisierung in Python bedeutet. Python ist dynamisch typisiert. Das heißt, der Typ einer Variablen wird zur Laufzeit geprüft und muss nicht explizit angegeben werden. Das folgende Codebeispiel veranschaulicht dies:

1# x is an integer
2x = 5
3# x is now a string
4x = "Hello, World!"

Dynamische Typisierung kann Python zwar einfacher nutzbar und besser lesbar machen, sie kann aber auch zu Typfehlern führen, die erst entdeckt werden, wenn der Code tatsächlich ausgeführt wird.

Die Rolle der statischen Typprüfung

Bei der statischen Typprüfung werden Typfehler früh im Entwicklungsprozess erkannt, also beim Programmieren oder Erstellen und nicht erst zur Laufzeit. So lässt sich verhindern, dass potenzielle Fehler in den Produktivcode gelangen. Das erhöht die Sicherheit und Zuverlässigkeit des Codes. Java und C++ sind Beispiele für statisch typisierte Programmiersprachen.

Obwohl Python dynamisch typisiert ist, unterstützt die Sprache auch optionale statische Typisierung mithilfe von Typannotationen. Damit können Sie erwartete Typen für Variablen, Funktionsparameter und Rückgabewerte angeben. Die Python-Laufzeitumgebung erzwingt diese Typen nicht, aber statische Analysetools können sie verwenden, um potenzielle Typfehler zu erkennen.

1def greet(name: str) -> str:
2    return 'Hello, ' + name

In diesem Beispiel wird erwartet, dass name eine Zeichenfolge ist und die Funktion ebenfalls eine Zeichenfolge zurückgibt.

Tools für die statische Typprüfung in Python

Verschiedene Tools unterstützen die statische Typprüfung in Python. Mypy, Pyright und Pyre zeichnen sich durch ihre Robustheit und breite Akzeptanz in der Python-Community aus.

Mypy: Ein optionaler statischer Typprüfer für Python, der die Vorteile dynamischer und statischer Typisierung miteinander verbinden soll. Er ist vielseitig und lässt sich in einer CI/CD-Pipeline einsetzen, um Typfehler zu erkennen, bevor sie in die Produktion gelangen.
Pyright: Pyright wurde von Microsoft entwickelt und ist ein statischer Typprüfer mit Fokus auf Performance. Er ist in TypeScript geschrieben und läuft auf Node.js.
Pyre: Pyre ist ein leistungsstarker Typprüfer für Python, der von Facebook entwickelt wurde. Er soll die Codequalität und Entwicklungsgeschwindigkeit verbessern, indem er Typfehler interaktiv im Terminal oder in Ihrem bevorzugten Editor meldet.

Codebeispiel: Typprüfung mit Mypy

Mypy lässt sich ganz einfach mit pip install mypy installieren. Nach der Installation können Sie damit Ihre Python-Dateien auf Typfehler überprüfen. Hier sehen Sie ein einfaches Beispiel:

1# file: hello.py
2def greet(name: str) -> str:
3    return 'Hello, ' + name
4
5# This will cause a type error
6greet(123)
7

So überprüfen Sie diese Datei mit Mypy:

$ mypy hello.py
hello.py:5: error: Argument 1 to "greet" has incompatible type "int"; expected "str"
Found 1 error in 1 file (checked 1 source file)

Wie Sie sehen, hat Mypy den Typfehler erkannt, bevor der Code ausgeführt wurde.

2. Linter in der statischen Python-Analyse

Linter sind Tools zur statischen Codeanalyse, die Programmierfehler, Bugs, Stilprobleme und verdächtige Konstrukte melden. Im Python-Umfeld spielen Linter eine entscheidende Rolle für die Qualität und Sicherheit Ihres Codes. Sie helfen dabei, Codierungsstandards durchzusetzen, potenzielle Bugs und Sicherheitslücken früh im Entwicklungsprozess zu erkennen sowie die Lesbarkeit und Wartbarkeit Ihres Python-Codes insgesamt zu verbessern.

Zu den in der Python-Umgebung am häufigsten verwendeten Linter gehören Pylint, Flake8 und Pyflakes.

Pylint: Pylint ist ein hochgradig konfigurierbares Open-Source-Tool, das Python-Code auf Fehler prüft, einen Codierungsstandard durchsetzt und nach Code-Smells sucht. Für bestimmte Anwendungsfälle können Sie mit Pylint auch benutzerdefinierte Plugins schreiben.
Flake8: Flake8 ist eine Python-Bibliothek, die PyFlakes, pycodestyle und Ned Batchelders McCabe-Skript bündelt. Das Toolkit prüft Ihr Projekt auf Konformität mit PEP 8, dem Styleguide für Python.
Pyflakes: Pyflakes prüft Python-Quelldateien schnell auf Fehler, ohne sie auszuführen. Da das Tool keine Styleguides durchsetzt, ist es schneller als Pylint und Flake8 und eignet sich gut für eine schnelle, grundlegende Überprüfung Ihres Python-Codes.

Code-Smells und die Durchsetzung von Codierungsstandards

Code-Smells sind Hinweise auf tieferliegende Probleme in Ihrem Code. Dabei handelt es sich um Codemuster, die auf Verstöße gegen grundlegende Designprinzipien hindeuten und die Designqualität beeinträchtigen. Häufige Code-Smells in Python sind beispielsweise große Klassen, lange Methoden, doppelter Code und nicht verwendeter Code.

Linter wie Pylint, Flake8 und Pyflakes helfen dabei, solche Code-Smells zu erkennen und Codierungsstandards in Ihrem Python-Code durchzusetzen, um die Codequalität zu verbessern und auf einem akzeptablen Niveau zu halten. Dazu prüfen sie Ihren Code anhand vordefinierter Regeln und Richtlinien, die oft auf bewährten Vorgehensweisen beruhen, die von der Community übernommen wurden, wie etwa PEP 8 für Python.

Codebeispiel für den Einsatz eines Linters

Hier sehen Sie ein Beispiel dafür, wie Sie mit Pylint eine statische Analyse einer Python-Datei namens example.py durchführen:

1# example.py
2def add(a, b):
3    return a+b

Mit dem folgenden Befehl führen Sie Pylint für diese Datei aus:

pylint example.py

Wenn Ihr Code Probleme enthält, meldet Pylint diese und erstellt einen detaillierten Bericht. Das Tool könnte beispielsweise darauf hinweisen, dass der Funktion add eine Funktionsdokumentation fehlt. Das verstößt gegen die Richtlinien von PEP 8 für gut geschriebenen Python-Code.

Benutzerdefinierte Regeln in Lintern

Mit Lintern wie Pylint können Sie benutzerdefinierte Regeln für Ihre Python-Projekte festlegen. Das ist besonders nützlich, wenn für Ihr Projekt oder Ihre Organisation bestimmte Codierungsstandards oder Richtlinien gelten.

Um in Pylint eine benutzerdefinierte Regel zu erstellen, erstellen Sie eine Python-Klasse, die von einer der Checker-Klassen von Pylint abgeleitet ist. Anschließend definieren Sie Methoden, die den Code tatsächlich prüfen. Sobald Sie Ihre benutzerdefinierten Regeln definiert haben, können Sie sie mithilfe der Methode register_checker zu Ihrem Pylint-Checker hinzufügen.

Hier sehen Sie ein einfaches Beispiel für eine benutzerdefinierte Pylint-Regel, die prüft, ob die print -Anweisung verwendet wird:

1from pylint.checkers import BaseChecker
2from pylint.interfaces import IAstroidChecker
3
4class NoPrintStatementsChecker(BaseChecker):
5    __implements__ = IAstroidChecker
6    name = 'no-print-statements'
7    msgs = {
8        'W0001': (
9            'Print statement used',
10            'no-print-statements',
11            'Print statements should not be used',
12        ),
13    }
14
15    def visit_print(self, node):
16        self.add_message('no-print-statements', node=node)
17
18def register(linter):
19    linter.register_checker(NoPrintStatementsChecker(linter))

In diesem Beispiel prüft die Klasse NoPrintStatementsChecker, ob die print -Anweisung verwendet wird, und gibt eine Warnung aus, wenn sie eine solche findet. Anschließend wird die Funktion register verwendet, um diesen benutzerdefinierten Checker bei Pylint zu registrieren.

3. Erkennung von Sicherheitslücken

Eine wichtige Dimension der statischen Python-Analyse ist die Erkennung von Sicherheitslücken. Sehen wir uns an, warum Sicherheit bei der statischen Python-Analyse wichtig ist, welche Sicherheitsrisiken in Python-Code häufig auftreten und welche Tools Sie zur Erkennung von Sicherheitslücken einsetzen können, zum Beispiel Bandit und Snyk Code.

Wenn Sie Python-Code schreiben, sollte Sicherheit kein nachträglicher Gedanke sein, sondern ein fester Bestandteil des Entwicklungsprozesses. Die statische Python-Analyse spielt eine entscheidende Rolle für die Codesicherheit, denn sie kann potenzielle Sicherheitslücken früh im Entwicklungszyklus erkennen – noch bevor der Code ausgeführt wird. In Python-Code treten häufig Schwachstellen wie Injection-Angriffe, unsichere direkte Objektreferenzen, fehlerhafte Sicherheitskonfigurationen und Cross-Site-Scripting auf.

Eine SQL-Injection-Schwachstelle in Python-Code könnte beispielsweise so aussehen:

1def get_user_details(user_id):
2    return database.execute(f'SELECT * FROM users WHERE id = {user_id}')

Im obigen Beispiel wird user_id direkt in einer SQL-Abfrage verwendet. Dadurch besteht die Möglichkeit einer SQL-Injection, wenn user_id nicht ordnungsgemäß bereinigt und vom Benutzer bereitgestellt wird.

Tools zur Erkennung von Sicherheitslücken

Bandit

Bandit ist ein Tool, das häufige Sicherheitsprobleme in Python-Code erkennt. Es verarbeitet jede Datei, erstellt aus dem Python-Code einen AST (Abstract Syntax Tree) und führt geeignete Plugins für die AST-Knoten aus.

So können Sie Bandit verwenden, um Ihren Python-Code auf Sicherheitslücken zu prüfen:

$ bandit -r path/to/your/python/code

Würde Bandit eine unsichere direkte Objektreferenz in Python erkennen? Sie sind sich nicht sicher? Lesen Sie als Nächstes mehr über Snyk.

Snyk Code

Snyk Code ist ein weiteres Tool mit einer schnellen, symbolischen und KI-gestützten Analyse-Engine. Mit Snyk Code finden Sie Sicherheitslücken in Ihrem Python-Code schnell. Die statische Analyse-Engine von Snyk Code versteht den Kontext und den Ablauf Ihres Codes und kann so komplexe Sicherheitslücken erkennen, die anderen Tools möglicherweise entgehen.

Snyk Code bietet außerdem ein PyCharm-IDE-Plugin, mit dem Entwickler Sicherheitsprobleme während des Programmierens in Echtzeit erkennen und beheben können.

Um mit Snyk Code zu starten, laden Sie einfach das PyCharm-IDE-Plugin von Snyk herunter. Anschließend können Sie es kostenlos nutzen.

Die Erkennung von Sicherheitslücken in Ihre statische Python-Analyse zu integrieren, ist entscheidend für die Sicherheit Ihrer Software. Tools wie Bandit und Snyk Code bieten Entwicklern eine einfache und effiziente Möglichkeit, Sicherheitslücken in ihrem Python-Code zu erkennen und zu beheben.

4. Analyse der Codekomplexität

Die Codekomplexität ist eine Kennzahl dafür, wie schwierig Ihr Code zu verstehen oder zu ändern ist. Eine höhere Komplexität erschwert in der Regel das Verständnis des Codes und beeinträchtigt dadurch seine Wartbarkeit.

Die Pflege von Code gehört zum Alltag eines Entwicklers. Wird die Codebasis jedoch komplex, wird es immer schwieriger, sie zu verstehen und zu ändern. Das kann zu Bugs führen und die Gesamtqualität der Software beeinträchtigen. Daher ist die Analyse der Codekomplexität entscheidend, um hochwertige und wartbare Software sicherzustellen.

Messung der zyklomatischen Komplexität mit Radon

Zur Messung der Codekomplexität in Python können verschiedene Tools eingesetzt werden, darunter Radon. Radon ist ein Python-Tool, das verschiedene Kennzahlen anhand der aus dem Abstract Syntax Tree (AST) gewonnenen Informationen berechnet. Eine dieser Kennzahlen ist die zyklomatische Komplexität.

Die zyklomatische Komplexität ist eine Softwarekennzahl, die die Komplexität eines Programms angibt. Sie misst quantitativ die Anzahl der linear unabhängigen Pfade durch den Quellcode eines Programms. Radon analysiert Ihren Python-Code und bewertet ihn auf einer Skala von A bis F: A bedeutet, dass der Code einfach und leicht verständlich ist, während F auf eine zu hohe Komplexität hinweist.

Um Radon zu verwenden, müssen Sie es zunächst installieren. Dazu können Sie pip verwenden:

pip install radon

Codebeispiel zur Analyse der Codekomplexität

Nach der Installation von Radon können Sie das Tool zur Analyse Ihres Python-Codes verwenden. Betrachten wir den folgenden Python-Code:

1def calculate_sum(n):
  if n < 0:
      return "Negative number"
  else:
      return sum(range(n+1))

Um die Komplexität des obigen Codes zu messen, führen Sie den folgenden Befehl aus:

radon cc your_file.py

Dieser Befehl gibt die zyklomatische Komplexität des Codes zurück. Im obigen Beispiel beträgt sie 2, der Code ist also nicht besonders komplex.

Betrachten wir jedoch eine komplexere Funktion, zum Beispiel:

1def complex_function(a, b, c):
  if a > b:
      if a > c:
          return a
      else:
          return c
  else:
      if b > c:
          return b
      else:
          return c

Bei der Ausführung von Radon für diesen Code würde eine Komplexität von 5 zurückgegeben, was auf eine höhere Komplexität hinweist.

Der Einsatz von Tools zur Messung der zyklomatischen Komplexität trägt zur Codequalität bei und erleichtert das Verständnis und die Änderung des Codes. Tools wie Radon bieten eine einfache Möglichkeit, die Komplexität von Python-Code zu messen. So wird Ihr Code besser wartbar und weniger fehleranfällig.

5. Abhängigkeitsanalyse

In der Welt der Open-Source-Software, einem zentralen Bestandteil der Softwareentwicklung, ist die Abhängigkeitsanalyse ein wichtiger Aspekt, den Entwicklerinnen und Entwickler nicht außer Acht lassen sollten. Sie ist besonders bei großen Codebasen in Sprachen wie Python entscheidend. Bei der Abhängigkeitsanalyse werden die Abhängigkeiten zwischen verschiedenen Elementen eines Softwareprojekts ermittelt. Sehen wir uns an, warum es wichtig ist, Abhängigkeiten zu verstehen und zu verwalten, welche Tools es dafür gibt – darunter Snyk und Snyk Advisor – und wie eine Abhängigkeitsanalyse in der Praxis aussieht.

Warum es wichtig ist, Abhängigkeiten zu verstehen und zu verwalten

In Python-Projekten sind Abhängigkeiten die externen Pakete oder Bibliotheken, die Ihr Projekt verwendet. Dazu können Web-Frameworks wie Django oder Flask ebenso gehören wie Data-Science-Bibliotheken wie NumPy oder pandas.

Abhängigkeiten zu verstehen und zu verwalten, ist aus mehreren Gründen entscheidend:

So lassen sich Stabilität und Zuverlässigkeit Ihrer Software erhalten. Wenn eine Abhängigkeit, auf die Ihr Projekt angewiesen ist, einen Fehler enthält oder ausfällt, kann auch Ihre Software beeinträchtigt werden.
Es trägt dazu bei, die Sicherheit Ihres Projekts zu verbessern. Abhängigkeiten können Sicherheitslücken aufweisen, die Ihr Projekt gefährden, wenn sie nicht behoben werden.
Es hilft Ihnen, Lizenzanforderungen einzuhalten. Jede Abhängigkeit kann einer eigenen Lizenz unterliegen. Daher müssen Sie sicherstellen, dass Sie alle Lizenzbedingungen erfüllen.

Snyk Advisor für die Abhängigkeitsanalyse

Snyk Advisor ist ein Tool, das Einblicke in die Abhängigkeiten Ihres Python-Projekts bietet, darunter Informationen zu Sicherheitslücken, Lizenzproblemen und veralteten Paketen. Es hilft Ihnen, die mit Ihren Abhängigkeiten verbundenen Risiken zu verstehen, und gibt konkrete Empfehlungen, wie Sie diese mindern können.

Der Paket-Health-Score des Python-Pakets requests von PyPI, angezeigt in Snyk Advisor

Mit der Snyk CLI können Sie die Abhängigkeiten Ihres Python-Projekts analysieren und sich über anfällige Open-Source-Pakete informieren lassen, die von PyPI installiert wurden, oder über unsicheren Code in Ihrem Python-Programm. Installieren Sie zunächst die Snyk CLI. Anschließend können Sie Ihr Projekt mit folgendem Befehl analysieren:

snyk test --all-projects

Dieser Befehl analysiert die Abhängigkeiten Ihres Projekts und erstellt einen Bericht zu Sicherheitslücken, Lizenzproblemen oder veralteten Paketen. Bei einem Scan eines Python-FastAPI-Projekts könnte das Tool beispielsweise auf Sicherheitslücken hinweisen:

Testing FastAPI...
✗ High severity vulnerability found in requests
  Description: Out-of-bounds Read
  Info: https://snyk.io/vuln/SNYK-PYTHON-REQUESTS-174006
  Introduced through: requests@2.25.1
  From: requests@2.25.1 > urllib3@1.26.3 > requests
  Fix: https://snyk.io/vuln/SNYK-PYTHON-REQUESTS-174006

Organization:      snyk
Package manager:   pip
Target file:       requirements.txt

Legen Sie mit Snyk für Python-Sicherheit los und schützen Sie Ihre erste Codezeile – bis hin zur letzten pip-Abhängigkeit und Ihren bereitgestellten Python-Container-Anwendungen.

Scannen Sie Ihren Python-Code in Echtzeit und erhalten Sie KI-gestützte Korrekturvorschläge direkt in Ihren bevorzugten IDEs, darunter Visual Studio Code und PyCharm.

Abhängigkeitsanalyse mit pipenv graph

Betrachten wir eine einfache Python-Flask-Anwendung, um die Abhängigkeitsanalyse in der Praxis zu veranschaulichen. Hier sehen Sie die Datei app.py:

1from flask import Flask
2app = Flask(__name__)
3
4@app.route('/')
5def hello_world():
6    return 'Hello, World!'

In diesem Beispiel verwenden wir Pipenv. Initialisieren Sie zunächst Pipenv und installieren Sie Flask:

pipenv install flask

Wenn Sie jetzt pipenv graph ausführen, wird Folgendes angezeigt:

flask==1.1.2
  - click [required: >=5.1, installed: 7.1.2]
  - itsdangerous [required: >=0.24, installed: 1.1.0]
  - Jinja2 [required: >=2.10.1, installed: 2.11.2]
    - MarkupSafe [required: >=0.23, installed: 1.1.1]
  - Werkzeug [required: >=0.15, installed: 1.0.1]

Die Ausgabe zeigt, dass Flask, die direkte Abhängigkeit unseres Projekts, von click, itsdangerous, Jinja2 und Werkzeug abhängt. Jinja2 wiederum hängt von MarkupSafe ab. Damit haben wir die Abhängigkeiten unseres Projekts erfolgreich analysiert.

Wenn pipenv für Sie neu ist und Sie mehr darüber erfahren möchten, empfehlen wir Ihnen die Lektüre von Python-Virtual-Environments meistern: Ein umfassender Leitfaden zu venv, Docker und zum Schutz Ihres Codes. Dort lernen Sie das Konzept virtueller Umgebungen in Python kennen.

Zusammenfassend lässt sich sagen: Eine regelmäßige Abhängigkeitsanalyse in Python-Projekten ist notwendig, um die Zuverlässigkeit des Codes zu erhalten, die Sicherheit zu verbessern und die Einhaltung von Lizenzbedingungen sicherzustellen. Tools wie Snyk, Snyk Advisor und Pipenv erleichtern diese Aufgabe und verschaffen Ihnen einen klaren Überblick über den Abhängigkeitsbaum.

6. Tools zur Codeformatierung

Ein einheitlicher Codestil und ein konsistentes Format sind weitere wichtige Aspekte, um die Lesbarkeit und Effizienz von Code zu erhalten. Code-Formatierungstools spielen dabei eine wichtige Rolle. Sie formatieren Codebasen automatisch anhand vordefinierter Regeln. Das verbessert nicht nur die allgemeine Codequalität, sondern reduziert auch den Zeit- und Arbeitsaufwand für manuelle Code-Reviews. Lernen Sie beliebte Code-Formatter wie Black und YAPF kennen.

Sehen wir uns ein Beispiel an, um zu verstehen, welchen Unterschied ein Code-Formatter machen kann. Unten sehen Sie Python-Code vor und nach der Formatierung mit Black.

Vor der Formatierung:

1def function(arg1,arg2,arg3=4,arg4=8,arg5=16):
2    return arg1+arg2+arg3+arg4+arg5
3print(function(1,2))

Nach der Formatierung mit Black:

1def function(arg1, arg2, arg3=4, arg4=8, arg5=16):
2    return arg1 + arg2 + arg3 + arg4 + arg5
3
4print(function(1, 2))

YAPF – Python-Code-Formatter

YAPF (Yet Another Python Formatter) ist ein weiterer Code-Formatter für Python. Er geht über PEP8 hinaus und sorgt für einen einheitlicheren Codestil. Anders als PEP8 berücksichtigt YAPF das Erscheinungsbild des Codes und verbessert dadurch seine Lesbarkeit.

Hier sehen Sie ein Beispiel für die Verwendung von YAPF:

# install yapf
pip install yapf

# use yapf to format a python file
yapf -i your_python_file.py

7. Abstrakte Syntaxbäume (AST) in Python

Was ist ein abstrakter Syntaxbaum (AST)? Ein abstrakter Syntaxbaum ist eine Baumdarstellung der syntaktischen Struktur von Quellcode, der in einer Programmiersprache geschrieben wurde. Jeder Knoten im Baum steht für ein Konstrukt im Quellcode. Die Syntax wird als „abstrakt“ bezeichnet, weil nicht jedes Detail der tatsächlichen Syntax dargestellt wird.

Wenn der Python-Interpreter Code ausführt, wandelt er ihn zunächst in eine Zwischenform um, den sogenannten Bytecode. Bei dieser Umwandlung wird ein AST erstellt. Ein AST in Python ist eine vereinfachte Darstellung der Python-Code-Struktur. Formatierungsdetails und Leerzeichen werden dabei ausgeblendet; im Fokus stehen allein die Anweisungen und ihre Reihenfolge. So entsteht eine strukturelle Ansicht des Codes.

Das Python-Modul ast und seine Funktionen

Die Python-Standardbibliothek enthält das Modul ast, mit dem sich ASTs erstellen, bearbeiten und untersuchen lassen. Dieses Modul bietet eine Reihe von Klassen, Funktionen und Hilfsmethoden, um ASTs in Python programmgesteuert zu verarbeiten.

Die Funktion ast.parse() ist ein häufig genutzter Einstiegspunkt zum Erstellen von ASTs. Sie analysiert Python-Quellcode und wandelt ihn in einen AST-Knoten um, der anschließend bearbeitet oder untersucht werden kann.

Das Modul ast bietet außerdem die Klasse NodeVisitor, mit der Sie den AST durchlaufen und für jeden gefundenen Knoten eine Besuchsfunktion aufrufen können. Sie können die Klasse unverändert verwenden oder von ihr erben, um Methoden zu überschreiben und Funktionen für bestimmte Knotentypen bereitzustellen.

AST untersuchen und bearbeiten: ein praktisches Beispiel

Sehen wir uns ein einfaches Beispiel an, in dem wir das Modul ast verwenden, um einen AST in Python zu untersuchen und zu bearbeiten.

1import ast
2
3# Parse some code into an AST
4root = ast.parse("print('Hello, World!')")
5
6# Print all the nodes in the AST
7for node in ast.walk(root):
8    print(type(node))
9
10# Modify the AST to print a different message
11for node in ast.walk(root):
12    if isinstance(node, ast.Str):  # Change the string literal in the Print node
13        node.s = 'Hello, AST!'
14
15# Convert the modified AST back into code
16code = compile(root, filename="<ast>", mode="exec")
17
18# Execute the modified code
19exec(code)
20

In diesem Beispiel wandeln wir zunächst eine einfache Python-print-Anweisung mit ast.parse() in einen AST um. Anschließend untersuchen wir den AST, indem wir alle Knoten durchlaufen und ihre Typen ausgeben. Danach ändern wir den AST, indem wir das Zeichenfolgenliteral im Print-Knoten ersetzen. Zuletzt wandeln wir den geänderten AST mit compile() wieder in Code um und führen ihn mit exec() aus. Die Ausgabe dieses Codes lautet „Hello, AST!“ und nicht „Hello, World!“.

Dieses Beispiel zeigt, wie sich das Modul ast in Python zum Untersuchen und Ändern von ASTs einsetzen lässt. Die möglichen Anwendungen von ASTs im Bereich Codesicherheit und Softwareentwicklung sind vielfältig: von der automatisierten Code-Umstrukturierung bis hin zu fortschrittlicher statischer Codeanalyse zur Erkennung von Sicherheitslücken.

8. Kontrollfluss- und Datenflussanalyse

Die Kontrollfluss- und Datenflussanalyse sind wichtige Komponenten. Diese Technik ermöglicht eine effiziente Fehlererkennung, verbessert die Lesbarkeit des Codes und steigert die Gesamtqualität von Python-Anwendungen.

Bei der Kontrollflussanalyse wird die Ausführungsreihenfolge von Anweisungen in einem Programm untersucht. Die Datenflussanalyse konzentriert sich dagegen darauf, Datenwerte im Programm zu verfolgen und ihre Veränderungen zu analysieren. Dafür sind diese Analysen wichtig:

Erkennung potenzieller Fehler: Die Kontrollfluss- und Datenflussanalyse kann helfen, potenzielle Bugs und Sicherheitslücken im Code zu erkennen, etwa Endlosschleifen, nicht erreichbaren Code oder ungenutzte Variablen.
Codeoptimierung: Wenn Sie verstehen, wie Daten durch Ihren Code fließen und wie der Kontrollfluss verläuft, können Sie ineffiziente Bereiche erkennen und gezielt verbessern.
Bessere Lesbarkeit des Codes: Die Kontrollfluss- und Datenflussanalyse kann den Code verständlicher machen, indem sie Abhängigkeiten und Wechselwirkungen zwischen verschiedenen Codeabschnitten sichtbar macht.
Sicherheitsgewährleistung: Für die Sicherheit ist es wichtig, den Daten- und Kontrollfluss in Ihrer Anwendung zu verstehen. So lassen sich potenzielle Sicherheitslücken wie Datenlecks oder Injection-Angriffe erkennen.

Codebeispiel zur Veranschaulichung der Kontrollfluss- und Datenflussanalyse

Um das Konzept der Kontrollfluss- und Datenflussanalyse in Python zu veranschaulichen, betrachten wir eine einfache Python-Funktion:

1def calculate_total(price, quantity):
  if quantity <= 0:
      return "Invalid quantity"
  else:
      total = price * quantity
      return total

In dieser Funktion wird der Kontrollfluss durch die Anweisung if-else bestimmt. Wenn quantity kleiner oder gleich 0 ist, gibt die Funktion eine Fehlermeldung zurück. Andernfalls berechnet sie den Gesamtpreis und gibt ihn zurück.

Der Datenfluss lässt sich dagegen von den Eingabeparametern (price und quantity) bis zum Endergebnis (total) verfolgen. Die Werte dieser Variablen ändern sich, während sie die Funktion durchlaufen.

Ein Tool zur statischen Analyse würde den Kontroll- und Datenfluss dieser Funktion untersuchen, um potenzielle Probleme zu erkennen. Es könnte beispielsweise einen Hinweis ausgeben, wenn price oder quantity verwendet würde, bevor die Variable definiert ist, oder wenn es einen möglichen Ausführungspfad gäbe, auf dem total vor der Rückgabe nicht definiert wäre.

Mit einer Kontrollfluss- und Datenflussanalyse können Sie effiziente, verständliche und sichere Python-Anwendungen entwickeln. Wenn Sie diesen Prozess in den Softwareentwicklungslebenszyklus integrieren, können Sie die Codequalität sichern und verhindern, dass potenzielle Sicherheitslücken in Ihre Anwendung gelangen.

9. Integration in Python-Entwicklungsumgebungen

Python-Tools zur statischen Analyse sind nicht als eigenständige Hilfsprogramme gedacht. Am effektivsten sind sie, wenn sie nahtlos in die Entwicklungsumgebung integriert sind. Das kann Entwicklungs-Workflows, Continuous-Integration-(CI)-Pipelines und Code-Editoren verbessern.

Im Folgenden erfahren Sie mehr über die Rolle von Python-Tools zur statischen Analyse in diesen Bereichen und sehen ein praktisches Beispiel für eine solche Integration:

Rolle in Entwicklungs-Workflows: Tools zur statischen Analyse spielen eine wichtige Rolle in Entwicklungs-Workflows. Python-Entwicklerinnen und -Entwickler können damit potenzielle Probleme bereits während der Entwicklungsphase erkennen und beheben, noch bevor der Code ausgeführt wird. Diese frühzeitige Erkennung kann viel Zeit beim Debuggen sparen und die Codequalität verbessern.
Rolle in CI-Pipelines: In Continuous-Integration-Pipelines können Tools zur statischen Analyse den Code bei jedem Commit oder Pull Request automatisch untersuchen. So wird sichergestellt, dass neue Änderungen den Codierungsstandards entsprechen und keine potenziellen Sicherheitslücken einführen. Diese Tools lassen sich in CI-Pipelines wie Jenkins, GitLab CI und GitHub Actions integrieren.
Rolle in Code-Editoren: Die meisten modernen Code-Editoren wie Visual Studio Code, PyCharm, Atom und Sublime Text unterstützen die Integration von Tools zur statischen Analyse. So erhalten Entwicklerinnen und Entwickler während des Schreibens in Echtzeit Feedback zur Struktur und zum Stil ihres Codes sowie zu potenziellen Sicherheitslücken.

Praxisbeispiel: PyLint in Visual Studio Code integrieren

PyLint ist ein beliebtes Python-Tool zur statischen Analyse. So integrieren Sie es in Visual Studio Code, einen weitverbreiteten Code-Editor.

Stellen Sie zunächst sicher, dass PyLint in Ihrer Python-Umgebung installiert ist. Falls nicht, können Sie es mit pip installieren:

pip install pylint

Öffnen Sie anschließend Visual Studio Code und installieren Sie über die Erweiterungsansicht die Python-Erweiterung von Microsoft.

Öffnen Sie nach der Installation der Erweiterung die Einstellungen (File > Preferences > Settings). Suchen Sie im Bereich User Settings nach Python Linting. Vergewissern Sie sich, dass das Kontrollkästchen Enabled aktiviert und im Dropdown-Menü Linter die Option Pylint ausgewählt ist.

Wenn Sie jetzt eine Python-Datei in Visual Studio Code öffnen, analysiert PyLint den Code automatisch und hebt gefundene Probleme hervor.

Hier sehen Sie Python-Beispielcode und erfahren, wie PyLint ein Problem hervorheben würde:

1def add_numbers(a, b):
2    return a + c

Im obigen Code würde PyLint c unterstreichen und die Warnmeldung Undefined variable 'c' anzeigen. So können Sie den Fehler erkennen, bevor Sie den Code ausführen.

10. Performance-Profiling

Performance-Profiling ist ein wesentlicher Aspekt der statischen Python-Codeanalyse. Dabei wird Ihr Code untersucht, um Engpässe, ineffiziente Abschnitte oder Teile zu identifizieren, die erhebliche CPU- oder Speicherressourcen beanspruchen. Mit einem gründlichen Performance-Profiling können Entwickler ihren Code optimieren und so die Geschwindigkeit und Effizienz der Anwendung insgesamt steigern.

Mit Performance-Profiling lässt sich die Komplexität Ihres Codes in Bezug auf Zeit und Speicherplatz messen. Die Zeitkomplexität beschreibt die Gesamtzeit, die für die Ausführung eines Programms benötigt wird, während die Speicherkomplexität sich auf die vom Programm verwendete Speichermenge bezieht. Ein Performance-Profil liefert einen detaillierten Bericht über die Anzahl der Funktionsaufrufe, die in den einzelnen Funktionen verbrachte Zeit und weitere Informationen, die dabei helfen können, die Leistung der Anwendung zu optimieren.

Python-Codebeispiel für Performance-Profiling

Python bietet verschiedene Tools für das Performance-Profiling. Eines der gängigsten ist jedoch das integrierte Modul cProfile, ein leistungsstarker und flexibler Profiler. Hier ein einfaches Beispiel für seine Verwendung:

1import cProfile
2import re
3
4def re_test():
5    re.compile("foo|bar")
6
7cProfile.run('re_test()')
8

Wenn Sie diesen Code ausführen, erstellt cProfile einen Bericht, der zeigt, wie viel Zeit in den einzelnen Funktionen verbracht wurde. Die Ausgabe könnte etwa so aussehen:

   200 function calls (195 primitive calls) in 0.002 seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    0.001    0.001 :0(setprofile)
       43    0.000    0.000    0.000    0.000 :0(time)
        5    0.000    0.000    0.000    0.000 <ipython-input-26-6e8e8b2a9e4f>:1(re_test)
...

Diese Ausgabe zeigt die Anzahl der Aufrufe jeder Funktion (ncalls), die insgesamt in der Funktion verbrachte Zeit ohne Aufrufe von Unterfunktionen (tottime), die kumulierte Zeit in der Funktion einschließlich Unterfunktionen (cumtime) und weitere nützliche Informationen.

Auch für Produktivanwendungen ist Performance-Profiling im Hinblick auf Speicherlecks und Speichernutzung entscheidend. Drew Wright hat einen lesenswerten Artikel über das Diagnostizieren und Beheben von Speicherlecks in Python verfasst. Darin berichtet er aus eigener Erfahrung und von den Herausforderungen mit Speicherlecks, denen er während seiner Zeit im Engineering-Team von Snyk begegnet ist.

Performance-Profiling wirkt sich direkt auf Ihren Code aus. Es hilft Ihnen, Bereiche zu erkennen, die Leistungsengpässe verursachen, sodass Sie sich bei der Optimierung gezielt darauf konzentrieren können. Durch Profiling lassen sich auch Fehler finden, die bei regulären Tests möglicherweise nicht sichtbar werden. Außerdem kann Performance-Profiling beeinflussen, wie Sie Code schreiben. Ein gutes Verständnis von Zeit- und Speicherkomplexität kann Sie dabei unterstützen, effizienteren Code zu schreiben und so letztlich die Anwendungsleistung zu verbessern.

Fazit

Statische Analyse ist ein leistungsstarkes Tool, mit dem Sie die Qualität Ihres Codes erheblich verbessern und ihn sicherer machen können. Wenn Sie die zehn in diesem Artikel vorgestellten Aspekte der statischen Python-Codeanalyse nutzen, können Sie Ihren Softwareentwicklungsprozess verbessern, potenzielle Fehler von vornherein aus Ihrer Codebasis fernhalten und dafür sorgen, dass Ihre Anwendungen weniger anfällig für Sicherheitsbedrohungen sind.

Die verschiedenen Aspekte der statischen Python-Codeanalyse greifen ineinander und decken potenzielle Probleme auf, bevor sie in der Produktionsumgebung zu tatsächlichen Vorfällen werden. Wenn Sie Fehler frühzeitig erkennen, sparen Sie die Kosten, die später für deren Behebung anfallen würden. Statische Python-Codeanalyse ist auch für die Codesicherheit unerlässlich. Sie kann potenzielle Sicherheitslücken aufdecken, die bei manuellen Code-Reviews leicht übersehen werden. Wenn Sie statische Python-Codeanalyse in Ihren Softwareentwicklungsprozess integrieren, können Sie Ihre Anwendungen sicherer machen und vor potenziellen Angriffen schützen.

Entwickler zu besserem und sichererem Code motivieren

Ich hoffe, dieser Artikel hat Ihnen ein besseres Verständnis der zehn Aspekte der statischen Python-Codeanalyse vermittelt und gezeigt, wie Sie damit Codequalität und Sicherheit verbessern können. Denken Sie daran: Hochwertiger, sicherer Code bedeutet nicht nur, Fehler oder Sicherheitslücken zu verhindern. Es geht darum, zuverlässige und robuste Software zu entwickeln, die den Herausforderungen der realen Welt gewachsen ist.

Wissen Sie, wie Sie Command Injection in Python verhindern? Wie schützen Sie sich vor Code-Injection in Python?

Die Einhaltung der Best Practices für Python-Sicherheit ist entscheidend, um die Sicherheit Ihrer Python-Anwendungen zu gewährleisten. Erstellen Sie noch heute kostenlos ein Snyk-Konto und installieren Sie die Snyk IDE-Erweiterung, um Sicherheitslücken in Ihrem Python-Code schnell und einfach zu finden und zu beheben.