Hva gjør ** (dobbel stjerne / stjerne) og * (stjerne / asterisk) gjøre for parametrene?

stemmer
1k

I de følgende metodedefinisjoner, hva betyr det *og **gjøre for param2?

def foo(param1, *param2):
def bar(param1, **param2):
Publisert på 31/08/2008 klokken 15:04
kilden bruker
På andre språk...                            


20 svar

stemmer
1k

Den *argsog **kwargser et vanlig tilfelle for å tillate vilkårlig antall argumenter til funksjoner som er beskrevet i avsnittet mer på definerer funksjoner i Python dokumentasjon.

Det *argsvil gi deg alle funksjonsparametere som en tuppel :

In [1]: def foo(*args):
   ...:     for a in args:
   ...:         print a
   ...:         
   ...:         

In [2]: foo(1)
1


In [4]: foo(1,2,3)
1
2
3

Det **kwargsvil gi deg alle søkeord argumenter bortsett fra for dem som tilsvarer en formell parameter som en ordbok.

In [5]: def bar(**kwargs):
   ...:     for a in kwargs:
   ...:         print a, kwargs[a]
   ...:         
   ...:         

In [6]: bar(name='one', age=27)
age 27
name one

Begge uttrykk kan blandes med vanlige argumenter for å gi et sett med faste og noen variable argumenter:

def foo(kind, *args, **kwargs):
   pass

En annen bruk av *lidiom er å pakke ut argumentlister når du ringer en funksjon.

In [9]: def foo(bar, lee):
   ...:     print bar, lee
   ...:     
   ...:     

In [10]: l = [1,2]

In [11]: foo(*l)
1 2

I Python 3 er det mulig å bruke *lpå venstre side av en tildeling ( Extended Iterable Pakke ut ), men det gir en liste i stedet for et tuppel i denne sammenheng:

first, *rest = [1,2,3,4]
first, *l, last = [1,2,3,4]

Også Python tre legger ny semantisk (se PEP 3102 ):

def func(arg1, arg2, arg3, *, kwarg1, kwarg2):
    pass

En slik funksjon aksepterer bare tre posisjon argumenter, og alt etter *kun kan sendes som søkeord argumenter.

Svarte 31/08/2008 kl. 15:17
kilden bruker

stemmer
458

Det er også verdt å merke seg at du kan bruke *og **når du ringer funksjoner også. Dette er en snarvei som gjør det mulig å passere flere argumenter til en funksjon direkte ved hjelp av enten en liste / tuppel eller en ordbok. For eksempel, hvis du har følgende funksjon:

def foo(x,y,z):
    print("x=" + str(x))
    print("y=" + str(y))
    print("z=" + str(z))

Du kan gjøre ting som:

>>> mylist = [1,2,3]
>>> foo(*mylist)
x=1
y=2
z=3

>>> mydict = {'x':1,'y':2,'z':3}
>>> foo(**mydict)
x=1
y=2
z=3

>>> mytuple = (1, 2, 3)
>>> foo(*mytuple)
x=1
y=2
z=3

Merk: Tastene på mydictå bli navngitt akkurat som parametrene av funksjon foo. Ellers vil det kaste en TypeError:

>>> mydict = {'x':1,'y':2,'z':3,'badnews':9}
>>> foo(**mydict)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() got an unexpected keyword argument 'badnews'
Svarte 31/08/2008 kl. 15:47
kilden bruker

stemmer
131

Singelen * betyr at det kan være en rekke ekstra posisjon argumenter. foo()kan påberopes som foo(1,2,3,4,5). I kroppen av foo () param2 er en sekvens inneholdende 2-5.

Den doble ** betyr at det kan være en rekke ekstra navngitte parametre. bar()kan påberopes som bar(1, a=2, b=3). I kroppen av bar () param2 er en ordbok som inneholder { 'en': 2, 'b': 3}

Med følgende kode:

def foo(param1, *param2):
    print param1
    print param2

def bar(param1, **param2):
    print param1
    print param2

foo(1,2,3,4,5)
bar(1,a=2,b=3)

utgangen er

1
(2, 3, 4, 5)
1
{'a': 2, 'b': 3}
Svarte 31/08/2008 kl. 15:20
kilden bruker

stemmer
108

