Python belgeleri, parametrelerin referans veya değere göre geçirilip geçirilmediği konusunda net görünmüyor ve aşağıdaki kod, değiştirilmemiş 'Orijinal' değerini üretiyor

class PassByReference:
    def __init__(self):
        self.variable = 'Original'
        self.change(self.variable)
        print(self.variable)

    def change(self, var):
        var = 'Changed'

Değişkeni gerçek referansla geçmek için yapabileceğim bir şey var mı?

Bağımsız değişkenler ödevle iletilir . Bunun arkasındaki mantık iki yönlüdür:

1. geçirilen parametresinin a, referans bir nesneye (ancak bir referans değeri ile geçirilir)
2. bazı veri türleri değiştirilebilir, ancak diğerleri

Yani:

• Değiştirilebilir bir nesneyi bir yönteme geçirirseniz , yöntem aynı nesneye başvuru alır ve kalbinizin zevkine dönüştürebilirsiniz, ancak yöntemdeki başvuruyu yeniden bağlarsanız, dış kapsam bu konuda hiçbir şey bilmez ve sonra işiniz bittiğinde, dış referans yine de orijinal nesneyi gösterecektir.

• Bir başarılı olursa iletmenin bir yöntemi nesne, yine dış başvuru rebind değildir, ve hatta nesne mutasyona olamaz.

Daha da netleştirmek için, bazı örnekler verelim.

Liste - değiştirilebilir bir tür

Bir yönteme geçirilen listeyi değiştirmeye çalışalım:

def try_to_change_list_contents(the_list):
    print('got', the_list)
    the_list.append('four')
    print('changed to', the_list)

outer_list = ['one', 'two', 'three']

print('before, outer_list =', outer_list)
try_to_change_list_contents(outer_list)
print('after, outer_list =', outer_list)

Çıktı:

before, outer_list = ['one', 'two', 'three']
got ['one', 'two', 'three']
changed to ['one', 'two', 'three', 'four']
after, outer_list = ['one', 'two', 'three', 'four']

Aktarılan parametre outer_listbir kopyası değil referans olduğu için , değişiklik listesi yöntemlerini kullanarak değiştirebiliriz ve değişikliklerin dış kapsama yansıtılmasını sağlayabiliriz.

Şimdi parametre olarak iletilen referansı değiştirmeye çalıştığımızda ne olacağını görelim:

def try_to_change_list_reference(the_list):
    print('got', the_list)
    the_list = ['and', 'we', 'can', 'not', 'lie']
    print('set to', the_list)

outer_list = ['we', 'like', 'proper', 'English']

print('before, outer_list =', outer_list)
try_to_change_list_reference(outer_list)
print('after, outer_list =', outer_list)

Çıktı:

before, outer_list = ['we', 'like', 'proper', 'English']
got ['we', 'like', 'proper', 'English']
set to ['and', 'we', 'can', 'not', 'lie']
after, outer_list = ['we', 'like', 'proper', 'English']

Yana the_listparametre kendisine yeni bir liste atayarak, değeri tarafından kabul edildi yöntemle dışında kod görebildiğini hiçbir etkisi olmadı. the_listBir kopyası olan outer_listreferans ve biz vardı the_listyeni listeye noktası, ama değiştirmek için hiçbir yolu yoktuouter_list sivri.

String - değişmez tip

Değişmez, bu yüzden dizenin içeriğini değiştirmek için yapabileceğimiz hiçbir şey yok

Şimdi referansı değiştirmeye çalışalım

def try_to_change_string_reference(the_string):
    print('got', the_string)
    the_string = 'In a kingdom by the sea'
    print('set to', the_string)

outer_string = 'It was many and many a year ago'

print('before, outer_string =', outer_string)
try_to_change_string_reference(outer_string)
print('after, outer_string =', outer_string)

Çıktı:

before, outer_string = It was many and many a year ago
got It was many and many a year ago
set to In a kingdom by the sea
after, outer_string = It was many and many a year ago

Yine, the_stringparametre değere göre iletildiğinden, ona yeni bir dize atamanın, yöntemin dışındaki kodun görebileceği bir etkisi yoktu. the_stringBir kopyası olan outer_stringreferans ve biz vardı the_stringyeni bir dizeye noktası, ama değiştirmek için hiçbir yolu yoktu outer_stringsivri.

