Was bedeutet ** (doppelter Stern/Sternchen) und * (Stern/asterisk) für Parameter?

Es ist auch erwähnenswert, dass können Sie * und ** beim aufrufen von Funktionen. Dies ist eine Verknüpfung, können Sie mehrere Argumente übergeben, um eine Funktion direkt entweder eine Liste/Tupel oder dictionary. Zum Beispiel, wenn Sie haben die folgende Funktion:

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

Können Sie Sachen wie tun:

>>> 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

Hinweis: Die Schlüssel in mydict haben, benannt zu werden, genau wie die Parameter der Funktion foo. Sonst wird es werfen eine 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'

InformationsquelleAutor Lorin Hochstein

Was bedeutet ** (double star) und * (Sterne) für Parameter

Ermöglichen Sie Funktionen werden definiert, um zu akzeptieren und für Benutzer zu übergeben eine beliebige Anzahl von Argumenten positionierten (*) und keyword (**).

Definition Von Funktionen

*args ermöglicht eine beliebige Anzahl von optionalen positions-Argumente (Parameter), die zugewiesen werden, um ein Tupel mit Namen args.

**kwargs ermöglicht eine beliebige Anzahl von optionalen Schlüsselwort-Argumente (Parameter), die in einem dict namens kwargs.

Kann (und sollte) wählen Sie einen beliebigen geeigneten Namen, aber wenn das die Absicht ist für die Argumente, um nicht-spezifische Semantik, die args und kwargs sind die standard-Namen.

Erweiterung, die Übergabe einer beliebigen Anzahl von Argumenten

Können Sie auch *args und **kwargs übergeben Parameter von Listen (oder beliebig iterierbar) und dicts (oder mapping), beziehungsweise.

Die Funktion empfängt die Parameter, die nicht wissen, dass Sie ausgebaut wird.

Beispielsweise Python 2 xrange nicht explizit erwarten *args, aber da dauert es 3 ganze zahlen als Argumente:

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

Als ein weiteres Beispiel, das wir verwenden können, dict expansion in str.format:

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

Neues in Python 3: Definition von Funktionen mit dem Schlüsselwort nur Argumente

Können Sie Stichwort nur Argumente nach der *args - zum Beispiel hier kwarg2 gegeben werden müssen, als keyword-argument - nicht positionsbezogen:

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

Verwendung:

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

Auch * kann allein verwendet werden, um anzuzeigen, dass das Schlüsselwort nur Argumente Folgen, ohne dass für unbegrenzte positions-Argumente.

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

Hier kwarg2 wieder muss ein explizit benannt, keyword-argument:

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

Ist und wir nicht länger akzeptieren können unbegrenzt positionale Argumente, weil wir nicht *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

Wieder, mehr einfach, hier benötigen wir kwarg sein name, nicht positionsbezogen:

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

In diesem Beispiel sehen wir, dass, wenn wir versuchen, pass kwarg positionsbezogen, bekommen wir einen Fehler:

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

Müssen wir explizit übergeben Sie die kwarg parameter als keyword-argument.

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

Python-2 kompatibel demos

*args (in der Regel gesagt "star-args") und **kwargs (Sterne, kann impliziert werden, indem Sie sagen: "kwargs", sondern explizit mit "Doppel-Sterne "kwargs") sind häufige Redewendungen von Python für die Verwendung der * und ** notation. Diese speziellen Variablen-Namen sind nicht erforderlich (z.B. könnten Sie *foos und **bars), aber eine Abkehr von der Konvention dürfte Wutanfall Ihre Kolleginnen und Python-Programmierer.

In der Regel verwenden wir diese, wenn wir nicht wissen, was unsere Funktion erhalten oder wie viele Argumente wir können vorbei, und manchmal sogar bei der Namensgebung jede variable separat bekommen würde sehr chaotisch und redundant (aber dies ist ein Fall, wo in der Regel explizit ist besser als implizit).

Beispiel 1

Die folgende Funktion beschreibt, wie Sie verwendet werden können, und zeigt, Verhalten. Beachten Sie die benannten b argument verbraucht wird, durch die zweite positionelle argument vor :

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))

Wir können überprüfen Sie die online Hilfe für die Funktion Unterschrift, mit help(foo), die uns sagt,

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

Nennen wir diese Funktion mit foo(1, 2, 3, 4, e=5, f=6, g=7)

ausgegeben:

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}

Beispiel 2

Können wir nennen es auch mit einer anderen Funktion, in die wir liefern nur 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) Drucke:

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}

Beispiel 3: praktische Anwendung in decorators

OK, also vielleicht sind wir nicht zu sehen, das Dienstprogramm noch. So stellen Sie sich vor Sie haben mehrere Funktionen, die mit redundanten code vor und/oder nach der Differenzierung von code. Die folgenden genannten Funktionen sind nur pseudo-code für illustrative Zwecke.

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

Könnten wir handhaben das anders, aber wir können sicherlich extrahieren Sie die Redundanz mit einem Dekorateur, und so unser Beispiel unten zeigt, wie *args und **kwargs sehr nützlich sein kann:

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

