Einführung in das grundlegende Erlernen von Python-Python-Tutorial-php.cn

In Python beziehen sich Namen mit dem ersten Buchstaben in Großbuchstaben auf Klassen. Die Klammern in dieser Klassendefinition sind leer, da wir diese Klasse aus Leerzeichen erstellen. Wir haben einen Dokumentstring geschrieben, der die Funktionalität dieser Klasse beschreibt. Funktionen in einer Klasse werden -Methoden genannt.

Nehmen Sie die Student-Klasse als Beispiel. In Python wird das Schlüsselwort class zum Definieren einer Klasse verwendet:

class Student(object):

pass

class Student(object):

bestanden

Unmittelbar nach der Klasse steht der Klassenname, d. h. Student. Der Klassenname ist normalerweise ein Wort, das mit einem Großbuchstaben beginnt, gefolgt von (Objekt), das normalerweise angibt, von welcher Klasse die Klasse geerbt wird Geerbte Klasse, verwenden Sie die Objektklasse, die Klasse, von der alle Klassen letztendlich erben.

class Student(object):

def __init__(self, name, score):

self.name = name

self.score = score

9.1.1 Klasse erstellen

Klasse Student(object):

def __init__(self, name, score):

self.name = name

self.score = score

　1. Die Methode __init__() ist eine spezielle Methode, die Python automatisch ausführt, wenn eine neue Instanz erstellt wird. Am Anfang und Ende stehen zwei Unterstriche . Dies ist eine Konvention, um Namenskonflikte zwischen Python-Standardmethoden und gewöhnlichen Methoden zu vermeiden. Bei der Definition dieser Methode ist der Formalparameter self wesentlich und muss
vor anderen Formalparametern stehen.
　2. Jeder einer Klasse zugeordnete Methodenaufruf übergibt automatisch den tatsächlichen Parameter self, der eine Referenz auf die Instanz selbst ist, wodurch die Instanz auf die Eigenschaften und Methoden in der Klasse zugreifen kann. self wird automatisch übergeben, sodass wir es nicht übergeben müssen.
　3. Variablen mit dem Präfix „self“ stehen allen Methoden in der Klasse zur Verfügung, und wir können auch über jede Instanz der Klasse auf diese Variablen zugreifen.
　4.self.name= name Variablen wie diese, auf die über Instanzen zugegriffen werden kann, werden Attribute genannt
　5. Ein wichtiges Merkmal der objektorientierten Programmierung ist die Datenkapselung. Sie können Funktionen für den Zugriff auf Daten direkt innerhalb der Klasse definieren und so die „Daten“ kapseln. Diese
Funktionen, die Daten kapseln
, sind mit der Student-Klasse selbst verknüpft, die wir Methoden der Klasse nennen
9.1.2 Erstellen Sie eine Instanz basierend auf der Klasse
Wir Normalerweise können Sie sich einen Namen vorstellen, bei dem der erste Buchstabe in Großbuchstaben geschrieben ist (z. B. Hund), der sich auf die Klasse bezieht, während sich ein Name in Kleinbuchstaben (z. B. my_dog) auf die aus der Klasse erstellte Instanz bezieht.
1. Um auf die Attribute der Instanz zuzugreifen, können Sie die
Punktnotation
verwenden. Wir haben den folgenden Code geschrieben, um auf den Wert des Attributnamens von my_dog zuzugreifen.
my_dog.name
Die Punktnotation wird in Python sehr häufig verwendet. Diese Syntax zeigt, wie Python den Wert eines Attributs lernt.
2. Nachdem Sie eine Instanz basierend auf der Dog-Klasse erstellt haben, können Sie die Punktnotation verwenden, um jede in der Dog-Klasse definierte Methode aufzurufen.
3. Sie können je nach Bedarf beliebig viele Instanzen basierend auf der Klasse erstellen.
9.2 Klassen und Instanzen verwenden

