Sınıf yöntemlerinin amacı nedir?


250

Kendime Python öğretiyorum ve en son dersim Python'un Java olmamasıydı ve bu yüzden tüm Sınıf yöntemlerimi fonksiyonlara dönüştürmek için biraz zaman harcadım.

Artık staticJava'da yöntemlerle yapacağım şeyler için Sınıf yöntemlerini kullanmam gerekmediğinin farkındayım , ancak şimdi bunları ne zaman kullanacağımdan emin değilim. Python Sınıfı yöntemleri hakkında bulabildiğim tüm tavsiyeler, benim gibi yeni başlayanların çizgilerinden geçiyor ve bunları tartışırken standart belgeler en opak.

Herkes Python bir Class yöntemi kullanmak için iyi bir örnek var mı ya da en azından birisi bana sınıf yöntemlerinin ne zaman makul bir şekilde kullanılabileceğini söyleyebilir?

Yanıtlar:


178

Sınıf yöntemleri, belirli bir örneğe özgü olmayan, ancak yine de sınıfı bir şekilde dahil eden yöntemlere ihtiyacınız olduğunda kullanılır. Onlar hakkında en ilginç şey, Java'nın statik yöntemlerinde veya Python'un modül seviyesi işlevlerinde mümkün olmayan bir şey olan alt sınıflar tarafından geçersiz kılınabilmeleridir.

Eğer bir sınıf varsa MyClassve Sınıfım (fabrikada, bağımlılık enjeksiyon saplama, vs) üzerinde çalışan bir modül düzeyi işlevini bunu bir hale classmethod. Sonra alt sınıflar için kullanılabilir olacak.


Anlıyorum. Ancak, yalnızca MyClass'a ihtiyaç duymayan bir yöntemi kategorilere ayırmak istiyorsam, ancak diğer MyClass'ta gruplandırırsam yine de bir şekilde mantıklıysa ne olur? Yardımcı modüle geçmeyi düşünebilirim ..
swdev

Orijinaliyle ilgili bir sorum var, belki aynı zamanda cevap verebilirsin? Bir nesnenin sınıf yöntemlerini çağırmanın hangi yolu "daha iyi" veya "daha deyimsel" dir: obj.cls_mthd(...)veya type(obj).cls_mthd(...)?
Alexey

63

Fabrika yöntemleri (alternatif kurucular) aslında sınıf yöntemlerinin klasik bir örneğidir.

Temel olarak, sınıf yöntemleri, sınıfın ad alanına doğal olarak uyan ancak sınıfın belirli bir örneğiyle ilişkili olmayan bir yöntem olmasını istediğiniz her zaman uygundur.

Örnek olarak, mükemmel tek yollu modülde:

Geçerli dizin

  • Path.cwd()
    • Geçerli geçerli dizini döndürün; ör Path("/tmp/my_temp_dir"). Bu bir sınıf yöntemidir.
  • .chdir()
    • Kendini geçerli dizin yap.

Geçerli dizin işlem çapında olduğundan, cwdyöntemin ilişkilendirilmesi gereken belirli bir örneği yoktur. Ancak, cwdbelirli bir Pathörneğin dizinini değiştirmek gerçekten de bir örnek yöntemi olmalıdır.

Hmmm ... Path.cwd()gerçekten bir Pathörnek döndürdüğü gibi, sanırım bir fabrika yöntemi olarak düşünülebilir ...


1
Evet ... ilk akla gelen fabrika yöntemleri idi. Ayrıca bu çizgiler boyunca, bir Singleton kalıbı uygulayacak şeyler de vardır: getAndOptionallyCreateSomeSingleInstanceOfSomeResource ()
Jemenake

3
Python'da bunlar statik yöntemler değil, sınıf yöntemleridir.
Jaykul

46

Bunu şu şekilde düşünün: normal yöntemler gönderimin ayrıntılarını gizlemek için yararlıdır: yöntemin nesnenin sınıfı veya üst sınıflarından biri tarafından uygulanıp uygulanmadığı myobj.foo()konusunda endişelenmeden yazabilirsiniz . Sınıf yöntemleri buna tam olarak benzer, ancak bunun yerine sınıf nesnesiyle: kendi özel sürümüne ihtiyaç duyduğu için özel olarak uygulanıp uygulanmadığı veya üst sınıfının çağrıyı yönetmesine izin verip vermediği konusunda endişelenmenize gerek kalmadan çağrı yapmanıza izin verir .foo()myobjMyClass.foo()foo()MyClass