Hva gjør **(dobbel stjerne) og *(stjerne) gjør for parametrene

De tillater for funksjoner som skal defineres til å akseptere og for brukere å passere en rekke argumenter, posisjons ( *) og søkeord ( **).

definere funksjoner

*argsgjør det mulig for et hvilket som helst antall valgfrie posisjon argumenter (parametere), som vil bli tildelt til en tuppel heter args.

**kwargsgjør det mulig for et hvilket som helst antall valgfrie søkeord argumenter (parametere), som vil være i en dict heter kwargs.

Du kan (og bør) velge noen passende navn, men hvis hensikten er for argumentene for å være av ikke-spesifikke semantikk, argsog kwargser standard navn.

Ekspansjon, Passerer en rekke argumenter

Du kan også bruke *argsog **kwargså passere i parametre fra listene (eller noen iterable) og dicts (eller kartlegging), henholdsvis.

Funksjonen mottar parametrene trenger ikke å vite at de blir utvidet.

For eksempel ikke Python 2s xrange ikke eksplisitt forvente *args, men siden det tar 3 heltall som argumenter:

>>> x = xrange(3) # create our *args - an iterable of 3 integers
>>> xrange(*x)    # expand here
xrange(0, 2, 2)

Som et annet eksempel kan vi bruke dict ekspansjon i str.format:

>>> foo = 'FOO'
>>> bar = 'BAR'
>>> 'this is foo, {foo} and bar, {bar}'.format(**locals())
'this is foo, FOO and bar, BAR'

Nye i Python 3: Definere funksjoner med søkeord bare argumenter

Du kan ha søkeord bare argumenter etter *args- for eksempel her, kwarg2må gis som et søkeord argument - ikke posisjonelt:

def foo(arg, kwarg=None, *args, kwarg2=None, **kwargs): 
    return arg, kwarg, args, kwarg2, kwargs

bruk:

>>> foo(1,2,3,4,5,kwarg2='kwarg2', bar='bar', baz='baz')
(1, 2, (3, 4, 5), 'kwarg2', {'bar': 'bar', 'baz': 'baz'})

Også *kan brukes av seg selv for å vise at søkeordet bare argumenter følge, uten noe som åpner for ubegrensede posisjon argumenter.

def foo(arg, kwarg=None, *, kwarg2=None, **kwargs): 
    return arg, kwarg, kwarg2, kwargs

Her kwarg2igjen må være en eksplisitt nevnt, søkeord argument:

>>> foo(1,2,kwarg2='kwarg2', foo='foo', bar='bar')
(1, 2, 'kwarg2', {'foo': 'foo', 'bar': 'bar'})

Og vi kan ikke lenger godta ubegrenset posisjon argumenter fordi vi ikke har *args*:

>>> foo(1,2,3,4,5, kwarg2='kwarg2', foo='foo', bar='bar')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() takes from 1 to 2 positional arguments 
    but 5 positional arguments (and 1 keyword-only argument) were given

Igjen, enklere, her trenger vi kwargå bli gitt ved navn, ikke posisjonelt:

def bar(*, kwarg=None): 
    return kwarg

I dette eksempelet ser vi at hvis vi prøver å passere kwargposisjonelt, vi får en feilmelding:

>>> bar('kwarg')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: bar() takes 0 positional arguments but 1 was given

Vi må eksplisitt passere kwargparameter som søkeord argument.

>>> bar(kwarg='kwarg')
'kwarg'

Python 2 kompatible demoer

*args(typisk sa "stjerne-args") og **kwargs(stjerner kan være implisitt ved å si "kwargs", men være eksplisitt med "dobbel-stjerners kwargs") er vanlige idiomer av Python for å bruke *og **notasjon. Disse spesifikke variabelnavn er ikke nødvendig (f.eks du kan bruke *foosog **bars), men et avvik fra konvensjonen er sannsynlig å gjøre rasende de andre Python programmerere.

Vi vanligvis bruker disse når vi ikke vet hva vår funksjon kommer til å motta eller hvor mange argumenter vi kan være bestått, og noen ganger også når navngi hver variabel for seg ville bli veldig rotete og redundante (men dette er en sak der vanligvis eksplisitt er bedre enn implisitt).

eksempel 1