Umarım bu biraz şeyleri temizler.

DÜZENLE: Bunun @David'in aslında "Değişkeni gerçek referansla geçmek için yapabileceğim bir şey var mı?" Bunun üzerinde çalışalım.

Bunu nasıl hallederiz?

@ Andrea'nın cevabının gösterdiği gibi, yeni değeri geri verebilirsiniz. Bu, işlerin aktarılma şeklini değiştirmez, ancak istediğiniz bilgileri geri almanıza izin verir:

def return_a_whole_new_string(the_string):
    new_string = something_to_do_with_the_old_string(the_string)
    return new_string

# then you could call it like
my_string = return_a_whole_new_string(my_string)

Bir dönüş değeri kullanmaktan gerçekten kaçınmak istiyorsanız, değerinizi korumak ve onu işleve aktarmak veya liste gibi mevcut bir sınıfı kullanmak için bir sınıf oluşturabilirsiniz:

def use_a_wrapper_to_simulate_pass_by_reference(stuff_to_change):
    new_string = something_to_do_with_the_old_string(stuff_to_change[0])
    stuff_to_change[0] = new_string

# then you could call it like
wrapper = [my_string]
use_a_wrapper_to_simulate_pass_by_reference(wrapper)

do_something_with(wrapper[0])

Bu biraz hantal gibi görünse de.

Sorun Python'da hangi değişkenlerin yanlış anlaşılmasından kaynaklanıyor. Geleneksel dillerin çoğuna alışkınsanız, aşağıdaki sırada neler olduğuna dair zihinsel bir modeliniz vardır:

a = 1
a = 2

Bunun adeğeri saklayan bir bellek konumu olduğuna inanıyorsunuz 1, daha sonra değeri saklamak için güncelleniyor 2. Python'da işler böyle çalışmaz. Aksine, adeğere sahip bir nesneye başvuru olarak başlar 1, sonra değere sahip bir nesneye başvuru olarak yeniden atanır 2. Bu iki nesne a, birincisine atıfta bulunmasa da birlikte var olmaya devam edebilir ; aslında, program içindeki herhangi bir sayıda başka referansla paylaşılabilirler.

Parametreli bir işlevi çağırdığınızda, iletilen nesneye başvuran yeni bir başvuru oluşturulur. Bu, işlev çağrısında kullanılan referanstan ayrıdır, bu nedenle bu başvuruyu güncellemenin ve yeni nesne. Örneğinizde:

def __init__(self):
    self.variable = 'Original'
    self.Change(self.variable)

def Change(self, var):
    var = 'Changed'

self.variabledize nesnesine bir başvurudur 'Original'. Aradığınızda nesneye Changeikinci bir başvuru oluşturursunuz var. İşlev içinde başvuruyu varfarklı bir dize nesnesine yeniden atarsınız 'Changed', ancak başvuru self.variableayrıdır ve değişmez.

Bunun tek yolu değiştirilebilir bir nesneyi geçirmektir. Her iki başvuru da aynı nesneye başvurduğundan, nesnede yapılan değişiklikler her iki yere de yansıtılır.

def __init__(self):         
    self.variable = ['Original']
    self.Change(self.variable)

def Change(self, var):
    var[0] = 'Changed'

Diğer cevapları oldukça uzun ve karmaşık buldum, bu yüzden Python'un değişkenleri ve parametreleri nasıl ele aldığını açıklamak için bu basit diyagramı oluşturdum.

Ne değere göre geçme ne de referansla geçme - nesneye göre çağrıdır. Bkz, Fredrik Lundh tarafından:

http://effbot.org/zone/call-by-object.htm

İşte önemli bir teklif:

"... değişkenler [adlar) nesne değildir ; diğer değişkenler tarafından gösterilemez veya nesneler tarafından adlandırılamazlar."

Örneğinizde, Changeyöntem çağrıldığında - bunun için bir ad alanı oluşturulur; ve varbu ad alanı içinde dize nesnesi için bir ad olur 'Original'. Bu nesnenin iki ad alanında bir adı vardır. Ardından, yeni bir dize nesnesine var = 'Changed'bağlanır varve böylece yöntemin ad alanı unutulur 'Original'. Son olarak, bu ad alanı unutulur ve dize 'Changed'ile birlikte unutulur .

