Lära Godtyckliga Argument | Godtyckliga Argument

Vi har redan undersökt funktionens positionella och valfria argument. Men vad gör man när det finns många argument, eller när man är osäker på vilka argument som måste skickas till en funktion? Detta problem kan lösas med hjälp av godtyckliga argument (variabel-längdsargument). Dessa argument gör det möjligt för en funktion att ta emot ett obestämt antal argument. Detta är särskilt användbart när du vill definiera en funktion som kan ta emot ett variabelt antal inmatningsvärden utan att ange det exakta antalet argument i förväg.

Notera

Kom ihåg att varje argument kan vara en datastruktur, såsom en lista eller ordbok. Du kan skicka ett godtyckligt antal sådana strukturer med hjälp av godtyckliga argument.

I Python kan du definiera godtyckliga argument som ett enda positionellt argument genom att placera en asterisk * före argumentnamnet. Här är ett exempel:


              12345678
            
# Define function with arbitrary arguments named values
def calculate_sum(*values):
	return sum(values)

# Test the function using different number of arguments
print(calculate_sum(1, 2, 3))
print(calculate_sum(1, 2, 3, 4))
print(calculate_sum(1, 2, 3, 4, 5))

I koden ovan använde vi * för att deklarera att variabeln values innehåller flera godtyckliga argument och tolkas som en tuple. Därefter använde vi den inbyggda funktionen sum för att beräkna summan. Vi kan se att resultatet är korrekt för alla exempel, och vi behöver inte ange antalet argument direkt. Observera att vi använder detta argument med dess namn utan * i funktionskroppen.

Observera

För att definiera en godtycklig argument-tuple räcker det att använda * före argumentnamnet. Det rekommenderas dock att använda konstruktionen *args. Detta förbättrar kodens tolkbarhet och läsbarhet.


              123456789101112131415161718
            
def example_function(*args):
    # Print the type of args
    print(f'Type of args: {type(args)}')
    # Print the whole tuple
    print(f'Args tuple: {args}')
    # Iterate over the tuple
    for arg in args:
        print(arg)

# Call the function without any arguments
print("Call without arguments:")
example_function()
# Call the function with one argument
print("\nCall with one argument:")
example_function(1)
# Call the function with multiple arguments
print("\nCall with multiple arguments:")
example_function(1, 2, 3, 'hello', [4, 5, 6])

Som du kan se från resultaten:

När funktionen anropas utan några argument kommer args att vara en tom tuple ().
När funktionen anropas med ett argument kommer args att vara en tuple med ett element (1,).
När funktionen anropas med flera argument lagras alla i tuplen, till exempel (1, 2, 3, 'hello', [4, 5, 6]).

Med *args kan du arbeta med värdena precis som med vilken annan tuple som helst i Python.

Uppgift

Swipe to start coding

Implementera en funktion calculate_total som beräknar totalpriset för varor i en kundvagn, med rabatter baserade på det totala beloppet.

Använd godtyckliga argument med namnet prices i funktionen calculate_total.
Om inga argument anges, returnera "Your cart is empty.".
Ge 20 % rabatt om totalen är $200 eller mer.
Ge 10 % rabatt om totalen är $100 eller mer.

Lösning

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 3. Kapitel 1

single

Fråga AI

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal

Awesome!

Completion rate improved to 4.35

Svep för att visa menyn