Følgende funksjon beskriver hvordan de kan brukes, og demonstrerer atferd. Merk den navngitte bargumentet vil bli fortært av den andre posisjons argument før:

def foo(a, b=10, *args, **kwargs):
    '''
    this function takes required argument a, not required keyword argument b
    and any number of unknown positional arguments and keyword arguments after
    '''
    print('a is a required argument, and its value is {0}'.format(a))
    print('b not required, its default value is 10, actual value: {0}'.format(b))
    # we can inspect the unknown arguments we were passed:
    #  - args:
    print('args is of type {0} and length {1}'.format(type(args), len(args)))
    for arg in args:
        print('unknown arg: {0}'.format(arg))
    #  - kwargs:
    print('kwargs is of type {0} and length {1}'.format(type(kwargs),
                                                        len(kwargs)))
    for kw, arg in kwargs.items():
        print('unknown kwarg - kw: {0}, arg: {1}'.format(kw, arg))
    # But we don't have to know anything about them 
    # to pass them to other functions.
    print('Args or kwargs can be passed without knowing what they are.')
    # max can take two or more positional args: max(a, b, c...)
    print('e.g. max(a, b, *args) \n{0}'.format(
      max(a, b, *args))) 
    kweg = 'dict({0})'.format( # named args same as unknown kwargs
      ', '.join('{k}={v}'.format(k=k, v=v) 
                             for k, v in sorted(kwargs.items())))
    print('e.g. dict(**kwargs) (same as {kweg}) returns: \n{0}'.format(
      dict(**kwargs), kweg=kweg))

Vi kan sjekke den elektroniske hjelpen for funksjonen underskrift, med help(foo), som forteller oss

foo(a, b=10, *args, **kwargs)

La oss kalle denne funksjonen med foo(1, 2, 3, 4, e=5, f=6, g=7)

som utskrifter:

a is a required argument, and its value is 1
b not required, its default value is 10, actual value: 2
args is of type <type 'tuple'> and length 2
unknown arg: 3
unknown arg: 4
kwargs is of type <type 'dict'> and length 3
unknown kwarg - kw: e, arg: 5
unknown kwarg - kw: g, arg: 7
unknown kwarg - kw: f, arg: 6
Args or kwargs can be passed without knowing what they are.
e.g. max(a, b, *args) 
4
e.g. dict(**kwargs) (same as dict(e=5, f=6, g=7)) returns: 
{'e': 5, 'g': 7, 'f': 6}

eksempel 2

Vi kan også kalle det å bruke en annen funksjon, der vi bare gi a:

def bar(a):
    b, c, d, e, f = 2, 3, 4, 5, 6
    # dumping every local variable into foo as a keyword argument 
    # by expanding the locals dict:
    foo(**locals()) 

bar(100) utskrifter:

a is a required argument, and its value is 100
b not required, its default value is 10, actual value: 2
args is of type <type 'tuple'> and length 0
kwargs is of type <type 'dict'> and length 4
unknown kwarg - kw: c, arg: 3
unknown kwarg - kw: e, arg: 5
unknown kwarg - kw: d, arg: 4
unknown kwarg - kw: f, arg: 6
Args or kwargs can be passed without knowing what they are.
e.g. max(a, b, *args) 
100
e.g. dict(**kwargs) (same as dict(c=3, d=4, e=5, f=6)) returns: 
{'c': 3, 'e': 5, 'd': 4, 'f': 6}

Eksempel 3: praktisk bruk i refined

OK, så kanskje vi ikke ser nytten enda. Så tenk du har flere funksjoner med overflødig kode før og / eller etter differensiere kode. Følgende navngitte funksjoner er bare pseudo-kode veiledende.

def foo(a, b, c, d=0, e=100):
    # imagine this is much more code than a simple function call
    preprocess() 
    differentiating_process_foo(a,b,c,d,e)
    # imagine this is much more code than a simple function call
    postprocess()

def bar(a, b, c=None, d=0, e=100, f=None):
    preprocess()
    differentiating_process_bar(a,b,c,d,e,f)
    postprocess()

def baz(a, b, c, d, e, f):
    ... and so on

Vi kan være i stand til å håndtere dette på en annen måte, men vi kan sikkert trekke ut redundans med en dekoratør, og så vår under eksemplet viser hvordan *argsog **kwargskan være svært nyttig:

def decorator(function):
    '''function to wrap other functions with a pre- and postprocess'''
    @functools.wraps(function) # applies module, name, and docstring to wrapper
    def wrapper(*args, **kwargs):
        # again, imagine this is complicated, but we only write it once!
        preprocess()
        function(*args, **kwargs)
        postprocess()
    return wrapper

Og nå hver innpakket funksjon kan skrives mye mer konsist, som vi har tatt ut redundans:

@decorator
def foo(a, b, c, d=0, e=100):
    differentiating_process_foo(a,b,c,d,e)

@decorator
def bar(a, b, c=None, d=0, e=100, f=None):
    differentiating_process_bar(a,b,c,d,e,f)

@decorator
def baz(a, b, c=None, d=0, e=100, f=None, g=None):
    differentiating_process_baz(a,b,c,d,e,f, g)

@decorator
def quux(a, b, c=None, d=0, e=100, f=None, g=None, h=None):
    differentiating_process_quux(a,b,c,d,e,f,g,h)

Og ved factoring ut vår kode, som *argsog **kwargstillater oss å gjøre, reduserer vi kodelinjer, bedre lesbarhet og vedlikehold, og har såle kanoniske steder for logikken i vårt program. Hvis vi trenger å endre noen del av denne strukturen, har vi ett sted der å gjøre hver endring.

Svarte 14/10/2014 kl. 16:34
kilden bruker

stemmer
38

La oss først forstå hva er posisjonelle argumenter og søkeord argumenter. Nedenfor er et eksempel på en funksjonsdefinisjon med Posisjons argumenter.

def test(a,b,c):
     print(a)
     print(b)
     print(c)

test(1,2,3)
#output:
1
2
3

Så dette er en funksjon definisjon med posisjonelle argumenter. Du kan kalle det med søkeord / navngitte argumenter også:

def test(a,b,c):
     print(a)
     print(b)
     print(c)

test(a=1,b=2,c=3)
#output:
1
2
3

Nå la oss studere et eksempel på funksjonsdefinisjonen med søkeord argumenter :

def test(a=0,b=0,c=0):
     print(a)
     print(b)
     print(c)
     print('-------------------------')

test(a=1,b=2,c=3)
#output :
1
2
3
-------------------------

Du kan kalle denne funksjonen med posisjonelle argumenter også:

def test(a=0,b=0,c=0):
    print(a)
    print(b)
    print(c)
    print('-------------------------')

test(1,2,3)
# output :
1
2
3
---------------------------------

Så nå vet vi funksjonsdefinisjoner med posisjon samt søkeord argumenter.

Nå la oss studere '*' operatør og '**' operatør.

Vær oppmerksom på disse operatørene kan brukes i 2 områder:

a) funksjonskall

b) funksjonsdefinisjon

Bruken av '*' operatør og '**' operatør i funksjonskall.

La oss få rett til et eksempel, og deretter diskutere det.

def sum(a,b):  #receive args from function calls as sum(1,2) or sum(a=1,b=2)
    print(a+b)

my_tuple = (1,2)
my_list = [1,2]
my_dict = {'a':1,'b':2}

# Let us unpack data structure of list or tuple or dict into arguments with help of '*' operator
sum(*my_tuple)   # becomes same as sum(1,2) after unpacking my_tuple with '*'
sum(*my_list)    # becomes same as sum(1,2) after unpacking my_list with  '*'
sum(**my_dict)   # becomes same as sum(a=1,b=2) after unpacking by '**' 

# output is 3 in all three calls to sum function.

så husk

når '*' eller '**' operatør brukes i et funksjonskall -

'*' Operatør pakker ut datastruktur, slik som en liste eller tuppel til argumenter som trengs av funksjonsdefinisjon.

'**' Driv pakker en ordbok til argumenter som trengs av funksjonsdefinisjon.

Nå la oss studere '*' operatør bruk i funksjonsdefinisjonen . Eksempel:

def sum(*args): #pack the received positional args into data structure of tuple. after applying '*' - def sum((1,2,3,4))
    sum = 0
    for a in args:
        sum+=a
    print(sum)

sum(1,2,3,4)  #positional args sent to function sum
#output:
10

