** (├žift y─▒ld─▒z / y─▒ld─▒z i┼čareti) ve * (y─▒ld─▒z / y─▒ld─▒z i┼čareti) parametreler i├žin ne yapar?


Al─▒nan cevaba git


A┼ča─č─▒daki y├Ântem tan─▒mlar─▒nda, * ve ** ne i├žin param2 ?

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

2115





2008-08-31




Cevap say─▒s─▒n─▒ say: 19






*args Ve **kwargs b├Â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.

*args Sen 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
 

Bu **kwargs , s├Âzl├╝k olarak formal bir parametreye kar┼č─▒l─▒k gelenler d─▒┼č─▒ndaki t├╝m anahtar kelime arg├╝manlar─▒n─▒ verecektir .

 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 deyim de, bir dizi sabit ve baz─▒ de─či┼čken de─či┼čkenlere izin vermek i├žin normal de─či┼čkenlerle kar─▒┼čt─▒r─▒labilir:

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

*l Deyimin bir ba┼čka kullan─▒m─▒, bir i┼člev ├ža─č─▒r─▒rken ba─č─▒ms─▒z de─či┼čken listelerini a├žmakt─▒r .

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

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

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

Python 3'te , bu ba─člamda bir tuple yerine bir liste vermesine ra─čmen *l , bir ├Âdevin sol taraf─▒nda ( Extended Iterable Unpacking ) kullanmak m├╝mk├╝nd├╝r :

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

Ayr─▒ca Python 3 yeni anlamsall─▒k ekler (bak─▒n─▒z PEP 3102 ):

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

Bu i┼člev sadece 3 konum arg├╝man─▒ kabul eder ve bundan sonraki her ┼čey * sadece anahtar kelime arg├╝manlar─▒ olarak iletilebilir.


2006







Kullanabilece─činiz dikkati ├žekiyor da ├Âyle * ve ** s─▒ra i┼člevi ├ža─čr─▒l─▒rken. Bu, bir listeye / tuple veya bir s├Âzl├╝─č├╝ kullanarak do─črudan bir i┼čleve birden ├žok arg├╝man iletmenizi sa─člayan bir k─▒sayoldur. ├ľrne─čin, a┼ča─č─▒daki i┼čleve sahipseniz:

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

Gibi ┼čeyler 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: ─░├žindeki tu┼člar─▒n mydict tam olarak i┼člev parametreleri gibi adland─▒r─▒lmas─▒ gerekir foo . Aksi takdirde, bir atar 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'
 

576







Tek *, herhangi bir say─▒da ekstra konumsal arg├╝man olabilece─či anlam─▒na gelir. foo() gibi ├ža─čr─▒labilir foo(1,2,3,4,5) . Foo () g├Âvdesinde param2, 2-5 i├žeren bir sekanst─▒r.

─░kili **, herhangi bir say─▒da ekstra adland─▒r─▒lm─▒┼č parametre olabilece─či anlam─▒na gelir. bar() gibi ├ža─čr─▒labilir bar(1, a=2, b=3) . Bar () g├Âvdesinde param2, {'a': 2, 'b': 3} i├žeren bir s├Âzl├╝kt├╝r.

A┼ča─č─▒daki kodla:

 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)
 

├ž─▒kt─▒

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

165







** (├çift y─▒ld─▒z) ve * (y─▒ld─▒z) parametreler i├žin ne yapar?

Fonksiyonlar─▒n kabul etmesi ve kullan─▒c─▒lar─▒n herhangi bir say─▒da arg├╝man, positional ( * ) ve anahtar s├Âzc├╝k ( ** ) iletmesi i├žin tan─▒mlanmas─▒na izin verir .

─░┼člevleri Tan─▒mlama

*args adl─▒ bir diziye atanacak herhangi bir say─▒da iste─če ba─čl─▒ konum arg├╝man─▒na (parametre) izin verir args .

**kwargs adland─▒r─▒lm─▒┼č bir dilde olacak herhangi bir say─▒da iste─če ba─čl─▒ anahtar s├Âzc├╝k ba─č─▒ms─▒z de─či┼čkenine (parametre) izin verir kwargs .

Herhangi bir uygun isim se├žebilirsiniz (ve gerekir), fakat e─čer ama├ž arg├╝manlar─▒n spesifik olmayan anlamsal olmalar─▒ i├žin args ve kwargs standart isimlerse.