Sınıf yöntemleri, gerçek bir örneğin oluşturulmasından önce gelen kurulum veya hesaplama yaparken önemlidir , çünkü örnek var olana kadar örneği yöntem çağrılarınız için gönderme noktası olarak kullanamazsınız. SQLAlchemy kaynak kodunda iyi bir örnek görülebilir; dbapi()aşağıdaki bağlantıdaki class yöntemine bir göz atın :

https://github.com/zzzeek/sqlalchemy/blob/ab6946769742602e40fb9ed9dde5f642885d1906/lib/sqlalchemy/dialects/mssql/pymssql.py#L47

Bunu görebilirsiniz dbapi()onu çalıştırmak gerektiğinden bir veritabanı arka uç kullandığı o on-demand ihtiyacı satıcıya özgü veritabanı kütüphanesi ithal etmek yöntemi, bir sınıf yöntemidir önce oluşturulan almaya başlamak belirli bir veritabanı bağlantısının örnekleri - ama bu olamaz basit bir işlev veya statik işlev olabilir, çünkü alt sınıflarda benzer şekilde üst sınıflarından daha özel olarak yazılması gerekebilecek diğer destekleyici yöntemleri çağırabilmelerini isterler. Eğer bir fonksiyona veya statik sınıfa gönderiyorsanız, o zaman "unutursunuz" ve hangi sınıfın başlatmayı yaptığı hakkında bilgi kaybedersiniz.


Bozuk bağlantı, lütfen ayarlayın
piertoni

28

Son zamanlarda, programlanabilir olarak ayarlanabilen günlükleme düzeyine bağlı olarak değişen miktarlarda çıktı verecek çok hafif bir günlükleme sınıfı istedim. Ancak her hata ayıklama iletisi veya hata veya uyarı vermek istediğimde sınıfı başlatmak istemedim. Ama aynı zamanda, bu kayıt tesisinin işleyişini kapsüllemek ve herhangi bir küreselin ilanı olmadan tekrar kullanılabilir hale getirmek istedim.

Bunu @classmethodbaşarmak için sınıf değişkenlerini ve dekoratörü kullandım.

Basit Logging sınıfımla şunları yapabilirim:

Logger._level = Logger.DEBUG

Sonra, benim kod, bir grup hata ayıklama bilgi tükürmek istedim, ben sadece kodlamak zorunda kaldı

Logger.debug( "this is some annoying message I only want to see while debugging" )

Hatalar atılabilir

Logger.error( "Wow, something really awful happened." )

"Üretim" ortamında,

Logger._level = Logger.ERROR

ve şimdi sadece hata mesajı verilecektir. Hata ayıklama mesajı yazdırılmaz.

İşte benim sınıfım:

class Logger :
    ''' Handles logging of debugging and error messages. '''

    DEBUG = 5
    INFO  = 4
    WARN  = 3
    ERROR = 2
    FATAL = 1
    _level = DEBUG

    def __init__( self ) :
        Logger._level = Logger.DEBUG

    @classmethod
    def isLevel( cls, level ) :
        return cls._level >= level

    @classmethod
    def debug( cls, message ) :
        if cls.isLevel( Logger.DEBUG ) :
            print "DEBUG:  " + message

    @classmethod
    def info( cls, message ) :
        if cls.isLevel( Logger.INFO ) :
            print "INFO :  " + message

    @classmethod
    def warn( cls, message ) :
        if cls.isLevel( Logger.WARN ) :
            print "WARN :  " + message

    @classmethod
    def error( cls, message ) :
        if cls.isLevel( Logger.ERROR ) :
            print "ERROR:  " + message

    @classmethod
    def fatal( cls, message ) :
        if cls.isLevel( Logger.FATAL ) :
            print "FATAL:  " + message

Ve bunu biraz test eden bazı kodlar:

def logAll() :
    Logger.debug( "This is a Debug message." )
    Logger.info ( "This is a Info  message." )
    Logger.warn ( "This is a Warn  message." )
    Logger.error( "This is a Error message." )
    Logger.fatal( "This is a Fatal message." )

if __name__ == '__main__' :

    print "Should see all DEBUG and higher"
    Logger._level = Logger.DEBUG
    logAll()

    print "Should see all ERROR and higher"
    Logger._level = Logger.ERROR
    logAll()

