Cara meneruskan daftar ke kelas dengan python

Tidak seperti C++, kelas dalam Python adalah objek dengan haknya sendiri, bahkan tanpa instance. Mereka hanyalah ruang nama mandiri. Oleh karena itu, selama kita memiliki referensi ke suatu kelas, kita dapat mengatur atau mengubah atributnya kapan pun kita mau

Pernyataan berikut membuat kelas tanpa atribut yang terpasang, dan faktanya, itu adalah objek namespace kosong

class Student: 
    pass

Nama kelas ini adalah Siswa, dan tidak mewarisi dari kelas lain mana pun. Nama kelas biasanya dikapitalisasi, tetapi ini hanya konvensi, bukan persyaratan. Segala sesuatu di kelas diindentasi, seperti kode di dalam fungsi, pernyataan if, for loop, atau blok kode lainnya. Baris pertama yang tidak menjorok berada di luar kelas

Dalam kode, pass adalah pernyataan tanpa operasi. Kelas Siswa ini tidak mendefinisikan metode atau atribut apa pun, tetapi secara sintaksis, perlu ada sesuatu dalam definisi tersebut, sehingga pernyataan lulus. Ini adalah kata khusus Python yang berarti terus berjalan, tidak ada yang bisa dilihat di sini. Itu adalah pernyataan yang tidak melakukan apa-apa, dan itu adalah tempat penampung yang baik saat kita mematikan fungsi atau kelas. Pernyataan pass di Python seperti sekumpulan kurung kurawal kosong {} di Java atau C

>>> Student.name = "Jack"
>>> Student.id = 20001

>>> print(Student.name)
Jack

Perhatikan bahwa ini berfungsi meskipun belum ada instance kelas

Banyak kelas yang diwariskan dari kelas lain, tetapi yang ada di contoh tidak. Banyak kelas mendefinisikan metode, tetapi yang ini tidak. Tidak ada yang mutlak harus dimiliki oleh kelas Python, selain nama. Secara khusus, pemrogram C++ mungkin merasa aneh bahwa kelas Python tidak memiliki konstruktor dan destruktor yang eksplisit. Meskipun tidak wajib, kelas Python dapat memiliki sesuatu yang mirip dengan konstruktor. metode __init__()

Di Python, objek dibuat dalam dua langkah

1. Membuat objek
   __baru()__
2. Inisialisasi objek
   __init()__

Namun, sangat jarang untuk benar-benar perlu mengimplementasikan __new()__ karena Python membangun objek kita untuk kita. Jadi, di sebagian besar kasus, kami biasanya hanya mengimplementasikan metode khusus, __init()__

Mari buat kelas yang menyimpan string dan angka

class Student(object):
        '''Classes can (and should) have docstrings too, just like modules and functions'''
	def __init__(self, name, id = 20001):
		self.name = name
		self.id = id

Ketika def muncul di dalam kelas, biasanya dikenal sebagai metode. Secara otomatis menerima argumen khusus pertama, self, yang memberikan pegangan kembali ke instance yang akan diproses. Metode dengan dua garis bawah di awal dan akhir nama adalah metode khusus

Metode __init__() dipanggil segera setelah instance kelas dibuat. Akan menggoda untuk menyebut ini sebagai konstruktor kelas. Ini sangat menggoda, karena terlihat seperti konstruktor C++, dan dengan konvensi, metode __init__() adalah metode pertama yang ditentukan untuk kelas. Tampaknya bertindak seperti konstruktor karena ini adalah bagian pertama dari kode yang dieksekusi dalam instance kelas yang baru dibuat. Namun, ini tidak seperti konstruktor, karena objek telah dibangun pada saat metode __init()__ dipanggil, dan kita sudah memiliki referensi yang valid ke instance baru dari kelas tersebut

Parameter pertama dari metode __init()__, self, setara dengan C++ ini. Meskipun kita tidak harus meneruskannya karena Python akan melakukannya untuk kita, kita harus menempatkan diri sebagai parameter pertama dari metode nonstatis. Tapi self selalu eksplisit dalam Python untuk membuat akses atribut lebih jelas

Diri selalu merujuk ke instance kelas saat ini. Meskipun argumen ini mengisi peran kata yang dicadangkan this di c++ atau Java, tetapi self bukan kata yang dicadangkan di Python, hanya konvensi penamaan. Meskipun demikian, tolong jangan menyebutnya apa pun kecuali diri;

Ketika sebuah metode menugaskan ke atribut diri, itu membuat atribut dalam suatu contoh karena diri mengacu pada contoh yang sedang diproses

