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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
