Python Crash Course

Kapitel 8

Funktionen

Wiederverwendbare Codeblöcke und Modularität

Was sind Funktionen?

• Benannte Codeblöcke für bestimmte Aufgaben
• Wiederverwendbar und modular
• Können Parameter entgegennehmen
• Können Werte zurückgeben

def greet_user():
    """Display a simple greeting."""
    print("Hello!")

greet_user()  # Funktion aufrufen

def greet_user(username):
    """Display a personalized greeting."""
    print(f"Hello, {username.title()}!")

greet_user('jesse')

Parameter und Argumente

# Positionsabhängige Argumente
def describe_pet(animal_type, pet_name):
    """Display information about a pet."""
    print(f"\nI have a {animal_type}.")
    print(f"My {animal_type}'s name is {pet_name.title()}.")

describe_pet('hamster', 'harry')
describe_pet('dog', 'willie')

# Schlüsselwort-Argumente
describe_pet(animal_type='hamster', pet_name='harry')
describe_pet(pet_name='willie', animal_type='dog')

Standardwerte für Parameter

def describe_pet(pet_name, animal_type='dog'):
    """Display information about a pet."""
    print(f"\nI have a {animal_type}.")
    print(f"My {animal_type}'s name is {pet_name.title()}.")

# Standard verwenden
describe_pet(pet_name='willie')

# Standard überschreiben
describe_pet(pet_name='harry', animal_type='hamster')

# Positionsabhängig
describe_pet('willie')
describe_pet('harry', 'hamster')

Rückgabewerte

def get_formatted_name(first_name, last_name):
    """Return a full name, neatly formatted."""
    full_name = f"{first_name} {last_name}"
    return full_name.title()

musician = get_formatted_name('jimi', 'hendrix')
print(musician)

# Optionale Parameter
def get_formatted_name(first_name, last_name, middle_name=''):
    """Return a full name, neatly formatted."""
    if middle_name:
        full_name = f"{first_name} {middle_name} {last_name}"
    else:
        full_name = f"{first_name} {last_name}"
    return full_name.title()

musician = get_formatted_name('jimi', 'hendrix')
musician = get_formatted_name('john', 'hooker', 'lee')

Dictionaries zurückgeben

def build_person(first_name, last_name, age=None):
    """Return a dictionary of information about a person."""
    person = {'first': first_name, 'last': last_name}
    if age:
        person['age'] = age
    return person

musician = build_person('jimi', 'hendrix', age=27)
print(musician)
# {'first': 'jimi', 'last': 'hendrix', 'age': 27}

# Funktion mit while-Schleife
def get_formatted_name(first_name, last_name):
    """Return a full name, neatly formatted."""
    full_name = f"{first_name} {last_name}"
    return full_name.title()

while True:
    print("\nPlease tell me your name:")
    print("(enter 'q' at any time to quit)")
    
    f_name = input("First name: ")
    if f_name == 'q':
        break
    
    l_name = input("Last name: ")
    if l_name == 'q':
        break
    
    formatted_name = get_formatted_name(f_name, l_name)
    print(f"\nHello, {formatted_name}!")

Listen an Funktionen übergeben

def greet_users(names):
    """Print a simple greeting to each user in the list."""
    for name in names:
        msg = f"Hello, {name.title()}!"
        print(msg)

usernames = ['hannah', 'ty', 'margot']
greet_users(usernames)

# Listen in Funktionen ändern
def print_models(unprinted_designs, completed_models):
    """Simulate printing each design, until none are left."""
    while unprinted_designs:
        current_design = unprinted_designs.pop()
        print(f"Printing model: {current_design}")
        completed_models.append(current_design)

def show_completed_models(completed_models):
    """Show all the models that were printed."""
    print("\nThe following models have been printed:")
    for completed_model in completed_models:
        print(completed_model)

*args - Beliebige Anzahl Argumente

# *args für beliebig viele Positionsargumente
def make_pizza(*toppings):
    """Print the list of toppings that have been requested."""
    print(toppings)

make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')

Normale + *args Argumente mischen

# Feste Parameter + beliebige Parameter
def make_pizza(size, *toppings):
    """Summarize the pizza we are about to make."""
    print(f"\nMaking a {size}-inch pizza with the following toppings:")
    for topping in toppings:
        print(f"- {topping}")

make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

Beliebige Schlüsselwort-Argumente

def build_profile(first, last, **user_info):
    """Build a dictionary containing everything we know about a user."""
    user_info['first_name'] = first
    user_info['last_name'] = last
    return user_info

user_profile = build_profile('albert', 'einstein',
                           location='princeton',
                           field='physics')
print(user_profile)

# Ausgabe:
# {'location': 'princeton', 'field': 'physics', 
#  'first_name': 'albert', 'last_name': 'einstein'}

Funktionen in Modulen speichern

# pizza.py
def make_pizza(size, *toppings):
    """Summarize the pizza we are about to make."""
    print(f"\nMaking a {size}-inch pizza with the following toppings:")
    for topping in toppings:
        print(f"- {topping}")

# making_pizzas.py
import pizza

pizza.make_pizza(16, 'pepperoni')
pizza.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

# Alternativen:
from pizza import make_pizza
from pizza import make_pizza as mp
import pizza as p
from pizza import *

Zusammenfassung Kapitel 8

• Funktionen: Wiederverwendbare Codeblöcke
• Parameter: Daten an Funktionen übergeben
• Standardwerte: Optionale Parameter
• Rückgabewerte: Ergebnisse zurückgeben
• *args/**kwargs: Flexible Argumentanzahl
• Module: Funktionen organisieren und teilen

Praktische Tipps

• Funktionsnamen: Beschreibend und mit Verben
• Docstrings: Immer Funktionen dokumentieren
• Ein Zweck: Eine Funktion, eine Aufgabe
• Parameter-Reihenfolge: Pflicht-, optionale, *args, **kwargs

# Gute Funktion
def calculate_area(length, width):
    """Calculate and return the area of a rectangle."""
    return length * width

# Gute Parameterreihenfolge
def example_function(required_param, optional_param='default', 
                    *args, **kwargs):
    pass