Untuk membuat instance kelas, cukup panggil kelas tersebut seolah-olah itu adalah fungsi, meneruskan argumen yang diperlukan oleh metode __init__(). Nilai yang dikembalikan akan menjadi objek yang baru dibuat. Di Python, tidak ada operator baru yang eksplisit seperti yang ada di c++ atau Java. Jadi, kami cukup memanggil kelas seolah-olah itu adalah fungsi untuk membuat instance baru dari kelas tersebut

s = Student(args)

Kami membuat instance dari kelas Student dan menugaskan instance yang baru dibuat ke variabel s. Kami melewati satu parameter, args, yang akan berakhir sebagai argumen dalam metode __init__() Student

s sekarang merupakan instance dari kelas Student. Setiap instance kelas memiliki atribut bawaan, __class__, yang merupakan kelas objek. Pemrogram Java mungkin akrab dengan kelas Kelas, yang berisi metode seperti getName() dan getSuperclass() untuk mendapatkan informasi metadata tentang suatu objek. Di Python, metadata semacam ini tersedia melalui atribut, tetapi idenya sama

Kita dapat mengakses docstring instance seperti halnya dengan fungsi atau modul. Semua instance kelas berbagi dokumen yang sama

Kita dapat menggunakan kelas Student yang didefinisikan di atas sebagai berikut

studentA = Student("Jack")
studentB = Student("Judy", 10005)

Tidak seperti C++, atribut objek Python bersifat publik, kita dapat mengaksesnya menggunakan titik (. ) operator

>>>studentA.name
'Jack'
>>>studentB.id
10005

Kami juga dapat menetapkan nilai baru ke atribut

>>> studentB.id = 80001
>>> studentB.id
80001

Bagaimana dengan penghancuran objek?
Python memiliki pengumpulan sampah otomatis. Sebenarnya, ketika sebuah objek akan dikumpulkan dari sampah, metode __del()__-nya dipanggil, dengan self sebagai satu-satunya argumennya. Tapi kami jarang menggunakan metode ini

Mari kita lihat contoh lain

class Student:
        def __init__(self, id):
                self.id = id
	def setData(self, value):
		self.data = value
	def display(self):
		print(self.data)

Apa itu diri. Indo?
Ini adalah variabel instan. Itu benar-benar terpisah dari id, yang diteruskan ke metode __init__() sebagai argumen. diri sendiri. id bersifat global untuk instance. Itu berarti kita dapat mengaksesnya dari metode lain. Variabel instan khusus untuk satu instance kelas. Misalnya, jika kita membuat dua instance Student dengan nilai id yang berbeda, masing-masing akan mengingat nilainya sendiri

Lalu, mari kita buat dua contoh

>>> s1 = Student()
>>> s2 = Student()

Di sini, kami membuat objek instance. Objek-objek ini hanyalah ruang nama yang memiliki akses ke atribut kelasnya. Kedua instance memiliki tautan kembali ke kelas tempat mereka dibuat. Jika kita menggunakan instance dengan nama atribut objek kelas, Python mengambil nama dari kelas

>>> Student.name = "Jack"
>>> Student.id = 20001

Perhatikan bahwa baik s1 maupun s2 tidak memiliki atribut setData() sendiri. Jadi, Python mengikuti tautan dari instance ke kelas untuk menemukan atributnya

Dalam fungsi setData() di dalam Student, nilai yang diteruskan ditetapkan ke self. data. Dalam suatu metode, self secara otomatis mengacu pada instance yang sedang diproses (s1 atau s2). Jadi, penugasan menyimpan nilai dalam ruang nama instance, bukan kelas

Saat kita memanggil metode display() kelas untuk mencetak sendiri. data, kita melihat diri. data berbeda di setiap contoh. Tapi nama display() sendiri sama di s1 dan s2

>>> Student.name = "Jack"
>>> Student.id = 20001

Perhatikan bahwa kami menyimpan tipe objek yang berbeda di anggota data di setiap instance. Di Python, tidak ada deklarasi untuk atribut instance (anggota). Mereka muncul ketika mereka diberi nilai. Atribut bernama data bahkan tidak ada di memori sampai ditugaskan dalam metode setData()

>>> Student.name = "Jack"
>>> Student.id = 20001

Kemudian, kami membuat objek instance

>>> Student.name = "Jack"
>>> Student.id = 20001