I funksjonsdefinisjon inn '*' operatør pakker av de mottatte argumentene inn i en tuppel.

Nå la oss se et eksempel på '**' brukes i funksjonsdefinisjonen:

def sum(**args): #pack keyword args into datastructure of dict after applying '**' - def sum({a:1,b:2,c:3,d:4})
    sum=0
    for k,v in args.items():
        sum+=v
    print(sum)

sum(a=1,b=2,c=3,d=4) #positional args sent to function sum

I funksjonsdefinisjon The '**' operatør pakker av de mottatte argumentene inn i en ordbok.

Så husk:

I en funksjonskall inn '*' pakker ut datastruktur av tuppel eller en liste til posisjon eller søkeord argumentene som skal mottas av funksjonsdefinisjon.

I en funksjon kalle den '**' pakker ut datastruktur av ordlisten i posisjon eller søkeord argumentene som skal mottas av funksjonsdefinisjon.

I en funksjonsdefinisjon inn '*' pakker posisjons argumenter i en tuppel.

I en funksjonsdefinisjon den '**' pakker søkeord argumenter i en ordbok.

Svarte 20/01/2016 kl. 11:40
kilden bruker

stemmer
20

*og **har spesiell bruk i funksjonen argumentlisten. * innebærer at argumentet er en liste og **innebærer at argumentet er en ordbok. Dette gjør at funksjoner for å ta vilkårlig antall argumenter

Svarte 11/09/2012 kl. 04:33
kilden bruker

stemmer
11

Fra Python dokumentasjon:

Hvis det er flere posisjons argumenter enn det finnes formell parameter slisser, er en Feiltype unntak hevet, med mindre en formell parameter ved hjelp av syntaksen "* identifikator" er til stede; i dette tilfellet mottar den formelle parameter en tuppel inneholder overskuddet av posisjon argumenter (eller en tom tuppel hvis det ikke var noe overskudd posisjons argumenter).

Dersom et søkeord argument ikke tilsvarer en formell parameter navn, er en Feiltype unntak hevet, med mindre en formell parameter ved hjelp av syntaksen "** identifikator" er til stede; i dette tilfellet mottar den formelle parameter en ordbok inneholder overskuddet av søke argumenter (ved bruk av nøkkelord som nøkler og argumentverdiene som tilsvarende verdier), eller en (ny) tom ordliste hvis det ikke var noe overskudd søkeord argumenter.

Svarte 31/08/2008 kl. 15:07
kilden bruker

stemmer
7

Mens anvendelser for stjerne / splat operatører har blitt ekspandert i Python 3, I som den følgende tabell som gjelder anvendelse av disse operatorene med funksjonene . Sprut operatøren (e) kan brukes både i funksjon konstruksjon og i funksjonsanrop :

            In function *construction*      In function *call*
=======================================================================
          |  def f(*args):                 |  def f(a, b):
*args     |      for arg in args:          |      return a + b
          |          print(arg)            |  args = (1, 2)
          |  f(1, 2)                       |  f(*args)
----------|--------------------------------|---------------------------
          |  def f(a, b):                  |  def f(a, b):
**kwargs  |      return a + b              |      return a + b
          |  def g(**kwargs):              |  kwargs = dict(a=1, b=2)
          |      return f(**kwargs)        |  f(**kwargs)
          |  g(a=1, b=2)                   |
-----------------------------------------------------------------------

Dette egentlig bare tjener til å oppsummere Lorin Hochstein er svaret , men jeg synes det er nyttig.

Svarte 30/11/2017 kl. 18:28
kilden bruker

stemmer
7

Jeg ønsker å gi et eksempel som andre ikke har nevnt

* Kan også pakke en generator

Et eksempel fra Python3 Document

x = [1, 2, 3]
y = [4, 5, 6]

unzip_x, unzip_y = zip(*zip(x, y))

unzip_x vil være [1, 2, 3], unzip_y vil være [4, 5, 6]

Glidelåsen () mottar flere iretable args, og returnere en generator.

zip(*zip(x,y)) -> zip((1, 4), (2, 5), (3, 6))
Svarte 08/11/2016 kl. 16:50
kilden bruker

stemmer
6

