Pour définir une fonction en Python, nous utilisons le mot-clé def suivi du nom de la fonction et de parenthèses. Voici la syntaxe de base :

def function_name(parameters):
    # Function body
    # Code to be executed
    return result  # Optional

Analysons les composants :

• def : Ce mot-clé indique à Python que nous définissons une fonction.
• function_name : C'est le nom que nous donnons à notre fonction. Il doit être descriptif et suivre les conventions de nommage Python.
• parameters : Ce sont les entrées que la fonction peut accepter (optionnel). Ils rendent la fonction flexible et dynamique.
• : est un deux-points qui commence le bloc de code indenté à l'intérieur de la fonction.
• Corps de la fonction : C'est le bloc de code indenté qui est exécuté lorsque la fonction est appelée.
• return : Ce mot-clé est utilisé pour spécifier la sortie de la fonction (optionnel). Si aucune instruction return n'est utilisée, la fonction retournera implicitement None

Appeler une fonction

Une fois qu'une fonction est définie, nous pouvons l'appeler en utilisant son nom suivi de parenthèses. Si la fonction nécessite des paramètres, nous les fournissons à l'intérieur des parenthèses. Voici un exemple :

# Define a function that greets a user
def greet_user(username):
    print(f"Hello, {username}! Welcome back to your dashboard.")

# Call the function with the argument "Alice"
greet_user("Alice")

# Output:
# Hello, Alice! Welcome back to your dashboard.

Dans cet exemple, nous avons défini une fonction appelée greet_user qui prend un paramètre username et affiche un message d'accueil. Notez qu'il n'y a pas d'instruction return. Nous avons ensuite appelé la fonction avec l'argument "Alice".

Obtenir des résultats avec return

Pour obtenir un résultat d'une fonction, utilisez l'instruction return, qui renvoie une valeur à l'appelant. Cela vous permet d'utiliser le résultat dans d'autres parties de votre code.

Par exemple, voici une fonction qui calcule le total des heures travaillées dans une semaine :

def calculate_weekly_hours():
    daily_hours = [8, 7.5, 9, 8.5, 6]  # Example hours for each day of the week
    total_hours = sum(daily_hours)
    return total_hours

Cette fonction ne prend aucun paramètre mais utilise return pour renvoyer le total des heures travaillées.

Paramètres positionnels

Les paramètres positionnels sont le type le plus courant. L'ordre des arguments est crucial lors de l'appel de la fonction, car chaque argument est assigné selon sa position.

Prenons une fonction qui calcule le prix final d'un produit après application d'une remise :

def calculate_discounted_price(price, discount_rate):
    discount_amount = price * (discount_rate / 100)  # Calculate discount
    final_price = price - discount_amount  # Subtract discount from original price
    return final_price

Lors de l'appel de cette fonction, l'ordre des arguments est important :

print(calculate_discounted_price(100, 10))  # price=100, discount_rate=10
# Output: 90.0

# If you switch the order of the arguments, the result won't make sense:
print(calculate_discounted_price(10, 100))  # Incorrect order: price=10 discount_rate=100
# Output: 0.0

Le résultat inattendu dans le second appel se produit car les arguments sont dans le mauvais ordre.

Utiliser des arguments mot-clés pour les paramètres positionnels

Les arguments mot-clés rendent les appels de fonction plus explicites et lisibles. En les utilisant, vous spécifiez le nom du paramètre avec sa valeur lors de l'appel.

# Using keyword arguments
print(calculate_discounted_price(price=100, discount_rate=10))  # Output: 90.0

# Order doesn't matter with keyword arguments
print(calculate_discounted_price(discount_rate=10, price=100))  # Output: 90.0

Dans ces deux appels, nous assignons explicitement chaque argument à son paramètre correspondant. Avec les arguments mot-clés, l'ordre d'assignation n'a pas d'importance.

Combiner arguments positionnels et mot-clés

Vous pouvez mélanger les arguments positionnels et mot-clés, mais les arguments positionnels doivent précéder les arguments mot-clés :