Objek instan hanyalah ruang nama yang memiliki akses ke atribut kelasnya. Sebenarnya, pada titik ini, kita memiliki tiga objek. sebuah kelas dan dua instance. Perhatikan bahwa baik a maupun a2 tidak memiliki atribut setData sendiri. Namun, nilai yang diteruskan ke setData ditetapkan ke diri sendiri. data. Dalam suatu metode, self secara otomatis mengacu pada instance yang sedang diproses (a atau a2). Jadi, tugas menyimpan nilai di ruang nama instance, bukan di kelas. Metode harus melalui argumen self untuk mendapatkan instance yang akan diproses. Kita bisa melihatnya dari keluaran

>>> Student.name = "Jack"
>>> Student.id = 20001

Seperti yang kami harapkan, kami menyimpan nilai untuk setiap objek instance meskipun kami menggunakan metode yang sama, display. Diri membuat semua perbedaan. Ini mengacu pada contoh

Superclass tercantum dalam tanda kurung di header kelas seperti yang kita lihat contoh di bawah ini

>>> Student.name = "Jack"
>>> Student.id = 20001

MyClassB mengubah tampilan superclass-nya, dan menggantikan atribut display sambil tetap mewarisi metode setData di MyClassA seperti yang kita lihat di bawah

>>> Student.name = "Jack"
>>> Student.id = 20001

Namun untuk instance MyClassA masih menggunakan tampilan yang telah didefinisikan sebelumnya di MyClassA

>>> Student.name = "Jack"
>>> Student.id = 20001

Overloading operator memungkinkan penyadapan objek dan menanggapi operasi. Itu membuat antarmuka objek lebih konsisten dan juga memungkinkan objek kelas bertindak seperti built-in

>>> Student.name = "Jack"
>>> Student.id = 20001

MyClassC adalah MyClassB, dan instance-nya mewarisi metode display() dari MyClassB

>>> Student.name = "Jack"
>>> Student.id = 20001

Saat MyClassC dibuat, argumen '123' diteruskan. Ini diteruskan ke argumen d dalam konstruktor __init__ dan ditugaskan ke self. data. Sebenarnya, MyClassC mengatur untuk mengatur atribut data secara otomatis pada waktu konstruksi. Itu tidak memerlukan panggilan setdata() dari instance di lain waktu

Untuk +, Python meneruskan objek instance di sebelah kiri argumen self di __add__ dan nilai di sebelah kanan ke d2. Untuk print(), Python meneruskan objek yang sedang dicetak ke self di __str__. Beberapa string apa pun yang dikembalikan metode ini dianggap sebagai string cetak untuk objek. Dengan mengimplementasikan __str__, kita dapat menggunakan print untuk menampilkan objek kelas ini, dan kita tidak perlu memanggil metode display()

__add__ membuat dan mengembalikan objek instance baru dengan memanggil MyClassC. Namun, mul mengubah objek instan saat ini di tempat dengan menugaskan kembali atribut diri

Berikut adalah contoh kelas Persegi Panjang dengan fungsi anggota yang mengembalikan luasnya

>>> print(Student.name)
Jack

Perhatikan bahwa versi ini menggunakan akses atribut langsung untuk lebar dan tinggi

Kita bisa menggunakan metode penyetel dan pengambil implementasi berikut

>>> print(Student.name)
Jack

Atribut objek adalah tempat kami menyimpan informasi kami, dan sebagian besar sintaks berikut sudah cukup

>>> print(Student.name)
Jack

Namun, ada kasus ketika lebih banyak fleksibilitas diperlukan. Misalnya, untuk memvalidasi metode penyetel dan pengambil, kita mungkin perlu mengubah seluruh kode seperti ini

>>> print(Student.name)
Jack

Solusi untuk masalah fleksibilitas adalah memungkinkan kita menjalankan kode secara otomatis pada akses atribut, jika diperlukan. Properti memungkinkan kita untuk merutekan akses atribut tertentu (operasi get and set atribut) ke fungsi atau metode yang kita sediakan, memungkinkan kita memasukkan kode untuk dijalankan secara otomatis. Properti dibuat dengan menugaskan hasil fungsi bawaan ke atribut kelas

>>> print(Student.name)
Jack

Kami lulus
1. fget. fungsi untuk mencegat pengambilan atribut
2. fset. fungsi untuk penugasan
3. fdel. fungsi untuk menghapus atribut
4. dokter. menerima string dokumentasi untuk atribut tersebut

Jika kita kembali ke kode sebelumnya, dan menambahkan property(), maka kodenya akan terlihat seperti ini

>>> print(Student.name)
Jack

Kita dapat menggunakan kelas seperti di bawah ini

