ÔÇťEn K├╝├ž├╝k ┼×a┼č─▒rtmaÔÇŁ ve De─či┼čken Varsay─▒lan Arg├╝man


Al─▒nan cevaba git


Python ile yeterince ilgilenen herkes a┼ča─č─▒daki sorunla ─▒s─▒r─▒ld─▒ (veya par├žalara ayr─▒ld─▒):

 def foo(a=[]):
    a.append(5)
    return a
 

Python acemi bu i┼člev her zaman yaln─▒zca bir eleman i├žeren bir liste d├Ânmek i├žin beklenir: [5] . Sonu├ž bunun yerine ├žok farkl─▒ ve ├žok ┼ča┼č─▒rt─▒c─▒ (bir acemi i├žin):

 >>> foo()
[5]
>>> foo()
[5, 5]
>>> foo()
[5, 5, 5]
>>> foo()
[5, 5, 5, 5]
>>> foo()
 

Bir zamanlar bir menajerim bu ├Âzellik ile ilk kar┼č─▒la┼čmas─▒n─▒ yapt─▒ ve bunu dilin "dramatik bir tasar─▒m kusuru" olarak nitelendirdi. Davran─▒┼č─▒n alt─▒nda yatan bir a├ž─▒klamas─▒ oldu─čunu ve i├žselleri anlamad─▒─č─▒n─▒zda ger├žekten ├žok ┼ča┼č─▒rt─▒c─▒ ve beklenmedik oldu─čunu s├Âyledim. Ancak, ┼ču soruyu kendime cevaplayamad─▒m (kendime): Fonksiyon tan─▒m─▒nda varsay─▒lan fonksiyonun ba─članmas─▒n─▒n sebebi nedir? Fonksiyonun y├╝r├╝t├╝lmesinde de─čil. Tecr├╝beli davran─▒┼č─▒n pratik bir kullan─▒m─▒ oldu─čundan ┼č├╝pheliyim (C de statik de─či┼čkenleri ├╝reyen b├Âcekler olmadan kim kullan─▒yor?)

D├╝zenle :

Baczek ilgin├ž bir ├Ârnek yapt─▒. ├ľzellikle yorumlar─▒n─▒z─▒n ve Utaal'lar─▒n─▒z─▒n ├žo─ču ile birlikte, daha fazla ayr─▒nt─▒ verdim:

 >>> def a():
...     print("a executed")
...     return []
... 
>>>            
>>> def b(x=a()):
...     x.append(5)
...     print(x)
... 
a executed
>>> b()
[5]
>>> b()
[5, 5]
 

Bana g├Âre, tasar─▒m karar─▒n─▒n parametrelerin kapsam─▒n─▒ nereye koyaca─č─▒na ba─čl─▒ oldu─ču g├Âr├╝l├╝yor: fonksiyonun i├žinde mi, yoksa onunla birlikte mi?

