parametreler için neler ** (çift yıldız / yıldız işaretini) ve * (yıldız / yıldız) yapar mı?

oy
1k

Aşağıdaki yöntem tanımlarda ne yok *ve **yapmak param2?

def foo(param1, *param2):
def bar(param1, **param2):
Oluştur 31/08/2008 saat 16:04
kaynak kullanıcı
Diğer dillerde...                            


22 cevaplar

oy
10

Python belgelerden;

biçimsel parametre yuvaları sayısından daha fazla pozisyon argümanlar varsa, bir TypeError istisnası sözdizimi kullanarak resmi bir parametre sürece "* tanımlayıcı" mevcutsa, yükseltilir; Bu durumda, bu resmi parametresi (bir fazla konum argümanlar olsaydı veya boş bir başlığın) fazla konum bağımsız değişken içeren bir demet alır.

herhangi bir anahtar kelime argüman resmi bir parametre adının karşılık gelmiyorsa, bir TypeError istisnası sözdizimi kullanarak resmi bir parametre sürece "** tanımlayıcı" mevcutsa, yükseltilir; Hiçbir fazlalık anahtar kelime argümanlar olsaydı bu durumda, o biçimsel parametre (anahtarları olarak anahtar kelimeler ve değerleri karşılık gelen argüman değerleri kullanılarak), fazla anahtar kelime argümanları içeren bir sözlük ya da bir (yeni) boş bir sözlük alır.

Cevap 31/08/2008 saat 16:07
kaynak kullanıcı

oy
1k

*argsVe **kwargsbölümünde açıklandığı gibi işlevlere bağımsız değişken keyfi sayıda izin vermek için ortak bir deyim olan daha fazla fonksiyon tanımlama konusunda Python belgelerinde.

*argsSen iyi işlev parametreleri verecek bir demet olarak :

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

**kwargsSen iyi verecektir anahtar kelime argümanları bir sözlük olarak resmi bir parametreye karşılık gelen hariç.

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

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

Her iki deyimler sabit bir dizi ve bazı değişken argümanları izin normal argümanlar ile karıştırılabilir:

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

Bir başka kullanım *ldeyim etmektir argüman listeleri paketten bir işlev çağrılırken.

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

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

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

Python 3 yılında kullanmak mümkündür *l(bir atamanın sol tarafındaki iterable Ambalajın açılması Extended yerine bu bağlamda bir başlığın bir listesini verir rağmen,):

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

Ayrıca Python 3 (bakınız yeni semantik ekler PEP 3102 ):

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

Böyle işlevi yalnızca 3 konumsal argümanları kabul eder ve her şey sonra *yalnızca anahtar kelime argümanlar olarak geçirilebilir.

Cevap 31/08/2008 saat 16:17
kaynak kullanıcı

oy
123

Tek * ekstra pozisyonel argümanlar herhangi bir sayı olabileceği anlamına gelir. foo()gibi çağrılabilir foo(1,2,3,4,5). Foo gövdesine () param2 2-5 ihtiva eden bir dizisidir.

Çift ** ekstra adlandırılmış parametrelerin herhangi sayıda olabileceği anlamına gelir. bar()gibi çağrılabilir bar(1, a=2, b=3). Çubuğunun gövdesine () param2 ihtiva eden bir sözlüğü {2, 'b': '' 3}

Aşağıdaki kod ile:

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)

çıkış

1
(2, 3, 4, 5)
1
{'a': 2, 'b': 3}
Cevap 31/08/2008 saat 16:20
kaynak kullanıcı

oy
428

Ayrıca kullanabilirsiniz dikkati çekiyor *ve **hem de işlevi çağrılırken. Bu doğrudan bir liste / tuple veya bir sözlük kullanarak bir işleve birden fazla argüman geçmesine izin veren bir kısa yoldur. Örneğin, şu işlev varsa:

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

Sen benzer işlemleri yapabilirsiniz:

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

