Programmation orientée objet
Orienté procédure : code de base de haut en bas basé sur la logique métier
Fonctionnel : encapsuler un certain code fonctionnel dans une fonction et l'appeler directement plus tard. Doit être réécrit
Orienté objet : classer et encapsuler les fonctions pour rendre le développement "plus rapide, meilleur et plus fort..."
# Langages de programmation tels que Java et C# uniquement Prend en charge la programmation orientée objet, et Python prend en charge un mélange de programmation fonctionnelle et de programmation orientée objet
Exemple orienté objet
# 函数式编程
def bar():
print('bar')
bar() # 直接调用函数
# 面向对象编程
class Foo: # 创建类
def bar(self): # 在类里面定义函数 这里self是一个特殊的参数 创建对象时Foo将自身传进来
print('bar')
obj = Foo() # 创建一个对象
obj.bar() # 由对象去访问类里面函数Trois caractéristiques majeures de l'objet- orienté : encapsulation, héritage et polymorphisme
Encapsulation
Encapsuler le contenu dont nous avons besoin dans la classe créée et l'appeler en cas de besoin
class Foo: # 创建类
def __init__(self, name, age): # Foo接收到两个参数后会封装在自己类内部
self.name = name
self.age = age
obj = Foo('kobe', 18) # 创建一个对象 传两个参数
print(obj.name, obj.age) # 外面调用封装好的参数
输出：
kobe 18Membres de la classe
Champs : champs ordinaires, champs statiques
Méthodes : méthodes ordinaires, méthodes statiques, méthodes de classe
Attributs : attributs ordinaires
1) Champs (paramètres encapsulés dans la classe)
class Foo:
# 字段（静态字段 保存在类里面）
CC = "中国"
def __init__(self, name):
# 字段(普通的字段 保存在对象里面)
self.name = name
# 普通字段通过对象访问
obj = Foo('上海')
print(obj.name)
# 静态字段通过类访问
print(Foo.CC)2) Méthodes (fonctions encapsulées dans la classe)
class Foo:
def show(self):
# 普通方法：对象调用执行 方法属于类
print(self.name)
@staticmethod
def f1():
# 静态方法 由类调用执行
print('f1')
@classmethod
def f2(cls): # class 自动给类名传进去了
# 类方法
# cls 是类名 加()创建对象
print(cls)
# 创建对象
obj = Foo()
# 通过对象去访问普通方法
obj.show()
# 通过类去访问静态方法
Foo.f1()
# 类方法 会将类 Foo 名字直接传入函数
Foo.f2()3) Attributs
Avant de définir les attributs de la classe, on besoin d'accéder aux méthodes de la classe après le nom de la méthode Add brackets() : Par exemple, après avoir défini les attributs dans obj.f1()
, on peut accéder directement aux méthodes de la classe obj.f1
class Foo:
@property
def f1(self):
print('f1')
obj = Foo()
obj.f1 # 无需加括号直接通过对象访问définissable et supprimable
class Foo:
@property # 在类方法上加上 property装饰器
def f1(self):
print('f1')
@f1.setter # 设置数值
def f1(self, values):
print(values)
@f1.deleter # 可删除
def f1(self):
print('del...')
obj = Foo()
obj.f1 # 无需加括号直接通过对象访问
obj.f2 = 100
del obj.f1
输出：
f1
del...Une autre façon d'écrire les attributs de classe
class Foo:
def f1(self):
return 100
def f2(self, value):
print(value)
def f3(self):
print('300')
# 类属性定义
Foo = property(fget=f1, fset=f2, fdel=f3)
obj = Foo()
# 取值
ret = obj.Foo
print(ret)
# 赋值
obj.Foo = 200
# 删除
del obj.Foo
# 输出
100
200
300Modificateur de membre de classe
Modificateur de membre de classe : Définir les champs ou les méthodes de la classe comme publics ou privés
Membres publics : accessibles n'importe où
Membres privés : accessibles uniquement à l'intérieur de la classe
class Foo:
__cc = 123
def __init__(self, name):
self.__name = name # 加两个下划线__表示私有字段 外部、继承都不能调用
def f1(self):
print(self.__name)
@staticmethod # 加 staticmethod 装饰器表示为静态方法，可以不加self参数直接外部调用
def f3(self):
print(Foo.__cc)
obj = Foo('kobe')
# print(obj.__name) # 通过对象外部访问内部普通字段不成功
obj.f1()
# print(Foo.__cc) # 通过外部访问内部静态字段也不成功
obj.f3()
# 特殊访问方法
print(obj._Foo__name)Membres spéciaux de la classe
__doc__
__init__ #Méthode de construction
__del__ #Méthode de destruction__call__ # Ajout de parenthèses après le l'objet déclenche l'exécution
__dict__ # Classe ou objet Tous les membres de
__getitem__ # Opérations d'index telles que le dictionnaire
__setitem__ # Opérations d'index
__delitem__ # Opérations d'index
1) __doc__ Informations de description
3)__init__ et __str__4) __del__
class Foo:
"""
注释 __doc__
"""
obj = Foo()
print(obj.__doc__)
输出：
注释 __doc__
2）__module__ 和 __class__
from lib.aa import C
obj = C()
print obj.__module__ # 输出 lib.aa，即：输出模块
print obj.__class__ # 输出 lib.aa.C，即：输出类5) __call__
class Foo:
def __init__(self, name, age): # 构造方法
self.name = name
self.age = age
def __str__(self): # str方法
return '%s - %s ' % (self.name, self.age)
obj1 = Foo(name='kobe', age=18)
obj2 = Foo(name='jordan', age=18)
print(obj1)
print(obj2)
# 输出：
kobe - 18
jordan - 186) __dict__
class Foo:
def __init__(self, name, age): # 构造方法
self.name = name
self.age = age
# 析构方法：在垃圾回收之前执行
def __del__(self):
pass
class Foo:
def __call__(self, *args, **kwargs):
print('call')
p = Foo()
# 对象后面加括号执行 __call__ 方法
p()
# 一个括号是类创建了一个对象 两个括号是去执行 __call__ 方法
Foo()()
# 输出：
call
callclass Foo:
def __init__(self, name, age): # 构造方法
self.name = name
self.age = age
obj1 = Foo(name='kobe', age=18)
# 获取对象中封装的数据返回一个字典
ret = obj1.__dict__
print(ret)
# 输出：
{'name': 'kobe', 'age': 18}
# 全部的类方法
# print(Foo.__dict__)super
class Foo:
def __getitem__(self, item):
print('getitem')
def __setitem__(self, key, value):
print('setitem')
print(item.start, item.stop, item.step)
def __delitem__(self, key):
print('delitem')
# 中括号语法自动执行 getitem 方法
obj = Foo()
obj['ab']
# 中括号并且赋值执行 setitem 方法
obj['k1'] = 111
del obj['k1']
# 切片也是去执行 setitem 方法
obj[1:6:2]
# 输出
setitem
delitem
getitem
1 6 2class Bar:
pass
class Foo(Bar):
# 返回一个可迭代对象
def __iter__(self):
# return iter([11, 22, 33, 44])
yield 1
yield 2
obj = Foo()
for item in obj:
print(item)
# 查看 obj 是否是 Foo 的实例
ret = isinstance(obj, Foo)
# 也可以查看是否是 父类 的实例
# ret = isinstance(obj, Bar)
print(ret)
# 查看 Foo 是否为 Bar 的子类
ret1 = issubclass(Foo, Bar)
print(ret1)
# 输出
1
2
True
TrueUtilisez super pour implémenter un dictionnaire ordonné
class C1:
def f1(self):
print('c1.f1')
class C2(C1):
def f1(self):
# 主动执行父类的 f1 方法
super(C2, self).f1()
print('c2.f1')
obj = C2()
obj.f1()
# 输出：
c1.f1
c2.f1Mode cas unique.
目录
backend
- commons.py
index.py
lib.py
setting.py
commons.py >>
class Foo:
def f1(self):
print('Foo.f1')
index.py >>
from setting import ClassName
from setting import Path
def execute():
model = __import__(Path, fromlist=True)
cls = getattr(model, ClassName)
obj = cls()
obj.f1()
if __name__ == '__main__':
execute()
setting >>
# Path = "backend.commons"
# ClassName = 'Foo'
Path = "lib"
ClassName = 'MyFoo'
lib >>
from backend.commons import Foo
class MyFoo(Foo):
def f1(self):
print('before')
super(MyFoo, self).f1()
print('after')
这样运行我们自己添加的lib 时结果如下
before
Foo.f1
afterclass MyDict(dict):
def __init__(self):
self.li = []
super(MyDict, self).__init__()
def __setitem__(self, key, value):
self.li.append(key)
super(MyDict, self).__setitem__(key, value)
def __str__(self):
temp_list = []
for key in self.li:
value = self.get(key)
temp_list.append("'%s':%s" % (key, value))
temp_str = "{" + ",".join(temp_list) + "}"
return temp_str
obj = MyDict()
obj['k1'] = 123
obj['k2'] = 456
print(obj)
# 输出
{'k1':123,'k2':456}class Foo:
instance = None
def __init__(self, name):
self.name = name
@classmethod
def get_instance(cls):
if cls.instance:
return cls.instance
else:
obj = cls('alex')
cls.instance = obj
return obj
obj1 = Foo.get_instance()
obj2 = Foo.get_instance()
print(obj1)
print(obj2)
# 输出
<__main__.Foo object at 0x000001C09B130B70>
<__main__.Foo object at 0x000001C09B130B70>Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Comment définir un écran large ppt
Les derniers prix des dix principales monnaies virtuelles
attributusage
Solution d'erreur SQL 5120
Étapes de création du projet SpringBoot
Que sont les variables d'environnement
Recommandation de classement des logiciels de détection de matériel informatique
Comment utiliser RealVNC
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
