Klasse (vier)
1. Klasse importieren
Wenn den Klassen Funktionalität hinzugefügt wird, kann die Datei selbst bei ordnungsgemäßer Verwendung der Vererbung sehr lang werden. Im Einklang mit der allgemeinen Philosophie von Python sollten Sie Ihre Dateien so sauber wie möglich halten. Dabei hilft Python, indem es ermöglicht, Klassen in Modulen zu speichern und anschließend die benötigten Module in das Hauptprogramm zu importieren.
1.1 Importieren Sie eine einzelne Klasse
Erstellen wir ein Modul, das nur die Car-Klasse enthält. Dies bringt uns zu einem subtilen Namensproblem: In diesem Kapitel gibt es bereits eine Datei namens car.py, aber dieses Modul sollte auch car.py heißen, da es den Code enthält, der das Auto darstellt. Wir lösen dieses Namensproblem, indem wir die Car-Klasse in einem Modul namens car.py speichern, das die zuvor verwendete Datei car.py überschreibt. Von nun an müssen Programme, die dieses Modul verwenden, einen spezifischeren Dateinamen verwenden, beispielsweise my_car.py. Hier ist das Modul car.py, das nur den Code für die Car-Klasse enthält:
❶ """一个可用于表示汽车的类。"""
class Car:
"""一次模拟汽车的简单尝试。"""
def __init__(self, make, model, year):
"""初始化描述汽车的属性。"""
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0
def get_descriptive_name(self):
"""返回整洁的描述性名称。"""
long_name = f"{
self.year} {
self.make} {
self.model}"
return long_name.title()
def read_odometer(self):
"""打印一条消息，指出汽车的里程。"""
print(f"This car has {
self.odometer_reading} miles on it.")
def update_odometer(self, mileage):
"""
将里程表读数设置为指定的值。
拒绝将里程表往回调。
"""
if mileage >= self.odometer_reading:
self.odometer_reading = mileage
else:
print("You can't roll back an odometer!")
def increment_odometer(self, miles):
"""将里程表读数增加指定的量。"""
self.odometer_reading += miles
❶ enthält eine Dokumentzeichenfolge auf Modulebene, die den Inhalt des Moduls kurz beschreibt. Sie sollten für jedes von Ihnen erstellte Modul eine Dokumentzeichenfolge schreiben.
Lassen Sie uns eine weitere Datei my_car.py erstellen, die Car-Klasse importieren und ihre Instanz erstellen:
❶ from car import Car
my_new_car = Car('audi', 'a4', 2019)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23
my_new_car.read_odometer()
Die Importanweisung in ❶ weist Python an, das Modul car zu öffnen und die Car-Klasse darin zu importieren. Auf diese Weise können wir die Car-Klasse so verwenden, als ob sie in dieser Datei definiert wäre. Die Ausgabe ist die gleiche wie die, die wir zuvor gesehen haben:
2019 Audi A4
This car has 23 miles on it.
Das Importieren von Klassen ist eine effiziente Art der Programmierung. Wie lang würde dieses Programm sein, wenn es die gesamte Class-Klasse enthalten würde! Durch das Verschieben dieser Klasse in ein Modul und das Importieren dieses Moduls ist die gesamte Funktionalität weiterhin verfügbar, aber die Hauptprogrammdatei ist sauber und leicht lesbar. Dadurch können Sie den Großteil Ihrer Logik auch in separaten Dateien speichern. Sobald Sie sicher sind, dass die Klasse wie gewünscht funktioniert, können Sie diese Dateien ignorieren und sich auf die übergeordnete Logik des Hauptprogramms konzentrieren.
1.2 Mehrere Klassen in einem Modul speichern
Sie können in einem Modul so viele Klassen speichern, wie Sie möchten, es sollte jedoch eine gewisse Abhängigkeit zwischen den Klassen im selben Modul bestehen. Sowohl die Battery-Klasse als auch die ElectricCar-Klasse helfen dabei, ein Auto zu simulieren. Fügen wir sie also beide zum Modul car.py hinzu:
"""一组用于表示燃油汽车和电动汽车的类。"""
class Car:
--snip--
class Battery:
"""一次模拟电动汽车电瓶的简单尝试。"""
def __init__(self, battery_size=75):
"""初始化电瓶的属性。"""
self.battery_size = battery_size
def describe_battery(self):
"""打印一条描述电瓶容量的消息。"""
print(f"This car has a {
self.battery_size}-kWh battery.")
def get_range(self):
"""打印一条描述电瓶续航里程的消息。"""
if self.battery_size == 75:
range = 260
elif self.battery_size == 100:
range = 315
print(f"This car can go about {
range} miles on a full charge.")
class ElectricCar(Car):
"""模拟电动汽车的独特之处。"""
def __init__(self, make, model, year):
"""
初始化父类的属性。
再初始化电动汽车特有的属性。
"""
super().__init__(make, model, year)
self.battery = Battery()
Jetzt können Sie eine neue Datei namens my_electric_car.py erstellen, die ElectricCar-Klasse importieren und ein Elektroauto erstellen:
from car import ElectricCar
my_tesla = ElectricCar('tesla', 'model s', 2019)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()
Die Ausgabe ist die gleiche wie die, die wir zuvor gesehen haben, aber der größte Teil der Logik ist in einem Modul versteckt:
2019 Tesla Model S
This car has a 75-kWh battery.
This car can go about 260 miles on a full charge.
1.3 Mehrere Klassen aus einem Modul importieren
Sie können beliebig viele Klassen in eine Programmdatei importieren. Wenn Sie im selben Programm ein normales Auto und ein Elektroauto erstellen möchten, müssen Sie sowohl die Car-Klasse als auch die ElectricCar-Klasse importieren:
❶ from car import Car, ElectricCar
❷ my_beetle = Car('volkswagen', 'beetle', 2019)
print(my_beetle.get_descriptive_name())
❸ my_tesla = ElectricCar('tesla', 'roadster', 2019)
print(my_tesla.get_descriptive_name())
Wenn Sie mehrere Klassen aus einem Modul in ❶ importieren, trennen Sie die Klassen durch Kommas. Sobald die erforderlichen Klassen importiert sind, können Sie so viele Instanzen jeder Klasse erstellen, wie Sie benötigen.
In diesem Beispiel wird bei ❷ ein normales Volkswagen Beetle-Auto und bei ❸ ein Tesla Roadster-Elektroauto erstellt:
2019 Volkswagen Beetle
2019 Tesla Roadster
Importieren Sie das gesamte Modul
Sie können auch ganze Module importieren und dann die Punktnotation verwenden, um auf die benötigten Klassen zuzugreifen. Diese Art des Imports ist einfach und der Code ist leicht zu lesen. Da der Code, der eine Instanz der Klasse erstellt, den Modulnamen enthält, kommt es nicht zu Konflikten mit den von der aktuellen Datei verwendeten Namen.
Der folgende Code importiert das gesamte Automodul und erstellt ein normales Auto und ein Elektroauto:
❶ import car
❷ my_beetle = car.Car('volkswagen', 'beetle', 2019)
print(my_beetle.get_descriptive_name())
❸ my_tesla = car.ElectricCar('tesla', 'roadster', 2019)
print(my_tesla.get_descriptive_name())
Bei ❶ wird das gesamte Fahrzeugmodul importiert. Als nächstes verwenden Sie die Syntax module_name.ClassName, um auf die gewünschte Klasse zuzugreifen. Erstellen Sie wie zuvor einen Volkswagen Käfer bei ❷ und einen Tesla Roadster bei ❸.
1.5 Importieren Sie alle Klassen im Modul
Um jede Klasse in ein Modul zu importieren, verwenden Sie die folgende Syntax:
from module_name import *
Diese Importmethode wird aus zwei Gründen nicht empfohlen. Zunächst wäre es hilfreich, eine klare Vorstellung davon zu haben, welche Klassen ein Programm verwendet, indem man sich einfach die Importanweisung am Anfang der Datei ansieht. Diese Importmethode gibt jedoch nicht explizit an, welche Klassen im Modul verwendet werden. Zweitens kann dieser Ansatz auch zu Namensverwirrungen führen. Wenn Sie versehentlich eine Klasse mit demselben Namen wie etwas anderes in Ihre Programmdatei importieren, werden schwer diagnostizierbare Fehler ausgegeben. Der Grund, warum diese Importmethode hier vorgestellt wird, besteht darin, dass sie zwar nicht empfohlen wird, Sie sie jedoch möglicherweise im von anderen geschriebenen Code sehen.
Wenn Sie viele Klassen aus einem Modul importieren müssen, ist es am besten, das gesamte Modul zu importieren und die Syntax module_name.ClassName zu verwenden, um auf die Klassen zuzugreifen. Wenn Sie dies tun, werden zwar nicht alle verwendeten Klassen am Anfang der Datei aufgeführt, Sie wissen jedoch genau, wo im Programm die importierten Module verwendet werden. Dadurch werden auch Namenskollisionen vermieden, die durch den Import jeder Klasse im Modul entstehen könnten.
1.6 Importieren eines Moduls in ein anderes Modul
Manchmal ist es notwendig, Klassen auf mehrere Module zu verteilen, damit die Module nicht zu groß sind oder nicht verwandte Klassen im selben Modul gespeichert werden. Wenn Sie Klassen in mehreren Modulen speichern, stellen Sie möglicherweise fest, dass eine Klasse in einem Modul von einer Klasse in einem anderen Modul abhängt. In diesem Fall können die notwendigen Klassen im vorherigen Modul importiert werden.
Im Folgenden wird die Car-Klasse in einem Modul und die ElectricCar-Klasse und die Battery-Klasse in einem anderen Modul gespeichert. Benennen Sie das zweite Modul electric_car.py (dadurch wird die zuvor erstellte Datei electric_car.py überschrieben) und kopieren Sie die Klassen Battery und ElectricCar in dieses Modul:
"""一组可用于表示电动汽车的类。"""
❶ from car import Car
class Battery:
--snip--
class ElectricCar(Car):
--snip--
Die ElectricCar-Klasse muss auf ihre übergeordnete Klasse Car zugreifen, daher wird die Car-Klasse direkt in dieses Modul in ❶ importiert. Wenn wir diese Codezeile vergessen, gibt Python einen Fehler aus, wenn wir versuchen, die ElectricCar-Instanz zu erstellen. Das Modul car muss außerdem aktualisiert werden, um nur die Car-Klasse zu enthalten:
"""一个可用于表示汽车的类。"""
class Car:
--snip--
Sie können jetzt Klassen aus jedem Modul separat importieren, um jeden gewünschten Autotyp zu erstellen: my_cars.py
❶ from car import Car
from electric_car import ElectricCar
my_beetle = Car('volkswagen', 'beetle', 2019)
print(my_beetle.get_descriptive_name())
my_tesla = ElectricCar('tesla', 'roadster', 2019)
print(my_tesla.get_descriptive_name())
In ❶ wird die Car-Klasse aus dem Modul car und die ElectricCar-Klasse aus dem Modul electric_car importiert. Als nächstes wurden ein normales Auto und ein Elektroauto geschaffen. Beide Autos sind korrekt erstellt:
2019 Volkswagen Beetle
2019 Tesla Roadster
2. Python-Standardbibliothek
Die Python-Standardbibliothek besteht aus einer Reihe von Modulen, die in unserer Python-Installation enthalten sind. Nachdem Sie nun ein allgemeines Verständnis dafür haben, wie Funktionen und Klassen funktionieren, können Sie mit der Verwendung von Modulen beginnen, die von anderen Programmierern geschrieben wurden. Jede Funktion und Klasse in der Standardbibliothek kann verwendet werden, indem am Anfang des Programms eine einfache Importanweisung eingefügt wird. Werfen wir einen Blick auf das Modul „Random“, das nützlich ist, wenn Sie viele reale Situationen simulieren.
Die Python-Standardbibliothek besteht aus einer Reihe von Modulen, die in unserer Python-Installation enthalten sind. Nachdem Sie nun ein allgemeines Verständnis dafür haben, wie Funktionen und Klassen funktionieren, können Sie mit der Verwendung von Modulen beginnen, die von anderen Programmierern geschrieben wurden. Jede Funktion und Klasse in der Standardbibliothek kann verwendet werden, indem am Anfang des Programms eine einfache Importanweisung eingefügt wird. Werfen wir einen Blick auf das Modul „Random“, das nützlich ist, wenn Sie viele reale Situationen simulieren.
>>> from random import randint
>>> randint(1, 6)
3
Eine weitere nützliche Funktion im Modul random ist choice(). Es nimmt eine Liste oder ein Tupel als Argument und gibt ein zufälliges Element zurück:
>>> from random import choice
>>> players = ['charles', 'martina', 'michael', 'florence', 'eli']
>>> first_up = choice(players)
>>> first_up
'florence'
Benutzen Sie das Modul nicht zufällig bei der Erstellung sicherheitsrelevanter Anwendungen, aber mit dem Modul lassen sich sehr gut zahlreiche interessante Projekte erstellen.
Beachten Sie, dass externe Module auch von anderen Orten heruntergeladen werden können. Jedes Projekt in Teil 2 erfordert die Verwendung externer Module, und Sie werden dort viele Beispiele dafür sehen.