class Student(object):

    name = 'Student'

　1. Eine wichtige Aufgabe, die Sie ausführen müssen, besteht darin, die Eigenschaften der Instanz zu ändern. Sie können die Eigenschaften einer Instanz direkt ändern oder Methoden schreiben, um sie auf eine bestimmte Weise zu ändern. 2. Eine Klasse ist eine Vorlage zum Erstellen von Instanzen, und Instanzen sind spezifische Objekte. Die Daten, die jeder Instanz gehören, sind unabhängig voneinander und beeinflussen sich nicht gegenseitig. Die Methode ist die an die Instanz gebundene Funktion , und die gewöhnliche Funktion Verschiedene Methoden können direkt auf die Daten der Instanz zugreifen. Durch Aufrufen der Methode in der Instanz verarbeiten wir die Daten direkt im Objekt, es ist jedoch nicht erforderlich, die Implementierungsdetails innerhalb der Methode zu kennen. Im Gegensatz zu statischen Sprachen können in Python beliebige Daten an Instanzvariablen gebunden werden. Das heißt, dass zwei Instanzvariablen, obwohl sie unterschiedliche Instanzen derselben Klasse sind, unterschiedliche Variablennamen haben können. 9.2.1 Anfangswert für Klasse festlegen Jedes Attribut in der Klasse muss einen Anfangswert haben, auch wenn der Wert 0 oder eine leere Zeichenfolge ist. In einigen Fällen, beispielsweise beim Festlegen eines Standardwerts, ist es möglich, einen solchen Anfangswert innerhalb der Methode __init__() anzugeben. Wenn Sie dies für ein Attribut tun, müssen Sie keine formalen Parameter angeben, die ihm einen Anfangswert verleihen Wert. Attribute direkt in der Klasse definieren, die Klassenattribute sind:
class Student(object): name = 'Student'

Verwenden Sie beim Schreiben eines Programms niemals denselben Namen für Instanzattribute und Klassenattribute, da Instanzattribute mit demselben Namen die Klassenattribute blockieren. Wenn Sie jedoch die Instanzattribute löschen, verwenden Sie erneut denselben Namen, um darauf zuzugreifen Was kommt an? werden Klassenattribute sein.

9.2.2 Den Wert des Attributs ändern

Sie können den Wert des Attributs auf drei verschiedene Arten ändern:

1. Ändern Sie direkt über die Instanz

>　2. Durch Methoden festlegen;

　3. Durch Methoden inkrementieren (einen bestimmten Wert erhöhen).

9.2.3 Zugriffsbeschränkungen

1. Innerhalb einer Klasse können Eigenschaften und Methoden vorhanden sein, und externer Code kann Daten manipulieren, indem er die Instanzvariablenmethode direkt aufruft, wodurch die interne komplexe Logik ausgeblendet wird .

2. Wenn Sie verhindern möchten, dass von außen auf interne Attribute zugegriffen wird, können Sie vor dem Namen des Attributs zwei Unterstriche hinzufügen. Wenn der Variablenname der Instanz in Python mit __ beginnt, wird er zu A Auf die private Variable (privat) kann nur intern und nicht von extern zugegriffen werden.

class Student(object):

    def __init__(self, name, score):

        self.__name = name

        self.__score = score

    def print_score(self):

        print('%s: %s' % (self.__name, self.__score))

class Student(object):
def __init__(self, name, score):

>>> bart = Student('Bart Simpson', 98)

>>> bart.__name

Traceback (most recent call last):

File "", line 1, in

AttributeError: 'Student' object has no attribute '__name'

self.__name = name

class Student(object):

    ...

    def get_name(self):

        return self.__name

    def get_score(self):

        return self.__score

self.__score = score

class Student(object):

    ...

    def set_score(self, score):

        self.__score = score

def print_score(self):

class Student(object):

    ...

    def set_score(self, score):

        if 0 <= score <= 100:
