Ist Python weniger fehleranfällig als andere Sprachen?

Die Schwächen von Python: Leistung und Multithreading

Das größte Manko der Programmiersprache Python ist die Leistung. Ja, Sie können C-basierte Bibliotheken verwenden, um hochleistungsfähige Versionen von Funktionen bereitzustellen, die eigentlich zu den Kernfunktionen der Sprache gehören, so dass die Leistung fast mit der von Java oder C# vergleichbar ist. Dies steht jedoch im Widerspruch zu den grundlegenden Architekturentscheidungen von Python.

Python ist eine interpretierte Sprache, die nicht kompiliert wird, und sie wurde nie für die effiziente Unterstützung von Multithreading entwickelt. Seit der Einführung von Python hat sich das Mainstream-Computing in Richtung Multithreading entwickelt. Fast jeder moderne Prozessor ist ein Multicore-Prozessor.

Auch hier können verschiedene Versionen von Python diese Leistungsbeschränkung überwinden, allerdings mit ihren eigenen Kompromissen. Dies führt zu einem fragmentierten Code-Ökosystem, in dem der Code vielleicht in einer Umgebung gut funktioniert, in einer anderen aber nicht.

Warum sollten Sie angesichts solcher Leistungs- und Multithreading-Probleme Python noch in Betracht ziehen? Dafür gibt es einen guten Grund.

Die Stärken von Python: Kürzerer, sauberer Code

Der Vorteil von Python liegt in der obigen Prämisse: Wenn alle anderen Dinge gleich sind, ist kürzerer Code mit größerer Wahrscheinlichkeit fehlerfrei.

Wenn Sie die dynamische Typisierung von Python mit seiner im Allgemeinen sehr kompakten Syntax kombinieren, können Sie komplexe Ideen und Berechnungen in weniger Codezeilen als in vergleichbaren Sprachen der C-Familie prägnant und klar ausdrücken. Dies verringert die kognitive Belastung für den Programmierer, und viele Standardfunktionen sind bereits in der Sprache enthalten. Der resultierende Code ist wahrscheinlich kürzer und klarer.

Hier ist eine andere Möglichkeit, sich das vorzustellen: Betrachten Sie die Codezeilen als eine Angriffsfläche für Bugs. Weniger Codezeilen bedeuten weniger Angriffsfläche.

Code-Beispiele: Python versus Java

Beginnen wir mit der guten alten „Hello World“-Anwendung. Um diese in Java zu erstellen, benötigen wir fünf Zeilen:

public class HelloWorld {

    public static void main(String[] args) {

        System.out.println("Hello, World!");

    }

} 

Dasselbe ist in Python nur eine Zeile lang:

print("Hello, World!")

Wir können dies jedoch als bloßen Standardcode abtun. Ein etwas konkreteres Beispiel ist die Definition einer Klasse. Eine einfache Klasse in Java benötigt etwa ein Dutzend Zeilen:

public class Person {

    private String name;

 

    public Person(String name) {

        this.name = name;

    }

 

    public void greet() {

        System.out.println("Hello, my name is " + name);

    }

 

    public static void main(String[] args) {

        Person person = new Person("Alice");

        person.greet();

    }

}

In Python erreichen wir das Gleiche in sieben Zeilen:

class Person:

    def __init__(self, name):

        self.name = name

 

    def greet(self):

        print(f"Hello, my name is {self.name}")

 

person = Person("Alice")

person.greet( )

Manchmal geht es bei der Einsparung von Code nicht so sehr um die Anzahl der Zeilen, sondern um die Lesbarkeit. Hier ist zum Beispiel eine Lambda-Funktion, die eine quadratische Funktion auf eine Liste in Java anwendet:

public class LambdaExample {

    public static void main(String[] args) {

        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        List<Integer> squared = numbers.stream()

                                       .map(n -> n * n)

                                       .collect(Collectors.toList());

        System.out.println(squared);

    }

}

Und hier ist der Code, um dasselbe in Python zu erreichen:

numbers = [1, 2, 3, 4, 5]

squared = [n * n for n in numbers]

print(squared)

Lassen Sie uns zum Schluss noch eine Runde Code Golf in beiden Sprachen vergleichen, um Duplikate aus einer Liste zu extrahieren. In Java lautet die Funktion:

public static List<Integer> RemoveDuplicateHashSet(List<Integer> items) {

    return new ArrayList<>(new HashSet<>(items));

}

Das Äquivalent in Python lautet:

def remove_duplicate_set(items):

    return list(set(items))

Gegenargumente: Vielseitigkeit, Bibliotheken, dynamische versus statische Typisierung

Es gibt mehrere Gegenargumente für die Annahme, dass kürzerer Code weniger fehleranfällig ist.

Der erste und wahrscheinlich einfachste Punkt ist, dass das Ziel einer Programmiersprache nicht die geringste Anzahl von Tastaturanschlägen ist. (Noch einmal: Code Golf.) Das kann bedeuten, dass sie weniger vielseitig ist als vergleichbare, eloquentere Sprachen.

Ein weiteres Zugeständnis ist, dass Python in hohem Maße auf externe Bibliotheken zurückgreift, um Aktionen auszuführen, die andere Sprachen von Haus aus beherrschen. Dadurch wird die wahre Größe des Python-Codes verschleiert.

Die Komplexität ist ein weiteres Argument gegen Python. Es ist bekanntermaßen schwer, in Python zu modellieren, und jeder kürzere Code, der erzeugt wird, ist wahrscheinlich sehr dicht und damit komplex. Wenn die vorherrschende Messgröße für die Wahrscheinlichkeit von Fehlern die Komplexität des Codes ist, dann ist die Länge des Codes kein gutes Maß dafür.

Schließlich ist Python eine dynamisch typisierte Sprache. Im Vergleich zu einer statisch typisierten Sprache ist es wahrscheinlicher, dass Bugs, die erst zur Laufzeit auftauchen, durch Typ-Fehlanpassungen und unerwartetes Data Casting verursacht werden.

Ist Python-Code sowohl kürzer als auch weniger fehleranfällig?

An all diesen Gegenargumenten ist etwas Wahres dran – aber auch an der ursprünglichen Prämisse.

Wenn der Code gleich ist und die Fähigkeiten der Programmierer ebenfalls gleich sind, benötigt Python weniger Zeilen typisierten Code, um das gleiche Ergebnis zu erzielen wie andere Sprachen.