Ich lerne Python in VScode (Python-Funktion, Python-Modulimport)

Meine persönliche Blog-Homepage: Wenn '' 1️⃣ wirklich entkommen kann, sagen Sie 1️⃣ Blog-Homepage
(1) zum Erlernen der grundlegenden Python-Grammatik ----> Sie können sich auf meinen Blog „Ich lerne Python in VScode“
(2) beziehen. Pip ist Es ist notwendig um die Bedeutung von Python zu lernen ---->> PiP beim Erlernen der Python-Sprache

Dieser Artikel ergänzt den Inhalt von „Ich lerne Python in VScode“

Py-Funktion

def user_info(name, age, gender="未知"):
    print(f"您的名字是: {
      
      name}，年龄是: {
      
      age}，性别是: {
      
      gender}")
print(type(user_info))

Eine Funktion ist ein wiederverwendbarer Codeblock, der eine bestimmte Aufgabe ausführt oder einen bestimmten Vorgang abschließt. Funktionen können Eingabeparameter empfangen, verarbeiten und Ausgabeergebnisse zurückgeben.

Funktionen sind ein wichtiges Konzept in der modularen Programmierung und ermöglichen die Zerlegung komplexer Programme in kleine, unabhängige Teile, von denen jeder seine eigene Aufgabe erfüllt. Funktionen können die Lesbarkeit, Wartbarkeit und Wiederverwendbarkeit Ihres Codes verbessern.

In Python ist eine Funktion eine Klasse von Objekten, die an andere Funktionen übergeben, in anderen Funktionen verschachtelt, Variablen zugewiesen werden kann usw. Funktionen in Python unterstützen auch erweiterte Funktionen wie Standardparameter, variable Parameter und Schlüsselwortparameter, die flexibler auf unterschiedliche Anforderungen eingehen können.

Plaudern:

In Python sind Funktionen erstklassige Bürger, was bedeutet, dass Funktionen wie andere Datentypen (Ganzzahlen, Zeichenfolgen, Listen usw.) als Argumente an andere Funktionen übergeben werden können. Die Übergabe von Funktionen als Parameter an andere Funktionen ist eine gängige funktionale Programmiertechnik, die Code flexibler und modularer macht und Abstraktion und Wiederverwendung besser unterstützt.

Sehen wir uns ein Beispiel an, um das Konzept der Übergabe von Funktionen als Parameter zu veranschaulichen. Angenommen, wir haben eine Funktion apply_operation, die zwei Parameter annimmt: eine Operatorfunktion und zwei Operanden, und diese beiden Operanden zur Verarbeitung an die Operatorfunktion übergibt.

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

def subtract(x, y):
    return x - y

def apply_operation(operation, x, y):
    return operation(x, y)

result_add = apply_operation(add, 3, 5)
result_subtract = apply_operation(subtract, 8, 3)

print(result_add)      # Output: 8 (3 + 5)
print(result_subtract) # Output: 5 (8 - 3)

In diesem Beispiel definieren wir zwei Funktionen add, subtractdie Addition bzw. Subtraktion durchführen. Dann definieren wir eine Funktion apply_operation, die eine Operationsfunktion und zwei Operanden annimmt, dann die Operationsfunktion aufruft, ihr diese beiden Operanden übergibt und das Ergebnis der Operation zurückgibt.

Beim Aufruf apply_operationder Funktion übergeben wir die Funktion addund subtractdie Funktion als Parameter an apply_operationdie Funktion. Auf diese Weise apply_operationkann die Funktion je nach Eingabeoperationsfunktion unterschiedliche Operationen ausführen und so die Anwendung eines Strategiemusters (Strategiemuster) realisieren.

Indem wir eine Funktion als Argument übergeben, können wir apply_operationdurch unterschiedliche Betriebsfunktionen unterschiedliche Verhaltensweisen erzielen, ohne die Funktion zu ändern. Diese Technik kann unseren Code flexibler machen, Codewiederholungen reduzieren und die Lesbarkeit und Wartbarkeit des Codes verbessern.

Lösen Sie das Problem [Finden Sie alle Elementkombinationen und ihre entsprechenden Indexkombinationen, die die Bedingungen in der Liste erfüllen]:

Finden Sie alle Mitgliedskombinationen und ihre entsprechenden Indexkombinationen, die die Bedingungen in der Liste erfüllen:
Eingabe: nums = [2, 2, 7, 6, 1, 7, 3, 6, 2, 3], Ziel = 9 Ausgabe:
alle Mitglieder Kombinationen: [(2,7), (2,7), (2,7), (2,7), (7,2), (6,3), (6,3), (7,2 ) , (3, 6), (6, 3)]
Mitgliedsindexkombinationen: [(0, 2), (0, 5), (1, 2), (1, 5), (2, 8), (3 , 6), (3, 9), (5, 8), (6, 7). (7, 9)]
Erläuterung: Zwei Mitglieder, die die Bedingungen erfüllen, werden zusammengefasst

der Code

def find_combinations(nums, target):

    member_combinations = []
    index_combinations = []
    for i in range(len(nums)):
        for j in range(i+1, len(nums)):
            if nums[i] + nums[j] == target:
                member_combinations.append((nums[i], nums[j]))
                index_combinations.append((i, j))
    return member_combinations, index_combinations
nums = [2, 2, 7, 6, 1, 7, 3, 6, 2, 3]
target = 9
member_combinations, index_combinations = find_combinations(nums, target)
print("所有成员组合:", member_combinations)
print("成员下标组合:", index_combinations)

Definition von Py-Funktionen

Das Funktionsdefinitionsformat von Python lautet wie folgt:

def function_name(parameters):
    """docstring"""
    # function body
    return [expression]

Unter diesen defwird das Schlüsselwort zum Definieren der Funktion verwendet, ist function_nameder Funktionsname parametersund die Parameterliste der Funktion (kann leer sein), in Klammern eingeschlossen.

Die Zeichenfolge am Anfang des Funktionskörpers ist eine Dokumentzeichenfolge, die optional zur Beschreibung der Funktion und Verwendung der Funktion verwendet wird. Der Funktionskörper enthält die Hauptlogik der Funktion. returnDie Anweisung wird verwendet, um das Ergebnis der Funktion zurückzugeben (kann null sein).

So rufen Sie die Py-Funktion auf

In Python erfordert der Aufruf einer Funktion den Funktionsnamen und ein Klammerpaar, in dem Parameter übergeben werden können. Wir haben zum Beispiel eine Summenfunktion:

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

Wir können diese Funktion aufrufen durch:

result = add(3, 5)
print(result)  # 输出8

Beim Aufruf einer Funktion müssen Parameter an die Funktion übergeben werden. Im obigen Beispiel übergeben wir 3 und 5 als Parameter an die Add-Funktion, weisen dann den Rückgabewert der Funktion der Variablen result zu und geben das Ergebnis aus.

Wenn die Funktion None zurückgibt, können wir die Funktion direkt aufrufen, ohne etwas mit ihrem Rückgabewert zu tun, zum Beispiel:

def print_hello():
    print("Hello")
    
print_hello()  # 输出Hello

Vergessen Sie beim Aufruf einer Funktion nicht, Parameter an die Funktion zu übergeben und den Rückgabewert der Funktion zur weiteren Verarbeitung in der gewünschten Variablen zu speichern.

verschachtelte Aufrufe