self.__score = score
else:
raise ValueError('bad score')
print('%s: %s' % (self.__name, self.__score))<🎜>
<🎜>　3. Nach der Änderung gibt es keine Änderungen am externen Code, aber auf die Instanzvariable .__name und die Instanzvariable .__score kann von außen nicht mehr zugegriffen werden: <🎜>
<🎜>>>> bart = Student('Bart Simpson', 98)>>> bart.__name Traceback (letzter Aufruf zuletzt): Datei „“, Zeile 1, in AttributeError: 'Student' Objekt hat kein Attribut '__name'

　4. Dadurch wird sichergestellt, dass externer Code den internen Zustand des Objekts nicht nach Belieben ändern kann, sodass durch Durch den Schutz von Zugriffsbeschränkungen ist der Code robuster. Wenn jedoch externer Code Name und Punktzahl erhalten möchte, können Sie der Student-Klasse Methoden wie get_name und get_score hinzufügen:
class Student(object): ... def get_name(self): return self.__name def get_score(self): return self.__score
5 . Wenn Sie externen Code erlauben möchten, die Punktzahl zu ändern, können Sie der Student-Klasse die Methode set_score hinzufügen:
class Student(object): ... def set_score(self, score): self.__score = score td>
　6. Im Vergleich zu den ursprünglichen Direktaufrufparametern können die Parameter in der Methode überprüft werden, um die Übergabe ungültiger Parameter zu vermeiden:
class Student(object): .. . def set_score(self, score): wenn 0 <= Punktzahl <= 100:<🎜><🎜> self.__score = Punktzahl<🎜><🎜> sonst :<🎜> <🎜> raise ValueError('schlechte Punktzahl')<🎜>
7. Es ist zu beachten, dass Variablennamen in Python ähnlich wie __xxx__ sind, d. h. sie beginnen mit einem doppelten Unterstrich und enden mit einem doppelten Unterstrich. Auf spezielle Variablen kann direkt zugegriffen werden und sie sind nicht privat . Variablen, daher können Variablennamen wie __name__ und __score__ nicht verwendet werden. Manchmal werden Instanzvariablennamen angezeigt, die mit einem Unterstrich beginnen, z. B. _name. Auf solche Instanzvariablen kann jedoch laut Konvention zugegriffen werden: „Obwohl ich kann.“ auf die zugegriffen werden kann, behandeln Sie mich bitte als private Variable und greifen Sie nicht nach Belieben darauf zu.
8. Auf Instanzvariablen, die mit doppelten Unterstrichen beginnen, kann nicht unbedingt von außen zugegriffen werden. Der Grund, warum auf __name nicht direkt zugegriffen werden kann, liegt darin, dass der Python-Interpreter die Variable __name extern in _Student__name ändert, sodass auf die Variable __name weiterhin über _Student__name zugegriffen werden kann.
9.3 Vererbung
1. Wenn eine Klasse einer speziellen Version einer anderen Klasse ähnelt, können Sie Vererbung verwenden. Wenn eine Klasse eine andere Klasse erbt, erhält sie automatisch alle Eigenschaften und Methoden der anderen Klasse. Die ursprüngliche Klasse ist die übergeordnete Klasse und die neue Klasse ist die untergeordnete Klasse.
2. Die Unterklasse erbt alle Attribute und Methoden der übergeordneten Klasse und kann auch eigene Attribute und Methoden definieren. Wenn wir in der OOP-Programmierung eine Klasse definieren, kann diese von einer vorhandenen Klasse erben. Die neue Klasse wird als Unterklasse (Subclass) bezeichnet, und die geerbte Klasse wird als Basisklasse, übergeordnete Klasse oder Superklasse bezeichnet Klasse).
Klasse Hund (Tier): #Inherit Animal
class Dog(Animal): #继承Animal
pass