10
Bu mu değil iyi bir örnek sınıf yöntemi gibi hepsi sadece tüm sınıf yöntemleri modül düzeyi işlevlerini yapma ve tamamen sınıfla uzağa yaparak daha az karmaşık bir şekilde yapılmış olabilir çünkü iyi gelir bana görünüyor.
martineau

10
Oh, daha da önemlisi, Python kullanımı çok basit bir günlük kaydı sınıfı sağlar. Optimalden daha az bir çözüm yaratmaktan çok daha kötü, tekerleği yeniden keşfettim. Çift el tokat. Ama en azından çalışan bir örnek sunuyor. Yine de kavramsal düzeyde sınıftan kurtulmaya katıldığımdan emin değilim. Bazen kolay yeniden kullanım için kodu kapsüllemek istersiniz ve günlük tutma yöntemleri yeniden kullanım için mükemmel bir hedeftir.
Marvo

3
Neden statik yöntem kullanmıyorsunuz?
bdforbes


11

Bir kullanıcı web sitemde oturum açtığında, kullanıcı adı ve şifresinden bir User () nesnesi başlatılır.

Kullanıcı oturum açmak için orada olmadan bir kullanıcı nesnesi gerekiyorsa (örneğin bir yönetici kullanıcı başka bir kullanıcı hesabını silmek isteyebilirsiniz, bu yüzden bu kullanıcıyı örneklemek ve onun silme yöntemini çağırmak gerekir):

Kullanıcı nesnesini kapmak için sınıf yöntemleri var.

class User():
    #lots of code
    #...
    # more code

    @classmethod
    def get_by_username(cls, username):
        return cls.query(cls.username == username).get()

    @classmethod
    def get_by_auth_id(cls, auth_id):
        return cls.query(cls.auth_id == auth_id).get()

9

Bence en açık cevap AmanKow'un cevabı . Kodunuzu nasıl düzenlemek istediğinize kadar kaynar. Her şeyi modülün ad alanına sarılmış modül seviyesi işlevleri olarak yazabilirsiniz.

module.py (file 1)
---------
def f1() : pass
def f2() : pass
def f3() : pass


usage.py (file 2)
--------
from module import *
f1()
f2()
f3()
def f4():pass 
def f5():pass

usage1.py (file 3)
-------------------
from usage import f4,f5
f4()
f5()

Yukarıdaki prosedür kodu iyi organize edilmemiştir, sadece 3 modülden sonra kafa karıştırıcı olduğunu görebiliyorsunuz, her yöntem ne yapıyor? İşlevler için uzun açıklayıcı adlar kullanabilirsiniz (java gibi), ancak yine de kodunuz çok hızlı bir şekilde yönetilemez hale gelir.

Nesneye yönelik yol, kodunuzu yönetilebilir bloklara ayırmaktır. Sınıflar ve nesneler ve işlevler, nesne örnekleri veya sınıflarla ilişkilendirilebilir.

Sınıf fonksiyonları ile, kodunuzda modül seviyesi fonksiyonlarına kıyasla başka bir bölüm seviyesi elde edersiniz. Böylece, ilgili sınıfa atadığınız bir göreve daha spesifik hale getirmek için bir sınıf içindeki ilgili işlevleri gruplayabilirsiniz. Örneğin, bir dosya yardımcı programı sınıfı oluşturabilirsiniz:

class FileUtil ():
  def copy(source,dest):pass
  def move(source,dest):pass
  def copyDir(source,dest):pass
  def moveDir(source,dest):pass

//usage
FileUtil.copy("1.txt","2.txt")
FileUtil.moveDir("dir1","dir2")

Bu şekilde daha esnek ve daha sürdürülebilir, işlevleri bir arada gruplandırıyorsunuz ve her işlevin ne yaptığına göre daha açık. Ayrıca ad çakışmalarını önlersiniz, örneğin işlev kopyası kodunuzda kullandığınız başka bir içe aktarılan modülde (örneğin ağ kopyası) bulunabilir, bu nedenle FileUtil.copy () tam adını kullandığınızda sorunu ve her iki kopyalama işlevini de kaldırırsınız. yan yana kullanılabilir.


1
F1 (), f2 () ve benzerlerini kullanmak için, yaptığınız gibi, modül içe aktarma * ve kullanım içe aktarma * kullanmamalısınız?
Jblasco

@Jblasco Karışıklığı gidermek için içe aktarma ifadelerini düzelttim, evet modülü içe aktarırsanız işlevlerin modül adıyla ön ekini eklemeniz gerekir. yani ithalat modülü -> modül.f1 () vb
firephil

