Les *args

Fait partie de la section Object Oriented Programming du Journey Python de Coddy — leçon 42 sur 64.

Le paramètre *args permet à une méthode d'accepter n'importe quel nombre d'arguments positionnels. L'astérisque collecte tous les arguments positionnels supplémentaires dans un tuple.

Voici un exemple d'une méthode utilisant *args :

class Calculator:
    def add_numbers(self, *args):
        return sum(args)
    
    def show_numbers(self, *args):
        for i, num in enumerate(args):
            print(f"Number {i+1}: {num}")

Appelez la méthode avec différents nombres d'arguments :

calc = Calculator()
result1 = calc.add_numbers(1, 2, 3)
result2 = calc.add_numbers(10, 20, 30, 40, 50)
print(result1)  # 6
print(result2)  # 150

Le *args collecte tous les arguments dans un tuple :

calc.show_numbers(5, 10, 15, 20)

Sortie :

Number 1: 5
Number 2: 10
Number 3: 15
Number 4: 20

Combinez des paramètres classiques avec *args :

class Logger:
    def log_message(self, level, *messages):
        print(f"[{level}]", end=" ")
        for message in messages:
            print(message, end=" ")
        print()  # Nouvelle ligne

logger = Logger()
logger.log_message("INFO", "User", "logged", "in")
logger.log_message("ERROR", "Connection", "failed")

Utilisez *args dans les méthodes constructeurs :

class Team:
    def __init__(self, team_name, *players):
        self.team_name = team_name
        self.players = list(players)
    
    def show_team(self):
        print(f"Team: {self.team_name}")
        for player in self.players:
            print(f"- {player}")

team = Team("Warriors", "Alice", "Bob", "Charlie", "Diana")
team.show_team()

Sortie :

6
150
Number 1: 5
Number 2: 10
Number 3: 15
Number 4: 20
[INFO] User logged in 
[ERROR] Connection failed 
Team: Warriors
- Alice
- Bob
- Charlie
- Diana

Vous pouvez également déballer des arguments lors de l'appel de méthodes :

numbers = [1, 2, 3, 4, 5]
result = calc.add_numbers(*numbers)  # Déballe la liste
print(result)  # 15

Point clé : *args collecte n'importe quel nombre d'arguments positionnels dans un tuple. Utilisez-le lorsque vous ne savez pas combien d'arguments seront passés à une méthode. Le nom args est conventionnel - vous pourriez utiliser n'importe quel nom après l'astérisque, mais args est la norme.

Défi

Facile

Dans ce défi, vous allez implémenter une fonction utilitaire numérique flexible.

Modifiez le fichier number_utils.py pour implémenter la fonction sum_all_numbers qui accepte n'importe quel nombre d'arguments numériques et retourne leur somme. La fonction doit :

Retourner 0 si aucun argument n'est fourni
Afficher "Error: All arguments must be numbers" et retourner None si des arguments non numériques sont fournis

Le fichier number_utils.py contient des commentaires TODO détaillés pour guider votre implémentation. Suivez attentivement ces commentaires pour vous assurer que votre solution répond à toutes les exigences.

Aide-mémoire

Le paramètre *args permet à une méthode d'accepter n'importe quel nombre d'arguments positionnels. L'astérisque collecte tous les arguments positionnels supplémentaires dans un tuple.

Utilisation basique de *args :

class Calculator:
    def add_numbers(self, *args):
        return sum(args)

calc = Calculator()
result1 = calc.add_numbers(1, 2, 3)  # 6
result2 = calc.add_numbers(10, 20, 30, 40, 50)  # 150

Combiner des paramètres réguliers avec *args :

class Logger:
    def log_message(self, level, *messages):
        print(f"[{level}]", end=" ")
        for message in messages:
            print(message, end=" ")
        print()

logger = Logger()
logger.log_message("INFO", "User", "logged", "in")

Utiliser *args dans les méthodes constructeurs :