calculate_discounted_price(100, discount_rate=10)  # Correct usage
# Output: 90.0

Inverser l'ordre causera une erreur :

calculate_discounted_price(price=100, 10)  # Incorrect usage
# SyntaxError: positional argument follows keyword argument

Utiliser des valeurs de paramètres par défaut

Vous pouvez définir des paramètres avec des valeurs par défaut. Le paramètre devient optionnel - si aucun argument n'est fourni, la fonction utilise sa valeur par défaut.

Modifions notre fonction pour calculer le prix total en incluant un paramètre optionnel tax_rate avec une valeur par défaut de 5% :

def calculate_total_cost(price, discount_rate, tax_rate=5):
    discounted_price = price - (price * discount_rate / 100)  # Apply the discount
    total = discounted_price + (discounted_price * tax_rate / 100)  # Apply tax to the discounted price
    return total

Vous pouvez maintenant appeler la fonction de deux façons :

# 1. With Default Tax Rate:
print(calculate_total_cost(100, 10))  # Uses default tax_rate=5
# Output: 94.5  # (100 - 10% discount) + 5% tax

# 2. With Custom Tax Rate:
print(calculate_total_cost(100, 10, 8))  # Overrides default with tax_rate=8
# Output: 97.2  # (100 - 10% discount) + 8% tax

Gérer plusieurs arguments

En Python, les fonctions peuvent accepter un nombre variable d’arguments en utilisant :

• *args pour collecter des arguments positionnels dans un tuple.
• **kwargs pour collecter des arguments nommés (mot-clés) dans un dictionnaire.

Cela permet d’écrire des fonctions flexibles et adaptées à des besoins variés.

Utilisation de *args pour des arguments positionnels

La syntaxe *args est utile lorsque vous souhaitez accepter un nombre illimité d’arguments positionnels, sans savoir combien seront fournis à l’avance.

Exemple pratique : Calculer un coût moyen

Supposons que vous deviez créer une fonction qui calcule le coût moyen de plusieurs articles. Comme vous ne savez pas combien d’articles seront fournis, vous pouvez utiliser *args:

def calculate_average_cost(*args):
    # *args allows the function to accept any number of arguments
    total = sum(args)  # Sum up all the arguments
    average = total / len(args)
    return f"Average cost: ${average:.2f}"

# Average of three items
print(calculate_average_cost(10, 20, 30))
# Output: Average cost: $20.00

# Average of two items
print(calculate_average_cost(5, 15))
# Output: Average cost: $10.00

Dans cet exemple :

• Tous les arguments fournis à la fonction sont collectés dans le tuple args.
• Vous pouvez appliquer des opérations comme sum() ou len() sur ce tuple pour effectuer vos calculs.

Si aucun argument n’est fourni, un message d’erreur pourrait être levé (division par zéro). Vous pouvez gérer ce cas avec une vérification préalable :

if not args:
    return "No price entered."

Utilisation de **kwargs pour des arguments mot-clés

La syntaxe **kwargs est utile pour accepter un nombre illimité d’arguments nommés sous forme de paires clé-valeur, regroupées dans un dictionnaire.

Exemple pratique : Gestion des tâches d’entreprise

Imaginez que vous deviez créer une fonction pour enregistrer et afficher des tâches liées à une entreprise. Comme vous ne savez pas à l’avance combien de tâches ni leurs descriptions, vous pouvez utiliser **kwargs :

def create_business_tasks(**kwargs):
    for task, description in kwargs.items():
        print(f"[ ] {task.replace('_', ' ').capitalize()}: {description}")

# Call the function with business-related keyword arguments
create_business_tasks(
    review_quarterly_report="Analyze Q3 financial statements",
    schedule_team_meeting="Set up monthly all-hands for October",
    update_project_timeline="Revise Gantt chart for Product Launch",
    follow_up_with_clients="Contact top 5 clients for feedback"
)

