I'm belajar bahasa pemrograman Python dan I've datang di sesuatu yang saya don't sepenuhnya memahami.
Dalam metode ini, seperti:
def method(self, blah):
def __init__(?):
....
....
Apa yang dimaksud dengan diri
lakukan? Apa itu dimaksudkan untuk menjadi? Apakah itu wajib?
Apa __init__
metode apa? Mengapa perlu? (dll.)
Saya pikir mereka mungkin OOP konstruksi, tapi aku don't tahu sangat banyak.
Dalam kode ini:
class A(object):
def __init__(self):
self.x = 'Hello'
def method_a(self, foo):
print self.x + ' ' + foo
... diri
variabel merupakan instance dari objek itu sendiri. Sebagian besar bahasa-bahasa berorientasi objek lulus sebagai parameter tersembunyi metode-metode yang telah ditetapkan pada suatu objek; Python tidak. Anda harus menyatakan secara eksplisit. Ketika anda membuat sebuah instance dari A
kelas dan memanggil metode, itu akan diteruskan secara otomatis, seperti di ...
a = A() # We do not pass any argument to the __init__ method
a.method_a('Sailor!') # We only pass a single argument
The __init__
metode kira-kira apa yang mewakili sebuah konstruktor di Python. Ketika anda menelepon A()
Python menciptakan sebuah objek untuk anda, dan lolos sebagai parameter pertama untuk __init__
metode. Setiap parameter tambahan (misalnya, A(24, 'Halo')
) juga akan mendapatkan dilewatkan sebagai argumen--dalam hal ini menyebabkan pengecualian untuk dibesarkan, karena konstruktor isn't mengharapkan mereka.
Yap, anda benar, ini adalah oop konstruksi.
__init__
adalah konstruktor untuk kelas. Diri
parameter mengacu pada instance dari objek (seperti ini
di C++).
class Point:
def __init__(self, x, y):
self._x = x
self._y = y
The __init__
metode dipanggil ketika memori untuk objek tersebut dialokasikan:
x = Point(1,2)
Hal ini penting untuk menggunakan diri
parameter dalam sebuah objek's metode jika anda ingin bertahan dengan nilai objek. Jika, misalnya, anda menerapkan __init__
metode seperti ini:
class Point:
def __init__(self, x, y):
_x = x
_y = y
Anda x
dan y
parameter akan disimpan di variabel pada stack dan akan dibuang ketika init metode yang keluar dari ruang lingkup. Pengaturan variabel-variabel tersebut sebagai diri._x
dan diri._y
set variabel tersebut sebagai anggota dari Titik
objek (diakses untuk seumur hidup dari objek).
Dengan harapan ini mungkin sedikit membantu, berikut ini's contoh sederhana yang saya digunakan untuk memahami perbedaan antara variabel yang dideklarasikan di dalam kelas, dan variabel yang dideklarasikan di dalam sebuah __init__
fungsi:
``python class MyClass(objek): i = 123 def init(self): mandiri.i = 345
a = MyClass()
print(a.i)
cetak(MyClass.i)
Output:
Tiga ratus empat puluh lima
Seratus dua puluh tiga
``
Singkatnya:
diri
seperti ini menunjukkan, mengacu pada sendiri- objek yang disebut metode. Artinya, jika anda memiliki N benda memanggil metode, maka diri.a
akan mengacu pada contoh terpisah dari variabel untuk masing-masing dari N benda. Bayangkan N salinan dari variabel a
untuk masing-masing objek__init__
adalah apa yang disebut sebagai konstruktor dalam OOP lainnya seperti bahasa C++/Java. Ide dasarnya adalah bahwa itu adalah khusus metode yang secara otomatis dipanggil ketika sebuah objek dari Kelas dibuat__init__
tidak bertindak seperti sebuah konstruktor. Anda'll harus lulus "mandiri" untuk setiap kelas memiliki fungsi sebagai argumen pertama jika anda ingin mereka untuk berperilaku sebagai non-statis metode. "mandiri" ini adalah contoh variabel untuk kelas anda.
Mencoba kode ini. Berharap itu membantu banyak pemrogram C seperti saya untuk Belajar Py.
#! /usr/bin/python2
class Person:
'''Doc - Inside Class '''
def __init__(self, name):
'''Doc - __init__ Constructor'''
self.n_name = name
def show(self, n1, n2):
'''Doc - Inside Show'''
print self.n_name
print 'Sum = ', (n1 + n2)
def __del__(self):
print 'Destructor Deleting object - ', self.n_name
p=Person('Jay')
p.show(2, 3)
print p.__doc__
print p.__init__.__doc__
print p.show.__doc__
Output:
Jay
Jumlah ' = 5
Doc - Di Dalam Kelas
Doc - __init__ Konstruktor
Doc - Dalam Acara
Destruktor untuk Menghapus objek - Jay
Punya masalah undestanding ini sendiri. Bahkan setelah membaca jawaban di sini.
Untuk benar memahami __init__
metode yang anda butuhkan untuk memahami diri.
Self Parameter
Argumen yang diterima oleh __init__
metode ini adalah :
def __init__(self, arg1, arg2):
Tapi kita hanya benar-benar lulus dua argumen :
instance = OurClass('arg1', 'arg2')
Dimana memiliki tambahan argumen datang dari ?
Ketika kita mengakses atribut dari suatu objek yang kita lakukan itu dengan nama (atau referensi). Berikut ini adalah contoh referensi ke objek baru. Kita mengakses printargs metode contoh objek dengan menggunakan contoh.printargs.
Dalam rangka untuk mengakses atribut objek dari dalam __init__
metode kita perlu referensi ke objek.
Setiap kali metode ini disebut, referensi ke objek utama yang dilewatkan sebagai argumen pertama. Dengan konvensi yang selalu kau sebut ini argumen pertama untuk metode anda sendiri.
Ini berarti dalam __init__
metode yang bisa kita lakukan :
self.arg1 = arg1
self.arg2 = arg2
Di sini kita setting atribut pada objek. Anda dapat memverifikasi ini dengan melakukan hal berikut :
instance = OurClass('arg1', 'arg2')
print instance.arg1
arg1
nilai-nilai seperti ini yang dikenal sebagai atribut objek. Di sini __init__
metode menetapkan arg1 dan arg2 atribut contoh.
sumber: http://www.voidspace.org.uk/python/articles/OOP.shtml#the-init-method
Atribut referensi menggunakan standar sintaks yang digunakan untuk semua atribut referensi di Python: obj.nama. Valid atribut nama-nama semua nama-nama yang berada di kelas namespace ketika kelas objek diciptakan. Jadi, jika definisi kelas tampak seperti ini:
class MyClass:
"""A simple example class"""
i = 12345
def f(self):
return 'hello world'
kemudian MyClass.aku
dan MyClass.f
adalah valid atribut referensi, kembali integer dan fungsi objek, masing-masing. Kelas atribut juga dapat ditugaskan untuk, sehingga anda dapat mengubah nilai MyClass.aku
dengan tugas. __doc__
juga atribut yang benar, kembali docstring milik kelas: "Sebuah contoh sederhana kelas".
Kelas instansiasi menggunakan fungsi notasi. Hanya berpura-pura bahwa kelas objek adalah parameterless fungsi yang mengembalikan sebuah instance baru dari class. Misalnya:
x = MyClass()
The instansiasi operasi ("memanggil" kelas objek) menciptakan objek kosong. Banyak kelas-kelas seperti untuk membuat objek dengan contoh disesuaikan dengan spesifik keadaan awal. Oleh karena itu sebuah class dapat mendefinisikan sebuah metode khusus yang bernama __init__()
, seperti ini:
def __init__(self):
self.data = []
Ketika kelas mendefinisikan __init__()
metode, kelas instansiasi secara otomatis memanggil __init__()
untuk yang baru dibuat kelas misalnya. Jadi dalam contoh ini, baru, diinisialisasi contoh dapat diperoleh dengan:
x = MyClass()
Tentu saja, __init__()
metode dapat memiliki argumen untuk fleksibilitas yang lebih besar. Dalam hal ini, argumen yang diberikan untuk kelas instansiasi operator diteruskan ke __init__()
. Misalnya,
class Complex:
def __init__(self, realpart, imagpart):
self.r = realpart
self.i = imagpart
x = Complex(3.0, -4.5)
x.r, x.i
Diambil dari pejabat dokumentasi yang membantu saya yang paling akhir.
class Bill():
def __init__(self,apples,figs,dates):
self.apples = apples
self.figs = figs
self.dates = dates
self.bill = apples + figs + dates
print ("Buy",self.apples,"apples", self.figs,"figs
and",self.dates,"dates.
Total fruitty bill is",self.bill," pieces of fruit :)")
Ketika anda membuat instance dari kelas Tagihan:
purchase = Bill(5,6,7)
Anda mendapatkan:
> Buy 5 apples 6 figs and 7 dates. Total fruitty bill is 18 pieces of
> fruit :)
perhatikan bahwa diri
benar-benar bisa berlaku python pengenal. Misalnya, kita bisa dengan mudah menulis, dari Chris B's contoh:
class A(object):
def __init__(foo):
foo.x = 'Hello'
def method_a(bar, foo):
print bar.x + ' ' + foo
dan itu akan bekerja persis sama. Namun dianjurkan untuk menggunakan diri karena lain pythoners akan mengenalinya dengan lebih mudah.
__init__
pada dasarnya adalah sebuah fungsi yang akan "menginisialisasi"/"mengaktifkan" sifat-sifat class untuk objek tertentu, setelah dibuat dan disesuaikan dengan kelas yang sesuai..diri
yang mewakili obyek yang akan mewarisi properti tersebut.Pada dasarnya, anda perlu menggunakan 'mandiri' kata kunci ketika menggunakan variabel dalam beberapa fungsi dalam kelas yang sama. Adapun init, it's digunakan untuk pengaturan nilai default bila tidak ada fungsi lain dari dalam kelas itu disebut.
The 'mandiri' adalah referensi ke kelas contoh
class foo:
def bar(self):
print "hi"
Sekarang kita dapat membuat sebuah instance dari foo dan memanggil metode pada itu, mandiri parameter yang ditambahkan oleh Python dalam hal ini:
f = foo()
f.bar()
Tapi itu dapat dilalui dengan baik jika metode panggilan isn't dalam konteks sebuah instance dari kelas, kode di bawah ini melakukan hal yang sama
f = foo()
foo.bar(f)
Menariknya nama variabel 'mandiri' adalah konvensi. Di bawah definisi akan bekerja persis sama.. Setelah mengatakan bahwa itu adalah sangat kuat konvensi yang harus diikuti selalu, tapi itu tidak mengatakan sesuatu tentang sifat fleksibel dari bahasa
class foo:
def bar(s):
print "hi"
Hanya demo untuk pertanyaan.
class MyClass:
def __init__(self):
print('__init__ is the constructor for a class')
def __del__(self):
print('__del__ is the destructor for a class')
def __enter__(self):
print('__enter__ is for context manager')
return self
def __exit__(self, exc_type, exc_value, traceback):
print('__exit__ is for context manager')
def greeting(self):
print('hello python')
if __name__ == '__main__':
with MyClass() as mycls:
mycls.greeting()
$ python3 class.objects_instantiation.py
__init__ is the constructor for a class
__enter__ is for context manager
hello python
__exit__ is for context manager
__del__ is the destructor for a class
Dalam kode ini:
class Cat:
def __init__(self, name):
self.name = name
def info(self):
print 'I am a cat and I am called', self.name
Di sini __init__
bertindak sebagai konstruktor untuk kelas dan ketika sebuah objek dibuat, fungsi ini disebut. diri
merupakan instantiate obyek.
c = Cat('Kitty')
c.info()
Hasil dari pernyataan-pernyataan di atas akan menjadi seperti berikut:
I am a cat and I am called Kitty
Apa mandiri lakukan? Apa itu berarti untuk menjadi? Itu wajib?
Argumen pertama dari setiap metode kelas, termasuk init, selalu referensi untuk contoh saat ini dari kelas. Dengan konvensi, argumen ini selalu bernama diri
. Di init metode, diri
mengacu pada objek yang baru dibuat; di lain metode kelas, hal ini mengacu pada contoh dan metode ini disebut.
Python doesn't memaksa anda untuk menggunakan "mandiri". Anda dapat memberikan nama apa pun yang anda inginkan. Tapi ingat argumen pertama dalam definisi metode adalah referensi ke objek. Python menambahkan diri
argumen untuk daftar untuk anda; anda tidak perlu seperti itu ketika anda memanggil metode.
jika anda didn't memberikan diri di init metode maka anda akan mendapatkan error
TypeError: __init___() takes no arguments (1 given)
Apa init metode apa? Mengapa perlu? (dll.)
init
pendek untuk inisialisasi. Ini adalah konstruktor yang dipanggil ketika anda membuat sebuah instance dari kelas dan hal ini tidak perlu. Tapi biasanya itu kita berlatih untuk menulis init metode untuk pengaturan default state dari objek. Jika anda tidak bersedia untuk mengatur keadaan objek awalnya maka anda don't perlu menulis metode ini.
# Source: Class and Instance Variables
# https://docs.python.org/2/tutorial/classes.html#class-and-instance-variables
class MyClass(object):
# class variable
my_CLS_var = 10
# sets "init'ial" state to objects/instances, use self argument
def __init__(self):
# self usage => instance variable (per object)
self.my_OBJ_var = 15
# also possible, class name is used => init class variable
MyClass.my_CLS_var = 20
def run_example_func():
# PRINTS 10 (class variable)
print MyClass.my_CLS_var
# executes __init__ for obj1 instance
# NOTE: __init__ changes class variable above
obj1 = MyClass()
# PRINTS 15 (instance variable)
print obj1.my_OBJ_var
# PRINTS 20 (class variable, changed value)
print MyClass.my_CLS_var
run_example_func()
Python
__init__
dandiri
apa yang mereka lakukan?Apa yang dimaksud dengan
diri
lakukan? Apa itu dimaksudkan untuk menjadi? Apakah itu wajib?Apa yang
__init__
metode apa? Mengapa perlu? (dll.)
Contoh yang diberikan adalah tidak benar, jadi mari saya membuat ini benar-benar contoh yang didasarkan pada:
class SomeObject(object):
def __init__(self, blah):
self.blah = blah
def method(self):
return self.blah
Ketika kita membuat sebuah instance dari objek, __init__
dipanggil untuk menyesuaikan objek setelah telah dibuat. Artinya, ketika kita sebut SomeObject
dengan 'bla'
di bawah ini (bisa apa saja), itu akan diteruskan ke __init__
fungsi sebagai argumen, blah
:
an_object = SomeObject('blah')
Diri
argumen adalah contoh dari SomeObject
yang akan ditugaskan untuk an_object
.
Kemudian, kita mungkin ingin memanggil metode pada objek ini:
an_object.method()
Lakukan putus-putus lookup, yaitu, an_object.metode
, mengikat contoh untuk contoh fungsi, dan metode (seperti yang disebut di atas) sekarang "pasti" metode - yang berarti kita tidak perlu secara eksplisit lulus misalnya untuk metode panggilan.
Metode panggilan menjadi contoh karena itu terikat pada putus-putus lookup, dan ketika dipanggil, kemudian mengeksekusi kode apapun itu diprogram untuk melakukan.
Secara implisit berlalu diri
argumen yang disebut diri
dengan konvensi. Kita bisa menggunakan hukum lainnya Python nama, tetapi anda mungkin akan mendapatkan beraspal dan berbulu lainnya Python programmer jika anda mengubahnya ke sesuatu yang lain.
__init__
adalah sebuah metode khusus, didokumentasikan dalam Python datamodel dokumentasi. Hal ini disebut segera setelah instance dibuat (biasanya melalui __baru__
- meskipun __baru__
tidak diperlukan kecuali jika anda subclassing berubah datatype).
Di sini, pria yang telah menulis cukup baik dan sederhana: https://www.jeffknupp.com/blog/2014/06/18/improve-your-python-python-classes-and-object-oriented-programming/
Baca link di atas sebagai referensi untuk ini:
diri
? Jadi apa yang's dengan self parameter untuk semua Pelanggan metode? Apa itu? Mengapa, itu's contoh, tentu saja! Masukan lain cara, metode seperti menarik mendefinisikan instruksi untuk penarikan uang dari beberapa abstrak pelanggan's akun. Panggilan jeff.menarik(100.0) menempatkan instruksi tersebut untuk digunakan pada jeff contoh.Jadi ketika kita mengatakan def menarik diri(self, jumlah):, we're mengatakan, "di sini's cara anda menarik uang dari Pelanggan obyek (yang kita'll call mandiri) dan dollar sosok (yang kita'll call jumlah). diri adalah contoh dari Pelanggan yang menarik dipanggil pada. Yang's tidak membuat saya analogi, baik. jeff.menarik(100.0) adalah singkatan untuk Pelanggan.menarik(jeff, 100.0), yang benar-benar valid (jika tidak sering dilihat) kode.
init self mungkin masuk akal untuk metode lain, tetapi apa yang tentang init? Ketika kita menyebut init, kami're dalam proses dari menciptakan sebuah objek, jadi bagaimana bisa ada sudah menjadi mandiri? Python memungkinkan kami untuk memperluas self pola untuk objek yang dibangun juga, meskipun itu doesn't-benar fit. Bayangkan saja bahwa jeff = Pelanggan('Jeff Knupp', 1000.0) adalah sama seperti memanggil jeff = Pelanggan(jeff, 'Jeff Knupp', 1000.0); jeff yang's berlalu dalam juga dibuat hasilnya.
Ini adalah mengapa ketika kita menyebut init, kita menginisialisasi objek dengan mengatakan hal-hal seperti diri.nama = nama. Ingat, karena diri adalah contoh, ini setara dengan mengatakan jeff.nama = nama, yang adalah sama seperti jeff.name = 'Jeff Knupp. Demikian pula, diri.balance = saldo adalah sama sebagai jeff.balance = 1000.0. Setelah dua baris, kita mempertimbangkan Pelanggan obyek "diinisialisasi" dan siap untuk digunakan.
hati-hati apa yang anda
__init__
Setelah init telah selesai, pemanggil benar dapat mengasumsikan bahwa objek siap untuk digunakan. Artinya, setelah jeff = Pelanggan('Jeff Knupp', 1000.0), kita dapat mulai membuat deposit dan withdraw panggilan pada jeff; jeff adalah sepenuhnya diinisialisasi objek.