Python Code Review-Checkliste von Redwerk – Alle Schritte Inklusive

Sie haben gerade ein Python-Projekt erhalten – vielleicht von einem Anbieter oder Ihrem internen Team – und man versichert Ihnen, dass es gut geschrieben ist. Doch blindes Vertrauen funktioniert selten bei Code. Um sicherzustellen, dass er solide und sicher ist, benötigen Sie eine professionelle Codeprüfung.

Heute funktioniert Ihre Software einwandfrei, aber wenn der Code schlecht geschrieben ist, wird es in 3-4 Jahren ein riesiges Problem sein, selbst die einfachsten Dinge zu Ihrer App hinzuzufügen. Es wird mehr kosten und ewig dauern. Bewerten Sie Ihre Codequalität frühzeitig, damit Sie ihn nicht komplett neu schreiben müssen, wenn Ihr Geschäft wächst und neue Funktionen hinzugefügt werden müssen.

Wir haben eine umfassende Python Code Review-Checkliste erstellt, um Ihnen bei diesem Prozess zu helfen. In diesem Artikel teilen wir, wie man Python-Code richtig überprüft und unsere Erfahrungen mit der Auditierung von Python-Projekten. Und wenn Sie ein Beispiel für eine Python Code Review suchen, finden Sie es am Ende des Artikels, also lesen Sie weiter!

PEP 8-Einhaltung

Ein wichtiger Aspekt einer Python-Codeüberprüfung ist die Sicherstellung, dass der Code einem Stilhandbuch wie PEP 8 folgt. PEP 8, das offizielle Python-Stilhandbuch, fördert die Konsistenz im Code durch standardisierte Formatierungs- und Benennungskonventionen.

Warum ist das wichtig? Code wird weit häufiger gelesen als geschrieben. Ein konsistenter Stil, wie von PEP 8 vorgeschrieben, macht Ihren Code sauber, organisiert und leichter zu warten. Dies führt zu einer reibungsloseren Zusammenarbeit – Teammitglieder können die Arbeit der anderen leichter verstehen.

Code-Layout:

• Überprüfen Sie, ob es 4 Leerzeichen pro Einrückungsebene gibt
• Stellen Sie sicher, dass keine Tabs und Leerzeichen für Einrückungen gemischt werden
• Überprüfen Sie, ob alle Zeilen auf maximal 79 Zeichen begrenzt sind
• Überprüfen Sie, ob Funktionen und Klassendefinitionen auf oberster Ebene von zwei Leerzeilen umgeben sind
• Überprüfen Sie, ob Methoden innerhalb einer Klasse durch eine einzige Leerzeile getrennt sind
• Überprüfen Sie, ob Importe am Anfang der Datei eingefügt werden, direkt nach eventuellen Modulkommentaren und Docstrings und vor Modul-Globals und Konstanten
• Überprüfen Sie, ob jedes Python-Modul oder jede Bibliothek in einer separaten Zeile importiert wird

    # Wrong:

    # Arguments on first line forbidden when not using vertical alignment
    foo = long_function_name(var_one, var_two,
        var_three, var_four)

    # Further indentation required as indentation is not distinguishable
    def long_function_name(
        var_one, var_two, var_three,
        var_four):
        print(var_one)

    # Correct:

    # Aligned with opening delimiter
    foo = long_function_name(var_one, var_two,
                             var_three, var_four)

    # Add 4 spaces (an extra level of indentation) to distinguish arguments from the rest
    def long_function_name(
            var_one, var_two, var_three,
            var_four):
        print(var_one)

    # Hanging indents should add a level
    foo = long_function_name(
        var_one, var_two,
        var_three, var_four)

Leerzeichen in Ausdrücken und Anweisungen:

• Stellen Sie sicher, dass sich keine überflüssigen Leerzeichen direkt innerhalb von Klammern, eckigen Klammern oder geschweiften Klammern befinden.
• Überprüfen Sie, ob keine überflüssigen Leerzeichen zwischen einem nachgestellten Komma und einer folgenden schließenden Klammer vorhanden sind.
• Stellen Sie sicher, dass sich keine überflüssigen Leerzeichen direkt vor einem Komma, Semikolon oder Doppelpunkt befinden.

    # Wrong:
    spam( ham[ 1 ], { eggs: 2 } )

    # Correct:
    spam(ham[1], {eggs: 2})

Kommentare:

• Überprüfen Sie, ob Kommentare vollständige Sätze sind und leicht zu verstehen.
• Wenn ein Kommentar ein Satz oder eine Phrase ist, sollte das erste Wort großgeschrieben werden, es sei denn, es handelt sich um einen Bezeichner, der mit einem Kleinbuchstaben beginnt.
• Stellen Sie sicher, dass Inline-Kommentare sparsam und nur dann verwendet werden, wenn der Code selbst nicht klar ist.
• Verwenden Sie Docstrings, um umfassende Erklärungen für Funktionen, Klassen und Module bereitzustellen.
• Stellen Sie sicher, dass Docstrings gemäß PEP 257 formatiert sind.

    # Incorrect usage of docstrings
    def add_numbers_incorrect(a, b):
        # Function to add two numbers a and b.
        # Returns the sum.
        return a + b

    # Correct usage of docstrings
    def add_numbers_correct(a, b):
        """
        Add two numbers and return the result.

        Parameters:
        a (int): The first number.
        b (int): The second number.

        Returns:
        int: The sum of a and b.
        """
        return a + b

Namenskonventionen:

• Überprüfen Sie, ob Modulnamen Kleinbuchstaben und Unterstriche (snake_case) verwenden. Zum Beispiel: my_module.py
• Überprüfen Sie, ob Klassennamen das CapWords-Format (auch bekannt als CamelCase) verwenden, bei dem der erste Buchstabe jedes Wortes großgeschrieben wird und keine Unterstriche verwendet werden. Zum Beispiel: MyClass
• Stellen Sie sicher, dass Variablen- und Funktionsnamen beschreibend sind und ihren Zweck klar angeben. Zum Beispiel: calculate_distance, format_string
• Überprüfen Sie, ob Funktions- und Variablennamen Kleinbuchstaben und Unterstriche (snake_case) verwenden. Zum Beispiel: my_function, my_variable
• Stellen Sie sicher, dass Konstanten vollständig aus Großbuchstaben bestehen und Wörter durch Unterstriche getrennt sind. Zum Beispiel: MAX_SIZE, PI
• Stellen Sie sicher, dass private Variablen und Funktionen ein einzelnes Unterstrich-Präfix (_) verwenden, um anzuzeigen, dass die Variable oder Funktion für den internen Gebrauch bestimmt ist. Zum Beispiel: _internal_function
• Überprüfen Sie, ob geschützte Variablen und Funktionen ein Doppelunterstrich-Präfix (__) verwenden, um anzuzeigen, dass die Variable oder Funktion geschützt ist (quasi privat, aber Unterklassen können darauf zugreifen). Zum Beispiel: __protected_variable
• Wenn eine Variable oder Funktion kein Präfix hat, wird sie als öffentlich betrachtet. Zum Beispiel: public_variable, public_function()

    # Not recommended (use descriptive names)
    a = 30
    items = ["apple", "banana", "milk"]

    # Good variable names
    age_of_customer = 30
    shopping_cart_items = ["apple", "banana", "milk"]

Codequalität

Die Codequalität in der Python-Entwicklung ist entscheidend für die Erstellung zuverlässiger, wartbarer und effizienter Software. Dieser Teil der Checkliste hilft Ihnen dabei, hohe Python-Codierstandards zu wahren.

Code Lesbarkeit und Einfachheit:

• Lesbarkeit bewerten: Die Syntax und Designprinzipien von Python fördern Einfachheit und Klarheit.
• Klarheit und Prägnanz sicherstellen: Die Logik sollte klar und prägnant sein, ohne übermäßig komplexe oder verworrene Code-Strukturen.
• Wartbarkeit fördern: Stellen Sie sicher, dass die Struktur des Codes durch die ordnungsgemäße Verwendung von Funktionen und Klassen die Wartbarkeit fördert.

Pythonische Code-Praktiken:

• Einhaltung von Pythonischen Idiomen: Bewerten Sie die Einhaltung von Pythonischen Idiomen und Best Practices, einschließlich der effektiven Verwendung von Listenverständnissen, Generatorausdrücken und Kontext-Managern.
• Erweiterte Python-Funktionen: Überprüfen Sie die Implementierung fortgeschrittener Python-Funktionen wie Dekoratoren und Metaklassen.
• Dynamische Typisierung: Untersuchen Sie die Verwendung von Pythons dynamischen Typisierungs- und Duck-Typisierungsprinzipien.

    # Filtering even numbers greater than 10
    numbers = [12, 3, 45, 22, 18, 7, 4, 102, 20]


    # Using overly complex logic with nested conditions
    def filter_numbers():
        filtered_numbers = []
        for number in numbers:
            if number % 2 == 0:
                if number > 10:
                    filtered_numbers.append(number)
        return filtered_numbers


    # Using list comprehension for simplicity and readability
    def filter_numbers():
        return [number for number in numbers if number % 2 == 0 and number > 10]

