Förstå Args och Kwargs i Python

I denna handledning kommer jag att fokusera på argument (* args) och sökordsargument (* kwargs) i Python.

Jag kommer att lära dig vad args och kwargs är och, viktigast av allt, hur man använder dem, det vill säga hur man tar in ett obegränsat antal argument och sökordsargument i funktioner.

Vad är Args?

* args brukar passera icke-nyckelord argument. Exempel på icke-nyckelordargument är kul (3,4), kul ("foo", "bar").

* args brukar användas som en åtgärd för att förhindra att programmet kraschar om vi inte vet hur många argument som ska överföras till funktionen. Detta används i C ++ samt andra programmeringsspråk.

Vad är kvarsatser?

** kwargs är en ordlista med sökordsargument. De ** tillåter oss att skicka ett antal sökordsargument. Ett sökordsargument är i princip en ordlista.

Ett exempel på ett sökordargumentet är kul (foo = 2, bar = 7).

** kwargs är precis som * args förutom att du förklarar variablerna och mängden inom funktionen argument.

Var att använda Args och Kwargs

Args och kwargs är användbara när du vill:

Minska kodreformering.
Gör din kod läsbar.
Återanvänd din kod

Använda Args och Kwargs in Functions

Låt oss titta på hur kwargs och args används i funktioner.

args

Funktionen nedan tar in tre argument. De tre argumenten har uttryckligen definierats, så mer eller mindre kommer det att orsaka ett fel i programmet.

def add (a, b, c): skriv ut (a + b + c) print add (2,3,4)

Låt oss köra funktionen. Funktionen lägger till de tre siffrorna, vilket ger följande utmatning:

Utgång 9

Vad händer om vi skulle skicka fyra argument i funktionen istället för de tre nödvändiga? Vi får ett fel som visas nedan.

Detta beror på att endast tre parametrar definierades i funktionen, men vi har passerat fyra positionsargument när vi ringer funktionen.

def add (a, b, c): skriv ut (a + b + c) print add (2,3,4,5)

Output TypeError: add () tar 3 positionsargument men 4 gavs

I det andra exemplet nedan, * är för icke-nyckelord argument och skickas in i funktionen. I stället för att ha definierade argument ersätter vi en, b och c med en enda parameter (* args).

Lägg märke till hur användningen av * args gör det enkelt att använda något antal argument utan att behöva byta kod. * args ge mer flexibilitet till din kod eftersom du kan ha så många argument som du önskar i framtiden.

def add (* args): total = 0 för arg i args: totalt + = arg utskrift totalt

Scenario 1 Skriv ut lägg till (1,2,5) Utgång 8

Scenario 2 print add (1,2,5,6) utgång 14

Scenario 3 Print add (1,2,5,8) Utgång 16

Fler exempel

Skapa en enkel funktion som visas:

def func (* args): # * args betyder för hur många argument du tar in, det kommer fånga dem alla för arg i args: print arg

Testa funktionen med en kombination av heltal och strängar:

def func (* args): # * args betyder för hur många argument du tar in, det kommer fånga dem alla för arg i args: print arg print func (11,3,4,5, "tuts")

Utmatning 11 3 4 5 tuttar