Bu cevaba katılmıyorum; Python Java değildir. Yönetilemez kod sorunu, görünüşte örnekteki kötü isimlerin kasıtlı olarak seçilmesinden kaynaklanmaktadır. Bunun yerine, FileUtilsınıf yöntemlerini bir file_utilmodülün işlevleri olarak çoğalttıysanız, karşılaştırılabilir olacak ve gerçekte hiçbir nesne olmadığında OOP'yi kötüye kullanmazsınız (aslında tercih edersiniz, çünkü sonuçta from file_util import FileUtilveya başka ayrıntılarda bulunmazsınız ). Ad çakışmaları benzer yaparak prosedürel kod önlenebilir import file_utilyerine from file_util import ....
ForgottenUmbrella

7

Dürüst? Statik yöntem veya sınıf yöntemi için hiç bir kullanım bulamadım. Genel bir işlev veya örnek yöntemi kullanılarak gerçekleştirilemeyen bir işlem görmedim.

Python'un Java'nın yaptığı gibi özel ve korunan üyeler kullanması farklı olurdu. Java, bir şey yapmak için bir örneğin özel üyelerine erişmek için statik bir yöntem gerekir. Python'da bu nadiren gereklidir.

Genellikle, gerçekten yapmaları gereken tek şey python'un modül düzeyindeki ad alanlarını daha iyi kullanmak olduğunda statik metodları ve sınıf metotlarını kullanan insanları görüyorum.


1
Özel: _variable_name ve Korumalı: __variable_name
Bradley Kreider

1
Bir vazgeçilmez kullanımıdır en unittest setUpClass ve tearDownClass. Birim testleri kullanıyorsunuz, değil mi? :)
dbn

7

Herhangi bir uyumlu sınıfla kullanabileceğiniz genel sınıf yöntemleri yazmanıza izin verir.

Örneğin:

@classmethod
def get_name(cls):
    print cls.name

class C:
    name = "tester"

C.get_name = get_name

#call it:
C.get_name()

Eğer kullanmazsanız @classmethod, self anahtar kelimeyle yapabilirsiniz, ancak bir Class örneğine ihtiyaç duyar:

def get_name(self):
    print self.name

class C:
    name = "tester"

C.get_name = get_name

#call it:
C().get_name() #<-note the its an instance of class C

5

PHP ile çalışırdım ve son zamanlarda kendime soruyordum, bu sınıf yöntemiyle neler oluyor? Python kılavuzu çok teknik ve kelimeler açısından çok kısa, bu yüzden bu özelliği anlamaya yardımcı olmaz. Ben googling ve googling yapıyordum ve cevap buldum -> http://code.anjanesh.net/2007/12/python-classmethods.html .

Tıklamak için tembelseniz. Açıklamam daha kısa ve aşağıda. :)

PHP'de (belki hepiniz PHP'yi bilmiyorsunuz, ancak bu dil o kadar ileri ki herkesin neden bahsettiğimi anlaması gerekiyor) böyle statik değişkenlerimiz var:


class A
{

    static protected $inner_var = null;

    static public function echoInnerVar()
    {
        echo self::$inner_var."\n";
    }

    static public function setInnerVar($v)
    {
        self::$inner_var = $v;
    }

}

class B extends A
{
}

A::setInnerVar(10);
B::setInnerVar(20);

A::echoInnerVar();
B::echoInnerVar();

Çıktı her iki durumda da olacaktır 20.

Bununla birlikte, python'da @classmethod dekoratörü ekleyebiliriz ve bu nedenle sırasıyla 10 ve 20 çıktısına sahip olmak mümkündür. Misal:


class A(object):
    inner_var = 0

    @classmethod
    def setInnerVar(cls, value):
        cls.inner_var = value

    @classmethod
    def echoInnerVar(cls):
        print cls.inner_var


class B(A):
    pass


A.setInnerVar(10)
B.setInnerVar(20)

A.echoInnerVar()
B.echoInnerVar()

Akıllı, değil mi?