# Output:
# [ ] Review quarterly report: Analyze Q3 financial statements
# [ ] Schedule team meeting: Set up monthly all-hands for October
# [ ] Update project timeline: Revise Gantt chart for Product Launch
# [ ] Follow up with clients: Contact top 5 clients for feedback

Dans cet exemple :

• Tous les arguments nommés passés à la fonction sont collectés dans le dictionnaire kwargs.
• Vous pouvez parcourir ce dictionnaire pour afficher ou manipuler les données comme vous le souhaitez.

Quand utiliser *args et **kwargs ?

• Utilisez *args lorsque vous avez besoin d’une liste flexible d’arguments positionnels, comme pour des calculs sur des nombres.
• Utilisez **kwargs lorsque vous devez gérer des paramètres nommés, comme des options ou des données spécifiques avec des clés claires.

Ces fonctionnalités rendent vos fonctions plus dynamiques et adaptables aux cas d’utilisation variés, que ce soit pour manipuler des collections de données ou offrir des options supplémentaires aux utilisateurs.

Conseils pour l'écriture de fonctions

Pour rendre vos fonctions plus lisibles, maintenables et efficaces, suivez ces conseils :

1. Noms descriptifs : Choisissez des noms significatifs qui décrivent clairement leur objectif. Suivez la convention snake_case en Python.
2. Fonctions ciblées : Chaque fonction doit avoir un objectif unique et clair. Suivez le "principe de responsabilité unique".
3. Limiter les paramètres : Minimisez le nombre de paramètres. Groupez-les dans un dictionnaire si nécessaire.
4. Valeurs par défaut : Fournissez des valeurs par défaut quand possible.
5. Documentation : Incluez une docstring qui décrit la fonction, ses paramètres et sa valeur de retour. Pour en savoir plus : Python Docstrings

def calculate_discounted_price(price, discount_rate):
    """
    Calculate the final price after applying a discount.

    Parameters:
    - price (float): The original price of the product.
    - discount_rate (float): The discount percentage to apply.

    Returns:
    - float: The final price after the discount.
    """
    discount_amount = price * (discount_rate / 100)
    final_price = price - discount_amount
    return final_price

6. Gérer les exceptions avec élégance : Anticipez les erreurs potentielles ou les cas limites dans votre fonction et gérez-les en utilisant des blocs try...except ou en validant les données d'entrée dès le début. Cela garantit que vos fonctions sont robustes et échouent de manière contrôlée.

7. Rester concis : Visez à maintenir les fonctions entre 20 et 30 lignes de code. Les fonctions plus courtes sont généralement plus faciles à comprendre et à tester.

8. Utiliser les annotations de type : Les annotations de type améliorent la lisibilité du code et facilitent le débogage en spécifiant les types attendus des paramètres et des valeurs de retour. Par exemple :

   python

   
   def add_numbers(x: float, y: float) -> float:
       return x + y
   

Exercice

Pour les exercices, créez un Notebook Jupyter nommé functions.ipynb dans le dossier exercises du dossier Functions.

1. Calculer la marge bénéficiaire

Tâche : Écrivez une fonction nommée calculate_profit_margin qui prend deux paramètres : revenue et cost. La fonction doit calculer et retourner la marge bénéficiaire en pourcentage.

• Formule :

$$ \text{Profit Margin} = \left( \frac{\text{revenue} - \text{cost}}{\text{revenue}} \right) \times 100 $$

# Calculate the profit margin for revenue of $5000 and cost of $3000
print(calculate_profit_margin(5000, 3000))

# Expected output:
# 40.0

2. Déterminer les catégories clients selon les dépenses

Tâche : Écrivez une fonction nommée segment_customers_by_spend qui catégorise les clients comme "High", "Medium", ou "Low" selon ces critères :

• "High" si l'achat est ≥ $1000
• "Medium" si l'achat est entre $500 et $999
• "Low" si l'achat est < $500

purchases = [1200, 800, 1500, 300, 700]
segment_customers_by_spend(purchases)