pass
9.3.1 Unterklassenmethode __init__()
1. Die Vererbung muss an das übergeordnete Element übergeben werden Klasse Allen Attributen werden Werte zugewiesen, und die __init__() der Unterklasse erfordert Hilfe von der übergeordneten Klasse.
　2. Und die übergeordnete Klasse muss in der Vererbungsdatei vor der Unterklasse stehen.
　3. Bei der Definition einer Unterklasse muss der Name der übergeordneten Klasse in Klammern angegeben werden. 　4.
super()-Sonderfunktion
hilft Python, übergeordnete Klassen und Unterklassen parallel zu verbinden. Die übergeordnete Klasse wird auch Superklasse genannt, der Ursprung von Super.
9.3.2 Methoden und Attribute von Unterklassen definieren
Eine Klasse eine Klasse erben lassen. Sie können Eigenschaften und Methoden hinzufügen, die Unterklassen von übergeordneten Klassen unterscheiden.
9.3.3 Umschreiben der übergeordneten Klasse
Die der übergeordneten Klasse entsprechenden Methoden können nur dann umgeschrieben werden, wenn sie die Anforderungen der Unterklasse nicht erfüllen, um sie zu beschreiben Merkmale der Unterklasse. Befreien Sie sich von den schlechten Dingen des Elterntyps und nehmen Sie das Beste.
9.3.4 Polymorphismus
1. Wenn die gleiche Methode sowohl in der Unterklasse als auch in der übergeordneten Klasse vorhanden ist, sagen wir, dass die Unterklasse die Methode der übergeordneten Klasse überschreibt, wenn der Code ausgeführt wird , Unterklassenmethoden werden immer aufgerufen. Auf diese Weise erhalten wir einen weiteren Vorteil der Vererbung: Polymorphismus
2. Wenn in der Vererbungsbeziehung der Datentyp einer Instanz eine Unterklasse ist, kann ihr Datentyp daher auch als betrachtet werden Ist die übergeordnete Klasse . Das Gegenteil ist jedoch nicht der Fall.
3. Der Vorteil des Polymorphismus besteht darin, dass wir, wenn wir Hund, Katze, Schildkröte ... übergeben müssen, nur den Tiertyp erhalten müssen, da Hund, Katze, Schildkröte ... alle Tiere sind Typen und arbeiten Sie dann einfach entsprechend dem Tiertyp. Da der Animal-Typ über eine run()-Methode verfügt, ruft jeder übergebene Typ automatisch die run()-Methode des tatsächlichen Typs auf, sofern es sich um eine Animal-Klasse oder -Unterklasse handelt.
4. Für eine Variable müssen wir nur wissen, dass sie vom Typ „Animal“ ist. Ohne ihren Subtyp genau zu kennen, können wir sicher die run()-Methode aufrufen, und die aufgerufene spezifische run()-Methode ist die Funktion Ob es sich um ein Tier-, Hunde-, Katzen- oder Schildkrötenobjekt handelt, wird durch den genauen Typ des Objekts zur Laufzeit bestimmt. Dies ist die wahre Stärke des Polymorphismus: Der Aufrufer kümmert sich nur um den Aufruf, unabhängig von den Details, und wenn wir a hinzufügen neue Unterklasse von Animal. Stellen Sie einfach sicher, dass die run()-Methode korrekt geschrieben ist, unabhängig davon, wie der ursprüngliche Code aufgerufen wird. Dies ist das berühmte „offene und geschlossene“ Prinzip:
Offen für Erweiterung: neue Tierunterklassen sind erlaubt
Geschlossen für Änderung: nicht Funktionen wie run_twice(), die vom Tiertyp abhängen, müssen geändert werden.
9.3.5 Verwendung von __slots__
class Student(object):
__slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称
Um Einschränkungen zu erreichen, können Sie in Python beim Definieren einer Klasse eine spezielle __slots__-Variable definieren, um die Attribute zu begrenzen, die hinzugefügt werden können zu Klasseninstanzen. <🎜>
<🎜>class Student(object):<🎜><🎜> __slots__ = ('name', 'age') # Verwenden Sie Tupel, um die Attributnamen zu definieren, die gebunden werden dürfen <🎜>
Beachten Sie bei der Verwendung von __slots__, dass sich die durch __slots__ definierten Attribute nur auf die aktuelle Klasseninstanz auswirken und keine Auswirkungen auf geerbte Unterklassen haben.
9.3.6 Mehrfachvererbung
1. Durch Mehrfachvererbung kann eine Unterklasse alle Funktionen mehrerer übergeordneter Klassen gleichzeitig erhalten.
2. Beim Entwerfen der Vererbungsbeziehung von Klassen wird die Hauptlinie normalerweise von einer einzigen Quelle geerbt. Beispielsweise erbt Ostrich von Bird. Wenn Sie jedoch zusätzliche Funktionen „einmischen“ müssen, können Sie dies durch Mehrfachvererbung erreichen. Lassen Sie Ostrich beispielsweise zusätzlich zur Erbung von Bird auch Runnable erben. Dieses Design wird oft als MixIn bezeichnet. Der Zweck von MixIn besteht darin, einer Klasse mehrere Funktionen hinzuzufügen. Auf diese Weise legen wir beim Entwurf einer Klasse Wert darauf, mehrere MixIn-Funktionen durch Mehrfachvererbung zu kombinieren, anstatt mehrstufige komplexe Vererbungsbeziehungen zu entwerfen.
　3. Auf diese Weise benötigen wir keine komplizierte und große Vererbungskette. Solange wir uns dafür entscheiden, die Funktionen verschiedener Klassen zu kombinieren, können wir schnell die erforderlichen Unterklassen erstellen. Da Python Mehrfachvererbung zulässt, ist MixIn ein gängiges Design. Sprachen, die nur eine einzelne Vererbung zulassen (z. B. Java), können das Design von MixIn nicht verwenden.
9.3.7 Angepasste Klassen
1. Es gibt viele Spezialfunktionen in Python-Klassen, die uns dabei helfen können, Klassen anzupassen.
__str__
Definieren Sie die Methode __str__() und Sie können eine gut aussehende Zeichenfolge zurückgeben:
>>> class Student(object):
...     def __init__(self, name):