Not: tuşları içinde mydicttam olarak fonksiyon parametreleri gibi adlandırılmış lazım foo. Aksi takdirde atacağım 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'
Cevap 31/08/2008 saat 16:47
kaynak kullanıcı

oy
20

*ve **fonksiyon argüman listesindeki özel kullanım alanına sahiptir. * argüman listesidir ve ima **argümanı bir sözlük olduğunu ima eder. Bu fonksiyonlar argümanları keyfi numara almak için izin verir

Cevap 11/09/2012 saat 05:33
kaynak kullanıcı

oy
102

Neyi **(çift yıldız) ve *(yıldız) parametreler için yapmak

Onlar izin için fonksiyonlar kabul etmek tanımlanması için ve kullanıcıların geçmesine herhangi argümanların sayısını, pozisyonel ( *) ve anahtar kelime ( **).

Fonksiyon Tanımları

*argsadında bir tuplea atanacak opsiyonel konumsal argümanlar (parametreler), herhangi bir sayı için izin verir args.

**kwargsadlı bir dict olacak opsiyonel anahtar kelime argümanlar (parametreler), herhangi bir sayı için izin verir kwargs.

Sen (ve) herhangi uygun bir ad seçer, ancak argümanlar spesifik olmayan semantik olması için niyet ise, olabilir argsve kwargsstandart isimlerdir.

Genleşme, bağımsız değişkenler herhangi bir sayıda geçen

Ayrıca kullanabilir *argsve **kwargssırasıyla listeleri (veya herhangi iterable) ve dicts (veya herhangi bir haritalama) den parametrelerinde geçmesine.

parametrelerini Recieving fonksiyonu onlar genişletilmiş ediliyor olduğunu bilmek zorunda değildir.

Örneğin, Python 2'nin xrange açıkça beklemediğini *argso argümanlar olarak 3 tamsayılar sürdüğünden, ama:

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

Başka bir örnek olarak, biz dict genişleme kullanabildiğiniz str.format:

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

Python 3 Yeni: anahtar kelimeyle fonksiyonlarını tanımlama sadece argümanlar

Sen olabilir anahtar kelime tek argümanları sonra *argsörneğin burada, - kwarg2bir anahtar kelime argüman olarak verilmelidir - değil pozisyonel:

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

Kullanımı:

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

Ayrıca, *sınırsız pozisyonel bağımsız değişkenler için izin vermeden, sadece argümanlar takip ettiğini anahtar kelimeyi belirtmek için kendisi tarafından kullanılabilir.

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

Burada kwarg2yine bir açıkça adlandırılmış, anahtar kelime argüman olmalıdır:

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

Biz yok çünkü Ve artık sınırsız pozisyonel argümanları kabul edebilir *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

Yine, daha basit, işte gerektiren kwargdeğil pozisyonel adı, tarafından verilecek:

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

Bu örnekte, biz geçmeye çalışması durumunda görüyoruz kwargpozisyonel, bir hatayla olsun:

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

Biz açıkça geçmelidir kwargbir anahtar kelime argüman olarak parametreyi.

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

Python 2 uyumlu demolar

*argsve (genellikle "yıldız-args" dedi) **kwargskullanmak için Python ortak deyimleri (yıldız "kwargs" diyerek ima ancak "çift yıldız kwargs" ile açık ve net olması olabilir) olan *ve **gösterim. Bunlar belirli değişken adları (örneğin şunu kullanabilirsiniz gerekli değildir *foosve **bars), ancak gelenekselden uzaklaşmayı dost Python coder'lara öfkelendirir muhtemeldir.

Genellikle bizim işlevi her değişken ayrı ayrı (çok dağınık ve gereksiz alacağı adlandırırken biz bile bazen geçirerek ve kaç adet argüman almaya gidiyor ya ne bilmiyorum bu kullanmak ancak bu genellikle açık olan bir durumdur ) örtük daha iyi.

örnek 1

Aşağıdaki fonksiyonu onlar nasıl kullanılabileceğini açıklar ve davranışı gösterir. Adlandırılmış Not bargüman ikinci pozisyonel argüman önce tüketilen edilecektir:

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

