CATATAN : Karena Python adalah bahasa pemrograman multi-paradigma, Anda dapat memilih paradigma yang paling sesuai dengan masalah yang ada, menggabungkan paradigma yang berbeda dalam satu program, dan / atau beralih dari satu paradigma ke paradigma lain saat program Anda berkembang.
class dengan Python
Berfokus pertama pada data, masing-masing benda atau benda merupakan turunan dari beberapa class. Struktur data primitif yang tersedia dengan Python, seperti angka, string, dan daftar dirancang untuk mewakili hal-hal sederhana seperti biaya sesuatu, nama sebuah puisi, dan warna favorit Anda masing-masing.
Bagaimana jika Anda ingin mewakili sesuatu yang jauh lebih rumit?
Misalnya, Anda ingin melacak sejumlah hewan yang berbeda. Jika Anda menggunakan daftar, elemen pertama bisa menjadi nama hewan sementara unsur kedua bisa mewakili umurnya.
Bagaimana Anda tahu elemen mana yang seharusnya? Bagaimana jika Anda memiliki 100 hewan yang berbeda? Apakah Anda yakin setiap hewan memiliki nama dan usia, dan sebagainya? Bagaimana jika Anda ingin menambahkan properti lainnya ke hewan-hewan ini? Ini tidak memiliki organisasi, dan ini adalah kebutuhan class yang pasti .class digunakan untuk membuat struktur data pengguna baru yang berisi informasi sewenang-wenang tentang sesuatu. Dalam kasus binatang, kita bisa membuat
sebuah Animal()class untuk melacak properti tentang Hewan seperti nama dan usia.
Penting untuk dicatat bahwa sebuah class hanya menyediakan struktur-ini adalah cetak biru untuk bagaimana sesuatu harus didefinisikan, namun sebenarnya tidak menyediakan konten nyata itu sendiri. class Animal() dapat menentukan bahwa nama dan usia yang diperlukan untuk mendefinisikan hewan, tetapi tidak akan benar-benar menyatakan apa
nama hewan tertentu atau usia. Ini mungkin membantu memikirkan class sebagai ide untuk bagaimana sesuatu harus didefinisikan.
Objek Python (Contoh)
Sementara class adalah cetak biru, sebuah contoh adalah salinan class dengan nilai sebenarnya , secara harfiah merupakan objek milik class tertentu. Ini bukan ide lagi; Ini adalah hewan yang sebenarnya, seperti seekor Dog bernama Roger yang berusia delapan tahun.
Dengan kata lain, class seperti bentuk atau kuesioner. Ini mendefinisikan informasi yang dibutuhkan. Setelah Anda mengisi formulir, salinan spesifik Anda adalah turunan dari class; Ini berisi informasi aktual yang relevan dengan Anda.
Anda dapat mengisi banyak salinan untuk membuat banyak contoh yang berbeda, namun tanpa formulir sebagai panduan, Anda akan tersesat, tidak tahu informasi apa yang dibutuhkan. Jadi, sebelum Anda dapat membuat contoh objek individual, pertama-tama kita harus menentukan apa yang dibutuhkan dengan mendefinisikan class.
Cara Menentukan class dengan Python
Mendefinisikan sebuah class sederhana dengan Python:
class Dog:
pass
Anda memulai dengan
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
4kata kunci untuk menunjukkan bahwa Anda menciptakan sebuah class, maka Anda menambahkan nama class (menggunakan notasi CamelCase , dimulai dengan huruf kapital.)
Selain itu, kami menggunakan kata kunci Python di
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
5sini. Ini sangat sering digunakan sebagai tempat pemegang kode dimana akhirnya akan pergi. Hal ini memungkinkan kita untuk menjalankan kode ini tanpa membuang kesalahan.
Catatan: Kode di atas benar pada Python 3. Dengan Python 2.x (“legacy Python”), Anda akan menggunakan definisi class yang sedikit berbeda:
# Python 2.x class Definition:
class Dog(object):
pass
Bagian
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
6dalam tanda kurung menentukan class induk yang Anda warisi (lebih lanjut tentang ini di bawah ini.) Dengan Python 3, ini tidak lagi diperlukan karena ini adalah default implisit.Atribut Instance
Semua class membuat objek, dan semua objek mengandung karakteristik yang disebut atribut (disebut sebagai properti pada paragraf pembuka). Gunakan
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
7metode untuk menginisialisasi (misalnya, tentukan) atribut awal objek dengan memberi mereka nilai default (atau side state). Metode ini harus memiliki setidaknya satu argumen dan juga
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
8variabel, yang mengacu pada objek itu sendiri (misalnya, Dog).
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
Dalam kasus class
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
9, setiap Dog memiliki nama dan usia tertentu, yang jelas penting untuk diketahui saat Anda mulai benar-benar menciptakan Dog yang berbeda. Ingat: class hanya untuk mendefinisikan Dog, sebenarnya tidak menciptakan contoh Dog individu dengan nama dan usia tertentu; kita akan segera melakukannya.
Demikian pula,
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
8variabel juga merupakan instance dari class. Karena contoh class memiliki nilai yang berbeda, kita dapat menyatakannya
class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
1daripada
class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
2. Tapi karena tidak semua Dog memiliki nama yang sama, kita harus dapat menetapkan nilai yang berbeda untuk berbagai kejadian. Oleh karena itu kebutuhan akan
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
8variabel khusus , yang akan membantu untuk melacak masing-masing instance dari masing-masing class.
CATATAN : Anda tidak perlu memanggil __init__()metode ini; Ini akan dipanggil secara otomatis saat Anda membuat instance ‘Dog’ baru.
Atribut class
Sementara atribut instance spesifik untuk setiap objek, atribut class sama untuk semua contoh — yang dalam hal ini adalah semua Dog.
class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
Jadi sementara setiap Dog memiliki nama dan umur yang unik, setiap Dog akan menjadi mamalia.
Mari buat beberapa instance Dogs …
Instantiating Objek
Instansiasi adalah istilah bagus untuk menciptakan instance class baru yang unik.
Sebagai contoh:
>>> class Dog:
... pass
...
>>> Dog()
<__main__.Dog object at 0x1004ccc50>
>>> Dog()
<__main__.Dog object at 0x1004ccc90>
>>> a = Dog()
>>> b = Dog()
>>> a == b
False
Kami memulai dengan menentukan class
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
9 baru , lalu menciptakan dua Dog baru, masing-masing ditugaskan ke benda yang berbeda. Jadi, untuk membuat sebuah instance dari sebuah class, Anda menggunakan nama class, diikuti dengan tanda kurung. Kemudian untuk menunjukkan bahwa setiap instance sebenarnya berbeda, kita menginstruksikan dua Dog lagi, menugaskan masing-masing variabel, kemudian diuji jika variabel tersebut sama.
Menurut Anda jenis instance class apa?
>>> class Dog:
... pass
...
>>> a = Dog()
>>> type(a)
<class '__main__.Dog'>
Mari kita lihat contoh yang sedikit lebih rumit …
class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
# Instantiate the Dog object
philo = Dog("Philo", 5)
mikey = Dog("Mikey", 6)
# Access the instance attributes
print("{} is {} and {} is {}.".format(
philo.name, philo.age, mikey.name, mikey.age))
# Is Philo a mammal?
if philo.species == "mammal":
print("{0} is a {1}!".format(philo.name, philo.species))
CATATAN : Perhatikan bagaimana kita menggunakan notasi titik untuk mengakses atribut dari masing-masing objek.
Simpan ini sebagai Dog_class.py , lalu jalankan programnya. Anda harus melihat:
Philo is 5 and Mikey is 6.
Philo is a mammal!
Apa yang sedang terjadi?
Kami membuat instance baru dari class
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
9 dan menugaskannya ke variabel
class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
6. Kami kemudian melewatinya dua argumen,
class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
7dan
class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
8, yang mewakili nama dan umur Dog itu masing-masing.
Atribut ini diteruskan ke
class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
9metode, yang dipanggil kapan pun Anda membuat instance baru, melampirkan nama dan usia ke objek. Anda mungkin bertanya-tanya mengapa kita tidak harus menyampaikan
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
8argumennya.
Ini adalah sihir Python; Saat Anda membuat instance baru dari class, Python secara otomatis menentukan apa
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
8itu (Dog dalam kasus ini) dan meneruskannya ke
class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
9metode ini.
Tinjau Latihan (# 1)
Menggunakan class
>>> class Dog:
... pass
...
>>> Dog()
<__main__.Dog object at 0x1004ccc50>
>>> Dog()
<__main__.Dog object at 0x1004ccc90>
>>> a = Dog()
>>> b = Dog()
>>> a == b
False
3 yang sama , instantiate tiga Dog baru, masing-masing dengan usia yang berbeda. Kemudian tulis sebuah fungsi yang disebut,,
>>> class Dog:
... pass
...
>>> Dog()
<__main__.Dog object at 0x1004ccc50>
>>> Dog()
<__main__.Dog object at 0x1004ccc90>
>>> a = Dog()
>>> b = Dog()
>>> a == b
False
4yang membutuhkan sejumlah usia (
>>> class Dog:
... pass
...
>>> Dog()
<__main__.Dog object at 0x1004ccc50>
>>> Dog()
<__main__.Dog object at 0x1004ccc90>
>>> a = Dog()
>>> b = Dog()
>>> a == b
False
5) dan mengembalikan yang tertua. Kemudian keluaran usia Dog tertua seperti:
The oldest Dog is 7 years.
class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
# Instantiate the Dog object
jake = Dog("Jake", 7)
doug = Dog("Doug", 4)
william = Dog("William", 5)
# Determine the oldest Dog
def get_biggest_number(*args):
return max(args)
# Output
print("The oldest Dog is {} years old.".format(
get_biggest_number(jake.age, doug.age, william.age)))
Instance Methods
Metode Instance didefinisikan di dalam class dan digunakan untuk mendapatkan isi sebuah instance. Mereka juga bisa digunakan untuk melakukan operasi dengan atribut objek kita. Seperti
class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
9metodenya, argumen pertama selalu
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
8:
# Python 2.x class Definition:
class Dog(object):
pass
0
impan ini sebagai Dog_instance_methods.py , lalu jalankan:
# Python 2.x class Definition:
class Dog(object):
pass
1
Dalam metode yang terakhir
>>> class Dog:
... pass
...
>>> Dog()
<__main__.Dog object at 0x1004ccc50>
>>> Dog()
<__main__.Dog object at 0x1004ccc90>
>>> a = Dog()
>>> b = Dog()
>>> a == b
False
8, kita mendefinisikan perilaku. Perilaku lain apa yang bisa Anda berikan kepada seekor Dog? Lihatlah kembali paragraf awal untuk melihat beberapa contoh perilaku untuk benda lain.
Mengubah Atribut
Anda dapat mengubah nilai atribut berdasarkan beberapa perilaku:
# Python 2.x class Definition:
class Dog(object):
pass
2
Di sini, kami menambahkan metode untuk mengirim email, yang memperbarui
>>> class Dog:
... pass
...
>>> Dog()
<__main__.Dog object at 0x1004ccc50>
>>> Dog()
<__main__.Dog object at 0x1004ccc90>
>>> a = Dog()
>>> b = Dog()
>>> a == b
False
9variabel ke
>>> class Dog:
... pass
...
>>> a = Dog()
>>> type(a)
<class '__main__.Dog'>
0.Obyek Warisan Python
Warisan adalah proses dimana satu class mengambil atribut dan metode yang lain. class yang baru terbentuk disebut class anak , dan class class anak diturunkan dari class orang tua disebut .
Penting untuk dicatat bahwa class anak menimpa atau memperluas fungsionalitas (misalnya, atribut dan perilaku) class orang tua. Dengan kata lain, class anak mewarisi semua atribut dan perilaku orang tua namun juga dapat menentukan perilaku yang berbeda untuk diikuti. Jenis class yang paling dasar adalah class
>>> class Dog:
... pass
...
>>> a = Dog()
>>> type(a)
<class '__main__.Dog'>
1yang umumnya mewarisi class lainnya sebagai orang tua mereka.
Ketika Anda mendefinisikan class baru, Python 3 secara implisit digunakan
>>> class Dog:
... pass
...
>>> a = Dog()
>>> type(a)
<class '__main__.Dog'>
1sebagai class induk. Jadi, dua definisi berikut ini setara:
# Python 2.x class Definition:
class Dog(object):
pass
3
Catatan: Dengan Python 2.x ada perbedaan antara class gaya baru dan gaya lama . Saya tidak akan menjelaskan secara rinci di sini, tapi pada umumnya Anda ingin menentukan objectsebagai class induk untuk memastikan Anda mendefinisikan class gaya baru jika Anda menulis kode OOP Python 2.
Dog Park Example
Mari kita berpura-pura bahwa kita berada di taman Dog. Ada beberapa objek Dog yang terlibat dalam perilaku Dog, masing-masing dengan atribut yang berbeda. Secara reguler-berbicara itu berarti beberapa Dog sedang berlari, sementara ada yang meregangkan tubuh dan ada yang hanya menonton Dog lain. Selanjutnya, masing-masing Dog diberi nama oleh pemiliknya dan, karena setiap Dog hidup dan bernapas, setiap umurnya.
Apa cara lain untuk membedakan satu Dog dengan Dog lain? Bagaimana dengan jenis Dognya:
# Python 2.x class Definition:
class Dog(object):
pass
4
Setiap jenis Dog memiliki perilaku yang sedikit berbeda. Untuk memperhitungkannya, mari buat class terpisah untuk setiap jenisnya. Ini adalah class anak class orang tua
>>> class Dog:
... pass
...
>>> a = Dog()
>>> type(a)
<class '__main__.Dog'>
3.
Memperluas Fungsi Parent class
Buat file baru bernama Dog_inheritance.py :
# Python 2.x class Definition:
class Dog(object):
pass
5
Baca komentar dengan keras saat Anda mengerjakan program ini untuk membantu Anda memahami apa yang terjadi, lalu sebelum menjalankan program, lihat apakah Anda dapat memprediksi keluaran yang diharapkan.
Anda harus melihat:
# Python 2.x class Definition:
class Dog(object):
pass
6
Kami belum menambahkan atribut khusus atau metode untuk membedakannya
>>> class Dog:
... pass
...
>>> a = Dog()
>>> type(a)
<class '__main__.Dog'>
4dari huruf a
>>> class Dog:
... pass
...
>>> a = Dog()
>>> type(a)
<class '__main__.Dog'>
5, namun karena sekarang mereka adalah dua class yang berbeda, misalnya kami memberi mereka atribut class yang berbeda yang menentukan kecepatan masing-masing.
Parent vs. Child classe
The
>>> class Dog:
... pass
...
>>> a = Dog()
>>> type(a)
<class '__main__.Dog'>
6Fungsi ini digunakan untuk menentukan apakah sebuah contoh juga merupakan contoh dari class induk tertentu.
Simpan ini sebagai Dog_isinstance.py :
# Python 2.x class Definition:
class Dog(object):
pass
7
Output:
# Python 2.x class Definition:
class Dog(object):
pass
8
Masuk akal? Keduanya
>>> class Dog:
... pass
...
>>> a = Dog()
>>> type(a)
<class '__main__.Dog'>
7dan
>>> class Dog:
... pass
...
>>> a = Dog()
>>> type(a)
<class '__main__.Dog'>
8merupakan contoh
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
9class, sementara
class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
# Instantiate the Dog object
philo = Dog("Philo", 5)
mikey = Dog("Mikey", 6)
# Access the instance attributes
print("{} is {} and {} is {}.".format(
philo.name, philo.age, mikey.name, mikey.age))
# Is Philo a mammal?
if philo.species == "mammal":
print("{0} is a {1}!".format(philo.name, philo.species))
0bukan merupakan instance dari
class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
# Instantiate the Dog object
philo = Dog("Philo", 5)
mikey = Dog("Mikey", 6)
# Access the instance attributes
print("{} is {} and {} is {}.".format(
philo.name, philo.age, mikey.name, mikey.age))
# Is Philo a mammal?
if philo.species == "mammal":
print("{0} is a {1}!".format(philo.name, philo.species))
1class. Kemudian sebagai pemeriksaan kewarasan, kita diuji jika
>>> class Dog:
... pass
...
>>> a = Dog()
>>> type(a)
<class '__main__.Dog'>
8merupakan turunan dari
>>> class Dog:
... pass
...
>>> a = Dog()
>>> type(a)
<class '__main__.Dog'>
7, yang tidak mungkin karena
>>> class Dog:
... pass
...
>>> a = Dog()
>>> type(a)
<class '__main__.Dog'>
7merupakan
class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
# Instantiate the Dog object
philo = Dog("Philo", 5)
mikey = Dog("Mikey", 6)
# Access the instance attributes
print("{} is {} and {} is {}.".format(
philo.name, philo.age, mikey.name, mikey.age))
# Is Philo a mammal?
if philo.species == "mammal":
print("{0} is a {1}!".format(philo.name, philo.species))
5class daripada class itu sendiri - oleh karena itu alasan untuk
class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
# Instantiate the Dog object
philo = Dog("Philo", 5)
mikey = Dog("Mikey", 6)
# Access the instance attributes
print("{} is {} and {} is {}.".format(
philo.name, philo.age, mikey.name, mikey.age))
# Is Philo a mammal?
if philo.species == "mammal":
print("{0} is a {1}!".format(philo.name, philo.species))
6.
Mengesampingkan Fungsi class Parrent
Ingat bahwa class anak juga bisa menggantikan atribut dan perilaku dari class orang tua. Sebagai contoh:
# Python 2.x class Definition:
class Dog(object):
pass
9
class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
# Instantiate the Dog object
philo = Dog("Philo", 5)
mikey = Dog("Mikey", 6)
# Access the instance attributes
print("{} is {} and {} is {}.".format(
philo.name, philo.age, mikey.name, mikey.age))
# Is Philo a mammal?
if philo.species == "mammal":
print("{0} is a {1}!".format(philo.name, philo.species))
7class mewarisi
class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
# Instantiate the Dog object
philo = Dog("Philo", 5)
mikey = Dog("Mikey", 6)
# Access the instance attributes
print("{} is {} and {} is {}.".format(
philo.name, philo.age, mikey.name, mikey.age))
# Is Philo a mammal?
if philo.species == "mammal":
print("{0} is a {1}!".format(philo.name, philo.species))
8dari class induk, sedangkan
class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
# Instantiate the Dog object
philo = Dog("Philo", 5)
mikey = Dog("Mikey", 6)
# Access the instance attributes
print("{} is {} and {} is {}.".format(
philo.name, philo.age, mikey.name, mikey.age))
# Is Philo a mammal?
if philo.species == "mammal":
print("{0} is a {1}!".format(philo.name, philo.species))
9class menimpa
class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
# Instantiate the Dog object
philo = Dog("Philo", 5)
mikey = Dog("Mikey", 6)
# Access the instance attributes
print("{} is {} and {} is {}.".format(
philo.name, philo.age, mikey.name, mikey.age))
# Is Philo a mammal?
if philo.species == "mammal":
print("{0} is a {1}!".format(philo.name, philo.species))
8, pengaturan untuk
Philo is 5 and Mikey is 6.
Philo is a mammal!
1.
Tinjau Latihan (# 2)
Buat
Philo is 5 and Mikey is 6.
Philo is a mammal!
2class yang menyimpan contoh Dog; class ini benar-benar terpisah dari
>>> class Dog:
... pass
...
>>> Dog()
<__main__.Dog object at 0x1004ccc50>
>>> Dog()
<__main__.Dog object at 0x1004ccc90>
>>> a = Dog()
>>> b = Dog()
>>> a == b
False
3class. Dengan kata lain,
>>> class Dog:
... pass
...
>>> Dog()
<__main__.Dog object at 0x1004ccc50>
>>> Dog()
<__main__.Dog object at 0x1004ccc90>
>>> a = Dog()
>>> b = Dog()
>>> a == b
False
3class tidak mewarisi dari
Philo is 5 and Mikey is 6.
Philo is a mammal!
2class. Kemudian tetapkan tiga contoh Dog ke sebuah instance dari
Philo is 5 and Mikey is 6.
Philo is a mammal!
2class. Mulailah dengan kode berikut di bawah ini. Simpan file sebagai pets_class.py . Keluaran Anda akan terlihat seperti ini:
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
0
Starter code:
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
1
Dengan menggunakan file yang sama, tambahkan atribut instance
Philo is 5 and Mikey is 6.
Philo is a mammal!
7ke
>>> class Dog:
... pass
...
>>> Dog()
<__main__.Dog object at 0x1004ccc50>
>>> Dog()
<__main__.Dog object at 0x1004ccc90>
>>> a = Dog()
>>> b = Dog()
>>> a == b
False
3 class. Kemudian tambahkan sebuah metode yang disebut
Philo is 5 and Mikey is 6.
Philo is a mammal!
9perubahan nilai
The oldest Dog is 7 years.
0pada
The oldest Dog is 7 years.
1saat dipanggil. Cari tahu cara terbaik untuk memberi makan setiap Dog lalu pilih "Dog saya lapar." Jika semua lapar atau "Dog saya tidak lapar." Jika semua tidak lapar. Hasil akhir akan terlihat seperti ini:
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
2
Selanjutnya, tambahkan
The oldest Dog is 7 years.
2metode ke class
Philo is 5 and Mikey is 6.
Philo is a mammal!
2dan
>>> class Dog:
... pass
...
>>> Dog()
<__main__.Dog object at 0x1004ccc50>
>>> Dog()
<__main__.Dog object at 0x1004ccc90>
>>> a = Dog()
>>> b = Dog()
>>> a == b
False
3class sehingga saat Anda memanggil metode di
Philo is 5 and Mikey is 6.
Philo is a mammal!
2class, masing-masing contoh Dog ditugaskan ke class
Philo is 5 and Mikey is 6.
Philo is a mammal!
2
The oldest Dog is 7 years.
2. Simpan ini sebagai Dog_walking.py . Ini sedikit lebih sulit.
Mulailah dengan menerapkan metode dengan cara yang sama seperti
>>> class Dog:
... pass
...
>>> Dog()
<__main__.Dog object at 0x1004ccc50>
>>> Dog()
<__main__.Dog object at 0x1004ccc90>
>>> a = Dog()
>>> b = Dog()
>>> a == b
False
8metode. Sedangkan untuk metode di
Philo is 5 and Mikey is 6.
Philo is a mammal!
2class, Anda perlu melakukan iterasi melalui daftar Dog, lalu memanggil metode itu sendiri.
Outputnya akan terlihat seperti ini:
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
3
Jawab pertanyaan berikut tentang OOP untuk memeriksa kemajuan pembelajaran Anda:
- Apa itu class?
- Apa itu instance?
- Apa hubungan antara class dan instance?
- Apa sintaks Python yang digunakan untuk menentukan class baru?
- Apa konvensi ejaan untuk nama class?
- Bagaimana Anda memberi instantiate, atau membuat instance dari, sebuah class?
- Bagaimana Anda mengakses atribut dan perilaku instance class?
- Apa itu metode?
- Apa tujuannya
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
8? - Apa tujuan dari
class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
9metode ini? - Jelaskan bagaimana pewarisan membantu mencegah duplikasi kode.
- Dapatkah class child menimpa sifat parents?
Jawaban :
- class adalah mekanisme yang digunakan untuk membuat struktur data pengguna baru yang ditentukan. Ini berisi data serta metode yang digunakan untuk memproses data tersebut.
- Instance adalah salinan class dengan nilai sebenarnya , secara harfiah merupakan objek class tertentu.
- Sementara class adalah cetak biru yang digunakan untuk menggambarkan bagaimana membuat sesuatu, instance adalah objek yang dibuat dari cetak biru tersebut.
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
# Instantiate the Dog object
jake = Dog("Jake", 7)
doug = Dog("Doug", 4)
william = Dog("William", 5)
# Determine the oldest Dog
def get_biggest_number(*args):
return max(args)
# Output
print("The oldest Dog is {} years old.".format(
get_biggest_number(jake.age, doug.age, william.age)))
2- CamelCase notasi, dimulai dengan huruf kapital — yaitu,
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
# Instantiate the Dog object
jake = Dog("Jake", 7)
doug = Dog("Doug", 4)
william = Dog("William", 5)
# Determine the oldest Dog
def get_biggest_number(*args):
return max(args)
# Output
print("The oldest Dog is {} years old.".format(
get_biggest_number(jake.age, doug.age, william.age)))
3 - Anda menggunakan nama class, diikuti dengan tanda kurung. Jadi jika nama classnya
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
9, contoh Dognya adalah - # class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
# Instantiate the Dog object
jake = Dog("Jake", 7)
doug = Dog("Doug", 4)
william = Dog("William", 5)
# Determine the oldest Dog
def get_biggest_number(*args):
return max(args)
# Output
print("The oldest Dog is {} years old.".format(
get_biggest_number(jake.age, doug.age, william.age)))
5. - Dengan notasi titik — misalnya,
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
# Instantiate the Dog object
jake = Dog("Jake", 7)
doug = Dog("Doug", 4)
william = Dog("William", 5)
# Determine the oldest Dog
def get_biggest_number(*args):
return max(args)
# Output
print("The oldest Dog is {} years old.".format(
get_biggest_number(jake.age, doug.age, william.age)))
6 - Sebuah fungsi yang didefinisikan di dalam class.
- Argumen pertama dari setiap metode merujuk pada instance class saat ini, yang menurut konvensi, diberi nama
class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
8. Dalam class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
9metode ini, class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
8mengacu pada objek yang baru dibuat; sementara dalam metode lain, class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
8mengacu pada contoh yang metode namanya disebut. Untuk lebih lanjut tentang class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
9vs class Dog:
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
8, lihat artikel ini . class Dog:
# class Attribute
species = 'mammal'
# Initializer / Instance Attributes
def __init__(self, name, age):
self.name = name
self.age = age
9Metode menginisialisasi sebuah instance dari class.- class child mewarisi semua atribut dan perilaku parents.
- Iya betul.
Kesimpulan
Anda sekarang harus tahu class apa, mengapa Anda ingin atau perlu menggunakannya, dan bagaimana menciptakan class parents dan class child untuk menyusun program Anda dengan lebih baik.
Perlu diketahui bahwa OOP adalah paradigma pemrograman dan bukan konsep Python. Sebagian besar bahasa pemrograman modern seperti Java, C#, C ++ mengikuti prinsip OOP. Jadi, kabar baiknya adalah bahwa belajar dasar pemrograman berorientasi objek akan sangat berharga bagi Anda dalam berbagai situasi-entah Anda bekerja dengan Python atau tidak.
Apa itu OOP pada Python?
OOP merupakan sebuah cara untuk membangun sebuah aplikasi dengan memandang sebagai presentasi objek-objek yang saling mendukung serta berinteraksi dari satu objek ke objek yang lainnya, dan dapat dikatakan code program akan terbentuk berkelompok berdasarkan objek. Pemrograman Berorientasi Objek akan membagi-bagi code ...
Bagaimana OOP bekerja?
Object oriented programming atau OOP adalah konsep pemrograman yang berorientasi pada objek atau data untuk mengatur sebuah desain program. Secara garis besar, cara kerja OOP yaitu membangun program dari gabungan objek-objek yang saling berhubungan dan disusun menjadi satu kesatuan.
OOP menggunakan bahasa apa?
Contoh bahasa pemrograman berorientasi objek antara lain Java, PHP, Python, dan Ruby.
Apa Kegunaan OOP?
OOP adalah metode yang memudahkan kalian merubah implementasi suatu objek tanpa harus mengubah data dan metode di dalam objek tersebut. (Encapsulation). OOP memudahkan kalian dalam membentuk metode umum yang dapat di gunakan untuk objek-objek lainnya tanpa harus menulisnya berulang-ulang.