─░┼člev i├žinde ba─člaman─▒n yap─▒lmas─▒, i┼člev x tan─▒mland─▒─č─▒nda, derin bir kusur olu┼čturacak bir ┼čey ├ža─čr─▒ld─▒─č─▒nda belirtilen varsay─▒lan de─čere etkin bir ┼čekilde ba─čl─▒ oldu─ču anlam─▒na gelir : def ├žizgi, ba─člaman─▒n (" i┼člev nesnesi) tan─▒mda ve i┼člev ├ža─č─▒rma zaman─▒nda k─▒smi (varsay─▒lan parametrelerin atanmas─▒) ger├žekle┼čir.

As─▒l davran─▒┼č daha tutarl─▒d─▒r: bu sat─▒r y├╝r├╝t├╝ld├╝─č├╝nde, fonksiyon tan─▒m─▒nda anlam─▒ olan her sat─▒r de─čerlendirilir.


2434









Cevap say─▒s─▒n─▒ say: 30






Asl─▒nda, bu bir tasar─▒m hatas─▒ de─čildir ve i├žsellerden veya performanstan dolay─▒ de─čildir.
Basit├že Python'daki fonksiyonlar─▒n birinci s─▒n─▒f nesneler oldu─ču ve sadece bir kod par├žas─▒ olmad─▒─č─▒ ger├že─činden geliyor.

Bu ┼čekilde d├╝┼č├╝nmeye ba┼člar ba┼člamaz, o zaman tamamen mant─▒kl─▒ geliyor: bir i┼člev tan─▒m─▒ ├╝zerinde de─čerlendirilen bir nesnedir; varsay─▒lan parametreler "├╝ye verisi" t├╝r├╝ndendir ve bu nedenle durumlar─▒ bir ├ža─čr─▒dan di─čerine de─či┼čebilir - aynen di─čer nesnelerde oldu─ču gibi.

Her durumda, Effbot, bu davran─▒┼č─▒n nedenlerini Python'daki Varsay─▒lan Parametre De─čerleri'nde ├žok iyi a├ž─▒klar .
├çok net buldum ve ger├žekten fonksiyon nesnelerinin nas─▒l ├žal─▒┼čt─▒─č─▒n─▒ daha iyi bilmek i├žin okumay─▒ ├Âneriyorum.


1541


2009-07-17





A┼ča─č─▒daki kodun sizde oldu─čunu varsayal─▒m

 fruits = ("apples", "bananas", "loganberries")

def eat(food=fruits):
    ...
 

Yeme─čin ilan─▒n─▒ g├Ârd├╝─č├╝mde, en az ┼ča┼č─▒rt─▒c─▒ ┼čey, ilk parametre verilmezse, dizgiye e┼čit olaca─č─▒n─▒ d├╝┼č├╝nmektir. ("apples", "bananas", "loganberries")

Ancak, daha sonra kodunda san─▒ld─▒─č─▒ gibi, ben bir ┼čey yapmak

 def some_random_function():
    global fruits
    fruits = ("blueberries", "mangos")
 

o zaman varsay─▒lan parametreler i┼člev bildirimi yerine i┼člev y├╝r├╝tme i┼člemine ba─čl─▒ysa, meyvelerin de─či┼čtirildi─čini ke┼čfetmek i├žin ├žok ┼ča┼č─▒r─▒rd─▒m (├žok k├Ât├╝ bir ┼čekilde). Bu, foo yukar─▒daki i┼člevinizin listeyi de─či┼čtirdi─čini ke┼čfetmekten daha ┼ča┼č─▒rt─▒c─▒ bir IMO olurdu .

As─▒l sorun de─či┼čken de─či┼čkenlere dayan─▒yor ve t├╝m dillerin bir dereceye kadar bu sorunu var. ─░┼čte bir soru: Java ile varsayal─▒m ki a┼ča─č─▒daki kod:

 StringBuffer s = new StringBuffer("Hello World!");
Map<StringBuffer,Integer> counts = new HashMap<StringBuffer,Integer>();
counts.put(s, 5);
s.append("!!!!");
System.out.println( counts.get(s) );  // does this work?
 

┼×imdi, haritam StringBuffer , haritaya yerle┼čtirildi─činde anahtar─▒n de─čerini kullan─▒yor mu, yoksa anahtar─▒ referansa g├Âre sakl─▒yor mu? Her iki durumda da, birileri ┼ča┼č─▒rm─▒┼č; nesneyi, Map i├žine koyduklar─▒ de─čerle ├Âzde┼č bir de─čer kullanarak ├ž─▒karmaya ├žal─▒┼čan ki┼či veya kulland─▒klar─▒ anahtar tam anlam─▒yla ayn─▒ nesne olsa bile nesnesini geri alamaz gibi g├Âr├╝nen ki┼či haritaya koymak i├žin kullan─▒l─▒yordu (Python'un de─či┼čken veri t├╝rlerinin s├Âzl├╝k anahtar─▒ olarak kullan─▒lmas─▒na izin vermemesinin nedeni budur).

├ľrnek, Python'un yeni gelenlerin ┼ča┼č─▒r─▒p ─▒s─▒rd─▒─č─▒ bir durumdan iyi bir tanesi. Ancak, e─čer bunu "d├╝zeltirsek", o zaman bunun sadece ─▒s─▒r─▒ld─▒klar─▒ yerde farkl─▒ bir durum yarataca─č─▒n─▒ ve bunun daha az sezgisel olaca─č─▒n─▒ savunuyorum. Dahas─▒, de─či┼čken de─či┼čkenlerle u─čra┼č─▒rken bu her zaman b├Âyledir; her zaman hangi kodun yazd─▒─č─▒na ba─čl─▒ olarak birisinin sezgisel olarak bir veya tam tersi bir davran─▒┼č bekleyebilece─či durumlarla kar┼č─▒la┼č─▒rs─▒n─▒z.

┼×ahsen Python'un ┼ču anki yakla┼č─▒m─▒n─▒ be─čeniyorum: varsay─▒lan i┼člev arg├╝manlar─▒ i┼člev tan─▒mland─▒─č─▒nda ve bu nesne her zaman varsay─▒lan oldu─čunda de─čerlendirilir. San─▒r─▒m bo┼č bir liste kullanarak ├Âzel dava a├žabilirlerdi, ancak bu t├╝r ├Âzel kaplamalar geriye d├Ân├╝k uyumsuzluktan bahsetmemekle birlikte daha fazla ┼ča┼čk─▒nl─▒─ča neden olur.


263







AFAICS hen├╝z kimse dok├╝mantasyonun ilgili b├Âl├╝m├╝n├╝ g├Ândermedi :

Varsay─▒lan parametre de─čerleri, i┼člev tan─▒m─▒ y├╝r├╝t├╝ld├╝─č├╝nde de─čerlendirilir. Bu, fonksiyon tan─▒mland─▒─č─▒nda ifadenin bir kez de─čerlendirildi─či ve her ├ža─čr─▒ i├žin ayn─▒ ÔÇť├Ânceden hesaplanm─▒┼čÔÇŁ de─čerin kullan─▒ld─▒─č─▒ anlam─▒na gelir. Bu, varsay─▒lan bir parametrenin liste veya s├Âzl├╝k gibi de─či┼čken bir nesne oldu─čunu anlamak i├žin ├Âzellikle ├Ânemlidir: i┼člev nesneyi de─či┼čtirdi─činde (├Ârne─čin, listeye bir ├Â─če ekleyerek), varsay─▒lan de─čer ge├žerli olur. Bu genellikle ama├žlanan ┼čey de─čil. Bunun bir yolu, varsay─▒lan olarak Yok se├žene─čini kullanmak ve i┼člev g├Âvdesinde a├ž─▒k├ža s─▒namakt─▒r [...]


229







Python terc├╝man─▒ i├ž i┼čleri hakk─▒nda hi├žbir ┼čey bilmiyorum (ve ayr─▒ca derleyiciler ve terc├╝manlar konusunda da uzman de─čilim) bu y├╝zden, hassas veya imkans─▒z bir ┼čey teklif edersem beni su├žlama.

Python nesnelerinin de─či┼čken olmas─▒ ko┼čuluyla , varsay─▒lan arg├╝manlar─▒n tasar─▒m─▒n─▒ yaparken bunun dikkate al─▒nmas─▒ gerekti─čini d├╝┼č├╝n├╝yorum. Bir listeyi ba┼člatt─▒─č─▒n─▒zda:

 a = []
 

taraf─▒ndan ba┼čvurulan yeni bir liste almay─▒ bekliyorsunuz a .

Niye olsun a=[] i├žinde

 def x(a=[]):
 

i┼člev tan─▒m─▒ ├╝zerinde yeni bir liste ba┼člat─▒ls─▒n m─▒? T─▒pk─▒ "Kullan─▒c─▒ arg├╝man─▒ sa─člam─▒yorsa, o zaman yeni bir liste ba┼člat ve arayanlar taraf─▒ndan olu┼čturuluyormu┼č gibi kullan " diye sordu─čun gibi . Bunun yerine belirsiz oldu─čunu d├╝┼č├╝n├╝yorum:

 def x(a=datetime.datetime.now()):
 

kullan─▒c─▒, a tan─▒mlarken veya uygularken kar┼č─▒l─▒k gelen tarih saatinde varsay─▒lan yapmak ister misiniz x ? Bu durumda, ├Âncekinde oldu─ču gibi, "atama" varsay─▒lan arg├╝man─▒n─▒n fonksiyonun ilk talimat─▒ oldu─ču ( datetime.now() fonksiyon ├ža─č─▒rma ├╝zerinde) olarak ayn─▒ davran─▒┼č─▒ s├╝rd├╝rece─čim . ├ľte yandan, kullan─▒c─▒ tan─▒m-zaman e┼člemesini isterse yazabilece─či:

 b = datetime.datetime.now()
def x(a=b):
 

Biliyorum, biliyorum: bu bir kapan─▒┼č. Alternatif olarak, Python, tan─▒m-zaman ba─člamas─▒n─▒ zorlamak i├žin bir anahtar kelime sa─člayabilir:

 def x(static a=b):
 

110







Bunun nedeni, basit├že, kod ├žal─▒┼čt─▒r─▒ld─▒─č─▒nda ciltlemelerin yap─▒lmas─▒ ve i┼člev tan─▒m─▒n─▒n y├╝r├╝t├╝lmesidir, i┼člevler tan─▒mland─▒─č─▒ndaÔÇŽ.

Bunu kar┼č─▒la┼čt─▒r─▒n:

 class BananaBunch:
    bananas = []

    def addBanana(self, banana):
        self.bananas.append(banana)
 

Bu kod ayn─▒ beklenmeyen durumdan muzdariptir. muzlar bir s─▒n─▒f niteli─čidir ve dolay─▒s─▒yla ona bir ┼čeyler ekledi─činizde, o s─▒n─▒f─▒n t├╝m ├Ârneklerine eklenir. Sebep tamamen ayn─▒.

Bu sadece "Nas─▒l ├çal─▒┼č─▒r" d─▒r ve i┼člev durumunda farkl─▒ ┼čekilde ├žal─▒┼čmas─▒n─▒ sa─člamak, muhtemelen karma┼č─▒k olacakt─▒r ve s─▒n─▒f durumunda, s─▒n─▒f kodunu etrafta tutman─▒z gerekti─či gibi, imkans─▒z veya en az─▒ndan nesne ba┼člatmay─▒ ├žok yava┼člat─▒r. ve nesneler olu┼čturuldu─čunda onu y├╝r├╝t├╝n.

Evet, beklenmedik bir durum. Ancak bir kez kuru┼č d├╝┼čt├╝─č├╝nde, Python'un genel olarak nas─▒l ├žal─▒┼čt─▒─č─▒na m├╝kemmel ┼čekilde uyar. Asl─▒nda, bu iyi bir ├Â─čretim yard─▒m─▒ ve bunun neden oldu─čunu bir kez anlad─▒ktan sonra pitonu ├žok daha iyi yakalayacaks─▒n─▒z.

Bu, herhangi bir Python ├Â─čreticisinde belirgin bir ┼čekilde ├Âne ├ž─▒kmas─▒ gerekti─čini s├Âyledi. ├ç├╝nk├╝ bahsetti─činiz gibi, herkes bu soruna er ya da ge├ž kar┼č─▒la┼č─▒r.


81







├çal─▒┼čma zaman─▒nda nesneleri yaratman─▒n daha iyi bir yakla┼č─▒m olaca─č─▒n─▒ d├╝┼č├╝n├╝rd├╝m. Art─▒k daha az eminim, ├ž├╝nk├╝ baz─▒ faydal─▒ ├Âzellikleri kaybedersiniz, ancak yeni ba┼člayanlar─▒n kafa kar─▒┼č─▒kl─▒─č─▒n─▒ ├Ânlemek i├žin ne olursa olsun buna de─čer olabilir. Bunu yapman─▒n dezavantajlar─▒:

1. Performans

 def foo(arg=something_expensive_to_compute())):
    ...
 

E─čer ├ža─čr─▒ zaman─▒ de─čerlendirmesi kullan─▒l─▒yorsa, fonksiyonunuz her arg├╝man olmadan kullan─▒ld─▒─č─▒nda pahal─▒ fonksiyon ├ža─čr─▒l─▒r. Her aramada pahal─▒ bir fiyat ├Âdersiniz veya de─čeri harici olarak manuel olarak ├Ânbelle─če almak, ad alan─▒n─▒z─▒ kirletmek ve ayr─▒nt─▒lar─▒n─▒ eklemek zorunda kal─▒rs─▒n─▒z.

2. Ba─čl─▒ parametreleri zorlamak

Yararl─▒ bir p├╝f noktas─▒, bir lambda'n─▒n parametrelerini , lambda olu┼čturuldu─čunda bir de─či┼čkenin mevcut ba─članmas─▒na ba─člamakt─▒r. ├ľrne─čin:

 funcs = [ lambda i=i: i for i in range(10)]
 

Bu, s─▒ras─▒yla 0,1,2,3 ... d├Ând├╝ren i┼člevlerin bir listesini d├Ând├╝r├╝r. Davran─▒┼č de─či┼čtirilirse, bunun yerine ba─člayacak i i├žin ├ža─čr─▒ zamanl─▒ t├╝m d├Ând├╝─č├╝n├╝ fonksiyonlar─▒n bir listesini alaca─č─▒, b├Âylece i de─čerine 9 .

Aksi takdirde bunu ger├žekle┼čtirmenin tek yolu i s─▒n─▒r─▒na, yani:

 def make_func(i): return lambda: i
funcs = [make_func(i) for i in range(10)]
 

3. Introspection

Kodu d├╝┼č├╝n├╝n:

 def foo(a='test', b=100, c=[]):
   print a,b,c
 

inspect Mod├╝l kullan─▒larak arg├╝manlar ve varsay─▒lanlar hakk─▒nda bilgi alabiliriz ;

 >>> inspect.getargspec(foo)
(['a', 'b', 'c'], None, None, ('test', 100, []))
 

Bu bilgiler, belge olu┼čturma, metaprogramlama, dekorat├Ârler vb. ┼×eyler i├žin ├žok kullan─▒┼čl─▒d─▒r.

┼×imdi, varsay─▒lanlar─▒n davran─▒┼č─▒n─▒n, e┼čde─čerde olaca─č─▒ ┼čekilde de─či┼čtirilebilece─čini varsayal─▒m:

 _undefined = object()  # sentinel value

def foo(a=_undefined, b=_undefined, c=_undefined)
    if a is _undefined: a='test'
    if b is _undefined: b=100
    if c is _undefined: c=[]
 

Ancak biz kendi duygular─▒n─▒ ve varsay─▒lan arg├╝manlar ne oldu─čunu g├Ârme olana─č─▒ kaybettim vard─▒r . Nesneler in┼ča edilmedi─či i├žin, fonksiyonu ger├žekten ├ža─č─▒rmadan hi├žbir zaman onlar─▒ alamay─▒z. Yapabilece─čimizin en iyisi kaynak kodunu saklamak ve onu bir dize olarak d├Ând├╝rmektir.


57







Neden i├žten i├že bakm─▒yorsun?

Ben ediyorum ger├žekten Python taraf─▒ndan sunulan anlay─▒┼čl─▒ i├ž g├Âzlem ger├žekle┼čtirildi (konu┼čup hi├ž kimsenin ┼ča┼č─▒rtt─▒ 2 ve 3 callables ├╝zerine uygulan─▒r).

Verilen basit bir k├╝├ž├╝k fonksiyon g├Âz ├Ân├╝ne al─▒nd─▒─č─▒nda func :

 >>> def func(a = []):
...    a.append(5)
 

Python kar┼č─▒la┼čt─▒─č─▒nda, yapacak ilk ┼čey code bu i┼člev i├žin bir nesne olu┼čturmak amac─▒yla derlemek . Bu derleme ad─▒m─▒ yap─▒l─▒rken Python * de─čerlendirir ve sonra varsay─▒lan arg├╝manlar─▒ ( burada bo┼č bir liste ) fonksiyon nesnesinin i├žinde saklar [] . Bahsedilen en ├╝st cevab─▒n s├Âyledi─či gibi: liste a art─▒k i┼člevin bir ├╝yesi olarak kabul edilebilir func .

├ľyleyse, listenin fonksiyon nesnesinin i├žinde nas─▒l geni┼čledi─čini incelemek i├žin bir ├Âncekinden ve sonras─▒nda baz─▒ i├ž g├Âzlemler yapal─▒m . Bunun i├žin kullan─▒yorum Python 3.x , Python 2 i├žin de ayn─▒s─▒ ge├žerli ( Python 2'de kullan─▒n __defaults__ veya func_defaults ayn─▒ ┼čey i├žin iki isim kullan─▒n).

Y├╝r├╝tmeden ├ľnce ─░┼člev:

 >>> def func(a = []):
...     a.append(5)
...     
 

Python bu tan─▒m─▒ y├╝r├╝tt├╝kten sonra ( a = [] burada) belirtilen herhangi bir varsay─▒lan parametreyi al─▒r ve onlar─▒ __defaults__ i┼člev nesnesi ├Âzniteli─činde s─▒k─▒┼čt─▒r─▒r (ilgili b├Âl├╝m: Callables):

 >>> func.__defaults__
([],)
 

Tamam, tek bir giri┼č olarak bo┼č bir liste __defaults__ , beklendi─či gibi.

Y├╝r├╝tmeden Sonra ─░┼člev:

┼×imdi bu i┼člevi ├žal─▒┼čt─▒ral─▒m:

 >>> func()
 

┼×imdi bunlar─▒ __defaults__ tekrar g├Ârelim :

 >>> func.__defaults__
([5],)
 

┼×a┼čk─▒na? Nesnenin i├žindeki de─čer de─či┼čir! Fonksiyona arka arkaya yap─▒lan ├ža─čr─▒lar ┼čimdi basit├že o g├Âm├╝l├╝ list nesneye eklenecektir :

 >>> func(); func(); func()
>>> func.__defaults__
([5, 5, 5, 5],)
 

├ľyleyse, burada bu kusurun olmas─▒n─▒n nedeni , varsay─▒lan arg├╝manlar─▒n i┼člev nesnesinin bir par├žas─▒ olmas─▒d─▒r. Burada olan garip bir ┼čey yok, hepsi biraz ┼ča┼č─▒rt─▒c─▒.

Bununla m├╝cadele etmek i├žin ortak ├ž├Âz├╝m None varsay─▒lan olarak kullanmak ve sonra i┼člev g├Âvdesinde ba┼člatmakt─▒r:

 def func(a = None):
    # or: a = [] if a is None else a
    if a is None:
        a = []
 

─░┼člev g├Âvdesi her seferinde yeniden y├╝r├╝t├╝ld├╝─č├╝nden, herhangi bir arg├╝man iletilmezse, her zaman yeni ve bo┼č bir liste al─▒rs─▒n─▒z a .


Listedeki __defaults__ fonksiyonun kullan─▒lan listeyle ayn─▒ oldu─čunu do─črulamak i├žin , fonksiyon g├Âvdesinde kullan─▒lan listenin listesini func d├Ând├╝rmek i├žin fonksiyonunuzu de─či┼čtirebilirsiniz . Ard─▒ndan, listedeki (konum i├žinde ) kar┼č─▒la┼čt─▒r─▒n; bunlar─▒n ger├žekten ayn─▒ liste ├Ârne─čine g├Ânderme yapt─▒─č─▒n─▒ g├Âreceksiniz: id a __defaults__ [0] __defaults__

 >>> def func(a = []): 
...     a.append(5)
...     return id(a)
>>>
>>> id(func.__defaults__[0]) == func()
True
 

T├╝m i├ž g├Âzlem g├╝c├╝ ile!


* Python'un fonksiyonun derlenmesi s─▒ras─▒ndaki varsay─▒lan arg├╝manlar─▒ de─čerlendirdi─čini do─črulamak i├žin a┼ča─č─▒dakileri ├žal─▒┼čt─▒rmay─▒ deneyin:

 def bar(a=input('Did you just see me without calling the function?')): 
    pass  # use raw_input in Py2
 

farkedece─činiz gibi, input() i┼člevin olu┼čturulma ve isme ba─članmas─▒ i┼čleminden ├Ânce ├ža─čr─▒l─▒r bar .


57







Python savunmas─▒nda 5 puan

  1. Basitlik : Davran─▒┼č ┼ču anlamda basittir: ├ço─ču ki┼či bu tuza─ča sadece bir kez d├╝┼čer, birka├ž kez de─čil.

  2. Tutarl─▒l─▒k : Python adlar─▒ de─čil, nesneleri her zaman ge├žirir. Varsay─▒lan parametre, a├ž─▒k├žas─▒, i┼člev ba┼čl─▒─č─▒n─▒n bir par├žas─▒d─▒r (i┼člev g├Âvdesi de─čil). Bu nedenle, i┼člev ├ža─čr─▒s─▒ s─▒ras─▒nda, mod├╝l y├╝kleme zaman─▒nda (ve yaln─▒zca yuvalanmad─▒k├ža mod├╝l y├╝kleme zaman─▒nda) de─čerlendirilmelidir.

  3. Yararl─▒l─▒k : Frederik Lundh "Python'daki Varsay─▒lan Parametre De─čerleri" a├ž─▒klamas─▒nda belirtti─čine g├Âre , mevcut davran─▒┼č, geli┼čmi┼č programlama i├žin olduk├ža faydal─▒ olabilir. (Az miktarda kullan─▒n.)

  4. Yeterli belgeler : En temel Python belgelerinde, e─čitimde, konu y├╝ksek sesle bir olarak a├ž─▒kland─▒ "├ľnemli uyar─▒" in ilk B├Âl├╝m├╝n alt b├Âl├╝m├╝nde "Fonksiyon Tan─▒mlar─▒ ├ťzerine Daha" . Uyar─▒, ba┼čl─▒klar─▒n d─▒┼č─▒nda nadiren uygulanan koyu renkli yaz─▒lar─▒ bile kullan─▒r. RTFM: ─░nce k─▒lavuzu okuyun.

  5. Meta-├Â─črenme : Tuza─ča d├╝┼čmek asl─▒nda ├žok yararl─▒ bir and─▒r (en az─▒ndan yans─▒t─▒c─▒ bir ├Â─čreniciyseniz) ├ž├╝nk├╝ daha sonra yukar─▒daki "Tutarl─▒l─▒k" noktas─▒n─▒ daha iyi anlayacaks─▒n─▒z ve bu size Python hakk─▒nda ├žok ┼čey ├Â─čretecektir.


53







Bu davran─▒┼č kolay a├ž─▒klan─▒r:

  1. i┼člev (s─▒n─▒f vb.) bildirimi yaln─▒zca bir kez y├╝r├╝t├╝l├╝r ve t├╝m varsay─▒lan de─čer nesneleri olu┼čturulur.
  2. her ┼čey referans taraf─▒ndan ge├žildi

Yani:

 def x(a=0, b=[], c=[], d=0):
    a = a + 1
    b = b + [1]
    c.append(1)
    print a, b, c
 
  1. a de─či┼čmez - her atama ├ža─čr─▒s─▒ yeni int nesnesi yarat─▒r - yeni nesne yazd─▒r─▒l─▒r
  2. b de─či┼čmez - yeni dizi varsay─▒lan de─čerden derlenir ve yazd─▒r─▒l─▒r
  3. c de─či┼čiklikler - i┼člem ayn─▒ nesnede ger├žekle┼čtirilir - ve yazd─▒r─▒l─▒r

49


2009-07-15





─░stedi─činiz ┼čey ┼čunun nedeni:

 def func(a=[], b = 2):
    pass
 

Buna dahili olarak e┼čde─čer de─čildir:

 def func(a=None, b = None):
    a_default = lambda: []
    b_default = lambda: 2
    def actual_func(a=None, b=None):
        if a is None: a = a_default()
        if b is None: b = b_default()
    return actual_func
func = func()
 

a├ž─▒k├ža g├Âz ard─▒ edece─čimiz func (Yok, Yok) i┼člevini ├ža─č─▒rmak d─▒┼č─▒nda.

Ba┼čka bir deyi┼čle, varsay─▒lan parametreleri de─čerlendirmek yerine neden her birini saklam─▒yor ve i┼člev ├ža─čr─▒ld─▒─č─▒nda bunlar─▒ de─čerlendiriyorsunuz?

Tek bir cevap muhtemelen tam orada - varsay─▒lan parametreleri olan her fonksiyonu etkin bir ┼čekilde kapatacak. Tamamen terc├╝man i├žinde gizlenmi┼č ve tamamen kapal─▒ bir kapak olmasa bile, verilerin bir yerde saklanmas─▒ gerekir. Daha yava┼č olurdu ve daha fazla haf─▒za kullan─▒rd─▒.


33







1) "De─či┼čken Varsay─▒lan Arg├╝man" olarak adland─▒r─▒lan sorun genel olarak a┼ča─č─▒dakileri g├Âsteren ├Âzel bir ├Ârnektir:
"Bu sorunla ilgili t├╝m i┼člevler , ger├žek parametre ├╝zerindeki benzer yan etki sorunundan da muzdariptir ,"
─░┼člevsel programlama kurallar─▒na ayk─▒r─▒d─▒r, genellikle dayan─▒lmaz ve her ikisi birlikte sabitlenmelidir.

├ľrnek:

 def foo(a=[]):                 # the same problematic function
    a.append(5)
    return a

>>> somevar = [1, 2]           # an example without a default parameter
>>> foo(somevar)
[1, 2, 5]
>>> somevar
[1, 2, 5]                      # usually expected [1, 2]
 

├ç├Âz├╝m : bir kopya
Kesinlikle g├╝venli bir ├ž├Âz├╝m ├Ânce copy veya deepcopy giri┼č nesnesine, ard─▒ndan da kopya ile ne gerekiyorsa onu yapmakt─▒r.

 def foo(a=[]):
    a = a[:]     # a copy
    a.append(5)
    return a     # or everything safe by one line: "return a + [5]"
 

Bir├žok yerle┼čik de─či┼čtirilebilir tipler gibi bir kopya y├Ântemine sahip some_dict.copy() ya some_set.copy() ya da benzeri kolay kopyalanabilir somelist[:] veya list(some_list) . Her nesne ayr─▒ca copy.copy(any_object) veya daha ayr─▒nt─▒l─▒ olarak da kopyalanabilir copy.deepcopy() (ikincil, de─či┼čtirilebilir nesne de─či┼čtirilebilir nesnelerden olu┼čuyorsa yararl─▒d─▒r). Baz─▒ nesneler temelde "dosya" nesnesi gibi yan etkilere dayan─▒r ve kopya ile anlaml─▒ bir ┼čekilde ├žo─čalt─▒lamaz. kopyalama

Benzer bir SO sorusu i├žin ├Ârnek problemhttps://stackoverflow.com/q/13484107/448474

 class Test(object):            # the original problematic class
  def __init__(self, var1=[]):
    self._var1 = var1

somevar = [1, 2]               # an example without a default parameter
t1 = Test(somevar)
t2 = Test(somevar)
t1._var1.append([1])
print somevar                  # [1, 2, [1]] but usually expected [1, 2]
print t2._var1                 # [1, 2, [1]] but usually expected [1, 2]
 

Bu i┼člev taraf─▒ndan d├Ând├╝r├╝len bir ├Ârne─čin hi├žbir ├Âzel niteli─činde kaydedilmemelidir . ( ├ľrne─čin ├Âzel niteliklerinin bu s─▒n─▒f─▒n d─▒┼č─▒ndan veya alt s─▒n─▒flar─▒n konvansiyonel olarak de─či┼čtirilmemesi gerekti─či varsay─▒larak, yani _var1 ├Âzel bir ├Âzellik)

Sonu├ž:
Girdi parametreleri nesneleri yerinde de─či┼čtirilmemeli (mutasyona tabi tutulmamal─▒) ya da i┼člev taraf─▒ndan d├Ând├╝r├╝len bir nesneye ba─članmamal─▒d─▒r. (┼×iddetle tavsiye edilen yan etkiler olmadan programlamay─▒ tercih edersek. "Yan etki" hakk─▒nda Wiki'ye bak─▒n─▒z. (─░lk iki paragraf bu ba─člamda ge├žerlidir.).)

2)
Yaln─▒zca ger├žek parametre ├╝zerindeki yan etki gerekliyse, ancak varsay─▒lan parametre ├╝zerinde istenmeyen ise, yararl─▒ ├ž├Âz├╝m def ...(var1=None): if var1 is None: var1 = [] Daha fazla ..

3) Baz─▒ durumlarda, varsay─▒lan parametrelerin de─či┼čken davran─▒┼č─▒ yararl─▒d─▒r .