Referans / değere göre ödevle aktarılan şeyleri düşünün . Bu şekilde, normal görev sırasında neler olduğunu anladığınız sürece neler olduğu her zaman açıktır.

Bu nedenle, bir listeyi bir işleve / yönteme iletirken liste parametre adına atanır. Listeye eklemek listenin değiştirilmesine neden olur. İşlev içindeki listeyi yeniden atamak orijinal listeyi değiştirmez, çünkü:

a = [1, 2, 3]
b = a
b.append(4)
b = ['a', 'b']
print a, b      # prints [1, 2, 3, 4] ['a', 'b']

Değişmez tipler değiştirilemediğinden, değerin geçirildiği anlaşılırlar - int'in bir fonksiyona geçirilmesi int'nin fonksiyonun parametresine atanması anlamına gelir. Bunu yalnızca yeniden atayabilirsiniz, ancak orijinal değişkenlerin değerini değiştirmez.

Effbot (diğer adıyla Fredrik Lundh) Python'un değişken geçiş stilini nesneye göre çağrı olarak tanımladı: http://effbot.org/zone/call-by-object.htm

Nesneler öbek üzerinde tahsis edilir ve onlara işaretçiler her yerden geçirilebilir.

• Gibi bir atama yaptığınızda x = 1000, geçerli ad alanındaki "x" dizesini bir işaretçi ile bin içeren tam sayı nesnesine eşleyen bir sözlük girdisi oluşturulur.

• "X" ile güncellediğinizde x = 2000, yeni bir tamsayı nesnesi oluşturulur ve sözlük yeni nesneyi gösterecek şekilde güncellenir. Eski bin nesne değişmez (ve başka bir şey nesneyi ifade edip etmediğine bağlı olarak hayatta olabilir veya olmayabilir).

• Yeni bir atama yaptığınızda y = x, "x" girişiyle aynı nesneyi gösteren yeni bir sözlük girdisi "y" oluşturulur.

• Dizeler ve tamsayılar gibi nesneler değişmezdir . Bu, nesneyi oluşturulduktan sonra değiştirebilecek hiçbir yöntem olmadığı anlamına gelir. Örneğin, bin tam sayı nesnesi oluşturulduktan sonra asla değişmez. Matematik, yeni tamsayı nesneleri oluşturularak yapılır.

• Listeler gibi nesneler değiştirilebilir . Bu, nesnenin içeriğinin, nesneye işaret eden herhangi bir şeyle değiştirilebileceği anlamına gelir. Örneğin, x = []; y = x; x.append(10); print yyazdırılacaktır [10]. Boş liste oluşturuldu. Hem "x" hem de "y" aynı listeyi gösterir. Ekleme yöntemi (bir veritabanına bir kayıt ekleme) mutasyon (güncellemeler) liste nesnesi ve sonuç her iki "x" ve "y" tarafından görülebilir (sadece bir veritabanı güncelleme olarak bu veritabanına her bağlantı için görünür olacaktır).

Bu sizin için sorunu açıklar.

Teknik olarak, Python her zaman referans değerlerle pass kullanır . İfademi desteklemek için diğer cevabımı tekrarlayacağım .

Python her zaman referans by değerleri kullanır. Herhangi bir istisna yoktur. Herhangi bir değişken ataması referans değerin kopyalanması anlamına gelir. İstisna yok. Herhangi bir değişken, referans değere bağlı addır. Her zaman.

Bir referans değeri hedef nesnenin adresi olarak düşünebilirsiniz. Adres kullanıldığında otomatik olarak kaydı kaldırılır. Bu şekilde, referans değerle çalışırken, doğrudan hedef nesne ile çalıştığınız anlaşılıyor. Ama her zaman arasında bir referans var, hedefe atlamak için bir adım daha.

İşte Python'un referans olarak geçerken kullandığını kanıtlayan örnek:

Bağımsız değişken değere göre iletildiyse, dış lstdeğiştirilemez. Yeşil, hedef nesnelerdir (siyah, içinde saklanan değerdir, kırmızı, nesne tipidir), sarı, içinde referans değerinin bulunduğu oktur - hafızadır. Mavi düz ok, işleve iletilen referans değerdir (kesikli mavi ok yolu üzerinden). Çirkin koyu sarı iç sözlüktür. (Aslında yeşil bir elips olarak da çizilebilir. Renk ve şekil sadece dahili olduğunu söylüyor.)

Kullanabilirsiniz id()Referans değerin ne olduğunu (yani hedef nesnenin adresi) öğrenmek yerleşik işlevi kullanabilirsiniz.

Derlenmiş dillerde bir değişken, türün değerini yakalayabilen bir bellek alanıdır. Python'da bir değişken, hedef nesneye referans değerini tutan referans değişkenine bağlı bir addır (dahili olarak dize olarak yakalanır). Değişkenin adı dahili sözlükteki anahtardır, söz konusu sözlük öğesinin değer kısmı referans değerini hedefe depolar.

Referans değerleri Python'da gizlidir. Referans değerini saklamak için açık bir kullanıcı türü yoktur. Bununla birlikte, tüm değişkenler hedef nesnelere referans olarak da depolandığından, bir liste öğesini (veya başka bir uygun kap türündeki öğeyi) referans değişkeni olarak kullanabilirsiniz. Başka bir deyişle, elemanlar aslında kabın içinde yer almaz - sadece elemanlara referanslar bulunur.

Python'da değişken yok

Parametre geçişini anlamanın anahtarı "değişkenler" hakkında düşünmeyi bırakmaktır. Python'da isimler ve nesneler var ve birlikte değişkenler gibi görünüyorlar, ancak her zaman üçünü ayırt etmek yararlıdır.

1. Python'un adları ve nesneleri var.
2. Atama, bir nesneye bir ad bağlar.
3. Bir işleve bağımsız değişken iletmek, bir nesneye bir ad (işlevin parametre adı) da bağlar.

Hepsi bu kadar. Değişebilirlik bu soru ile ilgisizdir.

Misal:

a = 1

Bu, adı a1 değerini tutan tamsayı türünde bir nesneye bağlar .

b = x

Bu, adı b, o xanda bağlı olduğu nesneye bağlar . Daha sonra, badın xartık adla ilgisi yoktur .

Bkz. Bölüm 3.1 ve 4.2Python 3 dil referansındaki .

Sorudaki örnek nasıl okunur

Soruda gösterilen kodda ifade self.Change(self.variable), adı var(işlev kapsamında Change) değeri tutan nesneye bağlar 'Original've atama var = 'Changed'(işlev gövdesinde Change) aynı adı yeniden atar: başka bir nesneye (gerçekleşir) bir dize tutmak için ama tamamen başka bir şey olabilirdi).

Referans ile nasıl geçilir

Dolayısıyla, değiştirmek istediğiniz şey değiştirilebilir bir nesne ise, sorun yoktur, çünkü her şey referansla etkili bir şekilde geçirilir.

Bir ise değişmez nesne (örneğin bir mantıksal değer, sayı, dize), hareket yolu bir değişken nesne sarın etmektir.
Bunun hızlı ve kirli çözümü tek elemanlı bir listedir (yerine self.variablegeçmek [self.variable]ve işlevde değişiklik yapmak var[0]).
Daha pitonik yaklaşım önemsiz, tek özellikli bir sınıf oluşturmak olacaktır. İşlev sınıfın bir örneğini alır ve özniteliği değiştirir.

Normalde kullandığım basit bir numara sadece bir listeye sarmaktır:

def Change(self, var):
    var[0] = 'Changed'

variable = ['Original']
self.Change(variable)      
print variable[0]

(Evet, bunun rahatsız edici olabileceğini biliyorum, ancak bazen bunu yapmak için yeterince basit.)

(değiştir - Blair, son derece popüler cevabını güncelledi, böylece şimdi doğru oldu)

Bence en çok oyu alan (Blair Conrad tarafından) mevcut yazının sonucuna göre doğru olmasına rağmen yanıltıcı ve tanımlarına göre sınırda yanlış olduğunu belirtmek önemlidir. Kullanıcının referansla veya değere göre geçmesine izin veren birçok dil (C gibi) olsa da, Python bunlardan biri değildir.