Geni┼čleme, Herhangi bir say─▒da arg├╝man iletme

Ayr─▒ca , s─▒ras─▒yla listelerden (veya yinelenenlerden) ve dikten (veya herhangi bir haritadan) gelen parametreleri iletmek i├žin de kullanabilir *args ve kullanabilirsiniz **kwargs .

Parametreleri alan fonksiyonun geni┼člediklerini bilmek zorunda de─čildir.

├ľrne─čin, Python 2'nin xrange'i a├ž─▒k├ža beklemiyor *args , ancak ba─č─▒ms─▒z de─či┼čken olarak 3 tam say─▒ ald─▒─č─▒ndan:

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

Ba┼čka bir ├Ârnek olarak, dict geni┼člemesini ┼čurada kullanabiliriz str.format :

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

Python 3ÔÇÖteki yenilikler: ─░┼člevleri yaln─▒zca anahtar s├Âzc├╝k arg├╝manlar─▒yla tan─▒mlama

Sen olabilir ancak arg├╝manlar─▒ anahtar kelime sonra *args ├Ârne─čin burada, - kwarg2 bir 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, * anahtar s├Âzc├╝klerin s─▒n─▒rs─▒z konumsal arg├╝manlara izin vermeden sadece arg├╝manlar─▒n takip etti─čini belirtmek i├žin kendi ba┼č─▒na kullan─▒labilir.

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

Burada, kwarg2 yine a├ž─▒k├ža bir anahtar s├Âzc├╝k arg├╝man─▒ olmal─▒d─▒r:

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

Ve art─▒k s─▒n─▒rs─▒z konumsal arg├╝manlar─▒ kabul edemiyoruz, ├ž├╝nk├╝ *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 olarak, burada kwarg konumsal olarak de─čil , ismimizle vermemiz gerekiyor:

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

Bu ├Ârnekte, kwarg konumsal olarak ge├žmeye ├žal─▒┼č─▒rsak bir hata ile kar┼č─▒la┼čt─▒─č─▒m─▒z─▒ g├Âr├╝yoruz:

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

kwarg Parametreyi a├ž─▒k├ža bir anahtar kelime arg├╝man─▒ olarak iletmeliyiz.

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

Python 2 uyumlu demolar

*args (genellikle "y─▒ld─▒z- **kwargs sark─▒kl─▒klar" denir )) ve (y─▒ld─▒zlara "kwarglar" s├Âylenerek ima edilebilir, ancak "├žift-y─▒ld─▒zl─▒ kwarglar" ile a├ž─▒k├ža belirtilebilir) * ve kullan─▒m─▒ i├žin Python'un ortak deyimleridir ** . Bu ├Âzel de─či┼čken isimleri gerekli de─čildir (├Ârne─čin *foos ve kullanabilirsiniz **bars ), ancak konvansiyondan ayr─▒lmak, di─čer Python kodlay─▒c─▒lar─▒n─▒z─▒ k─▒zd─▒racakt─▒r.

Bunlar─▒ genellikle fonksiyonumuzun ne alaca─č─▒n─▒ ya da ne kadar arg├╝man ge├žirece─čimizi bilmedi─čimiz zaman kullan─▒r─▒z ve bazen her de─či┼čkeni ayr─▒ ayr─▒ adland─▒r─▒rken bile ├žok da─č─▒n─▒k ve gereksiz hale gelir (ama bu genellikle a├ž─▒k olan bir durumdur) kapal─▒ oldu─čundan daha iyi).

├Ârnek 1

A┼ča─č─▒daki i┼člev nas─▒l kullan─▒labileceklerini a├ž─▒klar ve davran─▒┼člar─▒ g├Âsterir. Belirtilen b arg├╝man─▒n ├Ânce ikinci konum arg├╝man─▒ taraf─▒ndan t├╝ketilece─čini unutmay─▒n :

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

Fonksiyonun imzas─▒ i├žin ├ževrimi├ži yard─▒m─▒ kontrol ederek help(foo) bize bildiririz.

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

Bu fonksiyonu ile diyelim: foo(1, 2, 3, 4, e=5, f=6, g=7)