...         self.name = name

...     def __str__(self):

...         return 'Student object (name: %s)' % self.name

...

>>> print(Student('Michael'))

Student object (name: Michael)

>>> class Student(object):
... def __init__(self, name):
"

>>> s = Student('Michael')

>>> s

<__main__.Student object at 0x109afb310>

...
>>> print(Student('Michael'))
Studentenobjekt (Name: Michael)

class Student(object):

    def __init__(self, name):

        self.name = name

    def __str__(self):

        return 'Student object (name=%s)' % self.name

    __repr__ = __str__

Das so ausgedruckte Beispiel sieht nicht nur gut aus, sondern macht es auch leicht, die wichtigen Daten innerhalb der Instanz zu erkennen.

Geben Sie Variablen direkt ein, ohne sie zu drucken. Das gedruckte Beispiel sieht immer noch nicht gut aus:

>>> s = Student('Michael')

class Fib(object):

    def __init__(self):

        self.a, self.b = 0, 1 # 初始化两个计数器a，b

    def __iter__(self):

        return self # 实例本身就是迭代对象，故返回自己

    def __next__(self):

        self.a, self.b = self.b, self.a + self.b # 计算下一个值

        if self.a > 100000: # 退出循环的条件

            raise StopIteration()

        return self.a # 返回下一个值

>>> s
<__main__.Student object at 0x109afb310>

>>> for n in Fib():

...     print(n)

...

1

1

2

3

5

...

46368

75025