Python örnekle potansiyel bir sorun varsa olduğunu B.setInnerVar(20)dışarı bırakılmış, bu basacaktır 10hiçbir iki kez (ziyade ikinci echoInnerBar () çağrısı bir hata vermek inner_vartanımlandı.
martineau

5

Sınıf yöntemleri bir "anlamsal şeker" sağlar (bu terimin yaygın olarak kullanılıp kullanılmadığını bilmiyorum) - veya "anlamsal kolaylık".

Örnek: nesneleri temsil eden bir dizi sınıfınız var. Sen sınıf yöntemine sahip isteyebilirsiniz all()veya find()yazmak için User.all()veya User.find(firstname='Guido'). Bu tabii ki modül seviyesi fonksiyonları kullanılarak yapılabilir ...


Örneğin, elbette, sınıfın tüm örneklerini takip ettiğini ve oluşturulduktan sonra bunlara erişebileceğini varsayar - otomatik olarak yapılmayan bir şey.
martineau

1
"anlambilimsel şeker" kulağa "sözdizimsel şeker" ile iyi bir uyum sağlar.
XTL

3

Ruby'den gelen sadece bana çarpan şey, sınıf yöntemi olarak adlandırılan bir örnek yöntem ve sözde örnek yönteminin, ilk parametresine uygulanan anlamsal anlamı olan bir işlev olması ve işlev bir yöntem olarak çağrıldığında sessizce geçmesidir . bir nesne (yani obj.meth()).

Normalde bu nesne bir örnek olmalıdır ancak @classmethod yöntem dekoratörü bir sınıfı geçmek için kuralları değiştirir. Bir örnek üzerinde bir sınıf yöntemi çağırabilirsiniz (bu sadece bir işlevdir) - ilk argüman kendi sınıfı olacaktır.

Bu sadece bir işlev olduğu için, herhangi bir kapsamda (yani classtanım) yalnızca bir kez bildirilebilir . Bu nedenle, bir Rubyist için bir sürpriz olarak , bir sınıf yöntemine ve aynı ada sahip bir örnek yöntemine sahip olamayacağınıza dair .

Bunu düşün:

class Foo():
  def foo(x):
    print(x)

fooBir örneği arayabilirsiniz

Foo().foo()
<__main__.Foo instance at 0x7f4dd3e3bc20>

Ama bir sınıfta değil:

Foo.foo()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unbound method foo() must be called with Foo instance as first argument (got nothing instead)

Şimdi ekle @classmethod:

class Foo():
  @classmethod
  def foo(x):
    print(x)

Bir örneği çağırmak artık sınıfını geçer:

Foo().foo()
__main__.Foo

bir sınıfı çağırırken olduğu gibi:

Foo.foo()
__main__.Foo

Sadece selfbir örnek yönteminde ve clsbir sınıf yönteminde bu ilk argüman için kullandığımızı belirleyen kural . İkisini de bunun sadece bir argüman olduğunu göstermek için kullandım. Ruby'de selfbir anahtar kelime.

Ruby ile kontrast:

class Foo
  def foo()
    puts "instance method #{self}"
  end
  def self.foo()
    puts "class method #{self}"
  end
end

Foo.foo()
class method Foo

Foo.new.foo()
instance method #<Foo:0x000000020fe018>

Python sınıfı yöntemi sadece dekore edilmiş bir işlevdir ve kendi dekoratörlerinizi oluşturmak için aynı teknikleri kullanabilirsiniz . Dekore edilmiş bir yöntem gerçek yöntemi sarar ( @classmethodek sınıf argümanını geçmesi durumunda ). Temel yöntem hala orada, gizli ama yine de erişilebilir .


footnote: Bunu bir sınıf ve örnek yöntemi arasındaki bir isim çakışmasından sonra merakımı uyandırdıktan sonra yazdım. Ben bir Python uzmanı olmaktan uzak ve bu yanlış varsa yorum istiyorum.


"Bu işlev bir nesnenin yöntemi olarak çağrıldığında sessizce geçirilir" - bunun kesin olmadığına inanıyorum. AFICT, Python'da hiçbir şey "sessizce geçmez". IMO, Python bu anlamda Ruby'den çok daha mantıklı (hariç super()). AFICT, "büyü" bir öznitelik ayarlandığında veya okunduğunda gerçekleşir. obj.meth(arg)Python'daki çağrı (Ruby'nin aksine) basitçe ifade eder (obj.meth)(arg). Hiçbir şey sessizce herhangi bir yere aktarılmaz obj.meth, sadece oluşturulduğu işlevden bir argümanı daha az kabul eden çağrılabilir bir nesnedir.
Alexey

obj.meth, sırayla, basitçe anlamına gelir getattr(obj, "meth").
Alexey