hangi yazd─▒r─▒r:

 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, sadece sa─člad─▒─č─▒m─▒z ba┼čka bir i┼člevi kullanarak da s├Âyleyebiliriz 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├Ârlerdeki pratik kullan─▒m

Tamam, belki de hen├╝z yard─▒mc─▒ program─▒ g├Ârm├╝yoruz. Bu nedenle, farkl─▒la┼čt─▒rma kodundan ├Ânce ve / veya sonra gereksiz kodla birka├ž i┼čleve sahip oldu─čunuzu hayal edin. A┼ča─č─▒daki adland─▒r─▒lm─▒┼č i┼člevler a├ž─▒klama ama├žl─▒ sadece sahte koddur.

 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
 

Bunu farkl─▒ bir ┼čekilde ele alabiliriz, ancak art─▒k bir dekorat├Ârle fazlal─▒─č─▒ kesinlikle ├ž─▒karabiliriz ve bu nedenle a┼ča─č─▒daki ├Ârne─čimiz nas─▒l *args ve ne kadar **kwargs yararl─▒ olabilece─čini g├Âstermektedir :

 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
 

Art─▒k her sar─▒lm─▒┼č i┼člev, fazlal─▒─č─▒ belirledi─čimiz i├žin ├žok daha k─▒saca 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 bizim yapmam─▒z─▒ sa─člayan *args ve **kwargs yapmam─▒za izin veren kodumuzu dikkate alarak kod sat─▒rlar─▒n─▒ d├╝┼č├╝r├╝yoruz, okunabilirli─či ve s├╝rd├╝r├╝lebilirli─či art─▒r─▒yoruz ve program─▒m─▒zdaki mant─▒k i├žin tek kurall─▒ konumlar─▒m─▒z var. Bu yap─▒n─▒n herhangi bir b├Âl├╝m├╝n├╝ de─či┼čtirmemiz gerekirse, her de─či┼čikli─čin yap─▒laca─č─▒ bir yerimiz var.


131







├ľnce konumsal arg├╝manlar─▒n ve anahtar s├Âzc├╝k arg├╝manlar─▒n─▒n ne oldu─čunu anlayal─▒m. A┼ča─č─▒daki Konumsal arg├╝manlar ile bir fonksiyon tan─▒m─▒ ├Ârne─čidir .

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

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

Yani bu konumsal arg├╝manlarla bir fonksiyon tan─▒m─▒d─▒r. Anahtar kelime / adland─▒r─▒lm─▒┼č de─či┼čkenlerle de ├ža─č─▒rabilirsiniz:

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

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

┼×imdi anahtar kelime arg├╝manlar─▒ ile bir fonksiyon tan─▒m─▒ ├Ârne─či ├žal─▒┼čal─▒m :

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

Bu i┼člevi konumsal arg├╝manlarla da ├ž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
---------------------------------
 

B├Âylece art─▒k konumsal ve anahtar s├Âzc├╝k arg├╝manlar─▒ ile fonksiyon tan─▒mlar─▒n─▒ biliyoruz.

┼×imdi '*' operat├Âr├╝n├╝ ve '**' operat├Âr├╝n├╝ inceleyelim.

L├╝tfen bu operat├Ârlerin 2 alanda kullan─▒labilece─čini unutmay─▒n:

a) i┼člev ├ža─čr─▒s─▒

b) fonksiyon tan─▒m─▒

─░┼člev ├ža─čr─▒s─▒nda '*' operat├Âr├╝n├╝n ve '**' operat├Âr├╝n├╝n kullan─▒lmas─▒ .

Do─črudan bir ├Ârne─če bakal─▒m ve sonra tart─▒┼čal─▒m.

 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

i┼člev ├ža─čr─▒s─▒nda '*' veya '**' operat├Âr├╝ kullan─▒ld─▒─č─▒nda -

'*' operat├Âr├╝, liste veya fonksiyon gibi veri yap─▒s─▒n─▒ fonksiyon tan─▒m─▒n─▒n gerektirdi─či arg├╝manlara a├žar.

'**' operat├Âr├╝, bir s├Âzl├╝─č├╝ fonksiyon tan─▒m─▒n─▒n gerektirdi─či arg├╝manlara a├žar.

┼×imdi fonksiyon tan─▒mlamas─▒nda '*' operat├Âr kullan─▒m─▒n─▒ inceleyelim . ├ľ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
 