>>> print(Student.name)
Jack

Contoh di atas hanya menelusuri akses atribut. Namun, properti biasanya menghitung nilai atribut secara dinamis saat diambil, seperti yang diilustrasikan oleh contoh berikut

>>> print(Student.name)
Jack

Kelas mendefinisikan atribut V yang diakses seolah-olah itu adalah data statis. Namun, itu benar-benar menjalankan kode untuk menghitung nilainya saat diambil. Saat kode dijalankan, nilai disimpan dalam instance sebagai informasi keadaan, tetapi setiap kali kami mengambilnya melalui atribut terkelola, nilainya secara otomatis dikuadratkan

>>> print(Student.name)
Jack

Sekali lagi, perhatikan bahwa pengambilan menghitung kuadrat dari data instance

Kelebihan beban operator. 2. 6 __cmp__() (Dihapus di 3. 0)

By implementing __cmp__() method, all of the comparison operators(<, ==, !=, >, etc.) will work.

Jadi, mari tambahkan yang berikut ke kelas Rectangle kita

>>> print(Student.name)
Jack

Perhatikan bahwa kami menggunakan fungsi cmp() bawaan untuk mengimplementasikan __cmp__. Fungsi cmp() mengembalikan -1 jika argumen pertama lebih kecil dari yang kedua, 0 jika sama, dan 1 jika argumen pertama lebih besar dari yang kedua

Untuk Python3. 0, kami mendapatkan TypeError. jenis yang tidak dapat diurutkan. Jadi, kita perlu menggunakan metode khusus karena fungsi bawaan __cmp__() dan cmp() dihapus di Python 3. 0

Kelebihan beban operator. __str__

__str__ adalah operator overloading ke-2 yang paling umum digunakan di Python setelah __init__. __str__ dijalankan secara otomatis setiap kali sebuah instance diubah menjadi string cetaknya

Mari kita gunakan contoh sebelumnya

class Student(object):
        '''Classes can (and should) have docstrings too, just like modules and functions'''
	def __init__(self, name, id = 20001):
		self.name = name
		self.id = id

Jika kita mencetak instance, itu akan menampilkan objek secara keseluruhan seperti yang ditunjukkan di bawah ini

class Student(object):
        '''Classes can (and should) have docstrings too, just like modules and functions'''
	def __init__(self, name, id = 20001):
		self.name = name
		self.id = id

Ini menampilkan nama kelas objek, dan alamatnya di memori yang pada dasarnya tidak berguna kecuali sebagai pengidentifikasi unik

Jadi, mari tambahkan metode __str__

class Student(object):
        '''Classes can (and should) have docstrings too, just like modules and functions'''
	def __init__(self, name, id = 20001):
		self.name = name
		self.id = id

Kode di atas memperluas kelas kita untuk memberikan tampilan khusus yang mencantumkan atribut saat instance kelas kita ditampilkan secara keseluruhan, alih-alih mengandalkan tampilan yang kurang berguna. Perhatikan bahwa kami sedang melakukan pemformatan % string untuk membuat string tampilan di __str__

Perbedaan antara __str__ dan __repr__ tidak begitu jelas

Saat kita menggunakan print, Python akan mencari metode __str__ di kelas kita. Jika menemukan satu, itu akan memanggilnya. Jika tidak, ia akan mencari metode __repr__ dan memanggilnya. Jika tidak dapat menemukannya, itu akan membuat representasi internal dari objek kita

class Student(object):
        '''Classes can (and should) have docstrings too, just like modules and functions'''
	def __init__(self, name, id = 20001):
		self.name = name
		self.id = id

Tidak banyak informasi dari print(x) dan hanya mengulang objek x. Itu sebabnya kami menyesuaikan kelas dengan menggunakan __str__

class Student(object):
        '''Classes can (and should) have docstrings too, just like modules and functions'''
	def __init__(self, name, id = 20001):
		self.name = name
		self.id = id

Tapi tidak saat kita menggunakan print(myObjecs). Perhatikan bahwa instance ada dalam daftar

class Student(object):
        '''Classes can (and should) have docstrings too, just like modules and functions'''
	def __init__(self, name, id = 20001):
		self.name = name
		self.id = id

class Student(object):
        '''Classes can (and should) have docstrings too, just like modules and functions'''
	def __init__(self, name, id = 20001):
		self.name = name
		self.id = id