# Expected output:
# {"High": 2, "Medium": 2, "Low": 1}

3. Identifier le meilleur vendeur

Tâche : Créez une fonction nommée find_top_salesperson qui identifie le vendeur ayant réalisé le plus de ventes. Vous pouvez utiliser une boucle de ce type : for saler, sale in sales.items(): dans votre fonction.

sales = {"Alice": 5000, "Bob": 7000, "Charlie": 3000}
find_top_salesperson(sales)

# Expected output:
# "Bob"

4. Supprimer les clients en double

Tâche : Écrivez une fonction get_unique_customers qui élimine les doublons tout en préservant l'ordre d'apparition.

customer_list = ["Alice", "Bob", "Alice", "Charlie", "Bob", "David"]
print(get_unique_customers(customer_list))

# Expected Output
# ["Alice", "Bob", "Charlie", "David"]

5. Générer un rapport de ventes

Tâche : Créez une fonction generate_sales_report qui génère un rapport détaillé des ventes.

sales = [1000, 2000, 1500, 3000, 2500]
generate_sales_report(sales)

# Expected Output:
# {
#     "total_sales": 10000,
#     "average_sales": 2000.0,
#     "maximum_sale": 3000,
#     "minimum_sale": 1000,
#     "sales_count": 5
# }

Solution

def calculate_profit_margin(revenue, cost):
    """
    Calculate the profit margin as a percentage.

    Parameters:
    revenue (float): The total revenue.
    cost (float): The total cost.

    Returns:
    float: The profit margin as a percentage.
    """
    if revenue == 0:
        return 0  # Handle division by zero
    profit_margin = ((revenue - cost) / revenue) * 100
    return profit_margin

# Example usage
print(calculate_profit_margin(5000, 3000))
# Output: 40.0

def segment_customers_by_spend(purchases):
    """
    Segment customers into 'high', 'medium', and 'low' based on their purchase amounts.

    Parameters:
    purchases (list of int): A list of customer purchase amounts.

    Returns:
    dict: A dictionary with the counts of each customer segment.
    """
    segments_count = {'high': 0, 'medium': 0, 'low': 0}

    for purchase in purchases:
        if purchase >= 1000:
            segments_count['high'] += 1
        elif purchase >= 500:
            segments_count['medium'] += 1
        else:
            segments_count['low'] += 1

    return segments_count

# Example usage
purchases = [1200, 800, 1500, 300, 700]
print(segment_customers_by_spend(purchases))
# Output: {'high': 2, 'medium': 2, 'low': 1}

def find_top_salesperson(sales):
    """
    Identify the top-performing salesperson based on sales amount.

    Args:
    sales (dict): A dictionary where the keys are salesperson names (str) and the values are sales amounts (float).

    Returns:
    str: The name of the salesperson with the highest sales.
    """
    top_saler = ""
    max_sale = 0

    for saler, sale in sales.items():
        if sale > max_sale:
            max_sale = sale
            top_saler = saler

    return top_saler

# Example usage
sales = {"Alice": 5000, "Bob": 7000, "Charlie": 3000}
print(find_top_salesperson(sales))
# Output: "Bob"

def get_unique_customers(customer_list):
    """
    Remove duplicate customers while preserving order.

    Args:
    customer_list (list of str): A list of customer names, potentially with duplicates.

    Returns:
    list of str: A list of unique customer names, preserving the first occurrence order.
    """
    seen = set()
    unique_customers = []

    for customer in customer_list:
        if customer not in seen:
            seen.add(customer)
            unique_customers.append(customer)

    return unique_customers

# Example usage
customer_list = ["Alice", "Bob", "Alice", "Charlie", "Bob", "David"]
print(get_unique_customers(customer_list))
# Output: ["Alice", "Bob", "Charlie", "David"]