I Python 3.5, kan du også bruke denne syntaksen i list, dict, tuple, og setviser (også noen ganger kalt litteraler). Se PEP 488: Tilleggs Pakke generaliseringer .

>>> (0, *range(1, 4), 5, *range(6, 8))
(0, 1, 2, 3, 5, 6, 7)
>>> [0, *range(1, 4), 5, *range(6, 8)]
[0, 1, 2, 3, 5, 6, 7]
>>> {0, *range(1, 4), 5, *range(6, 8)}
{0, 1, 2, 3, 5, 6, 7}
>>> d = {'one': 1, 'two': 2, 'three': 3}
>>> e = {'six': 6, 'seven': 7}
>>> {'zero': 0, **d, 'five': 5, **e}
{'five': 5, 'seven': 7, 'two': 2, 'one': 1, 'three': 3, 'six': 6, 'zero': 0}

Det gir også flere iterables å bli pakket i en enkelt funksjon samtale.

>>> range(*[1, 10], *[2])
range(1, 10, 2)

(Takket være mgilson for PEP kobling).

Svarte 08/12/2015 kl. 21:38
kilden bruker

stemmer
5

For de av dere som lærer ved eksempler!

  1. Formålet * er å gi deg muligheten til å definere en funksjon som kan ta et vilkårlig antall argumenter gitt som en liste (f.eks f(*myList)).
  2. Formålet **er å gi deg muligheten til å mate en funksjon argumenter ved å tilby en ordbok (for eksempel f(**{'x' : 1, 'y' : 2})).

La oss vise dette ved å definere en funksjon som tar to normale variabler x, yog kan ta imot flere argumenter som myArgs, og kan ta imot enda flere argumenter som myKW. Senere vil vi vise hvordan du kan mate yhjelp myArgDict.

def f(x, y, *myArgs, **myKW):
    print("# x      = {}".format(x))
    print("# y      = {}".format(y))
    print("# myArgs = {}".format(myArgs))
    print("# myKW   = {}".format(myKW))
    print("# ----------------------------------------------------------------------")

# Define a list for demonstration purposes
myList    = ["Left", "Right", "Up", "Down"]
# Define a dictionary for demonstration purposes
myDict    = {"Wubba": "lubba", "Dub": "dub"}
# Define a dictionary to feed y
myArgDict = {'y': "Why?", 'y0': "Why not?", "q": "Here is a cue!"}

# The 1st elem of myList feeds y
f("myEx", *myList, **myDict)
# x      = myEx
# y      = Left
# myArgs = ('Right', 'Up', 'Down')
# myKW   = {'Wubba': 'lubba', 'Dub': 'dub'}
# ----------------------------------------------------------------------

# y is matched and fed first
# The rest of myArgDict becomes additional arguments feeding myKW
f("myEx", **myArgDict)
# x      = myEx
# y      = Why?
# myArgs = ()
# myKW   = {'y0': 'Why not?', 'q': 'Here is a cue!'}
# ----------------------------------------------------------------------

# The rest of myArgDict becomes additional arguments feeding myArgs
f("myEx", *myArgDict)
# x      = myEx
# y      = y
# myArgs = ('y0', 'q')
# myKW   = {}
# ----------------------------------------------------------------------

# Feed extra arguments manually and append even more from my list
f("myEx", 4, 42, 420, *myList, *myDict, **myDict)
# x      = myEx
# y      = 4
# myArgs = (42, 420, 'Left', 'Right', 'Up', 'Down', 'Wubba', 'Dub')
# myKW   = {'Wubba': 'lubba', 'Dub': 'dub'}
# ----------------------------------------------------------------------

# Without the stars, the entire provided list and dict become x, and y:
f(myList, myDict)
# x      = ['Left', 'Right', 'Up', 'Down']
# y      = {'Wubba': 'lubba', 'Dub': 'dub'}
# myArgs = ()
# myKW   = {}
# ----------------------------------------------------------------------

Advarsler

  1. ** er utelukkende reservert for ordbøker.
  2. Non-valgfritt argument oppdrag skjer først.
  3. Du kan ikke bruke en ikke-valgfritt argument to ganger.
  4. Hvis det er aktuelt, **må komme etter *, alltid.
Svarte 22/05/2018 kl. 07:03
kilden bruker

stemmer
4