Dalam bukunya, Learning Python, Mark Lutz merangkumnya sebagai berikut
__repr__, memberikan tampilan tingkat rendah as-code dari suatu objek saat ada. Terkadang kelas menyediakan __str__ untuk tampilan yang mudah digunakan dan __repr__ dengan detail tambahan untuk dilihat oleh pengembang. Karena pencetakan berjalan __str__ dan prompt interaktif menggemakan hasil dengan __repr__, ini dapat memberikan tampilan yang sesuai kepada audiens target

sys. argv adalah daftar argumen yang diteruskan ke program Python
Argumen pertama, sys. argv[0], sebenarnya adalah nama program. Itu ada agar kami dapat mengubah perilaku program kami tergantung pada bagaimana itu dipanggil. Sebagai contoh

1. sys. argv[0] bergantung pada sistem operasi apakah ini nama path lengkap atau tidak
2. Jika perintah dijalankan menggunakan opsi baris perintah -c ke juru bahasa, sys. argv[0] diatur ke string '-c'
3. Jika tidak ada nama skrip yang diteruskan ke juru bahasa Python, sys. argv[0] adalah string kosong

class Student(object):
        '''Classes can (and should) have docstrings too, just like modules and functions'''
	def __init__(self, name, id = 20001):
		self.name = name
		self.id = id

Jika kita menjalankannya dengan atau tanpa argumen apapun, kita mendapatkan output di bawah ini

class Student(object):
        '''Classes can (and should) have docstrings too, just like modules and functions'''
	def __init__(self, name, id = 20001):
		self.name = name
		self.id = id

getopt. getopt(args, opsi[, opsi_panjang])

Getopt. getopt() mem-parsing opsi baris perintah dan daftar parameter. args adalah daftar argumen yang akan diuraikan, tanpa referensi utama ke program yang sedang berjalan. Biasanya, ini berarti sys. argv[1. ]. pilihan adalah serangkaian huruf opsi yang ingin dikenali oleh skrip, dengan opsi yang memerlukan argumen diikuti dengan tanda titik dua (. )

long_options, jika ditentukan, harus berupa daftar string dengan nama opsi panjang yang harus didukung. Karakter terkemuka -- tidak boleh disertakan dalam nama opsi. Opsi panjang yang membutuhkan argumen harus diikuti dengan tanda sama dengan (=). Argumen opsional tidak didukung. Untuk hanya menerima opsi panjang, opsi harus berupa string kosong. Opsi panjang pada baris perintah dapat dikenali asalkan mereka memberikan awalan dari nama opsi yang sama persis dengan salah satu opsi yang diterima
Misalnya, jika long_options adalah ['foo', 'frob'], opsi --fo akan cocok dengan --foo, tetapi --f tidak akan cocok secara unik, sehingga GetoptError akan dimunculkan

Nilai pengembalian terdiri dari dua elemen

1. yang pertama adalah daftar pasangan (opsi, nilai).
2. yang kedua adalah daftar argumen program yang tersisa setelah daftar opsi dihapus (ini adalah potongan argumen yang tertinggal)

class Student(object):
        '''Classes can (and should) have docstrings too, just like modules and functions'''
	def __init__(self, name, id = 20001):
		self.name = name
		self.id = id

Jika kami menjalankan dengan dua opsi panjang file

s = Student(args)

Dengan opsi singkat

s = Student(args)

Perhatikan bahwa opsi panjang tidak harus sepenuhnya cocok

s = Student(args)

Python menjalankan metode __call__ ketika sebuah instance dipanggil sebagai bentuk fungsi. Ini lebih berguna ketika kita melakukan beberapa pekerjaan interfacing dengan API yang mengharapkan fungsi. Selain itu, kita juga dapat menyimpan informasi status seperti yang kita lihat pada contoh selanjutnya di bagian ini

Ini diyakini sebagai metode overloading operator ketiga yang paling umum digunakan, di belakang __init__ dan __str__ dan __repr__ menurut Mark Lutz (Learning Python)

Berikut adalah contoh dengan metode __call__ di kelas. Metode __call__ cukup mencetak argumen yang diperlukan melalui kata kunci args

s = Student(args)

Sebagai contoh lain dengan argumen yang sedikit lebih beragam

s = Student(args)

Sementara metode __call__ memungkinkan kita untuk menggunakan instance kelas untuk meniru fungsi seperti yang kita lihat pada contoh di atas, ada penggunaan lain dari metode __call__. kita dapat mempertahankan info negara

Bisakah Anda meneruskan daftar ke kelas?

Bisakah Anda meletakkan daftar di kelas dengan Python?

Bisakah Anda melewati daftar dengan Python?

Bagaimana Anda membuat daftar di dalam kelas dengan Python?