Ein verschachtelter Aufruf einer Funktion bedeutet, dass während der Ausführung einer Funktion eine andere Funktion aufgerufen wird. Die spezifische Implementierung kann im Code der Funktion erfolgen, direkt nach der aufzurufenden Funktion Klammern hinzufügen und die Parameter, die an die Funktion übergeben werden müssen, als Parameter in Klammern übergeben. Zum Beispiel:

def function_a(x):
    result = x * 2
    return result

def function_b(y):
    result = y + 1
    return result

def function_c(z):
    result_a = function_a(z)
    result_b = function_b(result_a)
    return result_b

print(function_c(3))  # 输出结果为 7

Im obigen Code function_cruft die Funktion die Funktion function_aund die Funktion auf function_b, übergibt den Rückgabewert einer der Funktionen als Parameter der anderen Funktion und gibt schließlich function_bdas Ergebnis von zurück. Diese Methode kann die Struktur des Programms klarer machen, die Logik einfacher machen und auch die Wiederverwendbarkeit des Codes erhöhen.

Bei der Verwendung von Python-Funktionen sind einige Einschränkungen zu beachten:

1. Der Funktionsname darf nicht mit einer in Python integrierten Funktion oder einem Schlüsselwort identisch sein. Wenn die Namen identisch sind, führt dies dazu, dass das Programm fehlerhaft ausgeführt wird.

2. In Funktionsdefinitionen sollten Parameternamen beschreibend sein und es sollte eine einheitliche Namenskonvention bestehen. Wenn die Funktion beispielsweise einen String-Parameter akzeptiert, sollte der Parametername mit „str“ enden.

3. Die an die Funktion übergebenen Parameter können Positionsparameter (übergeben in der Reihenfolge der Definition) oder Schlüsselwortparameter (übergeben unter Verwendung von Parameternamen) sein. Sobald jedoch Schlüsselwortparameter verwendet werden, müssen alle nachfolgenden Parameter Schlüsselwortparameter verwenden.

4. Wenn in einer Funktionsdefinition ein Parameter einen Standardwert hat, muss dieser der letzte Parameter sein. Andernfalls kommt es zu einem Fehler.

5. Funktionen in Python können mehrere Werte zurückgeben, die als Tupel zurückgegeben werden.

6. Nachdem die interne Ausführung der Funktion abgeschlossen ist, werden die lokalen Variablen automatisch zerstört. Wenn Sie eine Variable zwischen Funktionen gemeinsam nutzen müssen, können Sie die Variable als globale Variable definieren.

7. Funktionen sollten so prägnant wie möglich sein, eine Sache tun und sicherstellen, dass sie diese auch gut macht.

8. Funktionen sollten dokumentiert werden, damit Benutzer ihre Eigenschaften und deren Verwendung besser verstehen. Sie können Funktionsanmerkungen verwenden, um die Eingabe- und Ausgabeparameter einer Funktion sowie den Zweck und das Verhalten der Funktion zu beschreiben.

9. In Python können Funktionen verschachtelt definiert werden, d. h. eine Funktion kann innerhalb einer anderen Funktion definiert werden. Verschachtelte Funktionen können auf Variablen und Parameter der übergeordneten Funktion zugreifen.

Es gibt mehrere Möglichkeiten, Parameter von Python-Funktionen aufzurufen:

1. Positionsparameter: Übergeben Sie die Parameter einfach in der Reihenfolge an die Funktion, in der die Funktion definiert ist. Zum Beispiel:

def greet(name, message):
    print(message, name)

greet('Alice', 'Hello')  # 输出：Hello Alice

2. Schlüsselwortargumente: Verwenden Sie den Parameternamen, um den übergebenen Parameterwert anzugeben. Zum Beispiel:

def greet(name, message):
    print(message, name)

greet(message='Hello', name='Alice')  # 输出：Hello Alice

3. Standardparameter: Geben Sie einen Standardparameterwert in der Funktionsdefinition an. Wenn dieser Parameter im Funktionsaufruf nicht angegeben wird, wird der Standardwert verwendet. Zum Beispiel:

def greet(name, message='Hello'):
    print(message, name)

greet('Alice')        # 输出：Hello Alice
greet('Alice', 'Hi')  # 输出：Hi Alice

4. Variadische Argumente: Wird in Funktionsdefinitionen verwendet *args, die eine beliebige Anzahl von Positionsargumenten akzeptieren und in einem Tupel platzieren können. Zum Beispiel:

def greet(*names):
    for name in names:
        print('Hello', name)

greet('Alice', 'Bob', 'Charlie')  # 输出：Hello Alice，Hello Bob，Hello Charlie

5. Variadische Schlüsselwortargumente: Wird in Funktionsdefinitionen verwendet und **kwargskann eine beliebige Anzahl von Schlüsselwortargumenten akzeptieren und in ein Wörterbuch einfügen. Zum Beispiel:

def greet(**kwargs):
    for name, message in kwargs.items():
        print(message, name)

greet(Alice='Hello', Bob='Hi', Charlie='Hey')  # 输出：Hello Alice，Hi Bob，Hey Charlie

Es ist zu beachten, dass die aufrufende Methode der Parameter mit der Reihenfolge oder den Namen in der Funktionsdefinition übereinstimmen muss und die Anzahl der Parameter mit der in der Funktionsdefinition übereinstimmen muss.

Beachten:

Die Parameter zum Zeitpunkt der Funktionsdefinition werden als formale Parameter bezeichnet, da sie nur in der Definition der Funktion vorhanden sind und dazu dienen, den Typ und die Menge der Parameter anzugeben, die beim Aufruf der Funktion übergeben werden müssen. Formale Parameter werden üblicherweise in der Funktionsdefinition als Teil der Funktionssignatur angegeben.

Die Parameter, die beim Aufruf einer Funktion übergeben werden, werden als Aktualparameter bezeichnet. Anzahl und Typ der tatsächlichen Parameter müssen mit den formalen Parametern in der Funktionsdefinition übereinstimmen, andernfalls kommt es zu einem Kompilierungsfehler.

In Python ist die Anzahl der Argumente für eine Funktion unbegrenzt und durch Kommas getrennt. Beim Aufruf einer Funktion müssen die übergebenen tatsächlichen Parameter nacheinander den formalen Parametern entsprechen und durch Kommas getrennt werden. Wenn die Funktion mehr als einen Parameter hat, müssen die Parameter in der Reihenfolge der Parameter in der Funktionsdefinition übergeben werden. Wenn die Funktion beispielsweise als definiert ist def my_function(a, b, c):, sollte der Funktionsaufruf lauten my_function(value_for_a, value_for_b, value_for_c), wobei und die tatsächlichen Argumente sind value_for_a, die an die Funktion übergeben werden.value_for_bvalue_for_c

Rückgabewert [das Ergebnis, das nach Ausführung der Funktion an den Aufrufer zurückgegeben wird]

Der Funktionskörper endet nach der Rückkehr, sodass der nach der Rückkehr geschriebene Code nicht ausgeführt wird.