Ile Biz işlevin imza için online yardım kontrol edebilirsiniz help(foo)söyler, hangi

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

en ile bu işlevi diyelim foo(1, 2, 3, 4, e=5, f=6, g=7)

hangi baskılar:

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}

Örnek 2

Ayrıca biz sadece sağlayan içine başka fonksiyonunu kullanarak diyebilirsiniz 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) baskılar:

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}

Örnek 3: dekoratör pratik kullanımı

Tamam, belki biz henüz yarar görmüyoruz. Yani önce ve / veya ayırt kodundan sonra gereksiz kod ile çeşitli işlevleri vardır düşünün. Aşağıdaki adlı fonksiyonlar gösterim amaçlı sadece sözde kod bulunmaktadır.

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

Biz bunu farklı ele almak mümkün olabilir, ama biz kesinlikle bir dekoratör ile fazlalık çıkarabilir ve böylece bizim Aşağıdaki örnek gösterilmiştir *argsve **kwargsçok faydalı olabilir:

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

Biz fazlalık dışarı hesaba katılmaktadır Ve şimdi her sarılı fonksiyonu, çok daha özlü yazılabilir:

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

Ve kodunu dışarı faktoring *argsve **kwargsyapmamıza olanak sağlayan, biz okunabilirliği ve yaşatılabilirlik geliştirmek, kod satırları azaltmak ve bizim programda mantık için tek kanonik yerleri var. Bu yapının herhangi bir bölümünü değiştirmek gerekiyorsa, biz her değişiklik yapmak bir yeri vardır.

Cevap 14/10/2014 saat 17:34
kaynak kullanıcı

oy
3

Ayrıca args ve ** kwargs sınıf hiyerarşileri faydalıdır * aramaları, işlev ve ayrıca yazmak zorunda kalmamak için __init__Python yöntemi. Benzer kullanım Django kodu gibi çerçeveler görülen olabilir.

Örneğin,

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

Bir alt tarafı daha sonra

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

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

alt sonra da örneği

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

Ayrıca, yalnızca bu alt sınıf örneğine mantıklı bir yeni özelliği olan bir alt sınıf Taban sınıf çağırabilir __init__nitelikleri ayarını boşaltma. Bu * args ve ** kwargs aracılığıyla yapılır. Bu kod adlı argümanları kullanarak okunabilir böylece kwargs ağırlıklı kullandı. Örneğin,

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)

hangi instatiated edilebilir

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

Tam koddur burada

Cevap 16/08/2015 saat 04:23
kaynak kullanıcı

oy
5

Python 3.5, ayrıca bu sözdizimini kullanabilirsiniz list, dict, tuple, ve setgörüntüler (bazen denir değişmezleri). Bkz Ek Ambalajın açılması genellemeler: PEP 488 .

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

Aynı zamanda birden fazla Iterables tek işlev çağrısında çözdükten edilmesini sağlar.

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

(Teşekkürler PEP bağlantıdan mgilson için.)

Cevap 08/12/2015 saat 21:38
kaynak kullanıcı

oy
34

Öncelikle pozisyonel argümanları ve anahtar kelime argümanlar ne olduğunu anlamak edelim. Aşağıda fonksiyonlu tanımı örneğidir Konumsal argümanlar.

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

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

Yani bu konumsal bağımsız değişken içeren bir işlev tanımıdır. Siz de anahtar kelime / adlandırılmış argümanlarla diyebilirsin:

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

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

Şimdi bize ile fonksiyon tanımının bir örnek çalışma izin anahtar kelime argümanları :

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

Siz de pozisyonel argümanlarla bu işlevini çağırabilirsiniz:

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

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

Bu yüzden şimdi pozisyonel ile işlev tanımları yanı sıra anahtar kelime argümanları biliyorum.

Şimdi bize '*' operatörü ve '**' operatörünü çalışma edelim.

Bu operatörler 2 alanlarda kullanılabilir unutmayın:

a) işlev çağrısı