def generate_sales_report(sales):
    """
    Generate a summary report for sales data, including total sales, average sales, maximum sale,
    minimum sale, and the total count of sales.

    Args:
    sales (list of float): A list of sales amounts.

    Returns:
    dict: A dictionary containing total sales, average sales, maximum sale, minimum sale, and count of sales.
    """
    total_sales = sum(sales)  # Calculate the total sales
    sales_count = len(sales)  # Calculate the count of sales
    average_sales = total_sales / sales_count  # Calculate the average sales
    maximum_sale = max(sales)  # Find the maximum sale
    minimum_sale = min(sales)  # Find the minimum sale

    return {
        "total_sales": total_sales,
        "average_sales": average_sales,
        "maximum_sale": maximum_sale,
        "minimum_sale": minimum_sale,
        "sales_count": sales_count
    }

# Example usage
sales = [1000, 2000, 1500, 3000, 2500]
print(generate_sales_report(sales))
# Output: {'total_sales': 10000, 'average_sales': 2000.0, 'maximum_sale': 3000, 'minimum_sale': 1000, 'sales_count': 5}

Imaginez que vous gérez une liste de clients avec leur âge et que vous souhaitez les trier du plus jeune au plus âgé. Vous pourriez écrire une fonction classique pour dire à Python comment comparer les âges, mais cela ferait plusieurs lignes de code pour une tâche très simple. Voici comment on ferait avec une fonction traditionnelle :

def get_age(client):
    return client['age']

clients = [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}, {'name': 'Charlie', 'age': 20}]
sorted_clients = sorted(clients, key=get_age)
print(sorted_clients)

Mais pour une tâche aussi courte, Python propose une solution plus simple et plus lisible : les fonctions lambda.

Que sont les fonctions lambda ?

Les fonctions lambda, aussi appelées fonctions anonymes, sont des fonctions sans nom. Elles sont conçues pour être concises et sont souvent utilisées pour des opérations rapides ou pour passer une fonction comme argument à une autre fonction. Elles sont définies avec le mot-clé lambda et peuvent prendre n'importe quel nombre d'arguments, mais ne contiennent qu'une seule expression

lambda arguments: expression

Ici, "arguments" sont les paramètres que la fonction lambda acceptera et "expression" est l'opération que la fonction effectuera.

Exemple : Trier une liste de clients avec une fonction lambda

Reprenons l'exemple des clients. Avec une fonction lambda, le tri devient beaucoup plus simple et plus lisible :

clients = [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}, {'name': 'Charlie', 'age': 20}]
sorted_clients = sorted(clients, key=lambda client: client['age'])
print(sorted_clients)
# Output:
# [{'name': 'Charlie', 'age': 20}, {'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}]

Dans cet exemple, la fonction lambda lambda client: client['age'] remplace la fonction get_age. Elle indique à Python de trier les clients en fonction de leur âge, en une seule ligne de code.

Autre exemple : Calculer une taxe de vente

Voici un autre cas concret : calculer une taxe de vente. Avec une fonction lambda, cela devient très simple :

# Define a lambda function to calculate tax
calculate_tax = lambda amount, tax_rate: amount * tax_rate

# Calculate tax for a 200€ purchase with 7% tax rate
tax = calculate_tax(200, 0.07)

# Print the calculated sales tax, formatted to 2 decimal places
print(f"Sales Tax: {tax:.2f}€")
# Output:
# Sales Tax: 14.00€

Dans cet exemple, nous appelons la fonction lambda en utilisant le nom de variable calculate_tax et lui passons deux arguments. La fonction remplace ensuite 200 par amount et 0.07 par tax_rate, en évaluant l'expression amount * tax_rate. La syntaxe {tax:.2f} dans la f-string permet d'afficher le résultat avec 2 décimales, ce qui est utile pour formater des montants monétaires.

Bien que l'attribution d'une fonction lambda à une variable soit valide, comme le montre l'exemple ci-dessus, les fonctions lambda sont plus couramment utilisées comme fonctions inline à l'intérieur d'autres fonctions. C'est parce qu'elles sont rapides à définir et idéales pour les opérations petites et temporaires. Par exemple, les fonctions lambda sont souvent utilisées avec les fonctions intégrées de Python comme map(), filter() et sorted().