Der Rückgabewert einer Python-Funktion bezieht sich auf das Ergebnis, das nach Ausführung der Funktion zurückgegeben wird. Im Funktionskörper können Sie das Schlüsselwort return verwenden, um den Rückgabewert der Funktion anzugeben. Wenn eine Funktion aufgerufen wird, führt die Funktion den darin enthaltenen Code aus und gibt den durch den Ausdruck nach der Return-Anweisung berechneten Wert als Rückgabewert an den Aufrufer zurück. Wenn die Funktion nicht explizit eine Return-Anweisung angibt oder die Return-Anweisung keinen Rückgabewert angibt, wird standardmäßig None zurückgegeben. Bei Funktionen mit einem Rückgabewert kann der Aufrufer den Rückgabewert empfangen und für nachfolgende Operationen verwenden.

Der Wert von None: [Ein spezielles Literal, dessen Typ ist: <class NoneType'>. Eine Funktion ohne Rückgabewert gibt tatsächlich Folgendes zurück: den Literalwert von None]

定义变量，但暂时不需要变量有具体值，可以用None来代替

NoneIn Python handelt es sich um ein spezielles Objekt, das Null- oder fehlende Werte darstellt. Er wird häufig als Standardrückgabewert verwendet, wenn eine Funktion nicht explizit einen Wert zurückgibt.

NoneHat die folgenden Verwendungszwecke und Werte:

1. Zeigt an, dass die Funktion keinen Rückgabewert hat: Wenn die Funktion keine returnAnweisung angibt oder returndie Anweisung keinen Rückgabewert angibt, wird standardmäßig zurückgegeben None. Dadurch wird dem Aufrufer mitgeteilt, dass die Ausführung der Funktion abgeschlossen ist und keine Ergebnisse zurückgegeben wurden.

2. Variable initialisieren: Sie können eine Variable initialisieren None, um anzuzeigen, dass die Variable derzeit keinen bestimmten Wert hat. Sie können der Variablen später bei Bedarf andere Werte zuweisen.

3. Beurteilungsbedingung: NoneSie kann zur bedingten Beurteilung verwendet werden, z. B. zur Überprüfung, ob eine Variable vorhanden ist, Noneum festzustellen, ob ein gültiger Wert vorliegt.

4. Standardparameterwert: Der Standardwert des Parameters kann beim Definieren der Funktion angegeben werden. Der allgemeine Standardwert ist None. Wenn der entsprechende Parameter beim Aufruf der Funktion nicht angegeben wird, wird auf diese Weise der Standardwert verwendet None.

5. Platzhalter: In der Entwicklung ist es manchmal notwendig, zuerst eine Variable oder einen Platzhalter zu deklarieren, aber es gibt noch keinen spezifischen Wert oder Berechnungsergebnis. Zu diesem Zeitpunkt können Sie Nonezum Ausdruck bringen, um Fehler oder Ausnahmen zu vermeiden.

Kurz gesagt Nonehandelt es sich um ein spezielles Objekt, das zur Darstellung fehlender Werte, Nullwerte oder undefinierter Zustände in Python verwendet wird und einen bestimmten praktischen Wert hat.

Code:

当一个函数没有明确的返回值时，它会默认返回`None`。以下是一个简单的例子：

```python
def greet(name):
    print("Hello, " + name)

result = greet("Alice")
print(result)

Ausgabe:

Hello, Alice
None

Im obigen Beispiel greetverwendet die Funktion einen Parameter nameund gibt die Begrüßung aus. Da die Funktion jedoch keinen Rückgabewert angibt, wird standardmäßig zurückgegeben None. Nach dem Aufruf greet("Alice")wird dieser ausgedruckt Hello, Aliceund anschließend der Variable der Rückgabewert zugewiesen result. Schließlich resultkönnen Sie den Wert durch Drucken erkennen None. Dies weist darauf hin, dass die Funktion nach der Ausführung kein bestimmtes Ergebnis zurückgibt.

Bitte beachten Sie, dass es Nonesich in Python um eine Konstante handelt, die einen Nullwert darstellt und normalerweise zur Darstellung einer nicht vorhandenen oder ungültigen Situation verwendet wird.

Mehrere Rückgabewerte:

Wie akzeptiert Python mehrere Rückgabewerte?
Um in Python mehrere Rückgabewerte zu akzeptieren, können Sie Tupel verwenden. Wenn eine Funktion mehrere Werte zurückgibt, können diese Werte in ein Tupel gepackt und durch Entpacken mehreren Variablen zugewiesen werden.

def get_values():
    return 1, 2, 3

a, b, c = get_values()

print(a)  # 输出: 1
print(b)  # 输出: 2
print(c)  # 输出: 3

Beim Entpacken werden den Variablen a, b bzw. c Werte zugewiesen. Schließlich haben wir die Werte dieser drei Variablen separat gedruckt.

Welche Möglichkeiten gibt es, Python-Parameter zu verwenden:

In Python werden Parameter auf folgende Weise verwendet:

1. Positionsargumente: Dies ist die gebräuchlichste Art der Parameterübergabe. Wenn Sie eine Funktion aufrufen, werden die Parameter in der Reihenfolge, in der sie definiert wurden, an die Funktion übergeben. Zum Beispiel:

Eins-zu-eins-Korrespondenz

def greet(name, greeting):
    print(f"{
      
      greeting}, {
      
      name}!")

greet("John", "Hello")  # Output: Hello, John!

2. Schlüsselwortparameter [Schlüsselwortargumente] (Schlüsselwortargumente): Beim Aufruf der Funktion werden die Parameter durch Angabe des Parameternamens und -werts übergeben. == Auf diese Weise können Parameter nicht der Reihe nach übergeben werden, was die Lesbarkeit des Codes verbessert. == Zum Beispiel:

def greet(name, greeting):
    print(f"{
      
      greeting}, {
      
      name}!")

greet(greeting="Hello", name="John")  # Output: Hello, John!

Durch die Verwendung von Schlüsselwörtern zum Übergeben von Parametern können Parameter ohne feste Reihenfolge übergeben werden, wodurch der Funktionsaufruf flexibler und klarer wird. Codebeispiel:

Verwenden Sie Standardargumente und Schlüsselwortargumente, um flexiblere Funktionsaufrufe zu implementieren. Dadurch werden Funktionsaufrufe klarer und benutzerfreundlicher und die Reihenfolge der Parameter entfällt.

def user_info(name, age, gender="未知"):
    print(f"您的名字是: {
      
      name}，年龄是: {
      
      age}，性别是: {
      
      gender}")

# 使用关键字传参，不需要按照固定顺序
user_info(name="小明", age=20, gender="男")

# 也可以不指定性别参数，将使用缺省参数的默认值
user_info(name="小红", age=25)

# 可以和位置参数混用，但位置参数必须在前，且匹配参数顺序
user_info("小刚", age=18, gender="男")

In diesem Beispiel legen wir den Standardwert „unbekannt“ für den Geschlechtsparameter der Funktion user_info fest. Auf diese Weise wird beim Aufruf der Funktion der Standardwert verwendet, wenn der Geschlechtsparameter nicht angegeben ist. Gleichzeitig können durch die Verwendung von Schlüsselwörtern zum Übergeben von Parametern Parameter ohne feste Reihenfolge übergeben werden, wodurch Funktionsaufrufe flexibler und klarer werden.

Bitte beachten Sie, dass bei der Verwendung von Schlüsselwörtern zur Übergabe von Parametern Positionsparameter vorangestellt und entsprechend der von der Funktion definierten Reihenfolge der Parameter abgeglichen werden müssen. Dies kann nicht nur die Flexibilität der Schlüsselwortparameterübergabe nutzen, sondern auch mit der Verwendung von Positionsparametern kompatibel sein.

3. Standardparameter (Standardargumente): Beim Definieren einer Funktion können Sie Standardwerte für bestimmte Parameter angeben. Wenn zum Zeitpunkt des Funktionsaufrufs keine Werte für diese Parameter bereitgestellt werden, werden Standardwerte verwendet. Zum Beispiel:

def greet(name, greeting="Hello"):
    print(f"{
      
      greeting}, {
      
      name}!")

greet("John")  # Output: Hello, John!
greet("Jane", "Hi")  # Output: Hi, Jane!

4. Parameter variabler Länge: In Python gibt es zwei Arten von Parametern variabler Länge, nämlich:

• *args: Wird zum Empfang einer beliebigen Anzahl von Positionsparametern verwendet und packt die Parameter in ein Tupel.
• **kwargs: Wird zum Empfang einer beliebigen Anzahl von Schlüsselwortargumenten verwendet und packt die Argumente in ein Wörterbuch (dict).

def sum_numbers(*args):
    total = 0
    for num in args:
        total += num
    return total

print(sum_numbers(1, 2, 3, 4))  # Output: 10

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{
      
      key}: {
      
      value}")

print_info(name="John", age=30, city="New York")
# Output:
# name: John
# age: 30
# city: New York

5 Standardargumente:

Mit Standardparametern können Sie beim Definieren der Funktion Standardwerte für einige Parameter angeben, sodass beim Aufruf der Funktion der Standardwert verwendet wird, wenn der Wert des entsprechenden Parameters nicht angegeben wird. Dies vereinfacht Funktionsaufrufe und verleiht der Funktion gleichzeitig mehr Flexibilität. Platzieren Sie beim Definieren einer Funktion Parameter, deren Standardwerte Sie haben möchten, am Ende der Parameterliste.

def greet(name, greeting="Hello"):
    print(f"{
      
      greeting}, {
      
      name}!")

greet("John")          # Output: Hello, John! (默认使用"greeting"参数的默认值)
greet("Jane", "Hi")    # Output: Hi, Jane! (使用指定的"greeting"参数值)

6 Unbestimmte Längenparameter (variable Längenparameter):

Mit unbestimmten Argumenten können Sie Funktionen definieren, die eine beliebige Anzahl von Argumenten annehmen können. In Python gibt es zwei Arten von Parametern variabler Länge:

• *args: Wird zum Empfang einer beliebigen Anzahl von Positionsargumenten verwendet und packt diese Argumente in ein Tupel.
• **kwargs: Wird zum Empfang einer beliebigen Anzahl von Schlüsselwortargumenten verwendet und packt diese Argumente in ein Wörterbuch (dict).

Die Verwendung von Parametern variabler Länge kann die Übergabe einer unbekannten Anzahl von Parametern bewältigen, wodurch die Funktion flexibler wird. Verwenden Sie beim Definieren einer Funktion „*args“ und „**kwargs“, um Parameter variabler Länge zu deklarieren.

def sum_numbers(*args):
    total = 0
    for num in args:
        total += num
    return total

print(sum_numbers(1, 2, 3, 4))  # Output: 10

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{
      
      key}: {
      
      value}")

print_info(name="John", age=30, city="New York")
# Output:
# name: John
# age: 30
# city: New York

Bei der Verwendung von Funktionen können Sie Standardparameter und Parameter variabler Länge kombinieren, um Funktionsaufrufe prägnanter zu gestalten und unterschiedliche Parameterübergabesituationen zu bewältigen.

Wenn es um Parameter variabler Länge geht, bietet Python zwei Möglichkeiten: variable Positionsparameter (*args) und variable Schlüsselwortparameter (**kwargs).

1. Unbestimmte Positionsparameter (*Argumente):
   Unbestimmte Positionsparameter ermöglichen einer Funktion, eine beliebige Anzahl von Positionsargumenten zu akzeptieren und diese in ein Tupel zu packen. In Funktionsdefinitionen können Sie *argsdamit unbestimmte Positionsparameter deklarieren. Auf diese Weise können wir beim Aufruf der Funktion eine beliebige Anzahl von Positionsparametern an die Funktion übergeben, die automatisch in ein Tupel gepackt werden.

   def print_arguments(*args):
       for arg in args:
           print(arg)
   
   print_arguments("apple", "banana", "orange")
   # Output:
   # apple
   # banana
   # orange
   

   In diesem Beispiel print_argumentsnimmt die Funktion eine variable Anzahl von Positionsargumenten und packt diese Argumente in ein Tupel. Beim Aufruf der Funktion übergeben wir drei Positionsparameter, die zur Ausgabe in ein Tupel gepackt werden.

2. Unbestimmte Schlüsselwortargumente (**kwargs):
   Unbestimmte Schlüsselwortargumente ermöglichen einer Funktion, eine beliebige Anzahl von Schlüsselwortargumenten zu akzeptieren und sie in ein Wörterbuch (dict) zu packen. Verwenden Sie es in Funktionsdefinitionen, **kwargsum unbestimmte Schlüsselwortargumente zu deklarieren. Beim Aufruf einer Funktion können wir eine beliebige Anzahl von Schlüsselwortargumenten an die Funktion übergeben, die automatisch in ein Wörterbuch gepackt werden.

   def print_info(**kwargs):
       for key, value in kwargs.items():
           print(f"{
           
           key}: {
           
           value}")
   
   print_info(name="John", age=30, city="New York")
   # Output:
   # name: John
   # age: 30
   # city: New York
   

   In diesem Beispiel print_infoakzeptiert die Funktion eine variable Anzahl von Schlüsselwortargumenten und packt diese Argumente in ein Wörterbuch. Beim Aufruf der Funktion übergeben wir drei Schlüsselwortargumente, die zur Ausgabe in ein Wörterbuch gepackt werden.

3. Mischen von unbestimmten Positionsargumenten und unbestimmten Schlüsselwortargumenten:
   Wenn eine Funktion eine beliebige Anzahl von Positions- und Schlüsselwortargumenten gleichzeitig akzeptieren muss, können wir sie mischen *argsund abgleichen **kwargs.

   def mixed_arguments(*args, **kwargs):
       print("Positional arguments:")
       for arg in args:
           print(arg)
   
       print("Keyword arguments:")
       for key, value in kwargs.items():
           print(f"{
           
           key}: {
           
           value}")
   
   mixed_arguments("apple", "banana", "orange", country="USA", city="New York")
   # Output:
   # Positional arguments:
   # apple
   # banana
   # orange
   # Keyword arguments:
   # country: USA
   # city: New York
   

   In diesem Beispiel mixed_argumentsakzeptiert die Funktion eine variable Anzahl von Positions- und Schlüsselwortargumenten. Es packt Positionsargumente in Tupel und Schlüsselwortargumente in Wörterbücher und gibt sie in verschiedenen Typen aus.

Unbestimmte Positionsparameter und unbestimmte Schlüsselwortparameter bieten uns große Flexibilität und ermöglichen es Funktionen, eine Vielzahl unterschiedlicher Anzahlen und Arten von Parametern zu verarbeiten, wodurch sie allgemeiner und auf verschiedene Szenarien anwendbar werden.

Anonyme Funktion (Lambda-Funktion):

Anonyme Funktionen sind eine einfache Form von Funktionen, die häufig in der Programmierung verwendet werden und auch als Lambda-Funktionen (Lambda-Ausdrücke) bezeichnet werden. Auf diese Weise können kleine, temporäre Funktionen erstellt werden, die nicht benannt werden müssen. Im Gegensatz zu regulären Funktionsdefinitionen (def-Anweisungen) werden anonyme Funktionen mit dem Schlüsselwort lambda definiert und normalerweise verwendet, wenn eine einfache Funktion erforderlich ist, aber keine vollständige Funktion definiert ist.

Die Syntax einer anonymen Funktion lautet wie folgt:

lambda arguments: expression

Dabei argumentshandelt es sich um die Funktionsparameterliste und expressioneinen einfachen Ausdruck für den Funktionskörper. Eine anonyme Funktion gibt das Ergebnis eines Ausdrucks ohne explizite Return-Anweisung zurück.

Hier ist ein Beispiel, das die Summe zweier Zahlen mithilfe einer anonymen Funktion berechnet:

add = lambda x, y: x + y
result = add(3, 5)
print(result)  # Output: 8

In diesem Beispiel definieren wir eine anonyme Funktion add, die zwei Argumente x und y akzeptiert und deren Summe zurückgibt. Dann rufen wir die anonyme Funktion auf add(3, 5), die 8 zurückgibt.

Anonyme Funktionen eignen sich für einfache Funktionsszenarien, die nur für kurze Zeit verwendet werden müssen. Aufgrund ihrer Einfachheit werden sie häufig in der funktionalen Programmierung oder bei bestimmten Gelegenheiten verwendet. Es ist zu beachten, dass die Verwendung anonymer Funktionen geeigneten Szenarien und geeigneten Maßstäben folgen sollte. Wenn sie zu komplex ist oder mehrere Zeilen Codelogik erfordert, sollten gewöhnliche benannte Funktionen (def-Anweisungen) verwendet werden.

Vergleich anonymer Funktion und gewöhnlicher Definition:

Anonyme Funktionen (Lambda-Funktionen) und gewöhnliche Funktionen ( defdurch Anweisungen definierte Funktionen) sind zwei verschiedene Arten, Funktionen in Python zu definieren. Sie weisen einige Unterschiede in den Verwendungsszenarien, der Syntax und der Funktionalität auf. Vergleichen wir sie:

1. Grammatik:

   • Gewöhnliche Funktion: Sie wird defdurch eine Anweisung definiert, die einen Funktionsnamen, eine Parameterliste und einen Funktionskörper haben kann.
   • Anonyme Funktion: lambdaMit Schlüsselwörtern definiert, kann nur einen Ausdruck enthalten, hat keinen Funktionsnamen und wird nur für einfache Funktionsszenarien verwendet.

2. Lesbarkeit:

   • Gewöhnliche Funktion: Aufgrund des Funktionsnamens und der relativ vollständigen grammatikalischen Struktur ist sie normalerweise einfacher zu verstehen und zu lesen.
   • Anonyme Funktion: Da es keinen Funktionsnamen gibt und nur einfache Ausdrücke enthalten kann, ist die Lesbarkeit relativ schlecht. Wird normalerweise für kurze, einfache funktionale Anforderungen verwendet.

3. Anzahl Parameter:

   • Gewöhnliche Funktion: Es kann eine beliebige Anzahl von Parametern vorhanden sein, und es können Standardparameter und Parameter variabler Länge verwendet werden.
   • Anonyme Funktion: Kann nur begrenzte Parameter akzeptieren und wird normalerweise in Szenarien mit nur wenigen einfachen Parametern verwendet.

4. Zu verwendende Szenen:

   • Gewöhnliche Funktion: Sie eignet sich für komplexe Funktionslogik, hohe Anforderungen an die Lesbarkeit und Anlässe, die mehrmals aufgerufen oder wiederverwendet werden müssen.
   • Anonyme Funktionen: Einfache Funktionen, die für den einmaligen oder vorübergehenden Gebrauch geeignet sind, insbesondere wenn Funktionen als Argumente an andere Funktionen übergeben oder in der funktionalen Programmierung verwendet werden.

Hier ist ein Beispiel, das die Verwendung normaler und anonymer Funktionen vergleicht:

# 普通函数
def add(x, y):
    return x + y

# 调用普通函数
result1 = add(3, 5)
print(result1)  # Output: 8

# 匿名函数
add_lambda = lambda x, y: x + y

# 调用匿名函数
result2 = add_lambda(3, 5)
print(result2)  # Output: 8

In diesem Beispiel definieren wir eine gewöhnliche Funktion addund eine anonyme Funktion add_lambda, die dieselbe Funktion haben und beide die Additionsoperation implementieren. Eine einfache Funktion kann mithilfe einer anonymen Funktion präziser definiert werden, ist jedoch möglicherweise etwas weniger lesbar als eine normale Funktion.

Zusammenfassend lässt sich sagen, dass anonyme Funktionen eine vereinfachte Form der Funktionsdefinition sind, die für einfache, einmalige Funktionsanforderungen geeignet ist, während gewöhnliche Funktionen eher für komplexe Funktionslogik geeignet sind, die mehrere Aufrufe oder Wiederverwendung erfordert. Die Auswahl einer geeigneten Funktionsdefinitionsmethode hängt von spezifischen Programmierszenarien und -anforderungen ab.

Python-Modul

Ein Python-Modul ist eine Möglichkeit zum Organisieren und Wiederverwenden von Code, bei dem es sich um eine Datei handelt, die Python-Definitionen und -Anweisungen enthält. Module können Funktionen, Variablen, Klassen usw. enthalten, die importiert und in anderen Python-Programmen verwendet werden können. Einer der Vorteile der Verwendung von Modulen besteht darin, dass Code in logische Einheiten aufgeteilt werden kann, um die Wartbarkeit und Wiederverwendbarkeit des Codes zu verbessern.

So importieren Sie Module

[from 模块名] import [模块 类 变量函数] [as 别名]

1. import 模块名:
   Dies ist die einfachste Importmethode, die das gesamte Modul in den aktuellen Namespace importiert. Um die Funktionen im Modul nutzen zu können, müssen Sie 模块名.功能名die Methode Zugriff verwenden. Beispiel: import math, und rufen Sie dann math.sqrt()die Quadratwurzelfunktion mit auf.

import math
print(math.sqrt(16))  # 调用math模块的sqrt()函数计算平方根

2. from 模块名 import 类、变量、方法等:
   Mit dieser Methode können Sie gezielt bestimmte Klassen, Variablen oder Methoden im Modul in den aktuellen Namespace importieren, anstatt das gesamte Modul. Importierte Namen können direkt verwendet werden, ohne den Modulnamen voranzustellen. Beispiel: from math import sqrt, pi, dann können Sie sqrt()und verwenden pi.

from math import sqrt, pi
print(sqrt(16))  # 直接调用sqrt()函数计算平方根
print(pi)        # 直接输出导入的pi常量的值

3. from 模块名 import *:
   Diese Methode importiert alle öffentlichen Namen (die nicht mit beginnen) im Modul _in den aktuellen Namespace. Obwohl es den Zugriff erleichtert, ist es anfällig für Namenskonflikte und der Code ist nicht einfach zu warten, sodass es nicht für Produktionscode empfohlen wird.

from math import *
print(sqrt(16))  # 直接调用sqrt()函数计算平方根
print(pi)        # 直接输出导入的pi常量的值

4. import 模块名 as 别名:
   Mithilfe von asSchlüsselwörtern können Sie einen Alias ​​für das Modul angeben, sodass Sie den Alias ​​verwenden können, um im Code auf das Modul zu verweisen. Dies ist nützlich, wenn Sie Namenskollisionen vermeiden oder Modulnamen vereinfachen möchten. Zum Beispiel: , mit dem dann die Array-Funktionen von NumPy aufgerufen import numpy as npwerden können .np.array()

import numpy as np
arr = np.array([1, 2, 3])  # 使用别名np调用NumPy模块的array()函数创建数组

5. from 模块名 import 功能名 as 别名:
   Diese Methode importiert bestimmte Funktionen in das Modul und gibt ihnen einen Alias. Diese Funktionen können direkt über Aliase aufgerufen werden, ohne dass der ursprüngliche Name oder Modulname vorangestellt wird. Beispiel: from math import sqrt as square_root, dann können Sie square_root()stattdessen verwenden sqrt().

from math import sqrt as square_root
print(square_root(16))  # 使用别名square_root调用sqrt()函数计算平方根

Hinweis: Bei der tatsächlichen Programmierung wird empfohlen, die Form von import 模块名„or“ zu verwenden from 模块名 import 功能名und diese zu vermeiden from 模块名 import *, da letzteres zu unvorhersehbaren Problemen führen kann. Gleichzeitig wird aus Gründen der Lesbarkeit und Wartbarkeit des Codes empfohlen, sinnvolle Aliase für importierte Module und Funktionen zu verwenden.

Verglichen:

1 und 3

Der Unterschied ist wie folgt:

1. import 模块名:
   Diese Importmethode importiert das gesamte Modul in den aktuellen Namespace. Sie müssen 模块名.功能名die Methode verwenden, um auf die Funktionen im Modul zuzugreifen. Beispielsweise import mathwird das Modul importiert mathund math.sqrt()die Quadratwurzelfunktion mit aufgerufen.

2. from 模块名 import *:
   Diese Importmethode importiert alle öffentlichen Namen (die nicht mit beginnen) im Modul _in den aktuellen Namespace. Öffentlich bedeutet alle Variablen, Funktionen, Klassen usw. im Modul, mit Ausnahme _privater Mitglieder, die mit beginnen. Auf diese Weise kann der importierte Name direkt verwendet werden, ohne ihm den Modulnamen voranzustellen. Beispielsweise from math import *werden mathalle öffentlichen Mitglieder im Modul importiert und können dann direkt sqrt()verwendet werden pi, anstatt math.sqrt()and zu schreiben math.pi.

Hauptunterschied:

• Bei der ersten Methode müssen Sie die Methode verwenden, 模块名.功能名um auf die Funktion im Modul zuzugreifen, und bei der dritten Methode können Sie direkt den importierten Namen verwenden, um auf die Funktion zuzugreifen, wodurch die Verwendung des Modulnamenpräfixes vermieden wird.
• Die erste Methode ist sicherer als die dritte Methode, da alle öffentlichen Mitglieder im Modul mit der dritten Methode importiert werden, was leicht zu Namenskonflikten führen kann und nicht für die Verwendung im Produktionscode empfohlen wird. Die erste Methode importiert nur das gesamte Modul und verwendet das Modulnamenpräfix, um das Problem von Namenskonflikten zu vermeiden.

Aus Gründen der Lesbarkeit und Wartbarkeit des Codes wird daher empfohlen, die erste Methode ( import 模块名) oder die zweite Methode ( from 模块名 import 功能名) anstelle der dritten Methode zu verwenden.

from 模块名 import 类、变量、方法等Im Hinblick auf die Geschwindigkeit des Modulimports ist die zweite Importmethode ( ) normalerweise schneller als die dritte Methode ( from 模块名 import *).

Die Gründe sind wie folgt:

1. Die zweite Methode gibt eindeutig die Klasse, Variable oder Methode an, die importiert werden soll, sodass der Python-Interpreter nur den angegebenen Inhalt importiert, wodurch der Arbeitsaufwand und die Speichernutzung des Imports reduziert werden.
2. Bei der dritten Möglichkeit werden alle öffentlichen Mitglieder des Moduls importiert, was zu mehr Speicherverbrauch und Ladezeit führen kann, wenn das Modul groß ist oder über viele Funktionen verfügt.
3. Bei der zweiten Methode werden nur die explizit angegebenen Funktionen in den aktuellen Namespace importiert, wodurch der Import unnötiger Funktionen vermieden und die Klarheit und Wartbarkeit des Codes verbessert werden kann.

Während der 2. Weg in Bezug auf die Geschwindigkeit möglicherweise schneller ist, ist die Importgeschwindigkeit in der Praxis normalerweise nicht der Hauptengpass bei der Leistung. Es ist wichtiger, Importe auszuwählen, die für die Klarheit und Lesbarkeit des Codes geeignet sind. Daher wird empfohlen, im Produktionscode die zweite Methode zu verwenden und die zu importierenden Funktionen explizit anzugeben und die Verwendung der dritten Methode zum Importieren aller Elemente zu vermeiden. Dadurch bleibt der Code sauber und performant.

Gesamtanalyse der Vor- und Nachteile;

Vergleichen wir diese fünf Importmethoden:

1. import 模块名::

   • Um ein gesamtes Modul zu importieren, müssen Sie den Modulnamen voranstellen, um auf die darin enthaltenen Funktionen zugreifen zu können.
   • Diese Methode kann im Code mehrmals verwendet werden, um dasselbe Modul zu importieren, ohne dass es zu Konflikten kommt.
   • Geeignet für Fälle, in denen das Modul groß ist oder mehrere Funktionen erforderlich sind.

2. from 模块名 import 类、变量、方法等::

   • Importieren Sie selektiv bestimmte Funktionen in ein Modul, auf die direkt über den importierten Namen zugegriffen werden kann, ohne den Modulnamen voranzustellen.
   • Um den Code einfacher zu gestalten, können mehrere Funktionen gleichzeitig importiert werden.
   • Die Vermeidung der Verwendung von Modulnamenpräfixen eignet sich für Situationen, in denen nur eine kleine Anzahl von Funktionen erforderlich ist.

3. from 模块名 import *::

   • Importiert alle öffentlichen Namen im Modul, nicht für Produktionscode empfohlen.
   • Es kann leicht zu Namenskonflikten und Schwierigkeiten bei der Codepflege kommen. Vermeiden Sie daher die Verwendung dieser Methode.

4. import 模块名 as 别名::

   • Weisen Sie dem Modul einen Alias ​​zu und verwenden Sie den Alias, um auf die Funktionen im Modul zu verweisen.
   • Nützlich, wenn der Modulname lang ist oder Sie Namenskollisionen vermeiden müssen.

5. from 模块名 import 功能名 as 别名::

   • Importieren Sie eine bestimmte Funktion in ein Modul und geben Sie einen Alias ​​an, um die Funktion direkt über den Alias ​​aufzurufen.
   • Sie können Ihren Code vereinfachen, indem Sie den Originalnamen oder das Modulnamenpräfix vermeiden.

Insgesamt werden die erste und die zweite Methode am häufigsten verwendet. Der erste Weg eignet sich zum Importieren des gesamten Moduls und der zweite Weg eignet sich zum selektiven Importieren bestimmter Funktionen. Der dritte Weg wird nicht empfohlen, da er potenzielle Probleme verursachen kann. Die 4. und 5. Methode eignen sich für Situationen, in denen Aliase erforderlich sind, was die Lesbarkeit und Prägnanz des Codes verbessern kann. Im Allgemeinen hängt die Auswahl einer geeigneten Importmethode von der spezifischen Situation und den Anforderungen des Codes ab.

Benutzerdefinierte Module:

Ein benutzerdefiniertes Modul bezieht sich auf eine Datei mit Python-Code, der von einem Benutzer erstellt wurde und wiederverwendbare Codeblöcke wie Funktionen, Klassen, Variablen usw. enthalten kann. Der Hauptzweck benutzerdefinierter Module besteht darin, Code in logischen Einheiten zu organisieren, um ihn zu importieren und in verschiedenen Python-Programmen zu verwenden und so die Wartbarkeit und Wiederverwendbarkeit des Codes zu verbessern.

Die Schritte zum Erstellen eines benutzerdefinierten Moduls sind wie folgt:

1. Schreiben Sie Python-Code und speichern Sie ihn .pyals Datei mit der Erweiterung . Der Dateiname wird zum Namen des Moduls.
2. Legen Sie die gespeicherte Datei in einem Verzeichnis ab, in dem der Python-Interpreter sie finden kann, z. B. im aktuellen Arbeitsverzeichnis oder im Suchpfad der Python-Standardbibliothek.

Hier ist ein Beispiel für ein benutzerdefiniertes Modul:

Angenommen, wir erstellen ein my_utils.pybenutzerdefiniertes Modul namens , das einige nützliche Funktionen enthält:

# my_utils.py

def square(x):
    """计算一个数的平方"""
    return x * x

def add(a, b):
    """计算两个数的和"""
    return a + b

PI = 3.14159

Anschließend können wir dieses benutzerdefinierte Modul importieren und in anderen Python-Programmen verwenden:

# 导入整个模块
import my_utils

print(my_utils.square(5))  # 输出：25
print(my_utils.add(3, 7))  # 输出：10
print(my_utils.PI)         # 输出：3.14159

# 导入特定的函数和变量
from my_utils import square, PI

print(square(8))   # 输出：64
print(PI)          # 输出：3.14159

Vorsichtsmaßnahmen:

1. Der Dateiname eines benutzerdefinierten Moduls sollte .pymit z. B. enden my_utils.py.
2. Stellen Sie sicher, dass sich das benutzerdefinierte Modul im selben Verzeichnis oder unter dem richtigen Python-Suchpfad befindet wie das Python-Programm, das es verwendet.
3. Wenn Sie ein gesamtes Modul mithilfe importeiner Anweisung importieren, müssen Sie das Modulnamenpräfix verwenden, um auf Funktionen und Variablen im Modul zuzugreifen.
4. Wenn Sie das Formular zum Importieren bestimmter Funktionen und Variablen verwenden from 模块名 import 功能名, können Sie den Funktionsnamen direkt verwenden, ohne das Modulnamenpräfix zu verwenden.

Vorsichtsmaßnahmen:

Wenn Sie mehrere Module importieren und in diesen Modulen Funktionen, Klassen oder Variablen mit demselben Namen vorhanden sind, kann es zu Namenskonflikten kommen. Zu diesem Zeitpunkt kann der Python-Interpreter möglicherweise nicht unterscheiden, welches Modul die gleichnamige Funktion verwenden soll, was zu Codefehlern oder unerwarteten Ergebnissen führt.
Wenn in Python verschiedene Module Funktionen mit demselben Namen importieren (Funktionen, Klassen usw.) und diese Module erfolgreich in dasselbe Skript importiert werden, überschreiben die später importierten Module die Funktionen mit demselben Namen in den früher importierten Modulen. Dieses Verhalten wird als „Namenskonflikt“ (Namenskonflikt) bezeichnet.

Bei einem Namenskonflikt überschreibt eine Funktion mit demselben Namen in einem später importierten Modul eine Funktion mit demselben Namen in einem zuvor importierten Modul. Dies bedeutet, dass bei Verwendung der Funktion in einem Skript tatsächlich die Version im zuletzt importierten Modul verwendet wird.

Lassen Sie uns dieses Konzept anhand eines Beispiels veranschaulichen. Angenommen, es gibt zwei Module module_a.pyund module_b.py, die beide eine Funktion mit demselben Namen definieren common_function:

# module_a.py
def common_function():
    print("This is common function from module_a")

# module_b.py
def common_function():
    print("This is common function from module_b")

Jetzt importieren wir beide Module in einem Skript und rufen auf common_function:

from module_a import common_function
from module_b import common_function

common_function()

Die Ausgabe wird sein:

This is common function from module_b

weil module_b.pyes zuletzt importiert wird und eine gleichnamige Funktion in common_functionüberschreibt . module_a.pyDies liegt daran, dass später importierte Module Mitglieder mit demselben Namen in früher importierten Modulen überschreiben.

Um dieses Problem der Namenskollision zu vermeiden, werden einige Best Practices empfohlen:

1. Aliase verwenden : Beim Importieren von Funktionen mit demselben Namen können Sie einer oder mehreren davon einen Alias ​​zuweisen, um Namenskonflikte zu vermeiden. Zum Beispiel: from module_a import common_function as a_function.

2. Expliziter Import : Vermeiden Sie die Verwendung from module import *dieser Methode, sondern importieren Sie die erforderlichen Funktionen explizit. Zum Beispiel: from module_a import common_functionund from module_b import common_function.

3. Namespaces : Wenn der Name eines Moduls gebräuchlich ist und möglicherweise mit anderen Modulen in Konflikt steht, können Sie den Namespace des Moduls verwenden, um darin enthaltene Funktionen aufzurufen. Beispiel: import module_aund import module_b, dann verwenden Sie module_a.common_function()und, module_b.common_function()um die entsprechende Funktion aufzurufen.

Um diese Situation zu vermeiden, können Sie Folgendes tun:

1. Verwenden Sie den vollständigen Modulnamen:
   Wenn Sie die Funktion mit demselben Namen aufrufen, können Sie den vollständigen Modulnamen als Präfix verwenden, um eindeutig anzugeben, in welchem ​​Modul die Funktion verwendet werden soll, um Konflikte zu vermeiden.

Beispiel:

import module1
import module2

print(module1.some_function())  # 调用module1中的函数
print(module2.some_function())  # 调用module2中的函数

2. Verwenden Sie einen Alias ​​(als Alias):
   Geben Sie einen Alias ​​für das importierte Modul oder die importierte Funktion mit demselben Namen an und verwenden Sie den Alias, um Funktionen mit demselben Namen in verschiedenen Modulen zu unterscheiden.

Beispiel:

import module1 as m1
import module2 as m2

print(m1.some_function())  # 调用module1中的函数
print(m2.some_function())  # 调用module2中的函数

3. Verwenden Sie die from-import-Anweisung:
   Wenn Sie nur einige Funktionen importieren müssen und diese Funktionen denselben Namen haben, können Sie die from-import-Anweisung verwenden und einen Alias ​​für die importierten Funktionen angeben.

Beispiel:

from module1 import some_function as func1
from module2 import some_function as func2

print(func1())  # 调用module1中的函数
print(func2())  # 调用module2中的函数

Mit einer der oben genannten Methoden können Sie Namenskonflikte zwischen Modulen vermeiden und sicherstellen, dass Ihr Code ordnungsgemäß ausgeführt wird und die erwarteten Ergebnisse liefert. Bei der tatsächlichen Programmierung wird empfohlen, sinnvolle Aliase für importierte Module und Funktionen zu verwenden, um die Lesbarkeit des Codes und die Wartungsfreundlichkeit zu erhöhen.

__main__ Variable:

In Python __main__handelt es sich um eine spezielle integrierte Variable (integrierte Variable), die angibt, ob das aktuell ausgeführte Skript das Hauptprogramm (Hauptprogramm) ist. Wenn der Python-Interpreter ein Skript ausführt, legt er bestimmte Variablen für das Skript fest, darunter __name__. Wenn ein Python-Skript direkt ausgeführt wird, __name__wird der Wert der Variablen auf gesetzt __main__, andernfalls, wenn dieses Skript als Modul in andere Skripte importiert wird, __name__ist der Wert der Variablen der Name des Moduls.

__name__Genauer gesagt: Wenn Sie ein Python-Skript direkt in der Befehlszeile ausführen, setzt der Python-Interpreter die Variable des Skripts auf __main__, um anzuzeigen, dass das Skript das Hauptprogramm ist. Auf diese Weise können Sie __name__einen bestimmten Codeblock ausführen, indem Sie den Wert überprüfen. Dies ist beim Erstellen wiederverwendbarer Module und Skripte sehr nützlich, da Sie so unterschiedlichen Code in unterschiedlichen Kontexten ausführen können.

Angenommen, Sie haben ein example.pySkript mit folgendem Namen:

def do_something():
    print("Doing something!")

print("This will always be executed!")

if __name__ == "__main__":
    print("This will only be executed when the script is run directly.")
    do_something()

Wenn Sie es auf der Befehlszeile ausführen python example.py, erhalten Sie die folgende Ausgabe:

This will always be executed!
This will only be executed when the script is run directly.
Doing something!

Wenn Sie ihn jedoch in ein anderes Skript importieren example.py, if __name__ == "__main__":wird der Code im Block nicht ausgeführt. Angenommen, Sie haben ein main.pySkript mit dem folgenden Inhalt:

import example

print("This is the main program.")

Wenn Sie ausführen python main.py, erhalten Sie die folgende Ausgabe:

This will always be executed!
This is the main program.

Wie Sie sehen, wird der Code im Block example.pyin if __name__ == "__main__":nicht ausgeführt, da er main.pyals Modul in importiert wird.

Zusammenfassend lässt sich sagen, dass __main__eine Variable eine spezielle integrierte Variable in Python ist, mit der ermittelt wird, ob das aktuelle Skript das Hauptprogramm ist. Durch Überprüfen __name__des Werts können Sie bestimmte Codeblöcke ausführen, wenn das Skript als Hauptprogramm ausgeführt wird, und diese Codeblöcke nicht ausführen, wenn sie als Modul importiert werden.

alle :

__all__ist eine weitere spezielle Variable in Python. Es handelt sich um eine optionale Liste, die definiert, welche Mitglieder des Moduls (Variablen, Funktionen, Klassen usw.) from module import *bei der Verwendung von Anweisungen importiert werden sollen. Diese Funktion wird hauptsächlich zur Steuerung der öffentlichen Schnittstelle eines Moduls verwendet, um zu verhindern, dass versehentlich unnötige Mitglieder importiert werden.

__all__Wenn Sie eine Variable in einem Modul definieren , schränkt sie ein from module import *, was importiert wird, wenn Sie die Importanweisung verwenden. Wenn keine __all__Variable definiert ist, from module import *importiert use alle globalen Namen (d. h. öffentliche Mitglieder) in das Modul, die nicht mit einem Unterstrich beginnen. Dies ist jedoch keine empfohlene Vorgehensweise, da dadurch zu viele unnötige Inhalte importiert werden, was zu Namenskonflikten oder unerwünschten Ereignissen führen kann Effekte.

Um ein Beispiel zu sehen, nehmen wir an, Sie haben ein example_module.pyModul mit dem Namen und folgendem Inhalt:

# example_module.py

def function_a():
    print("Function A")

def function_b():
    print("Function B")

def _private_function():
    print("Private Function")

__all__ = ["function_a", "function_b"]

Im obigen Beispiel __all__wird die Variable auf eine Liste gesetzt, "function_a"die "function_b"zwei Zeichenfolgenelemente enthält. Dies bedeutet, dass beim from example_module import *Importieren eines Moduls mithilfe der Anweisung nur die Funktion function_aund function_bimportiert werden, _private_functionnicht jedoch, da sie mit einem Unterstrich beginnt und als private Funktion betrachtet wird.

In einem anderen Skript können wir es wie folgt verwenden example_module:

from example_module import *

function_a()  # Output: Function A
function_b()  # Output: Function B
_private_function()  # NameError: name '_private_function' is not defined

Beachten Sie, dass die Verwendung zwar __all__einschränken kann, was importiert wird, sie jedoch nur from module import *bei Verwendung der Anweisung wirksam wird. Die empfohlene Vorgehensweise besteht darin, erforderliche Mitglieder explizit zu importieren, z. B.: from example_module import function_a, function_b, anstatt from example_module import *. Dies vermeidet Namenskonflikte und macht den Code klarer und wartbarer.

So importieren Sie ein Python-Paket:

In Python verwenden Sie zum Importieren eines Pakets importdie Anweisung. Ein Paket ist ein Verzeichnis mit mehreren Modulen, mit dem Sie verwandte Funktionsmodule organisieren und verwalten können. Das Paketverzeichnis muss eine __init__.pyDatei mit dem Namen enthalten, die leer sein oder Initialisierungscode für das Paket enthalten kann.

Angenommen, Sie haben ein my_packagePaket mit folgender Verzeichnisstruktur:

my_package/
    __init__.py
    module_a.py
    module_b.py
    subpackage/
        __init__.py
        module_c.py

Sehen wir uns nun an, wie man dieses Paket und die darin enthaltenen Module importiert:

1. So importieren Sie ein gesamtes Paket oder Unterpaket:

import my_package

# 使用包中的模块
my_package.module_a.some_function()
my_package.subpackage.module_c.another_function()

2. Spezifische Module importieren:

from my_package import module_a, subpackage.module_c

# 使用特定的模块
module_a.some_function()
subpackage.module_c.another_function()

3. Verwenden Sie asSchlüsselwörter, um importierte Pakete oder Module mit Aliasnamen zu versehen:

import my_package as mp

mp.module_a.some_function()
mp.subpackage.module_c.another_function()

4. from ... import ...Importieren Sie bestimmte Mitglieder eines Pakets oder Moduls mit der folgenden Syntax:

from my_package.module_a import some_function
from my_package.subpackage.module_c import another_function

some_function()
another_function()

Bitte wählen Sie die entsprechende Importmethode entsprechend Ihren tatsächlichen Anforderungen. Die Verwendung von Paketen kann Ihnen dabei helfen, Ihren Code besser zu organisieren, Namenskonflikte zu vermeiden und eine höhere Ebene der Modulverwaltung bereitzustellen.