31







Bunun asl─▒nda varsay─▒lan de─čerlerle ilgisi yoktur, de─či┼čken de─či┼čken de─čerlere sahip i┼člevler yazd─▒─č─▒n─▒zda genellikle beklenmeyen bir davran─▒┼č olarak ortaya ├ž─▒kmas─▒ d─▒┼č─▒nda bir ┼čey olmaz.

 >>> def foo(a):
    a.append(5)
    print a

>>> a  = [5]
>>> foo(a)
[5, 5]
>>> foo(a)
[5, 5, 5]
>>> foo(a)
[5, 5, 5, 5]
>>> foo(a)
[5, 5, 5, 5, 5]
 

Bu kodda g├Âr├╝n├╝┼čte varsay─▒lan de─čer yok, ancak tamamen ayn─▒ sorunu ya┼čars─▒n─▒z.

Sorun ┼ču ki foo , arayan bunu beklemiyorsa, arayandan ge├žen de─či┼čken bir de─či┼čkeni de─či┼čtirmek . B├Âyle bir kod, fonksiyona ┼č├Âyle bir ┼čey s├Âylendiyse iyi olur append_5 ; daha sonra arayan ki┼či, girdi─či de─čeri de─či┼čtirmek i├žin fonksiyonu ├ža─č─▒r─▒r ve davran─▒┼č beklenir. Ancak, b├Âyle bir fonksiyonun varsay─▒lan bir arg├╝man alma olas─▒l─▒─č─▒ ├žok d├╝┼č├╝k olacakt─▒r ve muhtemelen listeyi geri d├Ând├╝rmez (arayan ki┼či zaten o listeye bir referansa sahip oldu─čundan; hen├╝z girdi─či bir listeye).

