Berorientasikan objek: Menggunakan konsep objek (entiti) untuk membina model dan mensimulasikan dunia objektif untuk menganalisis, mereka bentuk dan melaksanakan perisian. Pengaturcaraan Berorientasikan objek (pendek kata OOP) ialah kaedah reka bentuk dan pengaturcaraan yang menyelesaikan masalah penggunaan semula perisian Ia menerangkan logik operasi dan data aplikasi operasi yang serupa dalam sistem perisian dalam bentuk kelas dan objek contoh digunakan semula dalam sistem perisian untuk meningkatkan kecekapan pembangunan perisian.
Pengaturcaraan berorientasikan objek ialah konsep yang sangat penting dalam Python.
Tiga ciri utama berorientasikan objek:
Objek ialah teras pengaturcaraan berorientasikan objek, untuk digabungkan ciri dan tingkah laku biasa Satu set definisi abstrak objek, membentuk kelas
Kelas ialah sejenis benda, dan objek ialah pelaksanaan khusus bagi jenis perkara ini mempunyai sifat dan tingkah laku yang sama
Objek dengan sifat dan tingkah laku yang sama atau serupa boleh diabstraksikan ke dalam kelas
Untuk mencipta kelas, gunakan kata kunci kelas, tambah nama kelas, dan kemudian tambah kurungan, dengan objek dalam kurungan dipanggil kelas gaya baharu; ia juga boleh tanpa kurungan dan objek dalam kurungan dipanggil: kelas klasik.
# 新式类 class Meeting2(object): pass # 经典类 class Meeting2: pass
A = Meeting1() B
Parameter pertama kaedah kelas mestilah diri (mengikut konvensyen ia adalah diri, ia boleh juga nama lain), tidak perlu memasukkannya semasa memanggil. diri mewakili contoh kelas
Terdapat kelas bernama mesyuarat seperti berikut, di mana atribut seperti nama, umur, jantina, alamat dan serangan dimulakan, ditakrifkan Terdapat dua kaedah pengenalan dan diserang:
class Meeting(object):
"""meeting类的类描述"""
def __init__(self, name, age, sex, address, attack):
"""构造函数"""
self.name = name
self.age = int(age)
self.sex = sex
self.address = address
self.attack = int(attack)
def introduction(self):
print("姓名：{}".format(self.name))
print("年龄：{}".format(self.age))
print("性别：{}".format(self.sex))
print("地址：{}".format(self.address))
def attacked(self):
print(f"{self.name}正在向您发起攻击，攻击力为{self.attack}！")
def foreign_fun():
print("我是外部函数")Penggunaan:
hasattr (objek,nama)
Fungsi: Semak sama ada objek mengandungi atribut atau kaedah yang ditentukan
Nilai pulangan: mengembalikan benar jika wujud, palsu jika tidak wujud
# 实例化meeting类
Meeting = Meeting("张三", 20, "男", "南京", 108)
# 获取Meeting对象中是否存在name属性
print(hasattr(Meeting, "name"))# True
# 获取Meeting对象中是否存在mobile属性
print(hasattr(Meeting, "mobile"))# False
# 获取Meeting对象中是否存在attacked方法
print(hasattr(Meeting, "attacked"))# TruePenggunaan:
getattr(objek,nama[,default])
Fungsi : Dapatkan nilai atribut atribut yang ditentukan dalam objek
Nilai pulangan: Jika ia wujud, nilai atribut atribut dikembalikan jika ia tidak wujud, kandungan yang dinyatakan dikembalikan
# 实例化meeting类
Meeting = Meeting("张三", 20, "男", "南京", 108)
# 获取Meeting对象中name属性的属性值
print(getattr(Meeting, "name"))# 张三
# 获取Meeting对象中kills属性或方法的值，若不存在则返回指定内容
print(getattr(Meeting, "kills", "未找到kills方法或属性"))# 未找到kills方法或属性
# 获取Meeting对象中attacked方法，返回值为函数地址
print(getattr(Meeting, "attacked"))
# 使用getattr方法可以直接调用Meeting对象中的方法
f = getattr(Meeting, "attacked")
f()Hasil cetakan adalah seperti berikut:
用法：
setattr(object,name,value)
作用：为object对象的指定属性设置指定value
返回值：
# 实例化meeting类
Meeting = Meeting("张三", 20, "男", "南京", 108)
# 将对象中name属性的值改为“刘德华”
setattr(Meeting, "name", "刘德华")
# 获取对象中name的属性值
print(getattr(Meeting, "name"))# 刘德华
# 将对象外部的名为foreign_fun的方法引入对象内部，并重新命名为“new_foreign_fun”
setattr(Meeting, "new_foreign_fun", foreign_fun)
# 获取对象中是否存在foreign_fun的属性或方法，返回值为True或False
print(hasattr(Meeting, "foreign_fun"))# False
# 获取对象中是否存在new_foreign_fun的属性或方法，返回值为True或False
print(hasattr(Meeting, "new_foreign_fun"))# True打印结果如下：
__init__()方法是Python中一种特殊的方法，被称为构造函数或初始化方法，当创建这个类的实例时就会调用该方法。
class Meeting(object):
"""meeting类的类描述"""
def __init__(self, name, age, sex, address, attack):
"""构造函数"""
self.name = name
self.age = int(age)
self.sex = sex
self.address = address
self.attack = int(attack)
C = Meeting("张三", 20, "男", "南京", 108)
print(C.name)# 张三
print(C.address)# 南京当删除对象时，Python解释器会默认调用一个方法__del__()，相当于unittest框架中的tearDown()函数
def __del__(self):
"""析构函数"""
print("%s攻击结束" % (self.name)) 每调用一次对象，都会执行一次__del__()方法
D = Meeting("张三", 20, "男", "南京", 108)
# 计算当前实例引用计数，D引用一次，sys.getrefcount(D)引用一次
print(sys.getrefcount(D))# 2D对象的引用计数为2次，一次是D引用，一次是sys.getrefcount所引用的
__str__方法需要返回一个字符串，当做这个对象的描述信息，当使用print输出对象的时候，只要定义了__str__(self)方法，那么就会打印这个方法返回的数据
def __str__(self): """字符串函数""" return "我是Meeting类的字符串描述" # __str__()：字符串函数，定义__str__()方法时，打印对象，打印的是__str__()方法的返回值，否则打印类的内存地址 print(D)# 我是Meeting类的字符串描述
获取类的属性，包含一个字典，由类的数据属性组成
# __dict__：获取类的属性，返回值为字典类型
print(D.__dict__)
# {'name': '张三', 'age': 20, 'sex': '男', 'address': '南京', 'attack': 108} class Meeting(object): """meeting1类的类描述""" # __doc__：获取类的文档字符串 print(D.__doc__) # meeting1类的类描述
# __name__：获取类名 print(Meeting.__name__) # Meeting
类的全名是'__main__.clssName'，如果类位于一个导入模块mymod中，那么className.__module__等于mymod
from common.http_requests import HttpRequests # __module__：类定义所在的模块 print(Meeting.__module__)# __main__ print(HttpRequests.__module__)# common.http_requests
Meeting类的路径为__main__，而从common文件的http_requests文件中导入了HttpRequests类，打印其路径，则为common.http_requests
获取类的所有父类构成元素（包含了一个由所有父类元素组成的元组）。例如下面有一个Song类，其继承了父类Music，则获取到的Song类的所有父类构成元素为：(
class Music(object): pass class Song(Music): pass print(Song.__bases__)# (<class '__main__.Music'>,)
本篇文章我们介绍了面向对象的相关概念，下面来简单总结一下：
面向对象相关概念：
获取或添加对象属性：
魔法方法：
Python内置属性：
Atas ialah kandungan terperinci Pengaturcaraan Berorientasikan Objek Python - Elementary. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