Dies liegt daran, dass der direkte Anzeigevariablenaufruf nicht __str__() ist, sondern __repr__(). Der Unterschied zwischen den beiden ist __str__. () gibt die Zeichenfolge zurück, die der Benutzer sieht, und __repr__() gibt die Zeichenfolge zurück, die der Programmentwickler sieht. Mit anderen Worten: __repr__() dient dem Debuggen. Die Lösung besteht darin, ein weiteres __repr__() zu definieren. Aber normalerweise sind die Codes von __str__() und __repr__() gleich, daher gibt es eine einfache Möglichkeit, es zu schreiben: tbody >

class Student(object): def __init__(self, name): self.name = name def __str__(self): return 'Student object (name=%s)' % self.name __repr__ = __str__
__iter__ Wenn eine Klasse wie eine Liste oder ein Tupel in einer for...in-Schleife verwendet werden möchte, muss sie eine __iter__()-Methode implementieren, die eine zurückgibt iterierbares Objekt, dann ruft die for-Schleife von Python kontinuierlich die __next__()-Methode des Iterationsobjekts auf, um den nächsten Wert der Schleife abzurufen, bis sie die Schleife verlässt, wenn ein StopIteration-Fehler auftritt. Wir nehmen die Fibonacci-Folge als Beispiel und schreiben eine Fib-Klasse, die in for-Schleifen verwendet werden kann: class Fib(object): def __init__(self): self.a, self.b = 0, 1 # Zwei Zähler a, b initialisieren def __iter__(self): return self # Die Instanz selbst ist ein iteratives Objekt, also return self def __next__(self): self.a, self.b = self.b, self.a + self.b # Berechnen Sie den nächsten Wert if self .a > 100000: # Bedingungen für das Verlassen der Schleife                                     >
Versuchen Sie nun, die Fib-Instanz auf die for-Schleife anzuwenden:

>>> für n in Fib():... print (n)...1 1235 ...46368 75025

__getitem__

Obwohl die Fib-Instanz in for-Schleifen verwendet werden kann und ein bisschen wie eine Liste aussieht, ist es immer noch nicht möglich, sie als Liste zu verwenden. Nehmen Sie zum Beispiel das 5. Element:

>>> Fib()[5]

Traceback (most recent call last):

File "", line 1, in

TypeError: 'Fib' object does not support indexing

>>> >
Traceback (letzter Aufruf zuletzt):

class Fib(object):

    def __getitem__(self, n):

        a, b = 1, 1

        for x in range(n):

            a, b = b, a + b

        return a

Datei „“, Zeile 1, in
TypeError: „Fib“-Objekt unterstützt keine Indizierung

Um sich wie eine Liste zu verhalten und Elemente entsprechend den Indizes zu entfernen, müssen Sie die Methode __getitem__() implementieren:

class Fib(object):

def __getitem__(self, n ):

a, b = 1, 1

für x im Bereich(n):

a, b = b, a + b

from enum import Enum

Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))

return a

__getattr__ Python verfügt über einen anderen Mechanismus, der darin besteht, eine __getattr__()-Methode zu schreiben, um ein Attribut dynamisch zurückzugeben . Wenn Sie ein nicht vorhandenes Attribut wie Score aufrufen, versucht der Python-Interpreter, __getattr__(self, 'score') aufzurufen, um das Attribut abzurufen, sodass wir die Möglichkeit haben, den Wert von Score zurückzugeben. Vorhandene Attribute wie der Name werden in __getattr__ nicht nachgeschlagen. __call__ 1. Für jede Klasse müssen Sie nur eine __call__()-Methode definieren, um die Instanz direkt aufzurufen. 2. Durch die Funktion callable() können wir feststellen, ob ein Objekt ein „aufrufbares“ Objekt ist. 9.3.8 Aufzählungsklasse Definieren Sie einen Klassentyp für einen solchen Aufzählungstyp, und dann ist jede Konstante eine eindeutige Instanz der Klasse. Python stellt die Enum-Klasse zur Implementierung dieser Funktion bereit:

from enum import EnumMonth = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', ' Sep', 'Oct', 'Nov', 'Dec'))