Orijinaliniz foo , varsay─▒lan bir arg├╝manla, a a├ž─▒k├ža iletilmi┼č veya varsay─▒lan de─čere sahip olup olmad─▒─č─▒n─▒ de─či┼čtirmemelidir . Kodunuz, ba─č─▒ms─▒z de─či┼čkenlerin de─či┼čtirilmeleri gerekti─či ba─člam─▒ndan / ad─▒ndan / belgelerinden a├ž─▒k├ža anla┼č─▒lmad─▒k├ža, yaln─▒zca de─či┼čken arg├╝manlar─▒ b─▒rakmal─▒d─▒r. Ba─č─▒ms─▒z de─či┼čkenler olarak yerel de─či┼čkenler olarak iletilen de─či┼čken de─čerleri kullanmak, Python'da olup olmad─▒─č─▒m─▒z ve dahil olan varsay─▒lan arg├╝manlar─▒n olup olmad─▒─č─▒ son derece k├Ât├╝ bir fikirdir.

Bir ┼čeyi hesaplama s├╝recinde yerel bir ge├žici olan─▒ tahrip edici ┼čekilde manip├╝le etmeniz ve manip├╝lasyonunuzu bir arg├╝man de─čerinden ba┼člatman─▒z gerekirse, bir kopya ├ž─▒karman─▒z gerekir.


28


2011-05-23





Zaten me┼čgul olan bir konu, ancak burada okuduklar─▒mdan, a┼ča─č─▒dakiler dahili olarak nas─▒l ├žal─▒┼čt─▒─č─▒n─▒ fark etmeme yard─▒mc─▒ oldu:

 def bar(a=[]):
     print id(a)
     a = a + [1]
     print id(a)
     return a

>>> bar()
4484370232
4484524224
[1]
>>> bar()
4484370232
4484524152
[1]
>>> bar()
4484370232 # Never change, this is 'class property' of the function
4484523720 # Always a new object 
[1]
>>> id(bar.func_defaults[0])
4484370232
 

26







Bu bir performans optimizasyonu. Bu i┼člevselli─čin bir sonucu olarak, bu iki i┼člev ├ža─čr─▒s─▒ndan hangisinin daha h─▒zl─▒ oldu─čunu d├╝┼č├╝n├╝yorsunuz?

 def print_tuple(some_tuple=(1,2,3)):
    print some_tuple

print_tuple()        #1
print_tuple((1,2,3)) #2
 

