Heim > Artikel > Backend-Entwicklung > Ausführliche Erläuterung der objektorientierten automatisierten Betriebs- und Wartungs-Python-Serie
Ausführliche Erläuterung der objektorientierten automatisierten Betriebs- und Wartungs-Python-Serie
- 高洛峰Original
- 2017-03-26 18:53:331820Durchsuche
Objektorientierte Programmierung
Prozedurorientiert: Basiscode von oben nach unten basierend auf Geschäftslogik
Funktional: Kapseln Sie einen bestimmten Funktionscode in eine Funktion und rufen Sie ihn direkt auf Muss später noch einmal geschrieben werden.
Objektorientiert: Funktionen klassifizieren und kapseln, um die Entwicklung „schneller, besser und stärker“ zu machen.
# Programmiersprachen wie Java und C# unterstützen nur objektorientierte Programmierung, und Python unterstützt eine Mischung aus funktionaler Programmierung und objektorientierter Programmierung
Objektorientiertes Beispiel
# 函数式编程
def bar():
print('bar')
bar() # 直接调用函数
# 面向对象编程
class Foo: # 创建类
def bar(self): # 在类里面定义函数 这里self是一个特殊的参数 创建对象时Foo将自身传进来
print('bar')
obj = Foo() # 创建一个对象
obj.bar() # 由对象去访问类里面函数Drei Hauptmerkmale von Objekt- orientierte Programmierung: Kapselung, Vererbung und Polymorphismus
Kapselung
Kapseln Sie den Inhalt, den wir benötigen, in der erstellten Klasse und rufen Sie ihn bei Bedarf auf
class Foo: # 创建类
def __init__(self, name, age): # Foo接收到两个参数后会封装在自己类内部
self.name = name
self.age = age
obj = Foo('kobe', 18) # 创建一个对象 传两个参数
print(obj.name, obj.age) # 外面调用封装好的参数
输出：
kobe 18Klassenmitglieder
Felder: gewöhnliche Felder, statische Felder
Methoden: gewöhnliche Methoden, statische Methoden, Klassenmethoden
Attribute: gewöhnliche Attribute
1) Felder (Parameter in der Klasse gekapselt)
class Foo:
# 字段（静态字段 保存在类里面）
CC = "中国"
def __init__(self, name):
# 字段(普通的字段 保存在对象里面)
self.name = name
# 普通字段通过对象访问
obj = Foo('上海')
print(obj.name)
# 静态字段通过类访问
print(Foo.CC) 2) Methoden (in der Klasse gekapselte Funktionen)
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) Attribute
Bevor Sie die Attribute der Klasse definieren, Wir müssen auf die Methoden in der Klasse nach dem Methodennamen zugreifen. Fügen Sie Klammern () hinzu: Nachdem wir beispielsweise die Attribute in obj.f1()
definiert haben, können wir direkt auf die Methoden in der Klasse obj.f1 zugreifen
class Foo:
@property
def f1(self):
print('f1')
obj = Foo()
obj.f1 # 无需加括号直接通过对象访问einstellbar und löschbar
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...Eine andere Art, Klassenattribute zu schreiben
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
300Klassenmitgliedsmodifikator
Klassenmitglied Modifikator: Felder oder Methoden in der Klasse als öffentlich oder privat definieren
Öffentliche Mitglieder: überall zugänglich
Private Mitglieder: nur innerhalb der Klasse zugänglich
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)Besondere Mitglieder der Klasse
__doc__
__init__ #Konstruktionsmethode
__del__ #Zerstörungsmethode__call__ # Klammern danach hinzufügen das Objekt löst die Ausführung aus
__dict__ # Klasse oder Objekt Alle Mitglieder von
__getitem__ # Indexoperationen wie Wörterbuch
__setitem__ # Indexoperationen
__delitem__ # Index Operationen
1) __doc__ Beschreibungsinformationen
3)__init__ und __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
call6) __getitem__ __setitem__ delitem__ wird für Indexoperationen wie Wörterbücher verwendet: Sie können Werte abrufen, festlegen und löschen class 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__)7) __iter__, __isinstance__, __issubclass__
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 2super soll das Problem der Mehrfachvererbung in Python lösen und die Ausführung von Methoden erzwingen die übergeordnete Klasse class 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
TrueVerwenden Sie super, ohne den Quellcode zu ändern. Methoden zum Hinzufügen von Funktionen
Verwenden Sie super, um ein geordnetes Wörterbuch zu implementieren
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.f1Einzelfall Modus
目录
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
after# Der Singleton-Modus ist ein häufig verwendetes Software-Designmuster. Es enthält in seiner Kernstruktur nur eine spezielle Klasse, die Singleton-Klasse genannt wird. Der Singleton-Modus kann sicherstellen, dass es nur eine Instanz einer Klasse im System gibt und dass die Instanz von außen leicht zugänglich ist, wodurch die Kontrolle über die Anzahl der Instanzen erleichtert und Systemressourcen gespart werden. Wenn Sie möchten, dass nur ein Objekt einer bestimmten Klasse im System vorhanden ist, ist das Singleton-Muster die beste Lösung. class 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} Ausnahmebehandlungclass 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>Ausnahmebehandlung vollständiger CodeDas obige ist der detaillierte Inhalt vonAusführliche Erläuterung der objektorientierten automatisierten Betriebs- und Wartungs-Python-Serie. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!