Grundlegende Merkmale der objektorientierten Programmierung

Autor: Zen und die Kunst der Computerprogrammierung

1. Einleitung

Objektorientierte Programmierung (OOP) ist eine Methode mit einem hohen Abstraktionsgrad, einer Programmiermethode, die näher an der natürlichen Sprache liegt und eine starke Wartbarkeit und Skalierbarkeit aufweist. Die Hauptmerkmale von OOP sind wie folgt:

Abstraktion: Klassifizieren Sie ähnliche oder verwandte Dinge in der realen Welt in einer Sammlung und bearbeiten Sie diese Sammlung dann, um die Programmiereffizienz und die Wiederverwendbarkeit des Codes zu verbessern. Vererbung und Polymorphismus: Unterklassen können die Eigenschaften und Methoden der übergeordneten Klasse erben und ihr Verhalten neu schreiben nach Bedarf, um Codeduplizierung zu vermeiden; Kapselung: Implementierungsdetails ausblenden und nur Schnittstellen zur Außenwelt bereitstellen, wodurch die Zuverlässigkeit und Sicherheit des Codes verbessert wird; Multithreading und verteilte Verarbeitung: Unterstützung von Multithread-Programmierung, Nutzung von Multicore voll ausnutzen CPU-Ressourcen zur Erleichterung der Entwicklung verteilter Systeme;

2. Grundkonzepte

2.1 Klasse

„Klasse“ ist eine Abstraktion von etwas in der realen Welt. Sie beschreibt die Eigenschaften und das Verhalten dieses Dings durch Datenmitglieder und Mitgliedsfunktionen. Zum Beispiel: Hund ist eine Klasse, sie hat vier Beine, zwei Ohren, einen Schwanz und andere Attribute; sie hat auch Mitgliedsfunktionen wie Bellen und Fressen.

2.2 Objekt

Ein Objekt ist eine Instanz einer Klasse oder einer bestimmten Person. Ich habe zum Beispiel jetzt einen Welpen, der ein Objekt der Klasse „Hund“ ist.

2.3 Instanzvariable

Instanzvariablen sind innerhalb einer Klasse definierte Variablen, und jedes Objekt verfügt über eine eigene eindeutige Kopie. Instanzvariablen werden normalerweise zum Speichern verschiedener Attributwerte eines Objekts verwendet. Diese Attributwerte ändern sich, wenn sich der Status des Objekts ändert. Der Zugriff auf Instanzvariablen erfolgt über das Schlüsselwort self. Für das Objekt Hund der Klasse Hund können wir beispielsweise wie folgt auf sein Namensattribut zugreifen: dog.name = „Rufus“.

2.4 Klassenvariable

Eine Klassenvariable ist eine Variable, die außerhalb der Klasse definiert ist und alle Objekte den Wert der Variablen gemeinsam haben. Auf Klassenvariablen kann über @classmethod zugegriffen werden. Zum Beispiel können wir die Klasse „Hund“ schreiben, um die Anzahl der Hunde aufzuzeichnen:

class Dog:
    num_of_dogs = 0

    def __init__(self):
        Dog.num_of_dogs += 1

Im obigen Beispiel ist num_of_dogs der Dog-Klasse eine Klassenvariable mit einem Anfangswert von 0. Jedes Mal, wenn ein Dog-Objekt erstellt wird, wird der Wert von num_of_dogs um 1 erhöht.

2.5 Methode

Eine Methode ist eine Funktion, die zu einer Klasse gehört. Es wird zur Implementierung bestimmter Funktionen verwendet und kann für Objekte aufgerufen werden. Methoden akzeptieren normalerweise Parameter und geben berechnete Ergebnisse zurück. Beispiel: Wir definieren eine Methode zur Berechnung der Summe zweier Zahlen:

def add(x, y):
    return x + y

Wir können diese Methode als Mitgliedsfunktion zur Dog-Klasse hinzufügen:

class Dog:
    def __init__(self, name):
        self.name = name

    def bark(self):
        print("Woof!")

    def eat(self, food):
        print("{} is eating {}".format(self.name, food))

my_dog = Dog("Rufus")
print(my_dog)     # Output: <__main__.Dog object at 0x7f9c7e0f6a30>
my_dog.bark()    # Output: Woof!
my_dog.eat("banana")   # Output: Rufus is eating banana

Im obigen Beispiel verfügt die Dog-Klasse über zwei Methoden: init () und bark() sowie eine eat()-Methode. Unter diesen ist init () der Konstruktor, der zum Erstellen von Hundeobjekten verwendet wird; die bark()-Methode wird zum Bellen und die eat()-Methode zum Fressen verwendet.