Sana bir ipucu verece─čim. ─░┼čte s├Âkme (bkz. Http://docs.python.org/library/dis.html ):

# 1

 0 LOAD_GLOBAL              0 (print_tuple)
3 CALL_FUNCTION            0
6 POP_TOP
7 LOAD_CONST               0 (None)
10 RETURN_VALUE
 

# 2

  0 LOAD_GLOBAL              0 (print_tuple)
 3 LOAD_CONST               4 ((1, 2, 3))
 6 CALL_FUNCTION            1
 9 POP_TOP
10 LOAD_CONST               0 (None)
13 RETURN_VALUE
 

Tecr├╝beli davran─▒┼č─▒n pratik bir kullan─▒m─▒ oldu─čundan ┼č├╝pheliyim (C de statik de─či┼čkenleri ├╝reyen b├Âcekler olmadan kim kullan─▒yor?)

G├Ârd├╝─č├╝n├╝z gibi, orada olan de─či┼čmez varsay─▒lan arg├╝manlar kullan─▒rken bir performans yarar─▒. S─▒k kullan─▒lan bir i┼člev veya varsay─▒lan arg├╝man─▒n olu┼čturulmas─▒ uzun zaman al─▒yorsa, bu bir fark yaratabilir. Ayr─▒ca, Python'un C olmad─▒─č─▒n─▒ unutmay─▒n. C'de hemen hemen ├╝cretsiz olan sabitleriniz var. Python'da bu avantajdan yararlanamazs─▒n─▒z.


25







Python: De─či┼čken Varsay─▒lan Arg├╝man

Varsay─▒lan arg├╝manlar, fonksiyonun bir fonksiyon nesnesine derlendi─či s─▒rada de─čerlendirilir. ─░┼člev taraf─▒ndan kullan─▒ld─▒─č─▒nda, bu i┼člev taraf─▒ndan birden ├žok kez, ayn─▒ nesne kal─▒r ve kal─▒rlar.

De─či┼čken olduklar─▒nda, mutasyona u─črad─▒klar─▒nda (├Ârne─čin, ona bir element ekleyerek) ard─▒┼č─▒k ├ža─čr─▒larda mutasyona u─čram─▒┼č olarak kal─▒rlar.

Mutasyona u─črarlar ├ž├╝nk├╝ her seferinde ayn─▒ nesnelerdir.

E┼čde─čer kod:

─░┼člev nesnesi derlendi─činde ve ba┼člat─▒ld─▒─č─▒nda liste i┼čleve ba─čl─▒ oldu─čundan, bu:

 def foo(mutable_default_argument=[]): # make a list the default argument
    """function that uses a list"""
 

buna neredeyse tamamen e┼čde─čerdir:

 _a_list = [] # create a list in the globals

def foo(mutable_default_argument=_a_list): # make it the default argument
    """function that uses a list"""

del _a_list # remove globals name binding
 

g├Âsteri

─░┼čte bir tan─▒t─▒m - her ba┼čvuruda bulunduklar─▒nda ayn─▒ nesne olduklar─▒n─▒ do─črulayabilirsiniz

  • Listenin, fonksiyonun bir fonksiyon nesnesine derlemeyi bitirmeden ├Ânce olu┼čturuldu─čunu g├Ârmek,
  • kimli─čin listeye her ba┼čvuru yap─▒ld─▒─č─▒nda ayn─▒ oldu─čunu g├Âzlemleyerek,
  • onu kullanan i┼člev ikinci kez ├ža─čr─▒ld─▒─č─▒nda listenin de─či┼čmedi─čini g├Âzlemleyerek,
  • ├ç─▒kt─▒n─▒n kaynaktan bas─▒ld─▒─č─▒ s─▒ray─▒ (sizin i├žin uygun ┼čekilde numaraland─▒rd─▒─č─▒m) g├Âzlemleyerek:

example.py

 print('1. Global scope being evaluated')

def create_list():
    '''noisily create a list for usage as a kwarg'''
    l = []
    print('3. list being created and returned, id: ' + str(id(l)))
    return l

print('2. example_function about to be compiled to an object')

def example_function(default_kwarg1=create_list()):
    print('appending "a" in default default_kwarg1')
    default_kwarg1.append("a")
    print('list with id: ' + str(id(default_kwarg1)) + 
          ' - is now: ' + repr(default_kwarg1))

print('4. example_function compiled: ' + repr(example_function))


if __name__ == '__main__':
    print('5. calling example_function twice!:')
    example_function()
    example_function()
 

ve ile ├žal─▒┼čan python example.py :

 1. Global scope being evaluated
2. example_function about to be compiled to an object
3. list being created and returned, id: 140502758808032
4. example_function compiled: <function example_function at 0x7fc9590905f0>
5. calling example_function twice!:
appending "a" in default default_kwarg1
list with id: 140502758808032 - is now: ['a']
appending "a" in default default_kwarg1
list with id: 140502758808032 - is now: ['a', 'a']
 

Bu "En K├╝├ž├╝k ┼×a┼čk─▒nl─▒k" ilkesini ihlal ediyor mu?

Bu uygulama s─▒ras─▒ yeni Python kullan─▒c─▒lar─▒ i├žin kafa kar─▒┼čt─▒r─▒c─▒d─▒r. Python y├╝r├╝tme modelini anlarsan─▒z, olduk├ža beklenir.

Yeni Python kullan─▒c─▒lar─▒na verilen genel talimat:

Ancak bu nedenle, yeni kullan─▒c─▒lara verilen ola─čan talimat bunun yerine varsay─▒lan arg├╝manlar─▒n─▒ olu┼čturmakt─▒r:

 def example_function_2(default_kwarg=None):
    if default_kwarg is None:
        default_kwarg = []
 

Bu, fonksiyona varsay─▒landan ba┼čka bir arg├╝man al─▒p almad─▒─č─▒m─▒z─▒ bildirmek i├žin Yok tekilini sentinel nesnesi olarak kullan─▒r. Arg├╝man alamazsak, asl─▒nda [] varsay─▒lan olarak yeni bir bo┼č liste kullanmak istiyoruz .

Gibi kontrol ak─▒┼č─▒na ├Â─čretici b├Âl├╝m der ki:

Varsay─▒lan ├ža─čr─▒n─▒n sonraki ├ža─čr─▒lar aras─▒nda payla┼č─▒lmas─▒n─▒ istemiyorsan─▒z, bunun yerine i┼člevi ┼č├Âyle yazabilirsiniz:

 def f(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L
 

23







En k─▒sa cevap muhtemelen "tan─▒m uygulamad─▒r" olacakt─▒r, bu nedenle t├╝m arg├╝man hi├žbir anlam ifade etmemektedir. Daha ayr─▒nt─▒l─▒ bir ├Ârnek olarak, ┼čunu s├Âyleyebilirsin:

 def a(): return []

def b(x=a()):
    print x
 

Umar─▒m, varsay─▒lan arg├╝man ifadelerinin ifadenin y├╝r├╝t├╝lmesi s─▒ras─▒nda y├╝r├╝t├╝lmemesinin def kolay olmad─▒─č─▒n─▒ veya bir anlam ifade etmedi─čini veya her ikisini de g├Âstermesi yeterlidir .

Yine de, varsay─▒lan kurucular─▒ kullanmaya ├žal─▒┼čt─▒─č─▒n─▒zda bunun bir sonu├ž oldu─čunu kabul ediyorum.


23







Yok kullanarak basit bir ge├žici ├ž├Âz├╝m

 >>> def bar(b, data=None):
...     data = data or []
...     data.append(b)
...     return data
... 
>>> bar(3)
[3]
>>> bar(3)
[3]
>>> bar(3)
[3]
>>> bar(3, [34])
[34, 3]
>>> bar(3, [34])
[34, 3]
 

19







A┼ča─č─▒dakileri g├Âz ├Ân├╝nde bulundurursan─▒z, bu davran─▒┼č ┼ča┼č─▒rt─▒c─▒ de─čildir:

  1. Salt okunur s─▒n─▒f davran─▒┼č─▒, atama denemelerinde ortaya ├ž─▒kar ve
  2. ─░┼člevler nesnelerdir (kabul edilen cevapta iyi a├ž─▒klanm─▒┼čt─▒r).

(2) ' nin rol├╝ bu ba┼čl─▒kta yo─čun olarak ele al─▒nm─▒┼čt─▒r. (1) muhtemelen di─čer dillerden geldi─činde bu davran─▒┼č "sezgisel" olmad─▒─č─▒ i├žin, ┼ča┼čk─▒nl─▒─ča neden olan fakt├Ârd├╝r.

(1) Python dersinde s─▒n─▒flar ├╝zerinde a├ž─▒klanm─▒┼čt─▒r . Salt okunur bir s─▒n─▒f ├Âzelli─čine bir de─čer atama giri┼čiminde bulunmak i├žin:

... en i├žteki kapsam d─▒┼č─▒nda bulunan t├╝m de─či┼čkenler salt okunurdur ( bu t├╝r bir de─či┼čkene yazma denemesi, en i├žteki kapsamda ayn─▒ ┼čekilde adland─▒r─▒lan d─▒┼č de─či┼čkeni de─či┼čtirmeden b─▒rakarak, yaln─▒zca en i├ž kapsamda yeni bir yerel de─či┼čken olu┼čturur ).

Orijinal ├Ârne─če geri d├Ân├╝n ve yukar─▒daki noktalar─▒ g├Âz ├Ân├╝nde bulundurun:

 def foo(a=[]):
    a.append(5)
    return a
 

─░┼čte foo bir nesne ve (de mevcut ) a bir ├Âzniteli─čidir . Yana bir listedir, de─či┼čken ve b├Âylece bir okuma-yazma ├Âzelli─čidir . ─░┼člev ba┼člat─▒ld─▒─č─▒nda imzan─▒n belirtti─či ┼čekilde bo┼č listeye ilklendirilir ve i┼člev nesnesi oldu─ču s├╝rece okuma ve yazma i├žin kullan─▒labilir. foo foo.func_defs[0] a a foo

foo Bir varsay─▒lan─▒ ge├žersiz k─▒lmadan arama yapmak, bu varsay─▒lan─▒n de─čerini kullan─▒r foo.func_defs . Bu durumda, fonksiyon nesnesinin kod kapsam─▒ i├žinde foo.func_defs[0] kullan─▒l─▒r a . De─či┼čiklikler a de─či┼čtirme foo.func_defs[0] par├žas─▒ olan, foo kod y├╝r├╝t├╝lmesi aras─▒ndaki nesne ve devam foo .

┼×imdi, bunu ├Ârnekle kar┼č─▒la┼čt─▒r─▒n ; i┼člev imzas─▒ varsay─▒lanlar─▒, i┼člev her ├žal─▒┼čt─▒r─▒ld─▒─č─▒nda kullan─▒lacak , di─čer dillerin varsay─▒lan arg├╝man davran─▒┼č─▒n─▒ taklit etme belgesindeki bilgilerle kar┼č─▒la┼čt─▒r─▒n :

 def foo(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L
 

Alarak (1) ve (2) bu istenilen davran─▒┼č─▒ ger├žekle┼čtirir neden dikkate bir g├Ârebilir:

  • Zaman foo fonksiyonu nesne ├Ârne─či, foo.func_defs[0] ayarlan─▒r None de─či┼čken olmayan bir obje.
  • ─░┼člev varsay─▒lanlarla ├žal─▒┼čt─▒r─▒ld─▒─č─▒nda ( L i┼člev ├ža─čr─▒s─▒nda belirtilen parametre olmadan ), foo.func_defs[0] ( None ) yerel kapsamda oldu─ču gibi kullan─▒labilir L .
  • Sonras─▒nda L = [] , ├Âdev ba┼čar─▒l─▒ olamaz foo.func_defs[0] , ├ž├╝nk├╝ bu ├Âzellik salt okunurdur.
  • Ba┼č─▒na (1) , ayr─▒ca ad─▒nda yeni bir yerel de─či┼čken L yerel kapsam─▒nda olu┼čturulan ve i┼člev ├ža─čr─▒s─▒ kalan─▒ i├žin kulland─▒. foo.func_defs[0] B├Âylece gelecekteki ├ža─čr─▒lar i├žin de─či┼čmeden kal─▒r foo .

19







Buradaki ├ž├Âz├╝mler:

  1. None Varsay─▒lan de─čeriniz (veya bir nonce object ) olarak kullan─▒n ve ├žal─▒┼čma zaman─▒nda de─čerlerinizi olu┼čturmak i├žin bunu a├ž─▒n; veya
  2. lambda Varsay─▒lan parametreniz olarak a kullan─▒n ve varsay─▒lan de─čeri elde etmek i├žin bunu bir try blo─ču i├žinde ├ža─č─▒r─▒n (bu lambda soyutlamas─▒n─▒n i├žindir.

─░kinci se├ženek g├╝zeldir, ├ž├╝nk├╝ i┼člev kullan─▒c─▒lar─▒ ├Ânceden var olan bir ├ža─čr─▒labilir numaradan ge├žebilirler (├Ârne─čin a type )


17







Bir i┼čleve varsay─▒lan liste de─čerini iletmek i├žin alternatif bir yap─▒ g├Âsterece─čim (s├Âzl├╝klerle e┼čit derecede iyi ├žal─▒┼č─▒yor).

Di─čerlerinin kapsaml─▒ bir ┼čekilde yorum yapt─▒─č─▒ gibi, list parametresi, y├╝r├╝t├╝ld├╝─č├╝ zaman aksine tan─▒mland─▒─č─▒ zaman i┼čleve ba─član─▒r. Listeler ve s├Âzl├╝kler de─či┼čken oldu─čundan, bu parametrede yap─▒lacak herhangi bir de─či┼čiklik, bu fonksiyona yap─▒lan di─čer ├ža─čr─▒lar─▒ etkileyecektir. Sonu├ž olarak, i┼čleve yap─▒lan sonraki ├ža─čr─▒lar, i┼čleve yap─▒lan di─čer ├ža─čr─▒lar taraf─▒ndan de─či┼čtirilmi┼č olabilecek bu payla┼č─▒lan listeyi al─▒r. Daha da k├Ât├╝s├╝, iki parametre bu i┼člevin payla┼č─▒lan parametresini ayn─▒ anda di─čerinin yapt─▒─č─▒ de─či┼čikliklere al─▒┼čk─▒n olarak kullan─▒yor.

Yanl─▒┼č Y├Ântem (muhtemelen ...) :

 def foo(list_arg=[5]):
    return list_arg

a = foo()
a.append(6)
>>> a
[5, 6]

b = foo()
b.append(7)
# The value of 6 appended to variable 'a' is now part of the list held by 'b'.
>>> b
[5, 6, 7]  

# Although 'a' is expecting to receive 6 (the last element it appended to the list),
# it actually receives the last element appended to the shared list.
# It thus receives the value 7 previously appended by 'b'.
>>> a.pop()             
7
 

Bunlar─▒ kullanarak ayn─▒ nesnenin ayn─▒ oldu─čunu do─črulayabilirsiniz id :

 >>> id(a)
5347866528

>>> id(b)
5347866528
 

Brett Slatkin'in "Etkili Python: 59 Daha ─░yi Python Yazman─▒n ├ľzel Yollar─▒", Madde 20: None Dinamik varsay─▒lan arg├╝manlar─▒ belirlemek i├žin Kullan─▒m ve Dok├╝manlar (s. 48)

Python'da istenen sonucu elde etmek i├žin yap─▒lan kural varsay─▒lan bir de─čer sa─člamak None ve dok├╝manlardaki ger├žek davran─▒┼č─▒ belgelemektir.

Bu uygulama, i┼čleve yap─▒lan her ├ža─čr─▒ i├žin ya varsay─▒lan listeyi ya da i┼čleve iletilen listeyi al─▒r.

Tercih edilen y├Ântem :

 def foo(list_arg=None):
   """
   :param list_arg:  A list of input values. 
                     If none provided, used a list with a default value of 5.
   """
   if not list_arg:
       list_arg = [5]
   return list_arg

a = foo()
a.append(6)
>>> a
[5, 6]

b = foo()
b.append(7)
>>> b
[5, 7]

c = foo([10])
c.append(11)
>>> c
[10, 11]
 

Programc─▒n─▒n varsay─▒lan liste parametresini payla┼č─▒lmas─▒n─▒ istedi─či ÔÇťYanl─▒┼č Y├ÂntemÔÇŁ i├žin me┼čru kullan─▒m durumlar─▒ olabilir, ancak bu kuraldan ├žok istisna olabilir.


17







Bunu yapt─▒─č─▒m─▒zda:

 def foo(a=[]):
    ...
 

... biz arg├╝man atamak a bir kar┼č─▒ isimsiz Arayan de─čerini ge├žmez ise, listede.

Bu tart─▒┼čma i├žin i┼čleri kolayla┼čt─▒rmak i├žin, ge├žici olarak ads─▒z listeye bir ad verelim. Ne dersiniz pavlo ?

 def foo(a=pavlo):
   ...
 

Herhangi bir zamanda, arayan bize ne a oldu─čunu s├Âylemezse , yeniden kullan─▒r─▒z pavlo .

pavlo De─či┼čebilirse (de─či┼čtirilebilir) ve foo onu de─či┼čtirmeye kalkarsa , bir dahaki sefere foo belirtmeksizin farkedilir bir etkidir a .

Yani g├Ârd├╝─č├╝n├╝z budur (Unutma, pavlo [] i├žin ba┼člat─▒l─▒r):

  >>> foo()
 [5]
 

┼×imdi pavlo [5].

foo() Tekrar ├ža─č─▒rmak tekrar de─či┼čtirir pavlo :

 >>> foo()
[5, 5]
 

Belirtme a ├ža─č─▒ran foo() sa─člar pavlo dokunulmaz.

 >>> ivan = [1, 2, 3, 4]
>>> foo(a=ivan)
[1, 2, 3, 4, 5]
>>> ivan
[1, 2, 3, 4, 5]
 

├ľyleyse pavlo hala [5, 5] .

 >>> foo()
[5, 5, 5]
 

16







Bazen bu davran─▒┼č─▒ a┼ča─č─▒daki kal─▒ba alternatif olarak kullan─▒r─▒m:

 singleton = None

def use_singleton():
    global singleton

    if singleton is None:
        singleton = _make_singleton()

    return singleton.use_me()
 

E─čer singleton sadece taraf─▒ndan kullan─▒lan use_singleton , bir yedek olarak a┼ča─č─▒daki deseni gibi:

 # _make_singleton() is called only once when the def is executed
def use_singleton(singleton=_make_singleton()):
    return singleton.use_me()
 

Bunu, d─▒┼č kaynaklara eri┼čen istemci s─▒n─▒flar─▒n─▒ ba┼člatmak ve ayr─▒ca notland─▒rma i├žin al─▒nt─▒lar veya listeler olu┼čturmak i├žin kulland─▒m.

Bu ├Ârg├╝n├╝n iyi bilindi─čini d├╝┼č├╝nmedi─čim i├žin gelecekteki yanl─▒┼č anlamalar─▒ ├Ânlemek i├žin k─▒sa bir yorum yap─▒yorum.


16







Bunu, nesneyi (ve dolay─▒s─▒yla kapsam─▒ kapsam─▒yla de─či┼čtirerek) de─či┼čtirerek halledebilirsiniz:

 def foo(a=[]):
    a = list(a)
    a.append(5)
    return a
 

├çirkin, ama i┼če yar─▒yor.


15







Do─čru olabilir ki:

  1. Birileri her dil / k├╝t├╝phane ├Âzelli─čini kullan─▒yor ve
  2. Buradaki davran─▒┼č─▒ de─či┼čtirmek yanl─▒┼č tavsiye edilir, ancak

Yukar─▒daki ├Âzelliklerin her ikisine birden sahip olmak ve yine ba┼čka bir noktaya de─čmek tamamen tutarl─▒d─▒r:

  1. Bu kafa kar─▒┼čt─▒r─▒c─▒ bir ├Âzellik ve Python'da talihsizlik.

Di─čer cevaplar, ya da en az─▒ndan baz─▒lar─▒ ya 1 ve 2 puanlar─▒ ancak 3 de─čil, ya da 3 ve a┼ča─č─▒ puan 1 ve 2'yi g├Âsteriyor. Fakat ├╝├ž├╝ de do─čru.

Atlar─▒n ortas─▒ndaki atlar─▒ de─či┼čtirmenin ├Ânemli bir k─▒r─▒lma talep edece─či ve Python'un Stefano'nun a├ž─▒l─▒┼č snippet'ini sezgisel olarak ele almas─▒yla de─či┼čtirilerek yarat─▒lan daha fazla sorun olabilece─či do─čru olabilir. Ve Python'un i├žini iyi tan─▒yan birinin, bir may─▒n sonu├žlar─▒ alan─▒n─▒ a├ž─▒klayabilece─či do─čru olabilir. Ancak,

Var olan davran─▒┼č Pythonic de─čildir ve Python ba┼čar─▒l─▒d─▒r ├ž├╝nk├╝ dil hakk─▒nda ├žok az ┼čey bu kadar yak─▒n bir yerde en az ┼ča┼čk─▒nl─▒k ilkesini ihlal ediyor . Bu, onu s├Âkmenin ak─▒ll─▒ca olup olamayaca─č─▒ ger├žek bir sorundur. Bu bir tasar─▒m hatas─▒d─▒r. Davran─▒┼č─▒ izlemeye ├žal─▒┼čarak dili ├žok daha iyi anlarsan─▒z, C ++ 'in t├╝m bunlar─▒ ve daha fazlas─▒n─▒ yapt─▒─č─▒n─▒ s├Âyleyebilirim; ├ľrne─čin, ince i┼čaret├ži hatalar─▒nda gezinerek ├žok ┼čey ├Â─črenirsiniz. Ancak bu Pythonic de─čil: Python'un bu davran─▒┼č kar┼č─▒s─▒nda sebat edecek kadar ├Ânemseyen insanlar, diline ├žizilen insanlar ├ž├╝nk├╝ Python'un di─čer dillerden ├žok daha az s├╝rprizleri var. Dabblers ve merakl─▒lar─▒, Pythonistas olurlar, bir ┼čeyi elde etmek i├žin ne kadar az zaman harcad─▒klar─▒na ┼ča┼č─▒r─▒rlar - bir tasar─▒m fl y├╝z├╝nden de─čil - Python'a ├žizilen programc─▒lar─▒n sezgilerine ayk─▒r─▒ olan gizli mant─▒k bulmacas─▒ demek istiyorum. ├ž├╝nk├╝ sadece i┼če yar─▒yor .


12







Bu bir tasar─▒m hatas─▒ de─čil . Bunu yapan herkes yanl─▒┼č bir ┼čey yap─▒yor.

Bu soruna nerede bula┼čt─▒─č─▒n─▒z─▒ g├Ârd├╝─č├╝m 3 vaka var:

  1. Arg├╝man─▒ fonksiyonun bir yan etkisi olarak de─či┼čtirmeyi d├╝┼č├╝n├╝yorsunuz. Bu durumda hi├žbir zaman varsay─▒lan bir arg├╝man olmas─▒ mant─▒kl─▒ de─čildir. Bunun tek istisnas─▒, ├Ârne─čin i┼člev ├Âzniteliklerine sahip olmak i├žin arg├╝man listesini k├Ât├╝ye kullanman─▒z ve ├Ârne─čin cache={} i┼člevi ger├žek bir arg├╝manla ├ža─č─▒rman─▒z beklenmez.
  2. Sen de─či┼čtirilmemi┼č arg├╝man b─▒rakmak niyetinde, ancak yanl─▒┼čl─▒kla vermedi de─či┼čtirmek. Bu bir hata, d├╝zelt.
  3. ─░┼člevin i├žinde kullan─▒lacak arg├╝man─▒ de─či┼čtirmek niyetindesiniz, ancak de─či┼čimin i┼člevin d─▒┼č─▒nda g├Âr├╝nt├╝lenmesini beklemediniz. Bu durumda , arg├╝man─▒n bir kopyas─▒n─▒ ├ž─▒karman─▒z gerekir , varsay─▒lan olup olmad─▒─č─▒! Python bir de─čere g├Âre arama dili de─čil, bu nedenle kopyay─▒ sizin i├žin yapm─▒yor, bu konuda a├ž─▒k olman─▒z gerekiyor.

Sorudaki ├Ârnek kategori 1 veya 3'e girebilir. Hem ge├žen listeyi de─či┼čtirmesi hem de d├Ând├╝rmesi gariptir; birini ya da di─čerini se├žmelisin.


10







Bu "b├Âcek" bana fazla mesai yapt─▒! Fakat bunun potansiyel bir kullan─▒m─▒n─▒ g├Ârmeye ba┼čl─▒yorum (ama yine de y├╝r├╝tme zaman─▒nda olmas─▒n─▒ isterdim)

Size faydal─▒ bir ├Ârnek olarak g├Ârd├╝─č├╝m├╝ verece─čim.

 def example(errors=[]):
    # statements
    # Something went wrong
    mistake = True
    if mistake:
        tryToFixIt(errors)
        # Didn't work.. let's try again
        tryToFixItAnotherway(errors)
        # This time it worked
    return errors

def tryToFixIt(err):
    err.append('Attempt to fix it')

def tryToFixItAnotherway(err):
    err.append('Attempt to fix it by another way')

def main():
    for item in range(2):
        errors = example()
    print '\n'.join(errors)

main()
 

a┼ča─č─▒dakileri yazd─▒r─▒r

 Attempt to fix it
Attempt to fix it by another way
Attempt to fix it
Attempt to fix it by another way
 

9







Sadece i┼člevi de─či┼čtirin:

 def notastonishinganymore(a = []): 
    '''The name is just a joke :)'''
    a = a[:]
    a.append(5)
    return a
 

8







Bence bu sorunun cevab─▒ python'un verilere parametreye nas─▒l ge├žti─čini (de─čere veya referansa g├Âre), mutasyona de─čil de python'un "def" deyimini nas─▒l ele ald─▒─č─▒na ba─čl─▒ oldu─čunu d├╝┼č├╝n├╝yorum.

K─▒sa bir giri┼č. ─░lk olarak, python'da iki t├╝r veri tipi vard─▒r, biri basit temel veri t├╝r├╝d├╝r, say─▒lar gibi, di─čeri ise veri t├╝r├╝d├╝r. ─░kincisi, verileri parametrelere ge├žirirken, python temel veri t├╝r├╝n├╝ de─čere g├Âre iletir, yani de─čerin yerel bir kopyas─▒na yerel bir kopyas─▒n─▒ al─▒r, ancak nesneyi referans alarak, yani nesneye i┼čaret├žilerle iletir.

Yukar─▒daki iki noktay─▒ itiraf ederek, python koduna ne oldu─čunu a├ž─▒klayal─▒m. Sadece nesneler i├žin referans alarak, ancak de─či┼čken / de─či┼čmez olanla ya da tart─▒┼čmas─▒z "def" ifadesinin tan─▒mland─▒─č─▒nda sadece bir kez ger├žekle┼čtirilmi┼č olmas─▒yla ilgisi yoktur.

[] bir nesnedir, bu nedenle python [] referans─▒n─▒ iletir a , yani a sadece [] i┼čaretinidir ve bellekte nesne olarak kal─▒r. Bununla birlikte, bir├žok referans─▒ olan yaln─▒zca [] kopyas─▒ vard─▒r. ─░lk foo () i├žin [] listesi , append y├Ântemiyle 1 olarak de─či┼čtirilir . Ancak, liste nesnesinin yaln─▒zca bir kopyas─▒n─▒n oldu─čunu ve bu nesnenin ┼čimdi 1 oldu─čunu unutmay─▒n . ─░kinci foo'yu () ├žal─▒┼čt─▒r─▒rken, effbot web sayfas─▒n─▒n s├Âyledi─či (├Â─čeler art─▒k de─čerlendirilmez) yanl─▒┼č. a ┼×imdi nesnenin i├žeri─či 1 olmas─▒na ra─čmen, liste nesnesi olarak de─čerlendirilir . Bu referansa ge├žmenin etkisidir! Foo (3) sonucu ayn─▒ ┼čekilde kolayca elde edilebilir.

Cevab─▒m─▒ daha da do─črulamak i├žin, iki ek koda bakal─▒m.

====== No. 2 ========

 def foo(x, items=None):
    if items is None:
        items = []
    items.append(x)
    return items

foo(1)  #return [1]
foo(2)  #return [2]
foo(3)  #return [3]
 

[] bir nesnedir, ├Âyledir None (ikincisi de─či┼čmezken eskisi de─či┼čebilir. Fakat de─či┼čebilirli─čin soru ile ilgisi yoktur). Hi├žbiri uzayda bir yerde de─čil ama orada oldu─čunu ve orada Yok'un tek bir kopyas─▒n─▒n oldu─čunu biliyoruz. Bu nedenle, her bir foo ├ža─čr─▒ld─▒─č─▒nda, ├Â─čeler (yaln─▒zca bir kez de─čerlendirilen yan─▒t─▒n aksine) Yok olarak, a├ž─▒k olmas─▒ i├žin Yok'un referans─▒ (veya adresi) olarak de─čerlendirilir. Ard─▒ndan foo'da ├Â─če [] olarak de─či┼čtirilir, yani farkl─▒ bir adrese sahip ba┼čka bir nesneye i┼čaret eder.

====== No. 3 =======

 def foo(x, items=[]):
    items.append(x)
    return items

foo(1)    # returns [1]
foo(2,[]) # returns [2]
foo(3)    # returns [1,3]
 

Foo (1) 'in ├ža─čr─▒lmas─▒, ├Â─čeleri bir adresle [11111111] adresli bir liste nesnesine i┼čaret eder. Listenin i├žeri─či, sekanstaki foo i┼člevinde 1 olarak de─či┼čtirilir , ancak adres de─či┼čmedi, yine de 11111111 Ard─▒ndan foo (2, []) geliyor. Foo (2, []) i├žindeki [], foo (1) ├ža─čr─▒l─▒rken [] varsay─▒lan parametresiyle ayn─▒ i├žeri─če sahip olsa da, adresleri farkl─▒d─▒r! Parametreyi a├ž─▒k├ža verdi─čimiz i├žin, items bu yeni adresin [] 2222222 adresini ele almal─▒ ve baz─▒ de─či┼čiklikler yapt─▒ktan sonra geri vermeliyiz. ┼×imdi foo (3) y├╝r├╝t├╝l├╝r. yaln─▒zca x sa─čland─▒─č─▒ndan, ├Â─čelerin varsay─▒lan de─čerini tekrar almas─▒ gerekir. Varsay─▒lan de─čer nedir? Foo i┼člevi tan─▒mlan─▒rken ayarlan─▒r: 11111111'de bulunan liste nesnesi. 11111111 adresinde yer alan liste nesnesi 11111111 adresi olarak de─čerlendirilir. 2222222 adresinde yer alan liste ayr─▒ca bir ├Â─če 2 i├žerir, ancak herhangi bir ├Â─če taraf─▒ndan g├Âsterilmez. Daha. Sonu├ž olarak, 3'├╝n eki yapacakt─▒r items [1,3].

Yukar─▒daki a├ž─▒klamalardan, kabul edilen cevapta ├Ânerilen effbot web sayfas─▒n─▒n bu soruya alakal─▒ bir cevap veremedi─čini g├Ârebiliriz. Dahas─▒, effbot web sayfas─▒ndaki bir noktan─▒n yanl─▒┼č oldu─čunu d├╝┼č├╝n├╝yorum. Kullan─▒c─▒ Arabirimi ile ilgili kodun do─čru oldu─čunu d├╝┼č├╝n├╝yorum:

 for i in range(10):
    def callback():
        print "clicked button", i
    UI.Button("button %s" % i, callback)
 

Her d├╝─čme farkl─▒ de─čerlerini g├Âsterecek olan farkl─▒ bir geri arama i┼člevi tutabilir i . Bunu g├Âstermek i├žin bir ├Ârnek verebilirim:

 x=[]
for i in range(10):
    def callback():
        print(i)
    x.append(callback) 
 

E─čer ├žal─▒┼čt─▒r─▒rsak x[7]() , beklendi─či gibi 7 elde edece─čiz ve x[9]() 9'a bir de─čer daha verece─čiz i .


7







TLDR: Zaman tan─▒mlar─▒n─▒ tan─▒mla tutarl─▒ ve kesinlikle daha etkileyici.


Bir fonksiyon tan─▒mlamak iki kapsam─▒ etkiler: fonksiyonu i├žeren tan─▒mlay─▒c─▒ kapsam ve fonksiyonun i├žerdi─či y├╝r├╝tme kapsam─▒ . Haritan─▒n kapsamlara nas─▒l girece─či ├žok a├ž─▒k olsa da, soru ┼ču def <name>(<args=defaults>): : ait oldu─ču yer:

 ...                           # defining scope
def name(parameter=default):  # ???
    ...                       # execution scope
 

def name B├Âl├╝m olmal─▒d─▒r tan─▒mlayan kapsam─▒nda de─čerlendirmek - istedi─čimiz name sonu├žta orada kullan─▒labilir olmas─▒. Fonksiyonu sadece kendi i├žinde de─čerlendirmek eri┼čilmez hale getirir.

Yana parameter s├╝rekli bir isimdir, biz ayn─▒ anda "de─čerlendirmek" olabilir def name . Bu ayr─▒ca, i┼člevi name(parameter=...): yerine ├ž─▒plak olarak bilinen bir imzayla i┼člevi olu┼čturma avantaj─▒na sahiptir name(...): .

┼×imdi ne zaman de─čerlendirilir default ?

Tutarl─▒l─▒k zaten "tan─▒mda" diyor: her ┼čey def <name>(<args=defaults>): tan─▒mda da en iyi ┼čekilde de─čerlendiriliyor. Bunun par├žalar─▒n─▒ geciktirmek ┼ča┼č─▒rt─▒c─▒ bir se├žim olacakt─▒r.

─░ki se├ženek de ayn─▒ de─čildir: default Tan─▒m zaman─▒nda de─čerlendirilirse, y├╝r├╝tme s├╝resini yine de etkileyebilir. E─čer default y├╝r├╝tme s─▒ras─▒nda de─čerlendirilir, bu olamaz tan─▒m s├╝resini etkiler. "Tan─▒mda" se├žimi, her iki vakay─▒ da ifade etmeyi sa─člarken, "uygulamada" se├žimi ise yaln─▒zca birini ifade edebilir:

 def name(parameter=defined):  # set default at definition time
    ...

def name(parameter=default):     # delay default until execution time
    parameter = default if parameter is None else parameter
    ...
 

5







Di─čer her cevap, bunun neden ger├žekten ho┼č ve istenen bir davran─▒┼č oldu─čunu ya da neden buna hi├ž ihtiya├ž duymaman─▒z gerekti─čini a├ž─▒klar. Benimki dilin b├╝k├╝lme hakk─▒n─▒, istedi─či ┼čekilde de─čil, istedi─či gibi kullanmak isteyenler i├žin.

Bu davran─▒┼č─▒, varsay─▒lan de─čerinde b─▒rak─▒lan her bir konumsal arg├╝man i├žin ayn─▒ ├Ârne─či tekrar kullanmak yerine, varsay─▒lan de─čeri kopyalayacak bir dekorat├Ârle "d├╝zeltece─čiz".

 import inspect
from copy import copy

def sanify(function):
    def wrapper(*a, **kw):
        # store the default values
        defaults = inspect.getargspec(function).defaults # for python2
        # construct a new argument list
        new_args = []
        for i, arg in enumerate(defaults):
            # allow passing positional arguments
            if i in range(len(a)):
                new_args.append(a[i])
            else:
                # copy the value
                new_args.append(copy(arg))
        return function(*new_args, **kw)
    return wrapper
 

┼×imdi bu dekorat├Âr kullanarak fonksiyonumuzu yeniden tan─▒mlayal─▒m:

 @sanify
def foo(a=[]):
    a.append(5)
    return a

foo() # '[5]'
foo() # '[5]' -- as desired
 

Bu, ├Âzellikle birden fazla arg├╝man alan i┼člevler i├žin temizdir. Kar┼č─▒la┼čt─▒rmak:

 # the 'correct' approach
def bar(a=None, b=None, c=None):
    if a is None:
        a = []
    if b is None:
        b = []
    if c is None:
        c = []
    # finally do the actual work
 

ile

 # the nasty decorator hack
@sanify
def bar(a=[], b=[], c=[]):
    # wow, works right out of the box!
 

Anahtar s├Âzc├╝kler kullanmaya ├žal─▒┼č─▒rsan─▒z, yukar─▒daki ├ž├Âz├╝m├╝n bozuldu─čunu unutmay─▒n:

 foo(a=[4])
 

Dekorat├Âr buna izin verecek ┼čekilde ayarlanabilir, ancak bunu okuyucu i├žin bir al─▒┼čt─▒rma olarak b─▒rak─▒r─▒z;)


3



─░lgili yay─▒nlar


'Mutable' anahtar s├Âzc├╝─č├╝n├╝n, de─či┼čkenin const i┼člevi taraf─▒ndan de─či┼čtirilmesine izin vermekten ba┼čka bir amac─▒ var m─▒?

C varsay─▒lan arg├╝manlar

Scala derleyicisi neden a┼č─▒r─▒ y├╝klenmi┼č y├Ântemlere varsay─▒lan arg├╝manlarla izin vermiyor?

Varsay─▒lan olmayan arg├╝manlar neden varsay─▒lan arg├╝manlar─▒ izleyemiyor?

* Args ve ** kwargs ile varsay─▒lan arg├╝manlar

C++ varsay─▒lan arg├╝man─▒ ba┼čka bir arg├╝manla ba┼člat─▒labilir mi? [├žift]

Python i┼člevini * args, ** kwargs ve iste─če ba─čl─▒ / varsay─▒lan arg├╝manlarla ├ža─č─▒rmak

De─či┼čken i┼člev arg├╝man─▒ varsay─▒lan de─čerleri i├žin iyi kullan─▒mlar?

Parametre listesinin ortas─▒ndaki varsay─▒lan de─či┼čken mi?

─░┼člev varsay─▒lan de─či┼čkenleri ve adland─▒r─▒lm─▒┼č de─čerler

Etiketle ilgili di─čer sorular [python]


Node.js'in ne zaman kullan─▒laca─č─▒na nas─▒l karar verilir?

JavaScript ile nas─▒l y├Ânlendiririm? [├žift]

K├Ârseniz nas─▒l programlayabilirsiniz?

Bir Dosyay─▒ ve ─░li┼čkili Verileri, tercihen JSON olarak RESTful Web Servisine G├Ânderme

Toplu i┼č dosyas─▒nda bir de─či┼čken tan─▒mlama ve kullanma

Java ile parseInt ve valueOf aras─▒ndaki fark?

Javascript referansa g├Âre ge├žiyor mu?

Android Par├žas─▒ onAttach () kullan─▒mdan kald─▒r─▒ld─▒

Cocoapod'lar nas─▒l kurulur?

Konteynerinin dibine kadar y├╝zecek bir div nas─▒l alabilirim?