I tillegg til å fungere samtaler, * args og ** kwargs er nyttige i klassen hierarkier og også unngå å måtte skrive __init__metoden i Python. Lignende bruk kan sees i rammeverk som Django kode.

For eksempel,

def __init__(self, *args, **kwargs):
    for attribute_name, value in zip(self._expected_attributes, args):
        setattr(self, attribute_name, value)
        if kwargs.has_key(attribute_name):
            kwargs.pop(attribute_name)

    for attribute_name in kwargs.viewkeys():
        setattr(self, attribute_name, kwargs[attribute_name])

En underklasse kan da være

class RetailItem(Item):
    _expected_attributes = Item._expected_attributes + ['name', 'price', 'category', 'country_of_origin']

class FoodItem(RetailItem):
    _expected_attributes = RetailItem._expected_attributes +  ['expiry_date']

Underklasse deretter bli instansiert som

food_item = FoodItem(name = 'Jam', 
                     price = 12.0, 
                     category = 'Foods', 
                     country_of_origin = 'US', 
                     expiry_date = datetime.datetime.now())

Dessuten kan en underklasse med en ny egenskap som er fornuftig bare til at underklasse eksempel ringe base klassen __init__for å avlaste den attributter innstillingen. Dette gjøres gjennom * args og ** kwargs. kwargs hovedsakelig brukes slik at kode er lesbar ved hjelp av navngitte argumenter. For eksempel,

class ElectronicAccessories(RetailItem):
    _expected_attributes = RetailItem._expected_attributes +  ['specifications']
    # Depend on args and kwargs to populate the data as needed.
    def __init__(self, specifications = None, *args, **kwargs):
        self.specifications = specifications  # Rest of attributes will make sense to parent class.
        super(ElectronicAccessories, self).__init__(*args, **kwargs)

som kan instatiated så

usb_key = ElectronicAccessories(name = 'Sandisk', 
                                price = '$6.00', 
                                category = 'Electronics',
                                country_of_origin = 'CN',
                                specifications = '4GB USB 2.0/USB 3.0')

Den komplette kode er her

Svarte 16/08/2015 kl. 04:23
kilden bruker

stemmer
1

Dette eksempelet vil hjelpe deg å huske *args, **kwargsog selv superog arv i Python på en gang.

class base(object):
    def __init__(self, base_param):
        self.base_param = base_param


class child1(base): # inherited from base class
    def __init__(self, child_param, *args) # *args for non-keyword args
        self.child_param = child_param
        super(child1, self).__init__(*args) # call __init__ of the base class and initialize it with a NON-KEYWORD arg

class child2(base):
    def __init__(self, child_param, **kwargs):
        self.child_param = child_param
        super(child2, self).__init__(**kwargs) # call __init__ of the base class and initialize it with a KEYWORD arg

c1 = child1(1,0)
c2 = child2(1,base_param=0)
print c1.base_param # 0
print c1.child_param # 1
print c2.base_param # 0
print c2.child_param # 1
Svarte 26/11/2016 kl. 21:09
kilden bruker

stemmer
1

Et godt eksempel på bruk av både en funksjon er:

>>> def foo(*arg,**kwargs):
...     print arg
...     print kwargs
>>>
>>> a = (1, 2, 3)
>>> b = {'aa': 11, 'bb': 22}
>>>
>>>
>>> foo(*a,**b)
(1, 2, 3)
{'aa': 11, 'bb': 22}
>>>
>>>
>>> foo(a,**b) 
((1, 2, 3),)
{'aa': 11, 'bb': 22}
>>>
>>>
>>> foo(a,b) 
((1, 2, 3), {'aa': 11, 'bb': 22})
{}
>>>
>>>
>>> foo(a,*b)
((1, 2, 3), 'aa', 'bb')
{}
Svarte 26/10/2016 kl. 12:48
kilden bruker

stemmer
0

Bygger på nickd er svaret ...

def foo(param1, *param2):
    print(param1)
    print(param2)


def bar(param1, **param2):
    print(param1)
    print(param2)


def three_params(param1, *param2, **param3):
    print(param1)
    print(param2)
    print(param3)


print(foo(1, 2, 3, 4, 5))
print("\n")
print(bar(1, a=2, b=3))
print("\n")
print(three_params(1, 2, 3, 4, s=5))

