Python: Vom Anfänger zum Profi (Teil 3)

Funktionen in Python

Funktionen sind wiederverwendbare Codeblöcke, die eine bestimmte Aufgabe ausführen. Sie helfen dabei, Ihren Code zu organisieren, ihn lesbarer zu machen und Wiederholungen zu reduzieren. Nehmen Sie zum Beispiel das Schreiben von Codes, die sehr lang und sehr schwer zu lesen sein können, oder finden Sie heraus, was jede Zeile tut, vor allem, wenn Sie einen Wert aufrufen müssen.

    def greet(name):

Warum Funktionen verwenden?

Stellen Sie sich vor, Sie kochen eine komplexe Mahlzeit. Anstatt zu versuchen, alles auf einmal zu erledigen, unterteilen Sie den Prozess in kleinere Aufgaben: Gemüse hacken, Soße zubereiten, Hauptgericht kochen usw. Jede dieser Aufgaben könnte man sich als Funktion in der Programmierung vorstellen.

Jeder fügt einen Abschnitt ein, der aufgerufen werden kann, wenn wir ihn brauchen, ohne die ganze Mahlzeit mit dem ganzen Code verstopfen zu müssen, wodurch unser Code einfacher zu lesen ist und weniger Fehler verursacht.

Funktionen ermöglichen uns Folgendes:

• Code organisieren: Genau wie das Organisieren von Zutaten und Schritten in einem Rezept helfen uns Funktionen dabei, unseren Code in überschaubare, logische Teile zu organisieren.
• Code wiederverwenden: Wenn Sie dieselbe Aufgabe mehrmals ausführen müssen, können Sie eine Funktion erstellen und diese bei Bedarf aufrufen, anstatt immer wieder denselben Code zu schreiben.
• Komplexe Aufgaben vereinfachens: Große Probleme können in kleinere, besser beherrschbare Teile zerlegt werden.
• Verbesserung der Lesbarkeit: Gut benannte Funktionen erleichtern das Verständnis von Code, etwa klare Anweisungen in einem Rezept.

Beispiele aus dem wirklichen Leben:

• Rechner-App: Jede Operation (Addieren, Subtrahieren, Multiplizieren, Dividieren) könnte eine separate Funktion sein.
• Social-Media-Beitrag: Funktionen können das Posten von Text, das Hochladen von Bildern oder das Hinzufügen von Hashtags übernehmen.
• Online-Shopping: Funktionen können die Gesamtkosten berechnen, Rabatte anwenden oder Zahlungen verarbeiten.

Sehen wir uns nun an, wie man eine Funktion erstellt und definiert:

def greet(name):
    """
    This function takes a name and returns a greeting message.
    """
    return f"Hello, {name}! Welcome to Python programming."

Dies im Detail

• def teilt Python mit, dass wir eine Funktion definieren.
• Greet ist der Funktionsname (Sie können den Namen beliebig ändern!)
• (Alex) ist der Parameter – ein Platzhalter für die Daten, die die Funktion empfangen wird

Der eingerückte Block ist der Funktionskörper – was die Funktion tut.

return specifies what the function gives back when it's done

Verwenden (Aufrufen) einer Funktion

# Calling the function
message = greet("Alex")
print(message)


greet("Alex"):

• Hier „rufen“ oder „verwenden“ wir die Funktion.
• Wir sagen: „Hey, Funktion namens ‚Greet‘, bitte nimm ‚Alex‘ als Eingabe.“
• „Alex“ ist das Argument. Es ist, als würde man der Funktion eine bestimmte Information geben, mit der sie arbeiten kann.

Was passiert innerhalb der Funktion:

• Die Funktion nimmt „Alex“ und fügt es dort ein, wo {name} in der Begrüßung steht.

• So entsteht die Nachricht: „Hallo, Alex! Willkommen bei der Python-Programmierung.“

  message = ...:

• Was die Funktion zurückgibt (zurückgibt), speichern wir in einer Variablen namens „Nachricht“.

• Jetzt enthält „Nachricht“ also den Text „Hallo, Alex! Willkommen bei der Python-Programmierung.“

  Drucken (Nachricht):