Diğer ortak dillerden gelen insanlar için özel olarak hazırlanmış bir yanıtın olması mantıklıdır. Bununla birlikte, bu konuşmada eksik olan ve onu birbirine bağlayan bir şey, bir Python tanımlayıcısı kavramıdır . İşlevler tanımlayıcıdır ve bir işlev sınıfa ait bir öznitelik olduğunda "otomatik olarak" ilk bağımsız değişkeni bu şekilde geçer. Sınıf yöntemlerinin nasıl uygulandığı ve NASIL bağlantılı I'de saf bir python uygulaması sağlanır. Aynı zamanda bir dekoratör olması aslında bir çeşit yardımcıdır
juanpa.arrivillaga

2

Bu, enteresan bir konu. Benim düşüncem, python classmethod'un bir fabrikadan ziyade bir tekton gibi çalıştığıdır (üretilen bir sınıf örneğini döndürür). Bunun bir tekton olmasının nedeni, sınıf için yalnızca bir kez üretilen ancak tüm örnekler tarafından paylaşılan ortak bir nesnenin (sözlük) olmasıdır.

Bunu göstermek için bir örnek. Tüm örneklerin tek bir sözlüğe başvurusu olduğunu unutmayın. Anladığım kadarıyla bu Fabrika modeli değil. Bu muhtemelen python için çok benzersizdir.

class M():
 @classmethod
 def m(cls, arg):
     print "arg was",  getattr(cls, "arg" , None),
     cls.arg = arg
     print "arg is" , cls.arg

 M.m(1)   # prints arg was None arg is 1
 M.m(2)   # prints arg was 1 arg is 2
 m1 = M()
 m2 = M() 
 m1.m(3)  # prints arg was 2 arg is 3  
 m2.m(4)  # prints arg was 3 arg is 4 << this breaks the factory pattern theory.
 M.m(5)   # prints arg was 4 arg is 5

2

Aynı soruyu birkaç kez kendime soruyordum. Ve buradaki adamlar açıklamak için çok uğraşmış olsalar da, IMHO bulduğum en iyi cevap (ve en basit) cevap Python Belgelerinde Sınıf yönteminin açıklamasıdır .

Statik yönteme de atıfta bulunulmaktadır. Ve birisinin zaten örnek yöntemlerini (varsayalım) bilmesi durumunda, bu cevap hepsini bir araya getirmek için son parça olabilir ...

Bu konuyla ilgili daha ayrıntılı ve derinlemesine dokümantasyonda da bulunabilir: Standart tür hiyerarşisi ( Örnek yöntemleri bölümüne ilerleyin )


1

@classmethodo sınıftaki nesneleri dış kaynaklardan kolayca somutlaştırmak için yararlı olabilir. Aşağıdakileri göz önünde bulundur:

import settings

class SomeClass:
    @classmethod
    def from_settings(cls):
        return cls(settings=settings)

    def __init__(self, settings=None):
        if settings is not None:
            self.x = settings['x']
            self.y = settings['y']

Sonra başka bir dosyada:

from some_package import SomeClass

inst = SomeClass.from_settings()

İnst.x dosyasına erişmek, ['x'] ayarlarıyla aynı değeri verecektir.


0

Bir sınıf elbette bir dizi örneği tanımlar. Ve bir sınıfın yöntemleri bireysel örnekler üzerinde çalışır. Sınıf yöntemleri (ve değişkenler), tüm örnek kümeleriyle ilgili diğer bilgileri asmak için bir yer.

Örneğin, sınıfınız bir öğrenci kümesi tanımlarsa, sınıf değişkenleri veya öğrencilerin üye olabileceği not kümesi gibi şeyleri tanımlayan yöntemler isteyebilirsiniz.

Tüm kümede çalışmaya yönelik araçları tanımlamak için sınıf yöntemlerini de kullanabilirsiniz. Örneğin, Student.all_of_em () tüm bilinen öğrencileri döndürebilir. Açıkçası örnek kümeniz bir kümeden daha fazla yapıya sahipse, bu yapı hakkında bilmek için sınıf yöntemleri sağlayabilirsiniz. Students.all_of_em (derece = 'gençler')

Bunun gibi teknikler, örnek kümesinin üyelerini sınıf değişkenlerine dayanan veri yapılarında depolamaya yol açar. O zaman çöp koleksiyonunu sinirlendirmekten kaçınmaya dikkat etmelisiniz.

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.