─░┼člev tan─▒m─▒nda '*' operat├Âr├╝ al─▒nan arg├╝manlar─▒ bir tuple halinde paketler.

┼×imdi fonksiyon tan─▒mlamas─▒nda kullan─▒lan '**' ├Ârne─čini 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
 

Fonksiyon tan─▒m─▒nda '**' operat├Âr├╝ al─▒nan arg├╝manlar─▒ bir s├Âzl├╝kte toplar.

Hat─▒rla:

Bir i┼člev ├ža─čr─▒s─▒nda '*' , i┼člev tan─▒m─▒n─▒n al─▒nmas─▒ i├žin konum veya anahtar s├Âzc├╝k arg├╝manlar─▒na tuple veya list veri yap─▒s─▒n─▒ a├žar .

Bir de fonksiyonu ├ža─č─▒rmak '**' 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 konum hatas─▒.

Bir de i┼člev tan─▒m─▒ '**' packs bir s├Âzl├╝─č├╝ne kelime arg├╝manlar.


45







Python 3'te y─▒ld─▒z / splat operat├Ârleri i├žin kullan─▒mlar geni┼čletilirken , bu operat├Ârlerin fonksiyonlarla kullan─▒m─▒yla ilgili olarak a┼ča─č─▒daki tabloyu be─čendim . Uyar─▒c─▒ operat├Ârleri hem fonksiyon yap─▒s─▒ i├žinde hem de fonksiyon ├ža─čr─▒s─▒nda kullan─▒labilir :

             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'─▒n cevab─▒n─▒ ├Âzetlemeye hizmet ediyor ama ben bunu faydal─▒ buluyorum.


23







* ve ** i┼člev arg├╝man listesinde ├Âzel kullan─▒m var. * arg├╝man─▒n bir liste ** oldu─čunu ve arg├╝man─▒n bir s├Âzl├╝k oldu─čunu belirtir. Bu, fonksiyonlar─▒n keyfi say─▒da arg├╝man almalar─▒n─▒ sa─člar


21







├ľrneklerle ├Â─črenenler i├žin!

  1. Amac─▒, * liste halinde verilen (├Ârne─čin f(*myList) ) keyfi say─▒da arg├╝man alabilecek bir fonksiyon tan─▒mlayabilmenizi sa─člamakt─▒r .
  2. Amac─▒, ** size bir s├Âzl├╝k sa─člayarak i┼člevin arg├╝manlar─▒n─▒ besleyebilmenizi sa─člamakt─▒r (├Ârne─čin f(**{'x' : 1, 'y' : 2}) ).

─░ki normal de─či┼čkenleri al─▒r bir i┼člevi tan─▒mlayarak bize bu g├Âstereyim x , y ve daha arg├╝manlar─▒ kabul edebilir myArgs ve hatta daha arg├╝manlar─▒ kabul edebilir myKW . Daha sonra, beslemek i├žin nas─▒l g├Âsterecektir y kullanarak 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   = {}
# ----------------------------------------------------------------------
 

Uyar─▒lar

  1. ** sadece s├Âzl├╝kler i├žin ayr─▒lm─▒┼čt─▒r.
  2. ─░ste─če ba─čl─▒ olmayan ba─č─▒ms─▒z de─či┼čken atamas─▒ ├Ânce ger├žekle┼čir.
  3. ─░ste─če ba─čl─▒ olmayan bir arg├╝man─▒ iki kez kullanamazs─▒n─▒z.
  4. M├╝mk├╝nse her zaman ** sonra gelmelidir * .

15







Python belgelerine g├Âre:

Resmi parametre yuvalar─▒ndan daha fazla konumsal arg├╝man varsa, "* identifier" s├Âzdizimini kullanan resmi bir parametre olmad─▒─č─▒ s├╝rece, bir TypeError istisnas─▒ ortaya ├ž─▒kar; Bu durumda, bu bi├žimsel parametre a┼č─▒r─▒ konumsal arg├╝manlar─▒ i├žeren bir demet al─▒r (veya a┼č─▒r─▒ konumsal arg├╝man yoksa bo┼č bir demet).