David Cournapeau'nun cevabı gerçek cevabı işaret ediyor ve Blair Conrad'ın gönderisindeki davranışın neden tanımlar doğru olmasa da doğru göründüğünü açıklıyor.

Python değere göre geçtiği ölçüde, bir miktar veri (ister "değer" veya "referans" olsun) gönderilmesi gerektiğinden, tüm diller değere göre geçer. Bununla birlikte, bu, Python'un bir C programcısının düşüneceği anlamıyla değere göre geçtiği anlamına gelmez.

Davranışı istiyorsanız, Blair Conrad'ın cevabı iyidir. Ancak Python'un neden değerden geçmediği veya referans olarak geçmediğinin somunlarını ve cıvatalarını bilmek istiyorsanız, David Cournapeau'nun cevabını okuyun.

Burada gerçekten iyi cevaplar aldınız.

x = [ 2, 4, 4, 5, 5 ]
print x  # 2, 4, 4, 5, 5

def go( li ) :
  li = [ 5, 6, 7, 8 ]  # re-assigning what li POINTS TO, does not
  # change the value of the ORIGINAL variable x

go( x ) 
print x  # 2, 4, 4, 5, 5  [ STILL! ]


raw_input( 'press any key to continue' )

Bu durumda, varyöntemde başlıklı değişkene Changebir başvuru atanır self.variableve hemen bir dize atarsınız var. Artık işaret etmiyor self.variable. Aşağıdaki kod snippet'i, işaret ettiği veri yapısını varve self.variablebu durumda bir listeyi değiştirirseniz ne olacağını gösterir :

>>> class PassByReference:
...     def __init__(self):
...         self.variable = ['Original']
...         self.change(self.variable)
...         print self.variable
...         
...     def change(self, var):
...         var.append('Changed')
... 
>>> q = PassByReference()
['Original', 'Changed']
>>> 

Eminim başka biri bunu daha da netleştirebilir.

Python'un atama öteleme şeması, C ++ 'ın referans parametreleri seçeneğiyle aynı değildir, ancak pratikte C dilinin (ve diğerlerinin) argüman geçiş modeline çok benzemektedir:

• Değişmez argümanlar etkin bir şekilde “ değere göre geçirilir” . Tamsayılar ve dizeler gibi nesneler kopyalama yerine nesne başvurusu ile iletilir, ancak değiştirilemeyen nesneleri yine de yerinde değiştiremediğiniz için, efekt bir kopya yapmak gibidir.
• Değişken argümanlar etkin bir şekilde “ işaretçi ” ile aktarılır . Listeler ve sözlükler gibi nesneler de, C'nin dizileri işaretçi olarak geçirme biçimine benzer olan nesne başvurusu ile iletilir; değişken diziler, işlevde C dizileri gibi değiştirilebilir.

Tahmin edebileceğiniz gibi değişebilir bir nesneye sahip olmanız gerekir, ancak size yardımcı olabileceği veya hatta bu tür bir sorunu çözebileceği için küresel değişkenleri kontrol etmenizi öneriyorum!

http://docs.python.org/3/faq/programming.html#what-are-the-rules-for-local-and-global-variables-in-python

misal:

>>> def x(y):
...     global z
...     z = y
...

>>> x
<function x at 0x00000000020E1730>
>>> y
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'y' is not defined
>>> z
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'z' is not defined

>>> x(2)
>>> x
<function x at 0x00000000020E1730>
>>> y
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'y' is not defined
>>> z
2

Burada cevaplar bir sürü içgörü, ama bence burada ek bir nokta açıkça açıkça belirtilmemiş. Python belgelerinden alıntı https://docs.python.org/2/faq/programming.html#what-are-the-rules-for-local-and-global-variables-in-python