class Team:
    def __init__(self, team_name, *players):
        self.team_name = team_name
        self.players = list(players)

team = Team("Warriors", "Alice", "Bob", "Charlie")

Déballer (Unpack) des arguments lors de l'appel de méthodes :

numbers = [1, 2, 3, 4, 5]
result = calc.add_numbers(*numbers)  # Déballe la liste

Point clé : *args collecte n'importe quel nombre d'arguments positionnels dans un tuple. Le nom args est conventionnel, mais vous pouvez utiliser n'importe quel nom après l'astérisque.

Essayez vous-même

from number_utils import sum_all_numbers

# Gestionnaire complet de cas de test
test_case = input()

if test_case == "basic_test":
    # Teste la fonctionnalité de base avec des entiers positifs
    print(sum_all_numbers(1, 2, 3))  # Devrait retourner 6
    print(sum_all_numbers())  # Devrait retourner 0
    print(sum_all_numbers(10, 20, 30, 40))  # Devrait retourner 100
    print(sum_all_numbers(1, 2, "three"))  # Devrait afficher une erreur et retourner None

elif test_case == "float_test":
    # Teste avec des nombres à virgule flottante
    print(sum_all_numbers(1.1, 2.2, 3.3))  # Devrait retourner 6.6
    print(sum_all_numbers(5.5, 5.0))  # Devrait retourner 10.5

elif test_case == "mixed_numbers_test":
    # Teste avec un mélange d'entiers et de flottants
    print(sum_all_numbers(5, 5.5))  # Devrait retourner 10.5
    print(sum_all_numbers(10, 20.5, 30, 40))  # Devrait retourner 100.5

elif test_case == "zero_values_test":
    # Teste avec des valeurs nulles
    print(sum_all_numbers(0, 0, 0))  # Devrait retourner 0
    print(sum_all_numbers(0))  # Devrait retourner 0
    print(sum_all_numbers())  # Devrait retourner 0

elif test_case == "negative_values_test":
    # Teste avec des valeurs négatives
    print(sum_all_numbers(-1, -2, -3))  # Devrait retourner -6
    print(sum_all_numbers(-5, -5))  # Devrait retourner -10
    print(sum_all_numbers(-5, 5))  # Devrait retourner 0

elif test_case == "large_values_test":
    # Teste avec de très grandes valeurs
    print(sum_all_numbers(1000000000, 1000000000))  # Devrait retourner 2000000000
    print(sum_all_numbers(1000000000, 2000000000.5))  # Devrait retourner 3000000000.5

elif test_case == "single_value_test":
    # Teste avec une seule valeur
    print(sum_all_numbers(5))  # Devrait retourner 5
    print(sum_all_numbers(-10))  # Devrait retourner -10
    print(sum_all_numbers(3.5))  # Devrait retourner 3.5

elif test_case == "error_handling_test":
    # Teste avec diverses valeurs non numériques
    print(sum_all_numbers("string"))  # Devrait afficher une erreur et retourner None
    print(sum_all_numbers([1, 2, 3]))  # Devrait afficher une erreur et retourner None
    print(sum_all_numbers({"key": "value"}))  # Devrait afficher une erreur et retourner None
    print(sum_all_numbers(True))  # Devrait afficher une erreur et retourner None
    print(sum_all_numbers(None))  # Devrait afficher une erreur et retourner None

elif test_case == "mixed_valid_invalid_test":
    # Teste avec un mélange de valeurs valides et invalides
    print(sum_all_numbers(1, 2, "three"))  # Devrait afficher une erreur et retourner None
    print(sum_all_numbers(1, [2, 3], 4))  # Devrait afficher une erreur et retourner None
    print(sum_all_numbers(1.5, "two", 3))  # Devrait afficher une erreur et retourner None

elif test_case == "empty_args_test":
    # Teste sans arguments
    print(sum_all_numbers())  # Devrait retourner 0