Fonctions Lambda avec map()

Imaginez que vous gérez une boutique en ligne et que vous souhaitez appliquer une réduction de 10 % à tous les prix de vos produits. Au lieu de parcourir manuellement chaque prix et d'appliquer la réduction, vous pouvez utiliser la combinaison de map() et d'une fonction lambda pour effectuer cette opération rapidement et efficacement.

Exemple concret : Appliquer une réduction de 10 % à une liste de prix

# List of product prices
prices = [100, 250, 400, 120]

# Apply a 10% discount to all prices using a lambda function
discounted_prices = list(map(lambda price: price * 0.9, prices))

print(f"Prices after 10% discount: {discounted_prices}")
# Output:
# Prices after 10% discount: [90.0, 225.0, 360.0, 108.0]

Dans cet exemple :

• La fonction lambda lambda price: price * 0.9 prend chaque price de la liste et la multiplie par 0.9 pour appliquer une réduction de 10%.
• La fonction map() prend deux arguments :
  • Le premier argument est la fonction lambda lambda price: price * 0.9.
  • Le deuxième argument est la liste prices, qui contient les prix d'origine des produits.
• map() applique la fonction lambda à chaque élément de la liste prices, créant un objet des prix réduits.
• list(map(...)) prend l'objet renvoyé par map() et crée une nouvelle liste contenant les valeurs transformées.

La syntaxe map() est pertinente car elle permet d'appliquer une fonction à chaque élément d'un itérable (comme une liste) de manière concise et efficace, sans avoir à écrire une boucle explicite.

Elle est particulièrement utile pour des opérations répétitives, comme transformer des données ou appliquer des calculs, en combinant souvent une fonction lambda pour des opérations simples. Par exemple, pour appliquer une réduction de 10 % à une liste de prix, map(lambda price: price * 0.9, prices) est plus lisible et optimisé qu'une boucle manuelle.

De plus, map() renvoie un itérable, ce qui est efficace en mémoire, et peut être facilement converti en liste avec list(map(...)). Cela rend le code à la fois clair, performant et facile à maintenir.

Fonctions Lambda avec filter()

La fonction filter() en Python est utilisée pour filtrer les éléments d'un itérable (comme une liste) en fonction d'une condition définie par une fonction. Lorsqu'elle est combinée avec une fonction lambda, filter() devient un outil puissant pour ne sélectionner que les éléments qui répondent à un critère spécifique.

Examinons un exemple où nous filtrons tous les prix de produits supérieurs à 200€ :

# List of product prices
prices = [100, 250, 400, 120]

# Use a lambda function with filter() to find prices above 200€
high_value_prices = list(filter(lambda price: price > 200, prices))

print(f"High-value prices: {high_value_prices}")
# Output:
# High-value prices: [250, 400]

Dans cet exemple :

• La fonction lambda lambda price: price > 200 vérifie si chaque price de la liste est supérieur à 200. Elle renvoie True si la condition (price > 200) est remplie et False sinon.
• La fonction filter prend deux arguments :
  • Le premier argument est la fonction lambda lambda price: price > 200.
  • Le deuxième argument est la liste prices, qui contient les prix d'origine des produits.
• filter() applique la fonction lambda à chaque élément de la liste prices :
  • Pour chaque élément, si la fonction lambda renvoie True, cet élément est inclus dans la sortie.
  • Si la fonction lambda renvoie False, cet élément est exclu de la sortie.

Fonctions Lambda avec sorted()

La fonction sorted() peut utiliser une fonction lambda comme clé de tri. Par exemple, si vous avez une liste de dictionnaires représentant des produits avec leurs prix et que vous voulez les trier par prix, vous pouvez utiliser une fonction lambda :