"Python'da, yalnızca bir işlev içinde başvurulan değişkenler dolaylı olarak globaldir. Bir değişkene işlevin gövdesinde herhangi bir yerde yeni bir değer atanırsa, yerel olduğu varsayılır. Bir değişkene işlev içinde yeni bir değer atanırsa, değişken, dolaylı olarak yereldir ve bunu açıkça 'global' olarak bildirmeniz gerekir.İlk başta biraz şaşırtıcı olsa da, bir anın düşünülmesi bunu açıklar.Öte yandan, atanan değişkenler için global gereksinimi, istenmeyen yan etkilere karşı bir bar sağlar. diğer yandan, eğer tüm global referanslar için global gerekiyorsa, her zaman global kullanırsınız, yerleşik bir fonksiyona veya içe aktarılan bir modülün bir bileşenine yapılan her referansı global olarak beyan etmeniz gerekir. küresel bildirimin yan etkileri tanımlamak için yararlılığını yenebilir. "

Değişken bir nesneyi bir işleve geçirirken bile bu hala geçerlidir. Ve bana, nesneye atama ile işlevdeki nesne üzerinde çalışma arasındaki davranış farkının nedenini açıkça açıklıyor.

def test(l):
    print "Received", l , id(l)
    l = [0, 0, 0]
    print "Changed to", l, id(l)  # New local object created, breaking link to global l

l= [1,2,3]
print "Original", l, id(l)
test(l)
print "After", l, id(l)

verir:

Original [1, 2, 3] 4454645632
Received [1, 2, 3] 4454645632
Changed to [0, 0, 0] 4474591928
After [1, 2, 3] 4454645632

Genel olarak bildirilmeyen bir genel değişkene atama bu nedenle yeni bir yerel nesne oluşturur ve orijinal nesnenin bağlantısını keser.