Nun jedes gewickelt Funktion geschrieben werden kann viel mehr kurz und bündig, wir haben ausgeklammert, die Redundanz:

@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)

Und durch factoring aus unserem code, die *args und **kwargs können wir das tun, reduzieren wir die Zeilen code, die Lesbarkeit und Wartbarkeit, und allein die kanonischen Positionen für die Logik in unserem Programm. Wenn wir ändern müssen Teil dieser Struktur, wir haben einen Ort, in dem jeder ändern.

InformationsquelleAutor Aaron Hall

* und ** haben eine Besondere Verwendung in der Funktion argument-Liste. *
bedeutet, dass das argument eine Liste und ** bedeutet, dass das argument
ist ein Wörterbuch. Dies ermöglicht es Funktionen zu nehmen beliebige Anzahl von
Argumente

InformationsquelleAutor ronak

Für diejenigen, die lernen, indem Sie Beispiele!

1. Der Zweck der * ist, um Ihnen die Möglichkeit der Definition einer Funktion kann eine beliebige Anzahl von Argumenten als Liste (z.B. f(*myList) ).
2. Der Zweck der ** ist, um Ihnen die Fähigkeit zu ernähren, eine Funktion, die die Argumente, indem Sie ein Wörterbuch (z.B. f(**{'x' : 1, 'y' : 2}) ).

Lassen Sie sich von uns zeigen dies, indem Sie eine Funktion definieren, die zwei normale Variablen x, y, und kann akzeptieren, mehr Argumente als myArgs, und kann akzeptieren, auch mehr Argumente als myKW. Später werden wir zeigen, wie Sie zu füttern y mit 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   = {}
# ----------------------------------------------------------------------

Vorsichtsmaßnahmen

1. ** ist ausschließlich für Wörterbücher.
2. Nicht-optionales argument Abtretung zuerst Eintritt.
3. Sie nicht verwenden können, ein nicht-optionales argument zweimal.
4. Ggf. ** muss nach * immer.

InformationsquelleAutor Miladiouss

In Python 3.5, können Sie auch folgende syntax verwenden, die in list, dict, tuple, und set zeigt (manchmal auch Literale genannt). Sehen PEP 488: Zusätzliche Auspacken Verallgemeinerungen.

>>> (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}

Ermöglicht es auch, mehrere iterables entpackt werden in einem einzigen Funktionsaufruf.

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

(Dank mgilson für die PEP-link.)

InformationsquelleAutor leewz

Neben Funktionsaufrufe, *args und **kwargs sind nützlich in der Klasse Hierarchien und auch vermeiden, dass zu schreiben __init__ Methode in Python. Ähnliche Nutzung kann man in frameworks wie Django-code.

Beispielsweise

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])

Einer Unterklasse können dann

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

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

Die Unterklasse, die dann instanziiert werden, wie

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

Ebenfalls eine Unterklasse mit einem neuen Attribut, das macht nur Sinn, zu diesem Unterklasse-Instanz anrufen können, die Basis-Klasse __init__ zur Entlastung der Attribute festlegen.
Dies erfolgt mittels *args und **kwargs. kwargs hauptsächlich verwendet, damit der code lesbar ist die Verwendung von benannten Argumenten. Zum Beispiel,

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)

werden kann instatiated als

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

Ist aber der komplette code hier

InformationsquelleAutor HarisankarK

Ein gutes Beispiel für die Verwendung in einer Funktion ist:

>>> 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')
{}

InformationsquelleAutor amir jj

TL;DR

Er packt an die Funktion übergebenen Argumente in list und dict bzw. innerhalb der Funktion Körper. Wenn Sie eine Funktion definieren, die Signatur wie diese:

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

kann man mit einer beliebigen Anzahl von Argumenten und Schlüsselwort-Argumente. Die non-keyword-Argumente, verpackt in eine Liste namens args innerhalb der Funktion Körper und die keyword-Argumente, verpackt in ein dict genannt kwds innerhalb der Funktion Körper.

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

nun innerhalb der Funktion Körper, wenn die Funktion aufgerufen wird, gibt es zwei lokale Variablen args ist eine Liste mit dem Wert ["this", "is a list of", "non-keyword", "arguments"] und kwds was ist ein dict mit dem Wert {"keyword" : "ligma", "options" : [1,2,3]}

---

Dies funktioniert auch in umgekehrter Richtung, d.h. von der Anrufer-Seite. zum Beispiel, wenn Sie haben eine Funktion definiert als:

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

rufen Sie es mit dem Auspacken iterables oder Zuordnungen, die Sie haben in der aufrufenden scope:

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)

InformationsquelleAutor RBF06

• def foo(param1, *param2): ist eine Methode akzeptieren können beliebig viele Werte für *param2,
• def bar(param1, **param2): ist eine Methode akzeptieren können beliebig viele Werte mit Schlüsseln für *param2
• param1 ist ein einfacher parameter.

Beispielsweise die syntax für die Implementierung varargs in Java wie folgt:

accessModifier methodName(datatype… arg) {
    // method body
}

InformationsquelleAutor Premraj