• Dadurch wird einfach der Inhalt der „Nachricht“ auf dem Bildschirm angezeigt.

„Dies würde Folgendes ausgeben: „Hallo, Alex! Willkommen bei der Python-Programmierung.“
Hier ist „Alex“ ein Argument – ​​die tatsächlichen Daten, die wir an die Funktion übergeben.

Komplexeres Beispiel:
Erstellen wir eine Funktion, die die Gesamtkosten der Artikel in einem Warenkorb berechnet:

def calculate_total(items, tax_rate):
    subtotal = sum(items)
    tax = subtotal * tax_rate
    total = subtotal + tax
    return total

    # Using the function
    cart = [10.99, 5.50, 8.99]
    tax = 0.08  # 8% tax
    total_cost = calculate_total(cart, tax)
    print(f"Your total including tax is: ${total_cost:.2f}")

In diesem Beispiel habe ich mehr als ein Argument untersucht, indem ich „items“ und „tax_rate“ als Argumente in unsere Funktion eingefügt und einige klare Parameter festgelegt habe, denen unsere Funktion folgen soll.

• subtotal = sum(items) – während subtotal eine Variable oder ein Platzhalter für den Wert ist, den es berechnet, also die Summe (denken Sie daran, sum ist eine Bibliothek in Python, die die Summe eines „Startwerts“ zurückgibt (Standard). : 0) plus eine Iterable von Zahlen) von Elementen.

• tax = subtotal * tax_rate Hier nehmen wir „tax“ als neue Variable und sagen in dieser Variablen, dass wir die vorherige Variable „subtotal(sum(items)) * tax_rate“ verwenden, die ein Platzhalter für jede Variable ist Zahl, die der Benutzer eingibt.

• Gesamt = Zwischensumme + Steuer; Dies ist die Summe der beiden Variablen Zwischensumme und Steuer.

Sobald wir die Funktion „calcture_total(cart, tax)“ aufrufen, summiert der Warenkorb alle Werte im Warenkorb (10,99+5,50+8,99), und dann multiplizieren wir den Wert mit 0,08, um die Steuer zu erhalten, und addieren sie dann um die Gesamtsumme zu erhalten.

Unsere Druckanweisung verwendet eine formatierte Zeichenfolge, und dann sagten wir, dass „total_cost“ auf eine 2f-Dezimalstelle reduziert werden sollte.

Wichtige Punkte, die Sie beachten sollten

• Function Names: Use clear, descriptive names. calculate_total is better than calc or function1.
• Parameters: These are the inputs your function expects. In calculate_total, we have two: items and tax_rate.
• Return Statement: This specifies what the function gives back. Not all functions need to return something, but many do.
• Indentation: Everything inside the function must be indented. This is how Python knows what's part of the function.
• Calling the Function: We use the function name followed by parentheses containing the arguments.

Practice Exercise:
Try creating a function that takes a person's name and age, and returns a message like "Hello [name], you will be [age+10] in 10 years." This will help you practice using multiple parameters and doing calculations within a function.

Python Data Structures: Lists, Sets, Tuples, and Dictionaries

Python offers several built-in data structures that allow programmers to organize and manipulate data efficiently. we'll explore four essential data structures: lists, sets, tuples, and dictionaries. Each of these structures has unique characteristics and use cases.

Lists
Lists are the most commonly used data structure in Python. They are ordered, mutable collections that can contain elements of different data types. You can create a list using square brackets:

fruits = ["apple", "banana", "cherry"]

Lists maintain the order of elements, allowing you to access them by their index. For example, fruits[0] would return "apple". This ordering makes lists ideal for situations where the sequence of elements matters, such as maintaining a playlist or a to-do list.

One of the key advantages of lists is their mutability. You can easily add, remove, or modify elements:

fruits.append("date")  # Adds "date" to the end
fruits[1] = "blueberry"  # Replaces "banana" with "blueberry"

Lists also support various operations like slicing, concatenation, and list comprehensions, making them extremely versatile. Use lists when you need an ordered collection that you can modify and when you want to allow duplicate elements.