Herhangi bir anahtar kelime arg├╝man─▒ resmi bir parametre ad─▒na kar┼č─▒l─▒k gelmiyorsa, "** tan─▒mlay─▒c─▒" s├Âzdizimini kullanan resmi bir parametre olmad─▒─č─▒ s├╝rece, bir TypeError istisnas─▒ ortaya ├ž─▒kar; Bu durumda, bu formal parametre fazla anahtar kelime arg├╝manlar─▒n─▒ (anahtar kelimeleri anahtarlar ve arg├╝man de─čerlerini kar┼č─▒l─▒k gelen de─čerler olarak kullanarak) i├žeren bir s├Âzl├╝k veya fazla anahtar kelime arg├╝manlar─▒ yoksa (yeni) bo┼č bir s├Âzl├╝k al─▒r.


12







Python 3.5, ayr─▒ca bu s├Âzdizimini kullanabilirsiniz list , dict , tuple , ve set g├Âr├╝nt├╝ler (bazen denir de─či┼čmezleri). Bkz. PEP 488: Ek Paket A├žma Genelle┼čtirmeleri .

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

Ayr─▒ca, tek bir i┼člev ├ža─čr─▒s─▒nda birden fazla yinelemenin a├ž─▒lmas─▒n─▒ sa─člar.

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

(PEP ba─člant─▒s─▒ i├žin mgilson'a te┼čekk├╝rler.)


7







Ba┼čkalar─▒n─▒n bahsetmedi─či bir ├Ârnek vermek istiyorum

* bir jenerat├Âr├╝ de a├žabilir

Python3 Belgesinden bir ├Ârnek

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

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

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

Zip () birden fazla tekrarlanabilir yaylanma al─▒r ve bir jenerat├Âr d├Ând├╝r├╝r.

 zip(*zip(x,y)) -> zip((1, 4), (2, 5), (3, 6))
 

7







─░┼člev ├ža─čr─▒lar─▒na ek olarak, * args ve ** kwargs s─▒n─▒f hiyerar┼čilerinde kullan─▒┼čl─▒d─▒r ve __init__ Python'da y├Ântem yazmak zorunda kalmazlar . Django kodu gibi ├žer├ževelerde benzer kullan─▒mlar g├Âr├╝lebilir.

├ľ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 s─▒n─▒f daha sonra olabilir

 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 s─▒n─▒f daha sonra olarak ba┼člat─▒l─▒r.

 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─▒ gelen yeni bir ├Âzniteli─či olan bir alt s─▒n─▒f __init__ , ├Âznitelik ayar─▒n─▒ bo┼čaltmak i├žin Base s─▒n─▒f─▒n─▒ ├ža─č─▒rabilir . Bu * args ve ** kwargs ile yap─▒l─▒r. kwargs, kodun adland─▒r─▒lm─▒┼č arg├╝manlar kullan─▒larak okunabilmesi i├žin ├žo─čunlukla kullan─▒l─▒r. ├ľ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 olarak instatiated olabilir

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

Kodun tamam─▒ burada


5







* anlam─▒na gelir de─či┼čkeni arg├╝man olarak almak

** de─či┼čken olarak de─či┼čken arg├╝manlar─▒n─▒ s├Âzl├╝k olarak al

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
 

4







*args ve **kwargs : bir fonksiyona de─či┼čken say─▒da arg├╝man iletmenize izin verir.

*args :, fonksiyona anahtar kelimeli olmayan bir de─či┼čken uzunluklu 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*

**kwargs Bir fonksiyona anahtar kelimeli de─či┼čken uzunluktaki arg├╝manlar─▒ aktarman─▒za izin verir. **kwargs Bir i┼člevdeki adland─▒r─▒lm─▒┼č de─či┼čkenleri i┼člemek istiyorsan─▒z kullanmal─▒s─▒n─▒z .

 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.
 

2







Her ikisini de bir i┼člevde kullanman─▒n iyi bir ├Ârne─či:

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

1







Bu ├Ârnek hat─▒rlaman─▒za yard─▒mc─▒ olur *args , **kwargs hatta super ayn─▒ 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
 

1







Nick'in cevab─▒n─▒ geli┼čtirmek ...

 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─▒da konum arg├╝man─▒ * args kullanabilir ve adland─▒r─▒lm─▒┼č arg├╝manlar (veya kwargs aka anahtar kelime arg├╝manlar─▒) ** kwargs kullanabilir.


1


2019-07-10





TL; DR

─░┼čleve iletilen arg├╝manlar─▒ s─▒ras─▒yla i┼člev g├Âvdesinin i├žine list ve dict i├žine yerle┼čtirir. Bunun gibi bir i┼člev imzas─▒ tan─▒mlad─▒─č─▒n─▒zda:

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

herhangi bir say─▒da ba─č─▒ms─▒z de─či┼čken ve anahtar kelime ba─č─▒ms─▒z de─či┼čkeni ile ├ža─čr─▒labilir. Anahtar s├Âzc├╝k olmayan arg├╝manlar args , i┼člev g├Âvdesinde ad─▒ verilen bir listeye paketlenir ve anahtar s├Âzc├╝k arg├╝manlar─▒ kwds , i┼člev g├Âvdesinde ad─▒ verilen bir dikte i├žine paketlenir .

 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 args bir listesi olan bir de─čerdir ["this", "is a list of", "non-keyword", "arguments"] ve kwds bir edilir dict olan bir de─čer {"keyword" : "ligma", "options" : [1,2,3]}


Bu ayn─▒ zamanda geriye do─čru, yani arayan taraf─▒ndan da ├žal─▒┼č─▒r. ├Ârne─čin, bir fonksiyon tan─▒m─▒n─▒z varsa:

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

├ža─č─▒ran kapsamdaki yinelemeleri veya e┼člemeleri a├žarak arayarak arayabilirsiniz:

 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)
 