9.3.9 Metaklasse

type()

Um ein Klassenobjekt zu erstellen, übergibt die Funktion type() nacheinander drei Parameter:

Der Name der Klasse;
Eine Sammlung geerbter übergeordneter Klassen. Wenn es nur eine übergeordnete Klasse gibt, vergessen Sie nicht das einzelne Element Schreibmethode von Tupel;
Der Methodenname der Klasse ist an die Funktion gebunden. Hier binden wir die Funktion fn an den Methodennamen hallo.

Metaklasse

Metaklasse, wörtlich übersetzt als Metaklasse, die einfache Erklärung lautet: Nachdem wir eine Klasse definiert haben, können wir eine Instanz basierend auf dieser Klasse erstellen, also: zuerst Definieren Sie die Klasse und erstellen Sie dann Instanzen. Aber was ist, wenn wir eine Klasse erstellen möchten? Dann müssen Sie eine Klasse basierend auf der Metaklasse erstellen. Definieren Sie also zuerst die Metaklasse und erstellen Sie dann die Klasse. Die Verbindung besteht darin, zuerst die Metaklasse zu definieren, dann die Klasse und schließlich die Instanz zu erstellen. Die von der Methode

__new__() empfangenen Parameter sind:

Das Objekt der Klasse, die gerade erstellt wird; Klassenname;
Sammlung der von der Klasse geerbten Elternklassen
Sammlung von Methoden der Klasse.
9.3.10 Instanzen als Eigenschaften verwenden

9.3.11 Physische Objekte simulieren

Um komplexere physische Objekte zu simulieren, müssen Sie dies von einer höheren logischen Ebene aus betrachten. Um effizienteren, prägnanteren und genaueren Code zu schreiben, müssen Sie möglicherweise Klassen ständig neu organisieren.

9.4 Klassen importieren

1. Da weiterhin Klassen hinzugefügt werden, führt selbst eine hervorragende Vererbung dazu, dass der Code sehr lang wird, sodass Sie mit Python Klassen in Module importieren können. Und importieren Sie die erforderlichen Module zur Verwendung im Hauptprogramm.

2. Schreiben Sie für jedes Modul eine Dokumentationszeichenfolge, erläutern Sie die Funktion des Moduls und beschreiben Sie kurz den Inhalt.

3. Importieren Sie mehrere Klassen aus einem Modul, trennen Sie sie durch Kommas und erstellen Sie Instanzen entsprechend Ihren Anforderungen.

4. Sie können auch die gesamte Klasse importieren, den Klassennamen vor der Instanz hinzufügen und auf die erforderliche Klasse zugreifen.

5. Importieren Sie ein Modul in ein anderes Modul.

9.5 Python-Standardbibliothek (Modul)

Die Python-Standardbibliothek ist eine Reihe von Modulen, die nur mit der Importanweisung importiert und verwendet werden können.

Mit Wörterbüchern können Sie Informationen verknüpfen, aber nicht die Reihenfolge aufzeichnen, in der Sie Schlüssel-Wert-Paare hinzufügen. Um ein Wörterbuch zu erstellen und die Reihenfolge aufzuzeichnen, in der Sie Schlüssel-Wert-Paare hinzufügen, können Sie „orderedDict“ verwenden Klasse im Sammlungsmodul. Instanzen von OrderedDict sind mit Wörterbüchern identisch, zeichnen jedoch die Reihenfolge auf, in der Schlüssel-Wert-Paare hinzugefügt werden.

OrderdDict ist sehr gut, es hat die Eigenschaften sowohl einer Liste als auch eines Wörterbuchs, was manchmal benötigt wird.

Zufallsmodul

Enthält Funktionen zum Generieren von Zufallszahlen auf verschiedene Arten. Wobei randint() eine Ganzzahl innerhalb des angegebenen Bereichs zurückgibt.

datetime ist ein Modul