To learn more about lists, check this guide by Bala Priya C (Lists in Python – A Comprehensive Guide)

Sets
Sets are unordered collections of unique elements. You can create a set using curly braces or the set() function.

unique_numbers = {1, 2, 3, 4, 5}

The defining feature of sets is that they only store unique elements. If you try to add a duplicate element, it will be ignored. This makes sets perfect for removing duplicates from a list or for membership testing.

Sets also support mathematical set operations like union, intersection, and difference:

set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1.union(set2))  # {1, 2, 3, 4, 5}

While sets are mutable (you can add or remove elements), they must be immutable. Use sets when you need to ensure uniqueness of elements and don't care about their order.

To learn more about sets, check this guide on w3school

Tuples
Tuples are similar to lists in that they are ordered sequences, but they are immutable – once created, they cannot be modified. You create a tuple using parentheses:

coordinates = (10, 20)

The immutability of tuples makes them useful for representing fixed collections of items, like the x and y coordinates in our example. They're also commonly used to return multiple values from a function.

def get_user_info():
    return ("Alice", 30, "New York")

name, age, city = get_user_info()

Tuples can be used as dictionary keys (unlike lists) because of their immutability. Use tuples when you have a collection of related items that shouldn't change throughout your program's execution.

If you need more insight on tuples, Geeksforgeeks has a very informative guide on it

Dictionaries: Key-Value Pairs
Dictionaries are unordered collections of key-value pairs. They provide a way to associate related information. You create a dictionary using curly braces with key-value pairs:

person = {"name": "Alex", "age": 25, "city": "San Francisco"}

Dictionaries allow fast lookup of values based on their keys. You can access, add, or modify values using their associated keys:

 print(person["name"])  # Prints "Alex"
 person["job"] = "Engineer"  # Adds a new key-value pair

Dictionaries are incredibly useful for representing structured data, similar to JSON. They're also great for counting occurrences of items or creating mappings between related pieces of information.

I love what Simplilearn did with this guide on dictionary; find it here.

Choosing the Right Data Structure

When deciding which data structure to use, consider these factors:

• Müssen Sie für Ordnung sorgen? Wenn ja, ziehen Sie Listen oder Tupel in Betracht.
• Müssen Sie die Sammlung ändern? Wenn ja, verwenden Sie Listen oder Wörterbücher.
• Müssen Sie Einzigartigkeit sicherstellen? Wenn ja, verwenden Sie Sets.
• Müssen Sie Werte mit Schlüsseln verknüpfen? Wenn ja, verwenden Sie Wörterbücher.
• Benötigen Sie eine unveränderliche Sequenz? Wenn ja, verwenden Sie Tupel.

Wenn Sie diese Datenstrukturen verstehen und wissen, wann und wie sie verwendet werden, können Sie effizienteren und lesbareren Code schreiben. Mit zunehmender Erfahrung entwickeln Sie ein Gespür dafür, welche Struktur am besten zu Ihren spezifischen Bedürfnissen passt.

Denken Sie daran, dass die Flexibilität von Python es Ihnen ermöglicht, bei Bedarf zwischen diesen Strukturen zu konvertieren. Sie können beispielsweise eine Liste in einen Satz umwandeln, um Duplikate zu entfernen, und sie dann wieder in eine Liste umwandeln, wenn Sie die Reihenfolge beibehalten müssen. Diese Interoperabilität macht diese Datenstrukturen noch leistungsfähiger, wenn sie in Kombination verwendet werden.

Wie machen wir das? Finden Sie es heraus und posten Sie es in der Kommentarsitzung unserer Python-Lerngruppe.

Durch die Beherrschung von Listen, Mengen, Tupeln und Wörterbüchern verfügen Sie über eine solide Grundlage für die Bewältigung verschiedener Datenbearbeitungsaufgaben in Python. Im weiteren Verlauf Ihrer Programmierreise werden Sie noch speziellere Datenstrukturen entdecken, aber diese vier bleiben grundlegende Werkzeuge in Ihrem Python-Programmier-Toolkit.

Das obige ist der detaillierte Inhalt vonPython: Vom Anfänger zum Profi (Teil 3). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!