b) fonksiyon tanımlama

Içinde '*' operatör ve '**' operatörünün kullanılması işlev çağrısı.

Bir örnek düz dönelim ve sonra bunu tartışmak.

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.

Hatırla

'*' veya '**' operatörün kullanıldığında işlev çağrısı -

'*' Operatör bu fonksiyon tanımlama ihtiyacı bağımsız değişkenler bir liste ya da başlığın olarak veri yapısı açar.

'**' operatör fonksiyonu tanım gereği gerekli argümanları içine bir sözlük açar.

Şimdi bize '*' operatör kullanımını incelemek izin işlev tanımı . Örnek:

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

Fonksiyonu olarak tanımlanması '*' operatör başlığın içine alınan değişkenler paketleri.

Şimdi bize '**' işlevi tanımında kullanılan bir örnek görelim:

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

Fonksiyonu olarak tanımlanması '**' operatör sözlüğe alınan değişkenler paketleri.

Hatırla:

Bir de işlev çağrısı '*' paketten çıkarır fonksiyon tanım gereği alınacak pozisyonel veya anahtar kelime argümanları içine tuple veya listenin veri yapısını.

Bir de işlev çağrısı '**' paketten çıkarır fonksiyon tanım gereği alınacak pozisyonel veya anahtar kelime argümanları içine sözlüğü veri yapısını.

Bir olarak işlev tanımında '*' paketleri bir başlığın içine konumsal argümanlar.

Bir olarak işlev tanımında '**' paketleri bir sözlüğüne kelime argümanlar.

Cevap 20/01/2016 saat 11:40
kaynak kullanıcı

oy
1

bir işlev olarak kullanılmasının bir örneğidir:

>>> 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')
{}
Cevap 26/10/2016 saat 12:48
kaynak kullanıcı

oy
6

Diğerleri bahsetmedim bir örnek vermek istiyorum

* Ayrıca paketten jeneratör

Python3 Belgesi bir örnek

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

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

unzip_x olacak [1, 2, 3] unzip_y olacak [4, 5, 6]

fermuar (), birden çok iretable bağımsız değişken alır ve bir jeneratör döner.

zip(*zip(x,y)) -> zip((1, 4), (2, 5), (3, 6))
Cevap 08/11/2016 saat 16:50
kaynak kullanıcı

oy
1

Bu örnek, hatırlamanıza yardımcı olur *args, **kwargshatta superaynı anda Python ve miras.

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
Cevap 26/11/2016 saat 21:09
kaynak kullanıcı

oy
6

Yıldız / uyarısı operatörler için kullandığı olmakla birlikte genişletilmiş Python 3'te bu operatörlerin kullanmak ile ilgili olarak, ben şu tablo gibi fonksiyonları ile . Uyarısı operatör (ler) işlevi olan hem de kullanılabilir yapı ve işlev olarak çağrı :

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

Bu gerçekten sadece Lorin Hochstein en özetlemek için hizmet cevabı ama yararlı bulabilirsiniz.

Cevap 30/11/2017 saat 18:28
kaynak kullanıcı

oy
0

* Args = * alist = bir List tüm unsurları

** args = ** The Addicts = bir dict tüm öğeleri

Cevap 08/12/2017 saat 01:36
kaynak kullanıcı

oy
0

*argsve **kwargs: Eğer bir işleve bağımsız değişken bir dizi geçmesine izin verir.

*args: Işlevine olmayan bir keyworded değişken uzunlukta argüman listesi göndermek için kullanılır:

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

Üretecek:

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*

**kwargsEğer bir işleve argümanlar keyworded değişken uzunluğu geçmesine izin verir. Sen kullanmalıdır **kwargsbir fonksiyonun içinde isimli değişkenler işlemek istiyorum.

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

Üretecek:

Your name is Nikola.
Your last_name is Tesla.
Your birthday is 7.10.1856.
Your birthplace is Croatia.
Cevap 01/05/2018 saat 12:54
kaynak kullanıcı

oy
0