Vad händer om vi skulle skicka en lista som ett argument? Testa funktionen med en lista genom att ersätta tidigare argument med en lista, l = [11,3,4,5, "tuts].

def func (* args): # * args betyder för hur många argument du tar in, det kommer fånga dem alla för arg i args: skriv ut arg l = [11,3,4,5, "tuts"] print func )

Detta skriver ut listan som helhet, det beror på att det tolkar listan som ett objekt. Utgång [11,3,4,5, "tuts]

Från ovanstående exempel kan du också använda * args att packa upp argument som redan finns i en lista eller en tupel så att alla element i listan överförs som olika parametrar.

Använda samma funktion:

def func (* args): # * args betyder för hur många argument du tar in, det kommer att få dem alla för arg i args: print (arg) l = [11,3,4,5, "tuts"] print func (* l))

Den * kommer att packa upp listan och mata ut varje enskilt listobjekt. Utmatning 11 3 4 5 tuttar

Kwargs

Kwargs gör att du kan skicka sökordsargument till en funktion. De används när du inte är säker på antalet sökordsargument som ska överföras i funktionen.

Skriv en funktion my_func och passera in (x = 10, y = 20) som sökord argument som visas nedan:

def my_func (x = 10, y = 20): skriv ut x, y

Detta skriver ut värdena på x och y Utgång 10,20

Kvitton kan användas för att packa upp ordlistor, värdepar. Detta görs med hjälp av dubbla asterisknotationen (**). Det är viktigt att notera att varje nyckel måste matchas med ett värde.

Här är ett typiskt exempel på hur det görs. Funktionen nedan tar länder som nycklar och deras huvudstäder som värden. Det skriver sedan ut ett uttalande som iterates över kvargerna och kartlägger varje sökord till det värde som tilldelats det.

def capital_cities (** kwargs): # initiera en tom lista för att lagra resultatresultatet = [] för nyckelvärdet i kwargs.items (): result.append ("Huvudstaden  är  .format , värde) returresultat

Du kan ringa funktionen med alla argument du vill ha.

def capital_cities (** kwargs): # initiera en tom lista för att lagra resultatresultatet = [] för nyckelvärdet i kwargs.items (): result.append ("Huvudstaden  är  .format , värde) returresultat print capital_city (Kina = "Beijing", Kairo = "Egypten", Rom = "Italien"))

produktion ['Huvudstaden i Kina är Peking', 'Huvudstaden Kairo är Egypten', 'Romens huvudstad är Italien']

För ett mer komplext exempel, anta att vi har en modell för en kund som ser något ut så här:

klassen kund (models.Model): first_name = models.CharField (max_length = 100, null = True) last_name = models.CharField (max_length = 100) användarnamn = models.Charfield (max_length = 100) email = models.EmailField (max_length = 100) lösenord = models.CharField (max_length = 100)

Du kan använda kvargar för att göra både dataingångar och datasökningar från modellobjekt. Låt oss skriva en funktionsvy för att skapa en ny kund.

Kwargs = "first_name": "John", "last_name": "Doe", "användarnamn": "johndoe", "email" [email protected] "," lösenord ":" 1234 " new_user = Användare * Kwargs) new_user.save ()

Så här gör du en fråga från den kund som vi just skapat med hjälp av kvoter.

filter_customer = 'email': [email protected], 'användarnamn': johndoe, Customer.objects.filter (** filter_customer)

Använda båda Args och Kwargs i en funktion

När du använder både args och kwargs i samma funktionsdefinition, * args måste ske före ** kwargs.

klass MyFunction (Foo): def __init __ (själv, * args, ** kwargs): skriv ut 'min funktion' super (MyFunction, self) .__ init __ (* args, ** kwargs)

Exempel:

def Func (* args, ** kwargs): för arg i args: skriv arg arg för objekt i kwargs.items (): print item

Kom ihåg args bör komma före kwargs.

def Func (* args, ** kwargs): för arg i args: skriv arg arg för objekt i kwargs.items (): skriv ut artikelutskrift Func (1, x = 7, u = 8)

Utgång 1 ('x', 7) ('u', 8)

Slutsats

Jag hoppas att denna handledning har hjälpt dig att förstå args och kwargs.

Nedan följer några tips för att komma ihåg när du använder args och kwargs:

* args och ** kwargs är speciell syntax som används i funktioner för att överföra ett variabelt antal argument till en funktion.
* args förekomma före ** kwargs i en funktionsdefinition.
* args och ** kwargs används bäst i situationer där antalet ingångar blir relativt små.
Du kan använda vilket namn du vill ha; args och kwargs är endast enligt konvention och inte ett krav. Till exempel kan du använda * foo istället för * args eller ** foo istället för ** kwargs.

Den officiella Python-dokumentationen ger mycket information för vidare studier. Tveka inte att se vad vi har till salu och studera på marknaden, och tveka inte att ställa några frågor och ge din värdefulla feedback genom att använda foderet nedan.

Koda