0







  • def foo(param1, *param2): bir y├Ântemin keyfi say─▒da de─čeri kabul edebilece─či *param2 ,
  • def bar(param1, **param2): bir y├Ântemin keyfi ┼čekilde say─▒ tu┼člar─▒n─▒ kabul edebildi─či bir y├Ântemdir. *param2
  • param1 basit bir parametredir.

├ľrne─čin, Java'da varargs uygulamak i├žin s├Âzdizimi a┼ča─č─▒daki gibidir:

 accessModifier methodName(datatypeÔÇŽ arg) {
    // method body
}
 

-2



─░lgili yay─▒nlar


Bir fonksiyon ├ža─čr─▒s─▒nda y─▒ld─▒z operat├Âr├╝ ne anlama geliyor? [├žift]

POST isteklerinde% 5B ve% 5D ne anlama geliyor?

~~ (ÔÇťdouble tildeÔÇŁ) Javascript'te ne yapar?

├çifte soru i┼čareti (??) operat├Âr├╝ PHP'de ne anlama gelir?

Y─▒ld─▒z ├Ânceli─či olan bir ├Âzellik CSS'de ne anlama geliyor?

Python metodu / fonksiyon y─▒ld─▒z i┼čareti ve ├žift y─▒ld─▒z i┼čareti ile ba┼člayan arg├╝manlar [duplicate]

Bir ├Âni┼člemci direktifinde ## (double hash) ne yapar?

Bir dosyadaki kahverengi y─▒ld─▒z simgesi Eclipse'de ne anlama geliyor?

Bitsel kayd─▒rma (sola veya sa─ča) ne yapar ve ne i├žin kullan─▒l─▒r?

EntityManager.flush ne yapar ve neden kullanmam gerekiyor?

Etiketle ilgili di─čer sorular [python]


Bir ├Â─čenin jQuery'de gizli olup olmad─▒─č─▒n─▒ nas─▒l kontrol ederim?

Bir dizginin JavaScript'te bir alt dize i├žerip i├žermedi─čini kontrol etme

Nesnelerin dizesini string ├Âzellik de─čerine g├Âre s─▒ralama

Node.js module.exports'in amac─▒ nedir ve bunlar─▒ nas─▒l kullan─▒yorsunuz?

├çoklu g├Âr├╝n├╝m tipinde RecyclerView nas─▒l olu┼čturulur?

C++ derlemesi neden bu kadar uzun s├╝r├╝yor?

Apache2: 'AH01630: istemci sunucu yap─▒land─▒rmas─▒ taraf─▒ndan reddedildi'

Par├žas─▒ MyFragment, Aktiviteye ba─čl─▒ de─čil

Android durum ├žubu─ču rengini nas─▒l de─či┼čtirilir

Dize uzun d├Ân├╝┼čt├╝rmek / cast nas─▒l?