Produksjon:

1
(2, 3, 4, 5)

1
{'a': 2, 'b': 3}

1
(2, 3, 4)
{'s': 5}

I utgangspunktet en rekke posisjon argumenter kan bruke * args og noen navngitte argumenter (eller kwargs aka søkeord argumenter) kan bruke ** kwargs.

Svarte 10/07/2019 kl. 05:59
kilden bruker

stemmer
0

TL; DR

Det pakker argumenter som sendes til funksjonen inn i listog dicthenholdsvis på innsiden av funksjonsbasisen. Når du definerer en funksjon signatur som dette:

def func(*args, **kwds):
    # do stuff

det kan kalles med en rekke argumenter og søkeord argumenter. De ikke-nøkkelordargumenter få pakket inn i en liste kalt argsinne i funksjonen kroppen og søkeord argumentene få pakket inn i en dict kalt kwdsinne i funksjonen kroppen.

func("this", "is a list of", "non-keyowrd", "arguments", keyword="ligma", options=[1,2,3])

nå inne i funksjon legeme, når funksjonen kalles, er det to lokale variable, argssom er en liste som har verdi ["this", "is a list of", "non-keyword", "arguments"]og kwdssom er en dictsom har verdi{"keyword" : "ligma", "options" : [1,2,3]}


Dette fungerer også i revers, dvs. fra den som ringer side. for eksempel hvis du har en funksjon som er definert som:

def f(a, b, c, d=1, e=10):
    # do stuff

du kan kalle det med ved utpakking iterables eller kartlegginger du har i ringer omfang:

iterable = [1, 20, 500]
mapping = {"d" : 100, "e": 3}
f(*iterable, **mapping)
# That call is equivalent to
f(1, 20, 500, d=100, e=3)
Svarte 02/04/2019 kl. 12:43
kilden bruker

stemmer
0
  • def foo(param1, *param2):er en metode kan ta imot vilkårlig antall verdier for *param2,
  • def bar(param1, **param2): er en metode kan akseptere vilkårlig antall verdier med nøkler for *param2
  • param1 er en enkel parameter.

For eksempel, syntaksen for implementering varargs i Java som følger:

accessModifier methodName(datatype… arg) {
    // method body
}
Svarte 02/09/2018 kl. 05:14
kilden bruker

stemmer
0

* betyr motta variable argumenter som listen

** betyr motta variable argumenter som ordbok

Brukes som følgende:

1) enkelt *

def foo(*args):
    for arg in args:
        print(arg)

foo("two", 3)

Produksjon:

two
3

2) Nå **

def bar(**kwargs):
    for key in kwargs:
        print(key, kwargs[key])

bar(dic1="two", dic2=3)

Produksjon:

dic1 two
dic2 3
Svarte 07/08/2018 kl. 18:28
kilden bruker

stemmer
0

*argsog **kwargs: tillate deg å passere et variabelt antall argumenter til en funksjon.

*args: Brukes til å sende et ikke-keyworded variabel lengde argumentlisten til funksjonen:

def args(normal_arg, *argv):
    print ("normal argument:",normal_arg)

    for arg in argv:
        print("Argument in list of arguments from *argv:", arg)

args('animals','fish','duck','bird')

Vil produsere:

normal argument: animals
Argument in list of arguments from *argv: fish
Argument in list of arguments from *argv: duck
Argument in list of arguments from *argv: bird

**kwargs*

**kwargsgjør det mulig å passere keyworded variabel lengde argumenter til en funksjon. Du bør bruke **kwargshvis du ønsker å håndtere navngitte argumenter i en funksjon.

def who(**kwargs):
    if kwargs is not None:
        for key, value in kwargs.items():
            print ("Your %s is %s." %(key,value))

who (name="Nikola", last_name="Tesla", birthday = "7.10.1856", birthplace = "Croatia")  

Vil produsere:

Your name is Nikola.
Your last_name is Tesla.
Your birthday is 7.10.1856.
Your birthplace is Croatia.
Svarte 01/05/2018 kl. 12:54
kilden bruker

stemmer
-1

* Args = * alist = alle elementer i en liste

** args = ** adict = alle elementer i en dict

Svarte 08/12/2017 kl. 01:36
kilden bruker

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more