# List of products with prices
products = [
    {'name': 'Laptop', 'price': 1200},
    {'name': 'Phone', 'price': 800},
    {'name': 'Tablet', 'price': 300}
]

# Sort products by price using a lambda function
sorted_products = sorted(products, key=lambda product: product['price'])

print(f"Products sorted by price: {sorted_products}")
# Output:
# Products sorted by price: [{'name': 'Tablet', 'price': 300}, {'name': 'Phone', 'price': 800}, {'name': 'Laptop', 'price': 1200}]

Dans ce cas :

• La fonction lambda lambda product: product['price'] extrait le prix de chaque produit.
• La fonction sorted() utilise cette lambda comme clé de tri pour déterminer l'ordre de tri, ce qui donne une liste triée par prix.

Exercice

Partie 1 : Gestion des stocks

Étape 1 : Calculer la valeur du stock

• Tâche : Calculer la valeur totale du stock pour chaque article de l'inventaire.
• Entrée :

inventory = [
    {'product_name': 'Laptop', 'quantity': 10, 'unit_price': 800},
    {'product_name': 'Monitor', 'quantity': 15, 'unit_price': 150},
    {'product_name': 'Mouse', 'quantity': 50, 'unit_price': 20}
]

• Étapes :
  1. Définir une fonction lambda :
     • Créer une fonction lambda qui prend un argument item (un dictionnaire).
     • La fonction lambda doit calculer la valeur totale du stock : item['quantity'] * item['unit_price'].
  2. Utiliser la fonction map() :
     • Utiliser map() pour appliquer la fonction lambda à chaque élément de l'inventaire dans la liste.
     • Convertir le résultat en une liste avec list().
  3. Stocker le résultat :
     • Stocker le résultat dans une nouvelle liste appelée stock_values.

Étape 2 : Filtrer les articles à faible stock

• Tâche : Identifier les articles d'inventaire avec une quantité inférieure à 20.
• Étapes :
  1. Définir une fonction lambda :
     • Créer une fonction lambda qui prend un argument item (un dictionnaire).
     • La fonction lambda doit renvoyer True si item['quantity'] < 20, sinon False.
  2. Utiliser la fonction filter() :
     • Utiliser filter() pour appliquer la fonction lambda à la liste d'inventaire.
     • Convertir le résultat en une liste avec list().
  3. Stocker le résultat :
     • Stocker le résultat dans une nouvelle liste appelée low_stock_items.

Partie 2 : Segmentation marketing

Trier les clients par niveau d'engagement

• Tâche : Trier les clients par leur score d'engagement dans l'ordre décroissant.
• Entrée :

customers_engagement = [
    {'customer_name': 'John Doe', 'engagement_score': 80},
    {'customer_name': 'Jane Smith', 'engagement_score': 95},
    {'customer_name': 'Alice Johnson', 'engagement_score': 70}
]

• Étapes :
  1. Définir une fonction lambda :
     • Créer une fonction lambda qui prend un argument customer (un dictionnaire).
     • La fonction lambda doit renvoyer le score d'engagement : customer['engagement_score'].
  2. Utiliser la fonction sorted() :
     • Utiliser sorted() pour trier la liste des clients par score d'engagement.
     • Passer la fonction lambda comme argument key à sorted().
     • Définir reverse=True pour trier dans l'ordre décroissant.
  3. Stocker le résultat :
     • Stocker le résultat dans une nouvelle liste appelée sorted_customers.

Partie 3 : Prévisions financières

Calculer les projections de chiffre d'affaires futurs

• Tâche : Calculer le chiffre d'affaires projeté pour chaque produit après 3 ans, en supposant une croissance composée.
• Entrée :

products = [
    {'product_name': 'Laptop', 'current_sales': 100000, 'growth_rate': 0.05},
    {'product_name': 'Monitor', 'current_sales': 50000, 'growth_rate': 0.03},
    {'product_name': 'Mouse', 'current_sales': 30000, 'growth_rate': 0.02}
]