2.6 Statische Methode

Eine statische Methode ist eine für eine Klasse definierte Funktion. Sie hängt nicht von der Instanz oder Klasse ab und kann von der Klasse selbst oder direkt aufgerufen werden. Statische Methoden werden über @staticmethod deklariert. Statische Methoden können mit gewöhnlichen Methoden kombiniert werden, um Utility-Methoden in einer Klasse zu bilden.

Beispielsweise können wir eine statische Methode definieren, um das aktuelle Datum abzurufen:

import datetime

class TimeUtils:
    @staticmethod
    def get_current_date():
        now = datetime.datetime.now()
        return now.strftime("%Y-%m-%d")

print(TimeUtils.get_current_date())

Im obigen Beispiel verfügt die TimeUtils-Klasse über eine statische Methode namens get_current_date(), die das aktuelle Datum abruft und als String zurückgibt. Wir können diese Methode direkt über den Klassennamen aufrufen.

3. Grundprinzipien und Implementierung des Algorithmus

3.1 Heap-Sortierung

Heap Sort bezieht sich auf einen Sortieralgorithmus, der mithilfe einer Datenstruktur wie einem Heap implementiert wird. Ein Heap ist ein Binärbaum, in dem jeder Knoten größer oder gleich (max-heap) oder kleiner oder gleich (min-heap) seiner untergeordneten Knoten ist. Die Heap-Sortierung erstellt zunächst die zu sortierende Sequenz in einem Heap und passt dann den Heap an, sodass die resultierende Sequenz eine geordnete Sequenz ist.

3.1.1 Fallanalyse

Angenommen, es gibt ein Array arr der Länge n und Sie möchten die Elemente in arr in aufsteigender Reihenfolge sortieren. Der Prozess der Heap-Sortierung ist unten dargestellt:

Stellen Sie sich arr als einen Heap vor. Der Prozess zum Einrichten eines maximalen Heaps besteht darin, die Struktur des Heaps mithilfe der Eigenschaften eines großen Root-Heaps beizubehalten.

a. Erstellen Sie ausgehend vom letzten Nicht-Blattknoten k=n/2-1 (teilbar) den maximalen Heap von unten nach oben. b. Die linken und rechten Kindernummern jedes Knotens sind links=(2k+1) bzw. rechts=(2k+2). c. Wenn die linken und rechten Kinder vorhanden und kleiner als der Knoten sind, tauschen Sie sie aus.

Zu diesem Zeitpunkt bilden arr[0]~arr[n/2-1] einen maximalen Heap.
Passen Sie den Heap so an, dass eine geordnete Reihenfolge entsteht.

a. Tauschen Sie das obere Element arr[0] mit dem unteren Element arr[n-1] aus. b. Reduzieren Sie die Heap-Größe um 1 und rufen Sie Shift_down(0) auf, um die Größe des Heaps zu ändern.

c. Rufen Sie in der Schleife shift_down(0) auf, sodass arr[i] kleiner oder gleich arr[(2i+1)] ist und arr[i] kleiner oder gleich arr[(2i+2) ist. ], und vergleichen Sie dann arr[i] Swap-Positionen mit arr[heap_size-1]. Wenn arr[heap_size-1] größer als arr[i] ist, stoppen Sie die Schleife, andernfalls fahren Sie mit den Schritten 2a und 2b fort.

d. Wenn die Heap-Größe auf 1 reduziert wird, ist die Sortierung abgeschlossen.

Zeitkomplexität: O(nlogn).

Raumkomplexität: O(1).

def heap_sort(arr):
    for i in range((len(arr)-2)//2,-1,-1):
        heapify(arr, len(arr), i)

    for j in range(len(arr)-1,0,-1):
        arr[j], arr[0] = arr[0], arr[j]
        heapify(arr, j, 0)

def heapify(arr, size, root):
    largest = root
    left = (root*2)+1
    right = (root*2)+2

    if left < size and arr[left]>arr[largest]:
        largest = left

    if right < size and arr[right]>arr[largest]:
        largest = right

    if largest!= root:
        arr[root], arr[largest] = arr[largest], arr[root]
        heapify(arr, size, largest)

arr = [5, 2, 7, 1, 8, 6, 3]
heap_sort(arr)
print('sorted array:', arr)

Ausgabe:

sorted array: [1, 2, 3, 5, 6, 7, 8]