Das datetime-Modul enthält auch eine datetime-Klasse. Die datetime-Klasse wird über datetime import datetime importiert. Wenn Sie nur Datum/Uhrzeit importieren, müssen Sie den vollständigen Namen datetime.datetime angeben.

datetime.now() gibt das aktuelle Datum und die aktuelle Uhrzeit zurück, sein Typ ist datetime.

Häufig verwendete Bibliotheken von Drittanbietern

Es gibt auch MySQL-Treiber: mysql-connector-python, NumPy-Bibliothek für wissenschaftliches Rechnen: Numpy, Vorlagentool Jinja2 zum Generieren von Text usw. .

　1.urlparse-Modul, das urlpasrse-Modul bietet einige grundlegende Funktionen für die Verarbeitung von URL-Strings. Zu diesen Funktionen gehören urlparse(), urlunparse() und urljoin().

　2.urlparse() analysiert urlstr in ein 6-Tupel (prot_sch, net_loc, path, params, query, frag). Jede Komponente wurde bereits zuvor beschrieben.

3. Die Funktion von urlunparse() ist völlig entgegengesetzt zu urlpase(). Sie generiert ein URL-6-Tupel (prot_sch, net_loc, path, params, query, frag) aus der von urlparse() verarbeiteten URL. und fügt es in eine URL ein und kehrt zurück.

　4. Das urllib-Modul bietet viele Funktionen, die zum Herunterladen von Daten von einer bestimmten URL verwendet werden können. Es kann auch Zeichenfolgen kodieren und dekodieren, damit sie in der richtigen Form in der URL angezeigt werden können. Zu den im Folgenden vorgestellten Funktionen gehören urlopen(), urlretrieve(), quote(), unquote(), quote_plus(), unquote_plus() und urlencode().

5.urlopen() öffnet eine Webverbindung, die durch eine bestimmte URL-Zeichenfolge dargestellt wird, und gibt ein Objekt vom Dateityp zurück.

6. urlretrieve() wird nicht verwendet, um auf die URL in Form einer Datei zuzugreifen und sie zu öffnen, sondern um den vollständigen HTML-Code herunterzuladen und als Datei zu speichern.

9.6 Klassencodierungsstil

Machen Sie sich mit dem Codierungsstil für Klassen vertraut, insbesondere wenn das Programm komplex ist.

1. Der Klassenname sollte die

Kamelfall-Benennungsmethode

verwenden, d. h. der erste Buchstabe der Klasse wird großgeschrieben, ohne Unterstriche, während der erste Buchstabe des Instanznamens und des Moduls verwendet wird Der Name wird in Kleinbuchstaben geschrieben und Unterstriche werden zum Verbinden von Wörtern verwendet.

2. Fügen Sie nach jeder Klassendefinition eine Dokumentationszeichenfolgenbeschreibung hinzu, um die Funktion der Klasse kurz zu beschreiben, und fügen Sie unter jedem Modul eine Dokumentationszeichenfolgenbeschreibung hinzu, um zu beschreiben, was die Klassen unter dem Modul tun können.

3. Verwenden Sie Leerzeilen, um den Code zu organisieren, aber missbrauchen Sie ihn nicht. Sie können eine Leerzeile verwenden, um Methoden in einer Klasse zu trennen, und zwei Leerzeilen, um Klassen zu trennen.

4. Wenn Sie Module in der Standardbibliothek und von Ihnen selbst geschriebene Module gleichzeitig importieren müssen, schreiben Sie zuerst die Importanweisung zum Importieren des Standardbibliotheksmoduls, getrennt durch eine Leerzeile, und importieren Sie dann das Modulimportanweisung, die Sie geschrieben haben. Wenn mehrere Importanweisungen enthalten sind, ist es einfacher, den Ursprung jedes Moduls im Programm zu verstehen.

Das obige ist der detaillierte Inhalt vonEinführung in das grundlegende Erlernen von Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!