örneklerle öğrenir olanlarınız için:

def f(normal_input, *args, **kw):
    # Print the length of args and kw in a friendly format
    print("len(args) = {} and len(kw) = {}".format(len(args), len(kw)))

l = list(range(5))
d = {"k0":"v0", "k1":"v1"}

f(42, 0, 1, 2, 3, 4, 5) # len(args) = 6 and len(kw) = 0

f(42, l) # len(args) = 1 and len(kw) = 0
f(42, d) # len(args) = 1 and len(kw) = 0

f(42, *l) # len(args) = 5 and len(kw) = 0
f(42, *d) # len(args) = 2 and len(kw) = 0

try:
    f(42, **l) # Gives an error
except TypeError:
    print("l in f(**l) is not a dictionary!")

f(42, **d) # len(args) = 0 and len(kw) = 2

# Without explicitly feeding normal_input
# l[0] becomes normal_input
f(*l) # len(args) = 4 and len(kw) = 0

# Let's try everything now
f(42, 420, 4200, *l, **d) # len(args) = 7 and len(kw) = 2

İlk argüman normal_input olduğuna dikkat, 2., 3., ve * l sonraki 7 bağımsız değişkendir.

Cevap 22/05/2018 saat 07:03
kaynak kullanıcı

oy
0

* liste olarak değişken bir bağımsız değişken almak demektir

** sözlük olarak değişken argümanları almak demektir

Aşağıdaki gibi kullanılır:

1) Tek *

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

foo("two", 3)

Çıktı:

two
3

2) Şimdi **

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

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

Çıktı:

dic1 two
dic2 3
Cevap 07/08/2018 saat 18:28
kaynak kullanıcı

oy
0
  • def foo(param1, *param2):Bir yöntem için değerlerin rasgele sayı kabul edebilir *param2,
  • def bar(param1, **param2): Bir yöntem için tuşlarıyla değerlerin keyfi sayısını kabul edebilir edilir *param2
  • param1 basit bir parametredir.

Örneğin, uygulanması için sözdizimi varargs şöyle Java:

accessModifier methodName(datatype… arg) {
    // method body
}
Cevap 02/09/2018 saat 05:14
kaynak kullanıcı

oy
0

TL; DR

Bu içine işlevine geçirilen bağımsız değişkenler paketleri listve dictsırasıyla fonksiyon gövdesi içinde. Ne zaman böyle bir fonksiyon imza tanımlayın:

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

o argümanları ve anahtar kelime argümanlar herhangi bir sayı ile çağrılabilir. Olmayan kelime argümanlar denilen bir liste halinde paketlenmiş olsun argsfonksiyonu vücut ve anahtar kelime argümanlar adlı bir dict içine paketlenmiş olsun içeride kwdsişlev vücudun içinde.

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

Şimdi fonksiyonu olarak adlandırılan fonksiyonu gövdenin içinde, iki lokal değişkenler, orada argsbir listesi olan bir değerdir ["this", "is a list of", "non-keyword", "arguments"]ve kwdsbir edilir dictolan bir değer{"keyword" : "ligma", "options" : [1,2,3]}


Bu aynı zamanda arayan taraftan, yani ters yönde çalışıyor. Örneğin bir fonksiyon olarak tanımlanır varsa:

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

Eğer aradığınız kapsamında olan Iterables veya eşlemeleri açma yoluyla ile diyebilirsin:

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)
Cevap 02/04/2019 saat 12:43
kaynak kullanıcı

oy
0

Nickd en üstünde Bina cevap ...

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

Çıktı:

1
(2, 3, 4, 5)

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

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

Temel olarak, herhangi bir sayı pozisyonel argümanlar * args ve herhangi kullanabilirsiniz adlı argümanlar ** kwargs kullanabilirsiniz (aka veya kwargs anahtar kelime argümanlar).

Cevap 10/07/2019 saat 05:59
kaynak kullanıcı

oy
0

bağlam

  • piton 3.x
  • ile açma **
  • dize biçimlendirme ile kullanım

