객체 지향 프로그래밍
절차 지향: 비즈니스 로직을 기반으로 위에서 아래로 기본 코드
기능: 특정 기능 코드를 함수로 캡슐화하고 직접 호출 나중에 다시 작성해야 합니다.
객체 지향: 개발을 "더 빠르고, 더 좋고, 더 강력하게" 하기 위해 기능을 분류하고 캡슐화합니다...
# 프로그래밍 언어 Java, C# 등 객체지향 프로그래밍만 지원하고, Python은 함수형 프로그래밍과 객체지향 프로그래밍의 혼합을 지원합니다
객체지향 예제
# 函数式编程
def bar():
print('bar')
bar() # 直接调用函数
# 面向对象编程
class Foo: # 创建类
def bar(self): # 在类里面定义函数 这里self是一个特殊的参数 创建对象时Foo将自身传进来
print('bar')
obj = Foo() # 创建一个对象
obj.bar() # 由对象去访问类里面函数객체지향의 세 가지 주요 특징은 다음과 같습니다. 캡슐화, 상속, 다형성
캡슐화
필요한 콘텐츠를 생성된 클래스에 캡슐화하고 필요할 때 호출
class Foo: # 创建类
def __init__(self, name, age): # Foo接收到两个参数后会封装在自己类内部
self.name = name
self.age = age
obj = Foo('kobe', 18) # 创建一个对象 传两个参数
print(obj.name, obj.age) # 外面调用封装好的参数
输出：
kobe 18클래스 멤버
필드: 일반 필드, 정적 필드
메서드: 일반 메서드, 정적 메서드, 클래스 메서드
속성: 일반 속성
1) 필드(클래스에 캡슐화된 매개변수)
class Foo:
# 字段（静态字段 保存在类里面）
CC = "中国"
def __init__(self, name):
# 字段(普通的字段 保存在对象里面)
self.name = name
# 普通字段通过对象访问
obj = Foo('上海')
print(obj.name)
# 静态字段通过类访问
print(Foo.CC)2) 메소드(클래스에 캡슐화된 함수)
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) 속성
클래스의 속성을 정의하기 전에 클래스 뒤에 대괄호()를 추가해야 합니다. 클래스의 메소드에 액세스할 때 메소드 이름: obj.f1()
속성을 정의한 후 obj.f1
class Foo:
@property
def f1(self):
print('f1')
obj = Foo()
obj.f1 # 无需加括号直接通过对象访问클래스의 메소드에 직접 액세스할 수 있습니다. 삭제됨
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...클래스 속성을 작성하는 또 다른 방법
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
300클래스 멤버 수정자
클래스 멤버 수정자: 클래스의 필드 또는 메소드를 공개 또는 비공개로 정의
공개 멤버:
비공개 멤버는 어디에서나 액세스할 수 있습니다. 클래스 내부에서만 액세스할 수 있습니다.
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)클래스의 특별 멤버
__doc__ # 클래스 설명 정보
__module__ # 현재 개체가 속한 모듈
__class__ # 현재 개체가 속한 클래스
__str__ # 인쇄 시 반환되는 값 object
__init__ # 생성자 메서드
__del__ # 소멸자 메서드
__call__ # 개체 실행 후 괄호 추가
__dict__ # 개체의 모든 멤버 클래스 또는 객체
__getitem__ # 사전과 같은 인덱스 연산
__setitem__ # 인덱스 연산
__delitem__ 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
6) __getitem__ __setitem__ delitem__ 사전과 같은 인덱싱 작업에 사용됨: OK 값 가져오기, 설정, 삭제
class Foo:
def __call__(self, *args, **kwargs):
print('call')
p = Foo()
# 对象后面加括号执行 __call__ 方法
p()
# 一个括号是类创建了一个对象 两个括号是去执行 __call__ 方法
Foo()()
# 输出：
call
call7) __iter__, __isinstance__, __issubclass__
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__)super
super는 Python의 다중 상속 문제를 해결하고 상위 클래스의 실행을 강제하는 것입니다.
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 2의 메소드 super를 사용하여 소스 코드를 변경하지 않고 기능 추가
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
Truesuper를 사용하여 순서 있는 사전 구현
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.f1단일 케이스 모드
# 싱글톤 패턴은 일반적으로 사용되는 소프트웨어 디자인 패턴입니다. 핵심 구조에는 싱글톤 클래스라는 특수 클래스가 하나만 포함되어 있습니다. 싱글톤 모드는 시스템에 클래스의 인스턴스가 하나만 있고 해당 인스턴스에 외부 세계에서 쉽게 액세스할 수 있도록 보장하여 인스턴스 수를 쉽게 제어하고 시스템 리소스를 절약할 수 있습니다. 특정 클래스의 객체 하나만 시스템에 존재하도록 하려면 싱글톤 패턴이 가장 좋은 솔루션입니다.
目录
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
예외 처리
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}예외 처리 완료 코드
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>위 내용은 객체지향 자동화 운영 및 유지보수 Python 시리즈에 대한 자세한 설명의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!
![[웹 프런트엔드] Node.js 빠른 시작](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