Effiziente Nutzung der Python-Standardbibliothek:

• Ausnutzung eingebauter Funktionen: Überprüfen Sie, ob die eingebauten Funktionen und Bibliotheken von Python vollständig genutzt werden.
• Optimale Verwendung von Datenstrukturen: Überprüfen Sie die Verwendung eingebauter Datenstrukturen wie Listen, Tupel, Dictionaries und Sets und stellen Sie sicher, dass sie optimal für ihre vorgesehenen Zwecke verwendet werden.
• Effektive Dateiverwaltung und I/O-Operationen: Überprüfen Sie die effektive Nutzung von Pythons Datei- und I/O-Operationen.

    from collections import Counter


    # Inefficient use of file handling and word counting
    def count_words():
        word_count = {}
        file = open('example.txt', 'r')  # Opening file in a less optimal way
        lines = file.readlines()
        for line in lines:
            words = line.strip().split(' ')
            for word in words:
                if word in word_count:
                    word_count[word] += 1
                else:
                    word_count[word] = 1
        file.close()  # Manually closing the file
        return word_count


    # Efficient use of file handling and word counting using Python's built-in functions
    # The with statement ensures that the file is properly closed after its suite finishes,
    # even if an exception is raised during the execution of that suite
    def count_words():
        with open('example.txt', 'r') as file:
            return Counter(file.read().split())

Python-spezifische Herausforderungen:

• Umgang mit Python-spezifischen Herausforderungen: Bewerten Sie den Code im Hinblick auf den richtigen Umgang mit Python-spezifischen Herausforderungen, wie dem Global Interpreter Lock (GIL) in multithreaded Anwendungen.
• Dynamische Features: Überprüfen Sie den Umgang mit dynamischen Features wie Late Binding und Laufzeit-Typprüfung.

    # Incorrect runtime type checking
    def add_incorrect(a, b):
        if type(a) is not int or type(b) is not int:  # Using 'type' for type checking
            raise ValueError("Both arguments must be integers")
        return a + b

    # Correct runtime type checking using type hints (Python 3.5+)
    def add_correct(a: int, b: int) -> int:
        return a + b

Code-Funktionalität

Bei der Überprüfung der Code-Funktionalität stellen Sie sich diese grundlegende Frage: Erfüllt der Code seine beabsichtigte Aufgabe? Hier sind weitere Punkte, die Sie beachten sollten.

Beabsichtigter Zweck:

• Erfüllung der gewünschten Ergebnisse: Stellen Sie sicher, dass der Code die gewünschten Ergebnisse erzielt und den Projektspezifikationen entspricht, wobei die dynamische und interpretierte Natur von Python berücksichtigt wird.
• Testen unter verschiedenen Szenarien: Testen Sie den Code unter verschiedenen Szenarien, um konsistente und genaue Ergebnisse zu validieren, da Python vielseitig in der Handhabung verschiedener Datentypen ist.
• Effiziente Logikimplementierung: Überprüfen Sie, ob der Code Python-idiomatische Features wie Listenverständnisse oder Generatorausdrücke zur effizienten Logikimplementierung nutzt.

Umgang mit Randfällen:

• Umgang mit unerwarteten Szenarien: Bewerten Sie die Fähigkeit des Codes, unerwartete Szenarien zu bewältigen, da Pythons dynamische Typisierung und umfangreiche Bibliotheksunterstützung eine sorgfältige Handhabung von Grenzfällen erfordern.
• Umgang mit unerwarteten Eingaben: Überprüfen Sie die Reaktionen auf unerwartete Eingaben wie Nullwerte oder falsche Datentypen.
• Fehler- und Anomalienmanagement: Stellen Sie sicher, dass der Code vorausschauende Logik zur Verwaltung potenzieller Fehler und Anomalien enthält.

    # Incorrect handling: Does not anticipate or properly handle unexpected inputs
    def divide_incorrect(a, b):
        return a / b

    # Correct handling: Includes anticipatory logic for null values and incorrect data types
    def divide_correct(a, b):
        if a is None or b is None:
            raise ValueError("Input values cannot be None")
        if not all(isinstance(x, (int, float)) for x in [a, b]):
            raise TypeError("Input values must be numbers")
        if b == 0:
            raise ValueError("Division by zero is not allowed")
        return a / b

Effizientes Fehler-Handling und Logging:

• Überprüfen Sie, wie effektiv der Mechanismus zur Ausnahmebehandlung verwendet wird, um Fehler abzufangen und zu verwalten.
• Überprüfen Sie die Fehlermeldungen auf Klarheit und Nützlichkeit: Python ermöglicht anpassbare Fehlermeldungen für eine informative Fehlerbehebung.
• Stellen Sie sicher, dass das eingebaute Logging-Modul von Python voll ausgeschöpft wird, um Überwachung und Debugging zu erleichtern.

    import math
    import logging


    # Less effective exception handling
    def sqrt_less_effective(num):
        try:
            result = math.sqrt(num)
            return result
        except Exception:
            return "Error occurred"  # Generic error message, not very helpful


    # Effective exception handling with clear error messages and logging
    def sqrt_effective(num):
        try:
            if num < 0:
                raise ValueError("Cannot compute the square root of a negative number")
            result = math.sqrt(num)
        except ValueError as e:
            logging.error(f"ValueError encountered: {e}")
            raise  # Reraising the exception for further handling or logging
        return result

Python-spezifische Funktionalitäten:

• Bewerten Sie die Verwendung von Python-Dekoratoren zur Erweiterung der Funktionalität, ohne die Kernlogik zu ändern.
• Überprüfen Sie die effektive Nutzung der Python-Standardbibliothek, die zahlreiche Module zur Vereinfachung komplexer Funktionalitäten bietet.
• Bewerten Sie die Integration mit Python-Frameworks oder Drittanbieter-Bibliotheken, wo nötig, wie z.B. Requests für HTTP-Operationen oder Pandas für die Datenmanipulation.

Testing und Validierung:

• Bewerten Sie die Qualität der Unit-Tests und stellen Sie sicher, dass sie gut strukturiert, lesbar und wartbar sind.
• Überprüfen Sie, ob Integrationstests vorhanden sind, um reale Interaktionen mit externen Systemen wie Datenbanken oder APIs zu simulieren.
• Untersuchen Sie die Verwendung von Mock-Objekten und Test-Fixtures, um spezifische Komponenten oder Funktionalitäten in Python isoliert zu testen.

Performance

Die Leistungsbewertung in der Python-Entwicklung konzentriert sich auf die Effizienz und Optimierung des Codes. Es geht darum, die Ressourcennutzung, die Ausführungsgeschwindigkeit und die Effizienz der Datenverarbeitung zu bewerten.

Effiziente Algorithmen und Datenstrukturen:

• Untersuchen Sie die Wahl der Algorithmen und stellen Sie sicher, dass sie für die jeweiligen Aufgaben optimal sind und Python-spezifische Implikationen wie den Global Interpreter Lock (GIL) berücksichtigen.
• Bewerten Sie die Effizienz der Algorithmen in Bezug auf die Zeitkomplexität, besonders wichtig in Python, wo bestimmte Operationen langsam sein können und für die Skalierbarkeit optimiert werden müssen.
• Stellen Sie sicher, dass der Code die eingebauten Datentypen und Strukturen von Python, wie Listen, Dictionaries und Sets, auf die effizienteste Weise nutzt.

    # Check for duplicates in list
    numbers_list = [1, 3, 5, 7, 9, 3]


    # Inefficient usage: Using a list where a set would be more appropriate
    def check_duplicates_inefficient(numbers_list):
        for i in range(len(numbers_list)):
            for j in range(i + 1, len(numbers_list)):
                if numbers_list[i] == numbers_list[j]:
                    return True
        return False


    # Efficient usage: Using a set to check for duplicates
    def check_duplicates_efficient(numbers_list):
        unique_numbers = set(numbers_list)
        return len(numbers_list) != len(unique_numbers)

Minimale Berechnungs-Komplexität:

• Berechnungskomplexität bewerten: In Python ist es entscheidend, langsame Ausführungen aufgrund der interpretativen Natur der Sprache zu minimieren.
• Bereiche für Effizienzverbesserungen identifizieren: Optimieren Sie Schleifen, Listenverständnisse oder nutzen Sie die Effizienz von NumPy-Arrays für numerische Daten.
• Redundante Prozesse straffen: Überprüfen Sie, ob redundante Prozesse mit der Python-Standardbibliothek und optimierten Drittanbieter-Paketen ersetzt werden können, um ineffiziente benutzerdefinierte Implementierungen zu vermeiden.

    # Find common elements
    list1 = [1, 2, 3, 4, 5]
    list2 = [3, 4, 5, 6, 7]


    # Redundant approach (using loops)
    def redundant_approach(list1, list2):
        common_elements = []
        for element in list1:
            if element in list2:
                common_elements.append(element)
        return common_elements


    # Streamlined approach (using itertools.filter)
    def streamlined_approach(list1, list2):
        return list(filter(lambda x: x in list2, list1))

Leistungsoptimierung:

• Optimierungstechniken überprüfen: Insbesondere in rechenintensiven Anwendungen sollten Optimierungstechniken angewendet werden.
• Mögliche Engpässe analysieren: Identifizieren Sie Engpässe wie I/O-Operationen, Netzwerkverzögerungen oder ineffiziente Nutzung der Threading- und Multiprocessing-Funktionen von Python.
• Häufige Leistungsprobleme vermeiden: Achten Sie auf Speicherlecks, die in Python aufgrund des Garbage-Collection-Systems besonders knifflig sein können, oder auf übermäßige CPU-Auslastung durch ineffiziente Algorithmen.

    import math

    # Inefficient algorithm causing excessive CPU usage
    def find_prime_numbers(n):
        primes = []
        for num in range(2, n):
            prime = True
            for i in range(2, num):
                if num % i == 0:
                    prime = False
                    break
            if prime:
                primes.append(num)
        return primes


    # Efficient algorithm to reduce CPU usage
    def find_prime_numbers(n):
        is_primal = [True] * (n + 1)
        for i in range(2, math.floor(math.sqrt(n))):
            if is_primal[i]:
                j = i*i
                while j <= n:
                    is_primal[j] = False
                    j += i
        return [i for i in range(2, n) if is_primal[i]]

Profiling und Leistungstests:

• Profiling-Tools nutzen: Überprüfen Sie, ob die Codebasis Profiling-Tools wie cProfile oder line_profiler verwendet, um Abschnitte mit potenziellen Leistungsengpässen zu identifizieren.
• Leistungstest-Frameworks integrieren: Stellen Sie fest, ob das Projekt Leistungstest-Frameworks wie PyTest oder unittest zur Etablierung von Leistungs-Benchmarks verwendet.
• JIT-Compiler und Optimierungstools nutzen: Überprüfen Sie die Verwendung von JIT-Compilern wie PyPy oder Optimierungstools wie Cython für performancekritische Codeabschnitte.

Nutzung der asynchronen Fähigkeiten von Python:

• Asynchrone Programmierung evaluieren: Bewerten Sie die Verwendung der asynchronen Programmierung mit asyncio oder anderen Bibliotheken für eine effiziente Handhabung von I/O-gebundenen und latenzempfindlichen Operationen.
• Effektive Nutzung der async/await-Syntax: In Python 3.5+ ist die async/await-Syntax entscheidend für die Erstellung nicht-blockierenden Codes und die Verbesserung der Leistung von I/O-gebundenen Anwendungen.
• Implementierung von concurrent.futures überprüfen: Überprüfen Sie die Implementierung von concurrent.futures für die Verwaltung eines Pools von Threads oder Prozessen zur Optimierung CPU-gebundener Aufgaben in Python.

    import requests
    import asyncio
    import aiohttp


    # Wrong usage (blocking I/O calls)
    def download_file(url):
        """Downloads a file synchronously (blocking)"""
        response = requests.get(url)
        with open(f"file_{url.split('/')[-1]}", "wb") as f:
            f.write(response.content)

    def run_download():
        url1 = "https://example.com/file1.txt"
        url2 = "https://example.com/file2.txt"
        download_file(url1)
        download_file(url2)

    run_download()


    # Correct usage (using async/await for non-blocking I/O)
    async def download_file_async(url):
        """Downloads a file asynchronously (non-blocking)"""
        async with aiohttp.ClientSession() as session:
            async with session.get(url) as response:
                if response.status == 200:
                    filename = f"file_{url.split('/')[-1]}"
                    async with open(filename, "wb") as f:
                        await f.write(await response.read())

    async def main():
        url1 = "https://example.com/file1.txt"
        url2 = "https://example.com/file2.txt"
        tasks = [download_file_async(url) for url in [url1, url2]]
        await asyncio.gather(*tasks)  # Run tasks concurrently

    asyncio.run(main())

Skalierbarkeit und Wartbarkeit

Stellen Sie sich vor, Ihr Python-Projekt wächst – mehr Benutzer, mehr Daten, mehr Funktionen. So stellen Sie sicher, dass Ihr Code das Wachstum bewältigen und verwaltbar bleiben kann.

Modulares und wiederverwendbares Design:

• Überprüfen Sie, ob der Code in logische Einheiten wie Module oder Pakete unterteilt ist.
• Prüfen Sie, ob die Module lose gekoppelt und minimal voneinander abhängig sind.
• Überprüfen Sie, ob Funktionen in gut definierte, wiederverwendbare Funktionen und Klassen unterteilt sind.
• Bewerten Sie die Wiederverwendbarkeit von Codekomponenten: Eine Vielzahl wiederverwendbarer Module und Funktionen finden sich in der Standardbibliothek von Python.

    import math


    # Wrong usage (calculations are specific to this scenario)
    def main():
        # All calculations done within the main block (not reusable)
        radius = 5
        area_circle = 3.14 * radius * radius
        print(f"Circle Area: {area_circle}")

        length = 10
        width = 6
        area_rectangle = length * width
        print(f"Rectangle Area: {area_rectangle}")

    if __name__ == "__main__":
        main()


    # Correct usage (using reusable functions)
    def calculate_circle_area(radius):
        """Calculates the area of a circle"""
        return math.pi * radius * radius

    def calculate_rectangle_area(length, width):
        """Calculates the area of a rectangle"""
        return length * width

    def main():
        # Use reusable functions for calculations
        radius = 5
        circle_area = calculate_circle_area(radius)
        print(f"Circle Area: {circle_area}")

        length = 10
        width = 6
        rectangle_area = calculate_rectangle_area(length, width)
        print(f"Rectangle Area: {rectangle_area}")

    if __name__ == "__main__":
        main()

Berücksichtigung großer Datensätze:

• Überprüfen Sie die Handhabung großer Datensätze, eine häufige Anforderung in Python-Apps, insbesondere in den Bereichen Datenwissenschaft und maschinelles Lernen.
• Analysieren Sie die Architektur und Entwurfsmuster auf Skalierbarkeit, wie z.B. Lazy Loading, Generatoren oder effiziente Datenverarbeitungstechniken wie Vektorisierung mit NumPy.
• Identifizieren Sie Engpässe, die das Skalieren behindern könnten, wie übermäßige Speicherzuweisungen oder ineffiziente Datenbankabfragen.

    import numpy as np


    data = np.random.rand(1000000)


    # Inefficient data processing without vectorization
    def process_data_inefficient(data):
        total = sum(data)
        mean = total / len(data)
        return mean


    # Efficient data processing with NumPy
    def process_data_efficient(data):
        # Using NumPy for vectorized operations
        np_data = np.array(data)
        mean = np.mean(np_data)
        return mean

Nutzung des Python-Ökosystems für Skalierbarkeit:

• Bewerten Sie die Integration mit Python-Frameworks wie Django oder Flask, die die Skalierbarkeit von Web-Apps beeinflussen können.
• Prüfen Sie den Einsatz von Python-Bibliotheken wie Pandas, NumPy oder SciPy in datenintensiven Anwendungen und deren Einfluss auf die Leistung und Skalierbarkeit.
• Überprüfen Sie die Implementierung von asynchroner Programmierung mit asyncio oder anderen Frameworks.

Kompatibilität, Abhängigkeiten und Sicherheit

Dieser Teil unserer Python-Code-Überprüfung stellt sicher, dass der Code wie beabsichtigt in verschiedenen Umgebungen funktioniert und die Abhängigkeiten ordnungsgemäß verwaltet werden. Hier sind die Schritte, die zu befolgen sind.

Ordnungsgemäße Verwaltung von Abhängigkeiten:

• Bewerten Sie die Nutzung und Integration externer Bibliotheken und Frameworks, da Python ein reichhaltiges Ökosystem an Drittanbieter-Paketen bietet.
• Überprüfen Sie die genaue Spezifikation und Verwaltung der Abhängigkeiten, unter Verwendung von Tools wie pip für die Paketinstallation und virtualenv oder pipenv zur Erstellung isolierter Umgebungen.
• Überprüfen Sie die Kompatibilität der Bibliotheksversionen mit der Python-Version des Projekts.
• Prüfen Sie auf veraltete Bibliotheken oder solche mit bekannten Sicherheitslücken.

Minimale Abhängigkeitskonflikte:

• Identifizieren Sie potenzielle Konflikte zwischen Abhängigkeiten, ein häufiges Problem in Python-Projekten aufgrund der Interaktion mehrerer Pakete.
• Überprüfen Sie den Code auf Redundanz von Abhängigkeiten: Suchen Sie nach mehreren Paketen, die ähnliche Funktionen bieten.
• Untersuchen Sie Strategien zur Lösung von Abhängigkeitskonflikten, die entscheidend für die Stabilität und Funktionalität von Python-Projekten sind.

Versionierung und Abhängigkeits-Sperrung:

• Überprüfen Sie die Versionierung kritischer Abhängigkeiten, um unerwartete Unterbrechungen durch Paket-Updates zu vermeiden.
• Überprüfen Sie die Verwendung von Abhängigkeits-Sperrmechanismen wie Pipfile.lock oder requirements.txt, um reproduzierbare Builds und Bereitstellungen sicherzustellen.

Sicherheitsüberlegungen:

• Überprüfen Sie die Verwendung von Schutzmechanismen gegen bekannte Sicherheitslücken wie SQL-Injection, Cross-Site Scripting und unsichere direkte Objektverweise.
• Verifizieren Sie, ob sensible Daten wie Passwörter, Token oder Kreditkartennummern während der Übertragung und im Ruhezustand verschlüsselt sind und ob geeignete Zugangskontrollen vorhanden sind.
• Stellen Sie sicher, dass alle Benutzereingaben bereinigt werden: Überprüfen Sie Datentypen, Längen und erwartete Formate.
• Überprüfen Sie, wie Benutzerrollen und Berechtigungen verwaltet werden, um sicherzustellen, dass nur autorisierte Benutzer auf bestimmte Funktionen zugreifen können.
• Stellen Sie sicher, dass ordnungsgemäße Sitzungs-Timeouts und Invalidierungsmechanismen vorhanden sind, um unbefugten Zugriff zu verhindern.

    @app.route('/search', methods=['GET'])
    def search():
        user_query = request.args.get('query')
        db_connection = sqlite3.connect('database.db')
        cursor = db_connection.cursor()
    ----------------------------
        # Wrong: vulnerable to SQL injection
        cursor.execute(f"SELECT * FROM users WHERE name LIKE '%{user_query}%'")
    ----------------------------
        # Correct: Protected against SQL Injection
        query = "SELECT * FROM users WHERE name LIKE ?"
        cursor.execute(query, ('%' + user_query + '%',))
    ----------------------------
        results = cursor.fetchall()
        cursor.close()
        db_connection.close()
        return str(results)

Versionskontrolle

Die Versionskontrolle ist entscheidend für das effektive Verwalten und Verfolgen von Codeänderungen, insbesondere in kollaborativen Umgebungen. Sie gewährleistet eine klare Entwicklungshistorie und ist unerlässlich für die Aufrechterhaltung von qualitativ hochwertigem Code.

Aussagekräftige Commit-Nachrichten:

• Überprüfen Sie Commit-Nachrichten auf Klarheit und Informationsgehalt: Sie sollten Änderungen, Logik-Updates, Optimierungen oder Fehlerbehebungen prägnant beschreiben.
• Stellen Sie sicher, dass das Format und der Stil der Commit-Nachrichten konsistent sind.
• Bestätigen Sie, dass Commit-Nachrichten genügend Kontext für das Verständnis der Änderungen bieten, wie Modifikationen an Datenstrukturen, Algorithmus-Verbesserungen oder wichtige Refactoring-Entscheidungen.

Schlechte Commit-Nachrichten: „fixed bug“, „updates“, „fixed all errors“, „improved performance“

Gute Commit-Nachrichten: „fix: handle null values in user input“, „feat: implement user registration feature“, „test: add unit tests for login functionality“

Ordnungsgemäßer Einsatz von Branches und Pull Requests:

• Stellen Sie sicher, dass eine gute Versionskontroll-Hygiene praktiziert wird – mit beschreibenden Branching-Strategien und ohne große, unfokussierte Commits.
• Stellen Sie sicher, dass Pull Requests gründlich überprüft werden, mit Fokus auf Codequalität, Einhaltung der Projektstandards und Integration mit bestehendem Code.
• Überprüfen Sie, ob es übermäßig komplexe oder redundante Branches gibt, um eine saubere und übersichtliche Codebasis zu erhalten.

Effektive Zusammenarbeit und Code-Integration:

• Überprüfen Sie die Kollaborationsprozesse bei Codeänderungen: Stellen Sie sicher, dass sie eine effektive Teamarbeit fördern und für den Umfang und die Komplexität des Projekts geeignet sind.
• Bestätigen Sie eine reibungslose Handhabung von Code-Integrationen und eine effektive Lösung von Merge-Konflikten.
• Bewerten Sie den Einsatz von Python-Code-Überprüfungs-Tools und -Praktiken und stellen Sie sicher, dass sie zur Aufrechterhaltung der Codequalität und Konsistenz beitragen.

Verbesserung Ihrer Python-Code-Überprüfung

Während diese Python-Code-Überprüfungs-Checkliste Ihnen ermöglicht, effektive Überprüfungen intern durchzuführen, gibt es erhebliche Vorteile, unabhängige Code-Überprüfungsdienste zu nutzen.

Vorteile unabhängiger Code-Überprüfungen

Hier sind die Gründe, warum es eine kluge Entscheidung ist, einen externen Experten für eine eingehende Analyse Ihrer Codebasis zu beauftragen:

• Frische Perspektive: Es ist bekannt, dass Entwickler, wenn sie sich sehr gut mit ihrem eigenen Code auskennen, eine gewisse „Betriebsblindheit“ entwickeln können und den Überblick verlieren. Externe Prüfer helfen, übersehene Fehler zu identifizieren.
• Objektive Analyse: Externe Prüfer sind nicht von Teamdynamiken und bestehenden Beziehungen beeinflusst, sodass ihre Überprüfungen kritischer und immer unparteiisch sind.
• Tiefere Überprüfung: Code-Überprüfungen bei Redwerk gehen über die bloße Funktionalität hinaus. Unsere Prüfer untersuchen Ihren Code auf Sicherheitslücken, identifizieren Leistungsengpässe und helfen Ihnen, lesbaren und wartbaren Code zu erreichen.
• Stärkere Expertise: Externe Prüfer arbeiten an verschiedenen Projekten und begegnen einer Vielzahl von Codierungsstilen und potenziellen Fallstricken. Diese facettenreiche Erfahrung ermöglicht es ihnen, Muster zu erkennen, die auf potenzielle Probleme hinweisen können, während Ihr internes Team sich in der Regel mehr auf die spezifischen Funktionen Ihres Projekts konzentriert.

Unsere Python-Code-Überprüfungs-Expertise und Dienstleistungen

Bevor wir darüber sprechen, wie Sie von unseren Dienstleistungen profitieren können, möchten wir kurz die Ergebnisse unserer jüngsten Python-Code-Überprüfung erwähnen.

Complete Network, ein US-amerikanisches IT-Support-Unternehmen, hat sich mit Redwerk zusammengeschlossen, um ihre Angebotsmanagement-App, die in Python geschrieben ist, zu überprüfen. Wir wurden beauftragt, die Backend-API der App zu überprüfen. Unsere Code-Reviewer berichteten über 40 kritische Probleme in Bezug auf Architektur, Leistung und Sicherheit.

Wir haben auch einige einfache Lösungen zur Leistungssteigerung mit Django-Caching und Python-Beschleunigungs-Tools geteilt. Mit unserer Hilfe konnte Complete Network die Wartbarkeit ihres Codes um 80 % steigern und lernte Best Practices für die Python-Code-Überprüfung, um zukünftige Probleme zu vermeiden.

Egal, ob Sie Ihr Produkt für einen zukünftigen Verkauf oder eine große Veröffentlichung vorbereiten, eine umfassende und unvoreingenommene Code-Überprüfung kann Ihr Sicherheitsnetz sein. Hier ist, wie wir helfen können:

• Projektüberprüfung: Unsere statische Code-Analyse in Kombination mit automatisierter Code-Überprüfung hebt Bereiche zur Verbesserung der Funktionalität, Sicherheit, Wartbarkeit und Leistung hervor.
• Due Diligence: Unsere Code-Überprüfung kann Teil einer Due-Diligence-Prüfung sein und bietet ein klares Bild der Codequalität, potenziellen Risiken und langfristigen Wartbarkeit.
• Vorbereitende Überprüfung vor der Bereitstellung: Stellen Sie sicher, dass Ihr Python-Projekt für den Start bereit ist, mit unserer Vorbereitungsüberprüfung. Wir identifizieren und beheben verbleibende Probleme, um einen reibungslosen Rollout zu gewährleisten.
• Sicherheitsüberprüfung: Wir können eine gezielte Python-Sicherheitscode-Überprüfung durchführen, um Ihren Code nach branchenüblichen Praktiken zu überprüfen, Sicherheitslücken aufzudecken und externe Bibliotheken und Abhängigkeiten sorgfältig zu prüfen.

Haben Sie spezifische Bereiche, auf die wir uns konzentrieren sollen? Kontaktieren Sie uns, um zu besprechen, wie wir unseren Überprüfungsprozess an Ihre individuellen Bedürfnisse anpassen können.

Abschließende Gedanken

Eine Code-Überprüfung ist eine Investition in die Zukunft Ihres Projekts und spart Ihnen langfristig Zeit, Geld und Ärger. Durch die Nutzung der Expertise externer Prüfer erhalten Sie Zugang zu einem breiteren Pool an Wissen und Erfahrung. Diese, kombiniert mit ihrer frischen Perspektive und dem Fokus auf Best Practices der Code-Überprüfung, ermöglicht es Ihnen, subtile Probleme und Optimierungsmöglichkeiten zu identifizieren, die Ihrem internen Team, so großartig es auch ist, möglicherweise entgehen.

Sehen Sie, wie wir Complete Network geholfen haben, die Backend-API zu überprüfen und zukunftssicher zu machen und die Wartbarkeit um 80 % zu steigern.

Bitte geben Sie Ihre Geschäfts-E-Mail-Adresse ein

Fallstudie abrufen