dize biçimlendirme ile Kullanımı

Bu Konuya cevapları ilave olarak, burada başka yerde belirtilmeyen başka bir detaydır. Bu genişler Brad Solomon tarafından cevap

İle Ambalajın açılması **piton kullanırken de yararlıdır str.format.

Bu piton ile neler yapabileceğini biraz benzer f-strings f-string ama havai değişkenleri tutmak için bir dicti ilan katma ile (f telli bir dicti gerektirmez).

Hızlı Örneği

  ## init vars
  ddvars = dict()
  ddcalc = dict()
  pass
  ddvars['fname']     = 'Huomer'
  ddvars['lname']     = 'Huimpson'
  ddvars['motto']     = 'I love donuts!'
  ddvars['age']       = 33
  pass
  ddcalc['ydiff']     = 5
  ddcalc['ycalc']     = ddvars['age'] + ddcalc['ydiff']
  pass
  vdemo = []

  ## ********************
  ## single unpack supported in py 2.7
  vdemo.append('''
  Hello {fname} {lname}!

  Today you are {age} years old!

  We love your motto "{motto}" and we agree with you!
  '''.format(**ddvars)) 
  pass

  ## ********************
  ## multiple unpack supported in py 3.x
  vdemo.append('''
  Hello {fname} {lname}!

  In {ydiff} years you will be {ycalc} years old!
  '''.format(**ddvars,**ddcalc)) 
  pass

  ## ********************
  print(vdemo[-1])

Cevap 06/12/2019 saat 19:36
kaynak kullanıcı

oy
0

TL; DR

Aşağıda için 6 farklı kullanım durumları vardır *ve **piton programlamada:

  1. Pozisyonel istenen sayıda argümanı kabul etmek için: def foo(*args): pass burada fooyani pozisyonel argümanlar, herhangi bir sayıda kabul aşağıdaki aramalar geçerlidir foo(1),foo(1, 'bar')
  2. Anahtar kelime istenen sayıda argümanı kabul etmek için: def foo(**kwargs): pass Burada 'foo' yani anahtar kelime argümanlar, herhangi bir sayıda kabul aşağıdaki aramalar geçerlidir foo(name='Tom'),foo(name='Tom', age=33)
  3. Pozisyonel ve anahtar kelime herhangi bir sayıda argümanı kabul etmek için: def foo(*args, **kwargs): pass burada fooyani pozisyonel ve anahtar kelime argümanlar, herhangi bir sayıda kabul aşağıdaki aramalar geçerlidir foo(1,name='Tom'),foo(1, 'bar', name='Tom', age=33)
  4. Sadece argümanları (kullanım anahtar kelime uygulamak için *:) def foo(pos1, pos2, *, kwarg1): pass burada *dolayısıyla foo sadece POS2 sonra anahtar kelime argümanlar kabul etmesini araçlar foo(1, 2, 3)TypeError yükseltir ama foo(1, 2, kwarg1=3)ok.
  5. Daha pozisyonel argümanlar içerisinde daha başka ilgi ifade etmek (Not: Bu kongre sadece): def foo(bar, baz, *_): pass (Kongre tarafından) araçlar foosadece kullanımları barve bazişleyişinin argümanları ve diğerlerini göz ardı eder.
  6. Daha fazla anahtar kelime argümanlar içerisinde daha başka ilgi ifade etmek (Not: Bu kongre sadece): def foo(bar, baz, **_): pass (Kongre tarafından) araçlar foosadece kullanımları barve bazişleyişinin argümanları ve diğerlerini göz ardı eder.

BONUS: pyton 3.8 itibaren ileriye birini kullanabilirsiniz /konumsal sadece parametreleri uygulamak için işlev tanımında. Aşağıdaki örnekte, parametreler a ve b konumsal okunur c veya d konumsal veya kelime olabilir ve e veya f anahtar olunmalıdır ise:

def f(a, b, /, c, d, *, e, f)
Cevap 07/01/2020 saat 17:37
kaynak kullanıcı

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