İşte pass by objectPython'da kullanılan kavramın basit (umarım) açıklaması .
Bir nesneyi işleve ilettiğinizde, nesnenin kendisi iletilmez (Python'daki nesne aslında diğer programlama dillerinde bir değer olarak adlandırdığınız şeydir) bu nesnenin başvurusu değil. Başka bir deyişle, aradığınızda:

def change_me(list):
   list = [1, 2, 3]

my_list = [0, 1]
change_me(my_list)

Asıl nesne - [0, 1] (diğer programlama dillerinde bir değer olarak adlandırılır) geçiriliyor. Aslında fonksiyon aşağıdaki change_megibi bir şey yapmaya çalışacaktır:

[0, 1] = [1, 2, 3]

açıkçası, işleve iletilen nesneyi değiştirmez. İşlev şu şekilde görünüyorsa:

def change_me(list):
   list.append(2)

Sonra çağrı ile sonuçlanır:

[0, 1].append(2)

ki bu açıkça nesneyi değiştirecek. Bu cevap bunu iyi açıklıyor.

Bu şeylerin Python'da nasıl çalıştığına dair tüm büyük açıklamaların yanı sıra, sorun için basit bir öneri görmüyorum. Nesneler ve örnekler oluşturduğunuz gibi, örnek değişkenlerini işlemenin ve bunları değiştirmenin pitonik yolu şudur:

class PassByReference:
    def __init__(self):
        self.variable = 'Original'
        self.Change()
        print self.variable

    def Change(self):
        self.variable = 'Changed'

Örnek yöntemlerinde, normalde selförnek niteliklerine erişmeyi ifade edersiniz . Örnek niteliklerini ayarlamak __init__ve örnek yöntemlerinde bunları okumak veya değiştirmek normaldir . Bu yüzden aynı zamanda selfilk argümanıdef Change .

Başka bir çözüm şöyle statik bir yöntem oluşturmak olacaktır:

class PassByReference:
    def __init__(self):
        self.variable = 'Original'
        self.variable = PassByReference.Change(self.variable)
        print self.variable

    @staticmethod
    def Change(var):
        var = 'Changed'
        return var

Dil bir nesneyi mümkün kılmasa bile, nesneyi referans olarak iletmek için küçük bir hile vardır. Java'da da çalışır, tek bir öğeyle liste. ;-)

class PassByReference:
    def __init__(self, name):
        self.name = name

def changeRef(ref):
    ref[0] = PassByReference('Michael')

obj = PassByReference('Peter')
print obj.name

p = [obj] # A pointer to obj! ;-)
changeRef(p)

print p[0].name # p->name

Bu çirkin bir hack, ama işe yarıyor. ;-P

Birkaç Fortran kodunu Python'a hızlıca dönüştürmek için aşağıdaki yöntemi kullandım. Doğru, orijinal soru ortaya atıldığı için referans olarak geçilmez, ancak bazı durumlarda basit bir çalışmadır.

a=0
b=0
c=0
def myfunc(a,b,c):
    a=1
    b=2
    c=3
    return a,b,c

a,b,c = myfunc(a,b,c)
print a,b,c

Referans yoluyla geçiş, python'a iyi uyan ve nadiren kullanılması gereken bir şey olmasa da, aslında şu anda yerel bir değişkene atanan nesneyi almak için çalışabilecek veya hatta bir çağrılan fonksiyonun içinden yerel bir değişkeni yeniden atayabilecek bazı geçici çözümler vardır.

Temel fikir, bu erişimi gerçekleştirebilen ve nesne olarak diğer işlevlere geçirilebilen veya bir sınıfta saklanabilen bir işleve sahip olmaktır.

Bunun bir yolu, bir sarma işlevinde ( globalgenel değişkenler için) veya nonlocal(bir işlevdeki yerel değişkenler için ) kullanmaktır .

def change(wrapper):
    wrapper(7)

x = 5
def setter(val):
    global x
    x = val
print(x)

Aynı fikir, delbir değişkeni okumak ve tanımlamak için de geçerlidir.

Sadece okumak için, sadece lambda: xçağrıldığında x'in geçerli değerini döndüren bir çağrılabilir döndüren kullanmanın daha kısa bir yolu vardır . Bu biraz uzaktaki dillerde kullanılan "isimle çağrı" gibi bir şey.

Bir değişkene erişmek için 3 paket geçirmek biraz kullanışsızdır, böylece bunlar proxy özniteliğine sahip bir sınıfa sarılabilir:

class ByRef:
    def __init__(self, r, w, d):
        self._read = r
        self._write = w
        self._delete = d
    def set(self, val):
        self._write(val)
    def get(self):
        return self._read()
    def remove(self):
        self._delete()
    wrapped = property(get, set, remove)

# left as an exercise for the reader: define set, get, remove as local functions using global / nonlocal
r = ByRef(get, set, remove)
r.wrapped = 15

Pythons "yansıma" desteği, belirli bir kapsamdaki bir adı / değişkeni, o kapsamdaki işlevleri açıkça tanımlamadan yeniden atayabilen bir nesnenin elde edilmesini mümkün kılar:

class ByRef:
    def __init__(self, locs, name):
        self._locs = locs
        self._name = name
    def set(self, val):
        self._locs[self._name] = val
    def get(self):
        return self._locs[self._name]
    def remove(self):
        del self._locs[self._name]
    wrapped = property(get, set, remove)

def change(x):
    x.wrapped = 7

def test_me():
    x = 6
    print(x)
    change(ByRef(locals(), "x"))
    print(x)

Burada ByRefsınıf bir sözlük erişimini sarar. Böylece öznitelik erişimi wrapped, iletilen sözlükteki bir öğe erişimine çevrilir. Yerleşimin sonucunu localsve yerel bir değişkenin adını geçerek, yerel bir değişkene erişilir. 3.5'teki python belgeleri sözlüğü değiştirmenin işe yaramayabileceğini ama benim için işe yaradığını gösteriyor.

python'un değerleri ve bunlara referansları işleme şekli göz önüne alındığında, rastgele bir örnek niteliğine başvurabilmenin tek yolu ada göre:

class PassByReferenceIsh:
    def __init__(self):
        self.variable = 'Original'
        self.change('variable')
        print self.variable

    def change(self, var):
        self.__dict__[var] = 'Changed'

gerçek kodda, elbette, dict aramasına hata kontrolü eklersiniz.

Sözlükler başvuru ile iletildiğinden, içinde başvurulan değerleri depolamak için bir dikte değişkeni kullanabilirsiniz.

# returns the result of adding numbers `a` and `b`
def AddNumbers(a, b, ref): # using a dict for reference
    result = a + b
    ref['multi'] = a * b # reference the multi. ref['multi'] is number
    ref['msg'] = "The result: " + str(result) + " was nice!" # reference any string (errors, e.t.c). ref['msg'] is string
    return result # return the sum

number1 = 5
number2 = 10
ref = {} # init a dict like that so it can save all the referenced values. this is because all dictionaries are passed by reference, while strings and numbers do not.

sum = AddNumbers(number1, number2, ref)
print("sum: ", sum)             # the return value
print("multi: ", ref['multi'])  # a referenced value
print("msg: ", ref['msg'])      # a referenced value

Python'daki Referansla Geçiş, C ++ / Java'daki referansla geçiş kavramından oldukça farklıdır.

• Java & C #: ilkel tipler (dize dahil) değere göre geçiş (kopya), Referans tipi referansla (adres kopyası) geçirilir, böylece çağrılan işlevde parametrede yapılan tüm değişiklikler arayan tarafından görülebilir.
• C ++: Hem referans hem de by-pass değerine izin verilir. Bir parametre referansla iletilirse, parametrenin const olarak iletilip iletilmemesine bağlı olarak değiştirebilir veya değiştiremezsiniz. Bununla birlikte, const ya da değil, parametre nesneye başvuruyu korur ve çağrılan işlev içindeki farklı bir nesneyi işaret etmek için başvuru atanamaz.
• Python: Python “nesne-nesne-referansı” dır ki, sıklıkla söylenir: “Nesne referansları değere göre geçmektedir.” 1. Hem arayan hem de işlev aynı nesneyi ifade eder, ancak işlevdeki parametre, arayanın içinde nesnenin bir kopyasını tutan yeni bir değişkendir. C ++ gibi, bir parametre de değiştirilebilir veya işlevde olmayabilir - Bu, iletilen nesnenin türüne bağlıdır. Örneğin; Değişmez bir nesne türü çağrılan işlevde değiştirilemezken, değiştirilebilir bir nesne güncellenebilir veya yeniden başlatılabilir. Değişken değişkenin güncellenmesi veya yeniden atanması / yeniden başlatılması arasındaki önemli bir fark, güncellenen değerin çağrılan fonksiyona geri yansıtılması, yeniden başlatılmış değerin olmamasıdır. Değişken bir değişkene herhangi bir yeni nesne atamasının kapsamı, pitondaki fonksiyon için yereldir. @ Blair-conrad tarafından sağlanan örnekler bunu anlamak için mükemmeldir.

Örneğiniz nesne yönelimli olduğundan, benzer bir sonuç elde etmek için aşağıdaki değişikliği yapabilirsiniz:

class PassByReference:
    def __init__(self):
        self.variable = 'Original'
        self.change('variable')
        print(self.variable)

    def change(self, var):
        setattr(self, var, 'Changed')

# o.variable will equal 'Changed'
o = PassByReference()
assert o.variable == 'Changed'

Dahili nesne öznitelikleri bir örnek sözlüğünde depolandığından, başvuru nesnelerini depolamak için yalnızca boş bir sınıfı örnek olarak kullanabilirsiniz . Örneğe bakın.

class RefsObj(object):
    "A class which helps to create references to variables."
    pass

...

# an example of usage
def change_ref_var(ref_obj):
    ref_obj.val = 24

ref_obj = RefsObj()
ref_obj.val = 1
print(ref_obj.val) # or print ref_obj.val for python2
change_ref_var(ref_obj)
print(ref_obj.val)

Örneğin, C ++ 'dan bilinen referansları simüle etmek için bir yaklaşımdan bahsedilmediği için, bir "güncelleme" işlevi kullanmak ve gerçek değişken (veya daha doğrusu "ad") yerine bunu iletmektir:

def need_to_modify(update):
    update(42) # set new value 42
    # other code

def call_it():
    value = 21
    def update_value(new_value):
        nonlocal value
        value = new_value
    need_to_modify(update_value)
    print(value) # prints 42

Bu çoğunlukla "yalnızca dış referanslar" için veya birden çok iş parçacığı / işlem içeren bir durumda (güncelleme işlevi iş parçacığı / çok işlemciliğini güvenli hale getirerek) yararlıdır.

Açıkçası, yukarıdaki değer okumaya izin vermez , sadece güncellenir.