• Étapes :
  1. Définir une fonction lambda :
     • Créer une fonction lambda qui prend un argument product (un dictionnaire).
     • La fonction lambda doit calculer le chiffre d'affaires projeté : product['current_sales'] * (1 + product['growth_rate']) ** 3.
  2. Utiliser la fonction map() :
     • Utiliser map() pour appliquer la fonction lambda à chaque produit de la liste.
     • Convertir le résultat en liste avec list().
  3. Stocker le résultat :
     • Stocker le résultat dans une nouvelle liste nommée projected_revenue.

Solution

# Define the inventory list with product details
inventory = [
    {'product_name': 'Laptop', 'quantity': 10, 'unit_price': 800},
    {'product_name': 'Monitor', 'quantity': 15, 'unit_price': 150},
    {'product_name': 'Mouse', 'quantity': 50, 'unit_price': 20}
]

# Calculate the stock value for each item using a lambda function
# The lambda function multiplies quantity by unit price for each item
stock_values = list(map(lambda item: item['quantity'] * item['unit_price'], inventory))

# Print the result
print("Stock values:", stock_values)

# Output:
# Stock values: [8000, 2250, 1000]

# Filter inventory to find items with quantity less than 20
low_stock_items = list(filter(lambda item: item['quantity'] < 20, inventory))

# Print the result
print("Low stock items:", low_stock_items)

# Output:
# Low stock items: [{'product_name': 'Laptop', 'quantity': 10, 'unit_price': 800}, {'product_name': 'Monitor', 'quantity': 15, 'unit_price': 150}]

    # List of customers with their engagement scores
    customers_engagement = [
        {'customer_name': 'John Doe', 'engagement_score': 80},
        {'customer_name': 'Jane Smith', 'engagement_score': 95},
        {'customer_name': 'Alice Johnson', 'engagement_score': 70}
    ]
    
    # Sort customers by engagement score in descending order
    sorted_customers = sorted(customers_engagement,
                              key=lambda customer: customer['engagement_score'],
                              reverse=True)
    
    # Print the sorted list of customers
    print(sorted_customers)
    
    # Output:
    # [{'customer_name': 'Jane Smith', 'engagement_score': 95}, {'customer_name': 'John Doe', 'engagement_score': 80}, {'customer_name': 'Alice Johnson', 'engagement_score': 70}]

    # List of products with their current sales and growth rates
    products = [
        {'product_name': 'Laptop', 'current_sales': 100000, 'growth_rate': 0.05},
        {'product_name': 'Monitor', 'current_sales': 50000, 'growth_rate': 0.03},
        {'product_name': 'Mouse', 'current_sales': 30000, 'growth_rate': 0.02}
    ]
    
    # Calculate projected revenue after 3 years using a lambda function
    projected_revenue = list(map(lambda product: product['current_sales'] * (1 + product['growth_rate']) ** 3, products))
    
    # Print the result
    print("Projected revenue after 3 years:", projected_revenue)
    
    # Output:
    # Projected revenue after 3 years: [115762.5, 54636.35, 31836.24]

Excellent travail ! Dans cette leçon, vous avez découvert les fonctions Python et les fonctions lambda, deux outils puissants qui vous aident à écrire du code propre, réutilisable et efficace.

Vous savez maintenant comment définir et appeler des fonctions en utilisant le mot-clé def, passer des arguments et utiliser efficacement les valeurs de retour. Vous avez exploré les meilleures pratiques pour l'écriture de fonctions, comme les garder petites et ciblées, utiliser des noms descriptifs et ajouter des docstrings pour documenter leur objectif.

De plus, vous avez appris à utiliser les fonctions lambda, qui sont des petites fonctions anonymes définies avec le mot-clé lambda. Vous avez découvert comment utiliser les fonctions lambda pour des fonctions courtes et temporaires, et comment elles peuvent être passées comme arguments à d'autres fonctions comme map(), filter() et sorted() pour améliorer la lisibilité et la concision du code.

Continuez votre excellent travail !