Einführung
Willkommen zum Lab über Pythons eingebaute Funktionen (built-in functions). Der Python-Interpreter stellt eine reichhaltige Sammlung von Funktionen und Typen bereit, die immer verfügbar sind, ohne dass Importe erforderlich sind. Diese Funktionen sind die grundlegenden Bausteine für die Durchführung gängiger Aufgaben, von der Datenmanipulation bis hin zu Ein-/Ausgabeoperationen.
In diesem Lab sammeln Sie praktische Erfahrungen mit einigen der wichtigsten eingebauten Funktionen, die in logische Gruppen unterteilt sind. Am Ende dieses Labs werden Sie in der Lage sein, diese Funktionen sicher zu verwenden, um effizienteren und lesbareren Python-Code zu schreiben.
Datentypkonvertierung und Inspektion
In diesem Schritt lernen Sie, zwischen verschiedenen Datentypen zu konvertieren und Objekte mithilfe von Funktionen wie int(), str(), list(), dict(), type() und isinstance() zu inspizieren. Diese sind grundlegend für die Datenverarbeitung in Python.
Hinweis: Wenn Sie mit der Verwendung der WebIDE (ähnlich VS Code) nicht vertraut sind, lernen Sie dies zuerst in diesem Lab.
Öffnen Sie zuerst die Datei step1_conversion.py im Dateiexplorer auf der linken Seite. Wir werden unseren Code in dieser Datei schreiben.
Fügen Sie den folgenden Code zu step1_conversion.py hinzu. Dieser Code demonstriert, wie man einen String in einen Integer konvertiert, ein Tupel in eine Liste und eine Liste von Paaren in ein Dictionary. Er zeigt auch, wie man den Typ eines Objekts überprüft.
## step1_conversion.py
## int(): Gibt ein Integer-Objekt aus einer Zahl oder einem String zurück.
num_str = "123"
num_int = int(num_str)
print(f"String '{num_str}' als Integer: {num_int}")
## str(): Gibt eine String-Version eines Objekts zurück.
int_val = 456
str_val = str(int_val)
print(f"Integer {int_val} als String: '{str_val}'")
## list(): Erstellt eine neue Liste aus einem Iterable (iterierbares Objekt).
my_tuple = ('a', 'b', 'c')
my_list = list(my_tuple)
print(f"Tupel {my_tuple} als Liste: {my_list}")
## dict(): Erstellt ein neues Dictionary.
my_pairs = [('x', 1), ('y', 2)]
my_dict = dict(my_pairs)
print(f"Liste von Paaren {my_pairs} als Dict: {my_dict}")
## type(): Gibt den Typ eines Objekts zurück.
print(f"Typ von num_int: {type(num_int)}")
## isinstance(): Gibt True zurück, wenn das Objekt eine Instanz einer Klasse ist.
is_list = isinstance(my_list, list)
print(f"Ist my_list eine Instanz von list? {is_list}")
Speichern Sie nun die Datei und führen Sie sie im Terminal aus.
python3 step1_conversion.py
Sie sollten die folgende Ausgabe sehen, die bestätigt, dass die Datentypkonvertierungen und -inspektionen erfolgreich waren.
String '123' as integer: 123
Integer 456 as string: '456'
Tuple ('a', 'b', 'c') as list: ['a', 'b', 'c']
List of pairs [('x', 1), ('y', 2)] as dict: {'x': 1, 'y': 2}
Type of num_int: <class 'int'>
Is my_list an instance of list? True
Mathematische und Numerische Operationen
In diesem Schritt führen Sie gängige mathematische Berechnungen mithilfe eingebauter Funktionen durch. Wir behandeln abs(), sum(), min(), max(), round() und pow().
Öffnen Sie die Datei step2_math.py im Dateiexplorer.
Fügen Sie den folgenden Code zu step2_math.py hinzu. Dieses Skript demonstriert, wie verschiedene mathematische Funktionen auf Zahlen und Listen von Zahlen angewendet werden.
## step2_math.py
numbers = [5, -10, 15, -2, 8]
## abs(): Gibt den Absolutwert einer Zahl zurück.
print(f"Absolutwert von -10: {abs(-10)}")
## sum(): Summiert die Elemente eines Iterables.
print(f"Summe der Zahlen {numbers}: {sum(numbers)}")
## min(): Gibt das kleinste Element in einem Iterable zurück.
print(f"Minimum der Zahlen: {min(numbers)}")
## max(): Gibt das größte Element in einem Iterable zurück.
print(f"Maximum der Zahlen: {max(numbers)}")
## round(): Gibt die auf eine angegebene Präzision gerundete Zahl zurück.
pi_approx = 3.14159
print(f"Runden von {pi_approx} auf 2 Dezimalstellen: {round(pi_approx, 2)}")
## pow(): Gibt die Basis hoch den Exponenten zurück.
print(f"2 hoch 3: {pow(2, 3)}")
Speichern Sie die Datei und führen Sie sie im Terminal aus.
python3 step2_math.py
Die Ausgabe sollte die Ergebnisse jeder mathematischen Operation anzeigen.
Absolute value of -10: 10
Sum of numbers [5, -10, 15, -2, 8]: 16
Minimum of numbers: -10
Maximum of numbers: 15
Rounding 3.14159 to 2 decimal places: 3.14
2 to the power of 3: 8
Arbeiten mit Sequenzen und Iterables
In diesem Schritt lernen Sie, wie man Sequenzen wie Listen und Tupel manipuliert und verarbeitet. Wir behandeln len(), sorted(), reversed(), enumerate(), map(), filter() und zip(). Viele dieser Funktionen geben Iteratoren zurück, welche effiziente, speichersparende Objekte sind.
Öffnen Sie die Datei step3_sequences.py.
Fügen Sie den folgenden Code zu step3_sequences.py hinzu. Dieses Skript demonstriert, wie man die Länge einer Liste ermittelt, sie sortiert, umkehrt und komplexere Transformationen mithilfe von map, filter und zip durchführt.
## step3_sequences.py
my_list = [3, 1, 4, 1, 5, 9]
print(f"Original list: {my_list}")
## len(): Gibt die Länge (die Anzahl der Elemente) eines Objekts zurück.
print(f"Length of the list: {len(my_list)}")
## sorted(): Gibt eine neue sortierte Liste aus den Elementen im Iterable zurück.
print(f"Sorted list: {sorted(my_list)}")
## reversed(): Gibt einen umgekehrten Iterator zurück. Wir konvertieren ihn in eine Liste, um ihn auszugeben.
print(f"Reversed list: {list(reversed(my_list))}")
## enumerate(): Gibt ein Enumerate-Objekt zurück (Iterator von Index-, Wert-Paaren).
print(f"Enumerated list: {list(enumerate(my_list))}")
## map(): Gibt einen Iterator zurück, der eine Funktion auf jedes Element des Iterables anwendet.
squared_numbers = map(lambda x: x*x, my_list)
print(f"Squared numbers (map): {list(squared_numbers)}")
## filter(): Konstruiert einen Iterator aus Elementen des Iterables, für die eine Funktion True zurückgibt.
even_numbers = filter(lambda x: x % 2 == 0, my_list)
print(f"Even numbers (filter): {list(even_numbers)}")
## zip(): Iteriert parallel über mehrere Iterables.
list_a = ['a', 'b', 'c']
list_b = [1, 2, 3]
zipped = zip(list_a, list_b)
print(f"Zipped lists: {list(zipped)}")
Speichern Sie die Datei und führen Sie sie aus.
python3 step3_sequences.py
Sie sehen die Ausgabe verschiedener Sequenzoperationen. Beachten Sie, wie Funktionen wie reversed, map, filter und zip Iteratoren zurückgeben, die wir mithilfe von list() in Listen umwandeln, um ihren Inhalt anzuzeigen.
Original list: [3, 1, 4, 1, 5, 9]
Length of the list: 6
Sorted list: [1, 1, 3, 4, 5, 9]
Reversed list: [9, 5, 1, 4, 1, 3]
Enumerated list: [(0, 3), (1, 1), (2, 4), (3, 1), (4, 5), (5, 9)]
Squared numbers (map): [9, 1, 16, 1, 25, 81]
Even numbers (filter): [4]
Zipped lists: [('a', 1), ('b', 2), ('c', 3)]
Input/Output und Objekt-Repräsentation
In diesem Schritt behandeln Sie grundlegende Ein-/Ausgabe-Operationen (I/O) und steuern, wie Objekte als Strings dargestellt werden. Wir konzentrieren uns auf print(), open(), repr() und format(). Wir werden auch kurz input() erwähnen.
Öffnen Sie die Datei step4_io.py.
Die Funktion input() liest eine Zeile von der Konsole, konvertiert sie in einen String und gibt diesen zurück. Zum Beispiel: name = input("Enter your name: "). Wir werden sie in unserem Skript nicht verwenden, um eine Ausführungspause zu vermeiden, aber es ist eine wichtige Funktion, die man kennen sollte.
Fügen Sie nun den folgenden Code zu step4_io.py hinzu. Dieses Skript schreibt in eine Datei, liest daraus und demonstriert verschiedene Wege, Objekte als Strings darzustellen und zu formatieren.
## step4_io.py
import datetime
## open(): Öffnet eine Datei und gibt ein entsprechendes Datei-Objekt zurück.
## Wir verwenden eine 'with'-Anweisung, um sicherzustellen, dass die Datei automatisch geschlossen wird.
file_path = "/home/labex/project/my_file.txt"
with open(file_path, "w") as f:
f.write("Hello, LabEx!\n")
f.write("This is a test file.")
print(f"Successfully wrote to {file_path}")
## Lesen aus der Datei
with open(file_path, "r") as f:
content = f.read()
print("--- File Content ---")
print(content)
print("--------------------")
## repr(): Gibt einen String zurück, der eine druckbare, eindeutige Repräsentation eines Objekts enthält.
now = datetime.datetime(2023, 10, 27, 10, 30, 0)
print(f"str(now): {str(now)}")
print(f"repr(now): {repr(now)}")
## format(): Konvertiert einen Wert in eine „formatierte“ Darstellung.
formatted_string = format(123.4567, ".2f")
print(f"Formatted number (123.4567 to .2f): {formatted_string}")
Speichern Sie die Datei und führen Sie sie im Terminal aus.
python3 step4_io.py
Das Skript erstellt und beschreibt die Datei my_file.txt, liest sie zurück und gibt den Inhalt aus. Es zeigt auch den Unterschied zwischen str() und repr() für ein datetime-Objekt und demonstriert die Zahlenformatierung.
Successfully wrote to /home/labex/project/my_file.txt
--- File Content ---
Hello, LabEx!
This is a test file.
--------------------
str(now): 2023-10-27 10:30:00
repr(now): datetime.datetime(2023, 10, 27, 10, 30)
Formatted number (123.4567 to .2f): 123.46
Objekt-Introspektion und Metaprogrammierung
In diesem letzten Schritt erkunden Sie fortgeschrittene Funktionen zur Interaktion mit Objektattributen und Namensräumen (Namespaces). Dies wird oft als Introspektion oder Reflexion bezeichnet. Wir werden getattr(), hasattr(), setattr(), dir(), globals() und locals() verwenden.
Öffnen Sie die Datei step5_introspection.py.
Wir definieren eine einfache Klasse und verwenden dann Introspektionsfunktionen, um ihre Instanzen dynamisch zu untersuchen und zu modifizieren. Fügen Sie den folgenden Code zu step5_introspection.py hinzu.
## step5_introspection.py
class Person:
species = "Homo sapiens"
def __init__(self, name, age):
self.name = name
self.age = age
p = Person("Alice", 30)
## hasattr(): Gibt True zurück, wenn das Objekt das benannte Attribut besitzt.
print(f"Does person have 'name' attribute? {hasattr(p, 'name')}")
print(f"Does person have 'height' attribute? {hasattr(p, 'height')}")
## setattr(): Dies ist das Gegenstück zu getattr(). Es setzt ein Attribut auf einem Objekt.
print("Setting attribute 'height' to 175...")
setattr(p, 'height', 175)
print(f"Does person have 'height' attribute now? {hasattr(p, 'height')}")
## getattr(): Gibt den Wert des benannten Attributs eines Objekts zurück.
print(f"Person's name: {getattr(p, 'name')}")
print(f"Person's height: {getattr(p, 'height')}")
## dir(): Gibt die Liste der Namen im aktuellen lokalen Gültigkeitsbereich (Scope) oder die Attribute eines Objekts zurück.
## Wir prüfen, ob 'height' nun in der Liste der Attribute enthalten ist.
print(f"Is 'height' in dir(p)? {'height' in dir(p)}")
## globals(): Gibt ein Dictionary der aktuellen globalen Symboltabelle zurück.
## Wir prüfen, ob unsere 'Person'-Klasse in globals enthalten ist.
print(f"Is 'Person' in globals? {'Person' in globals().keys()}")
## locals(): Gibt ein Dictionary der aktuellen lokalen Symboltabelle zurück.
def a_func():
x = 10
print(f"Is 'x' in locals()? {'x' in locals().keys()}")
a_func()
Speichern Sie die Datei und führen Sie sie aus.
python3 step5_introspection.py
Die Ausgabe demonstriert, wie Sie Attribute eines Objekts dynamisch anhand ihrer String-Namen überprüfen, setzen und abrufen können. Sie zeigt auch, wie man die Attribute eines Objekts sowie die im globalen und lokalen Gültigkeitsbereich verfügbaren Variablen inspiziert.
Does person have 'name' attribute? True
Does person have 'height' attribute? False
Setting attribute 'height' to 175...
Does person have 'height' attribute now? True
Person's name: Alice
Person's height: 175
Is 'height' in dir(p)? True
Is 'Person' in globals? True
Is 'x' in locals()? True
Zusammenfassung
Herzlichen Glückwunsch zum Abschluss des Labs! Sie haben praktische Erfahrungen mit einer Vielzahl der wesentlichen eingebauten Funktionen (Built-in Functions) von Python gesammelt.
In diesem Lab haben Sie gelernt, wie man:
- Zwischen Datentypen konvertiert und Objekte inspiziert (
int,str,type,isinstance). - Gängige mathematische Operationen durchführt (
abs,sum,min,max,round). - Sequenzen und Iterables manipuliert und verarbeitet (
len,sorted,map,filter,zip). - Grundlegende Datei-I/O und die String-Repräsentation von Objekten behandelt (
open,repr,format). - Objekte und Namensräume inspiziert und dynamisch modifiziert (
hasattr,getattr,setattr,dir).
Diese Funktionen sind grundlegend für die alltägliche Python-Programmierung. Ihre Beherrschung wird Ihre Code-Effizienz und Lesbarkeit erheblich verbessern. Erkunden Sie weiterhin andere eingebaute Funktionen und üben Sie deren Verwendung in Ihren eigenen Projekten.
