Python23_ 객체 지향

객체 지향

PS : 상관없이 어떤 언어, 객체 지향 세 가지 요소가 없습니다 : (클래스 변수와 함수를 캡슐화) 패키지, 상속, 다형성

객체 지향 (OO, 객체 지향은) 코드를 작성하는 생각의 방법입니다 : 프로그램이 구성하는 것입니다. 객체 지향 프로그래밍 : OOP (객체 지향 프로그래밍)

클래스는, 사실, 추상화입니다. 은 동일한 특성을 분류하여 그는 일, 추상적 인 소위. 예를 들어, 사용자 클래스, 추상 사용자 정보를 함께

속성 및 클래스의 방법.

등록 정보 :이 클래스의 특성을 보여줍니다

방법 (동작) 기능 클래스를 지정합니다

추신 : 혹 구조와 규칙, 클래스, 대문자 첫 글자

프로그램 (클래스) 데이터 구조 (특성) + 알고리즘 (방법, 작용) =

객체 지향 프로세스 절차의 세계에 현실 세계를지도하는 것입니다

특정 클래스 : 예

자기 : 현재의 오브젝트 (메소드의 호출)
CLS : 오브젝트의 클래스
참고 : 자기 또는 CLS 중 하나, 다만 변수 이름 만이 두 이름의 사용에 익숙한, 당신은 또한 다른 이름을 사용할 수 있습니다 (현재되지 않은 학습 공식 설명, 개인의 이해 : 첫 번째 매개 변수의 인스턴스 방법은 개체 자체의 인스턴스를 나타낸다는 첫 번째 매개 변수) 자체 클래스 클래스 메서드를 나타내는

기본 생성자의 매개 변수가 파이썬은 할 수 없습니다

클래스 기능 호출 항에있어서 어느

class Cat:
    #__new__方法分配内存，单例模式时会用到此方法
    def __new__(cls, *args, **kwargs):	#new方法为什么需要这些参数？此处这样写只是为了可以接受任何形式与数目的参数，在new里面一般并用不到，但是执行了new之后会自动调用init方法，那时会用到这些参数。亦即：*args与**kwargs并不是必要的格式。比如，在init方法中，如果需要的是除了self之外的一个参数（如name），那么此处也可以只声明一个变量接受该参数即可
        print("__new__")
        return super().__new__(cls)		#也可以：return = object.__new__(cls) 另，此处以本人目前的知识猜测，在object类中应是用了@property修饰了__new__()方法的，所以此处如果用object可以不加括号。加了括号也是一样的
        #注意：__new__方法必须要有返回值，返回实例化出来的实例，可以返回父类__new__返回代实例（此处采用的方法），也可以直接将object的__new__出来的实例返回
    #构造方法，该方法会创建对象（实例），自动调用
    def __init__(self, color, name):
        #前后有双下划线的方法由程序自动调用
        self.color = color
        self.name = name        
    def catch_mouse(self):
        print(self.name + " 正在抓老鼠")
    def __del__(self):
    	print("对象空间已经被释放")	#当对象的空间被释放的时候（引用对象的个数为0的时候）会自动调用此方法
    #ps：对象的引用个数可以用`import sys \n sys.getrefcount(Object)`来获取，比实际的对象多1，如果该对象空间已经被释放，则会报错

#创建实例 
tom = Cat("Blue","Tom")

print(tom.name)

프로세스 개체의 예 :

1. (__new __ ())는,이 방법이 때 하나의 디자인 패턴을 사용하는 메모리를 할당한다. 공간의 새로운 블록이 후 자동으로 init 메소드를 호출하면,이 때 새로운 방법은 자동으로 수신 된 매개 변수 init 메소드에 전달됩니다. 새로운 공간은 자기 참조의 init 메소드에 전달
2. 초기화 값 (의 __init __ ())

__new__()方法的注意事项：__new__方法必须要有返回值，返回实例化出来的实例，可以返回父类__new__返回代实例（此处采用的方法），也可以直接将object的__new__出来的实例返回

등록 민영화 :
3. XX : 밑줄 민영화 속성 또는 메서드 전에 단일 세트가 개체에 액세스 할 수있는 모듈에 직접 사용하지만, somemodule 수입 * 수입, 클래스와 서브 클래스 금지 할 수 있습니다
4. 때 명명 된 속성 앞에 플러스 "__", 즉 문법 규칙입니다, 두 개의 밑줄입니다.
S : XX는 , 파이썬 키워드와 충돌을 피하기 위해, 하나의 게시물을 밑줄
도 클래스에 사용되는 개인 재산 또는 개인 방법, 추가해야합니다 __, 즉, 이중 밑줄을

왜 밑줄 민영화 (숨겨진 변수) 두배로 할 수
__dict__을 : 모든 개체는 인스턴스의 모든 속성으로 가득이 속성이 있습니다. 이중 밑줄 속성을 시작으로, 이름이 변환됩니다 : _ __ + 클래스 이름 속성 명,이 시간에 의해 对象名._类名__属性名접근

전용 속성에 액세스하는 방법 : 방법으로

class Student:
    """
    学生类
    """
    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    def set_name(self, name):
        if not len(name) < 3:
            self.__name = name

    def get_name(self):
        return self.__name
        
    #标注，默认是get的。@就是一个标记，比如下面的@age.setter，当用“=”时，就调用该函数。如果是用的"."，就调用此方法
    @property   #@语法糖，前面加这个的可以像使用属性一样使用方法，即不用加括号
    def age(self):
        return self.__age
        
    #使用了@后方法名必须与属性名一致
        
    @age.setter #让方法可以像属性一样使用
    def age(self,age):
        self.__age = age


tom = Student("tom", 23)
print(tom.get_name())
tom.set_name("jack")
print(tom.get_name())

tom.hight = 23	#为tom额外添加hiht属性。

print(tom.age)  #可直接获得年龄，其实tom.age是在调用方法

tom.age = 18    #使用语法糖的方式更改属性值
print(tom.age)  #这里也使用了语法糖，实际上是调用的age方法


#输出：
tom
jack
23
18

재산의 사용에 대한 두 번째 방법

class A(object):
    def __init__(self):
        self.__num = 10

    def set_num(self,num):
        self.__num = num
    def get_num(self):
        return self.__num

    num = property(get_num,set_num)	#这里的方法名可以任意取，则当使用=进行赋值操作时，相当调用第二个方法（设置值的方法），当仅仅是取值的时候，则调用第一个方法（取值的方法），等号前面的变量名必须与属性的变量名一致，但是不用加双下划线

obj = A()

print(obj.num)
obj.num = 15
print(obj.num)
	

Object 클래스 자체는
일반적으로 : 클래스 속성, 클래스 메소드를 조작하려면, 객체가 작동 예를 들어, 방법의 예를 들면
자기 속성 이름 : 인스턴스 속성.

class User:
    # 在类里面定义的属性称为类属性，由所有实例共享。一般不在这里面写东西。
    num = 0

    def __init__(self, name):
        self.__name = name
        User.num += 1

    def print_name(self):
        print(self.__name)
        print(User.num)

    @property
    def name(self):
        return self.__name

    @classmethod  # 标注，表明这是类方法。即可以通过类名调用，必须用一个cls参数，cls就是类本身，与对象的self相当。
    def creat_user(cls, name, age):  # cls其实就是类本身
        user = cls(name)
        user.age = age
        return user

    @staticmethod  # 静态方法，可以直接通过类名调用。当一个方法即和类没有关系又和对象没有关系时，就用静态方法，就不用cls和self参数
    def sum(a, b):
        return a + b

    def __str__(self):  #当print对象的时候会调用这个方法。这个方法必须返回一个字符串
        _str = ""
        for k,v in self.__dict__.items():
            _str += str(k)
            _str += ":"
            _str += str(v)+" "
        return  _str



u = User("zhangsan")
u1 = User("lisi")
u.print_name()
u1.print_name()
User.num += 1
print(User.num)

u2 = User.creat_user("wangwu", 20)
# @classmethod修饰的方法是类方法，类方法可以通过类名调用。类方法必须有一个参数，cls，即类本身
print(u2.name)
print(User.sum(1, 3))	#通过类名调用静态方法
print(u.sum(2,4))	#通过实例对象调用静态方法
print(u1.sum(1,3))
u3 = u1.creat_user("laoli",50)
print(u3.name)
print(u1)

상속

파이썬 지원하는 다중 상속 및 상속 연속 순서 관련 콘텐츠 (제 클래스에서 상속되는 속성)

상위 클래스의 직접적인 방법을 호출 할 수있는 서브 클래스 객체는 또한 상위 클래스의 속성이 있습니다

모든 클래스는 기본 객체 클래스를 상속합니다

주 : 사유 재산과 부모 클래스의 private 메소드는 (__의로 시작하는) 상속되지 않습니다 만, 사유 재산이 상속되는 경우 방법 (재 작성하지 않음) 개인 속성 또는 부모 클래스의 방법, 부모 클래스를 방문하거나 개인 방법이나하자이 방법을 사용

class A:
    def __init__(self):
        self.name = "A"
    def print_test(self):
        print("A"*10)

class B(object):	#ps：如果一个类没有继承任何类，建议写上object类，object类是所有类最终的父类，即：所有类都继承自object类
    def __init__(self):
        self.name = "B"
    def print_test(self):
        print("B"*10)

class C(A):		#A是C的父类，又称基类。C是A的子类，派生类。C继承自A
    def __init__(self):
        super().__init__()    #调用父类的初始化方法
        self.age = 20
class D(A,B):   #多继承，是按照顺序，比如此处有两个name,那么D就继承到了A的。
    def print_test(self):
        super().print_test()
        self.print_test()

c = C()
print(c.name)
print(c.age)
d = D()
print(d.name)
print(C.__mro__)	#mro中的顺序是由C3算法决定的
#上面这句会输出：(<class '__main__.C'>, <class '__main__.A'>, <class 'object'>)，表明调用C类的对象的方法时，搜索的顺序，如果C没有该方法，就用A的，如果A还没有，就调用object类的（caution，object类是所有类的父类，因为这里A没有继承除了object类之外的类，所以是A中找不到就到object中去找，如果A继承了其他类，比如D类，则A中找不到就会到D中去查找。即查找顺序为：本类>父类（按继承的先后顺序，先继承的先用）>父类的父类
print(isinstance(d,A))  #判断一个对象是否是一个类的实例。输出True，子类的对象也是父类的实例
print(issubclass(D,A))  #判断一个类是否是另一个类的子类
#以上的顺序表明了查找属性的顺序（多继承的访问顺序），如果C本身有，就用C本身的，如果C本身没有，而A有，则用A的，再否则用B的

오리 형

불과 몇 클래스는 같은 부모로부터 상속하지 않습니다, 같은 클래스에 속하는 것으로 간주 할 수있다하더라도, 유사한 기능이나 특성을가집니다. 예를 들어, 다음과 같은 프로그래머와 관리자의 경우, 비록 같은 부모로부터 상속하지,하지만 직원이,이 메서드 나 속성에 의도적으로 유사한 정의 가능한 것이 분명하다

class Programer:
    def dowork(self):
        print("编程")

class Manager:
    def dowork(self):
        print("管理")

p = Programer()
m = Manager()
p.dowork()
m.dowork()

#判断某一对象是否是一个类的实例
print(isinstance(p,Programer))

고쳐 쓰기

이것은 부모 클래스와 서브 클래스 방법에서 같은 이름의 정의를 다시 작성하는 방법이다, 메소드 호출을 호출 한 후 오히려 부모 클래스의 방법보다, 자신의 것입니다.

class Animal:
    name = "狗"
    def eat(self):
        print("-----吃-----")
    def run(self):
        print("-----跑-----")

class Dog(Animal):
    def bark(self):
        print("-----汪汪叫-----")

class XiaoTian(Dog):
    def fly(self):
        print("-----fly-----")
    def bark(self)：
    	print("-----狂叫-----“）
    	#Dog.bark(self)	#通过父类的类名，并以self为参数，可以调用父类中被重写了的方法
    	super().bark()	#通过super().方法名(),可以也可以调用父类被重写的方法，此种方法不需要self参数


xt = XiaoTian()

xt.run()
xt.bark()
xt.eat()
print(xt.name)

다형성

정의 : 유형 정의 및 런타임의 동일한 유형이 아닌 경우,이 시간이 다형성이라고합니다. (추신 : C ++와 자바는 다형성 C에서 다양 ++ 및 Java, 다형성, 캐스트 다소 유사)

class Dog(object):
	def print_self(self):
		print("This is dog")
class XiaoTianQuan(Dog):
	def print_self(self):
		print("This is XiaoTianQuan")
def introduce(temp):
	temp.print_self()
dog1 = Dog()
dog2 = XiaoTianQuan()
introduce(dog1)
introduce(dog2)

#所谓多态，即写完程序后，只是知道它调用一个方法，但是不确定它究竟是调用基类的还是调用子类的，在真正执行的一刹那，才根据当前的对象是谁去决定调用哪个方法
#因为python是动态类型的语言，所以python中的多态体现得不态明显

클래스 속성 인스턴스 속성

#需求：用一个变量存储一个类创建了多少个对象
class Tool(object):
	#属性：定义在类之内，方法之外的属性称为类属性
	count = 0
	#方法
	def __init__(self, name):
		self.__name = name
		Tool.count += 1	#对于类属性，用类名进行访问（就像实例对象的属性通过实例对象的名字访问一样）
tool1 = Tool("铁锹")
tool2 = Tool("共兵铲")

注意：实际上程序并不是每创建一个对象就在该对象的空间内放一个方法，而是在该空间内多了一个属性（变量），该属性可以知道这个对象的class，即保存了该类的一个引用，然后在调用该方法时到该类中查找该方法。故而一个抽象的类实际上也占用了内存空间，亦即类在程序里面也是一个对象，这个对象称为类对象，通过类创建出来的对象称为实例对象，实例对象里面的属性称为实例属性，类里面的属性称为类属性。

주의 : 오브젝트 인스턴스는 특성과 관련된 데이터를 상기 오브젝트의 인스턴스와 다른 예는 공유하지 속성이다. class 속성에 속하는 클래스의 목적은, 동일한 속성 클래스 인스턴스 오브젝트의 복수의 사이에서 공유 될 수있다. 클래스 정의의 클래스 속성은 한 번만 개체의 인스턴스를 생성과는 아무런 정의 할 수 없습니다.

• 예 속성
  없음 이름 속성이 클래스 초기화를 정의하지 가정하고, 그 다음 예 인스턴스로서 지칭 객체를 생성 할 수 속성 __init__ 방법 및 후속 속성과 (예를 들면 속성 S.name 이러한 의해 = "개" 방법 속성은 인스턴스 속성을 생성하고, init 메소드에 정의 된 속성) 인스턴스 속성 속하는

방법 클래스 방법, 고정 방법 으로서는

참고 :实例方法中的第一参数为self只是大家都遵循的一个规则，同时，类方法中的第一个参数cls也只是大家都遵循的规则

class Game(object):
	#类属性
	num = 0
	#实例方法
	def __init__(self):
		self.name = "laowang"
		
	#在方法前加了@classmethod的都称为类方法
	@classmethod	#装饰器
	def add_num(cls):	#不同于实例方法中必须有self参数保存该对象（实例），cls就是用来保存类的引用的，是class的简写。
		cls.num = 100

= 게임 게임 ()
# 클래스 메서드 Game.add_num ()이 클래스의 이름으로 호출 할 수 있습니다. 또한 클래스 메서드를 호출하기 위해이 클래스 객체에 의해 만들 수 있습니다 (개인 이해의 클래스 객체 인스턴스가 생성되고, 또한 클래스를, 그래서이 클래스의 메소드를 호출 할 수 있습니다)
인쇄 (Game.num)

참고 : 실제 개발을 미래에, 당신은 일반적인 범주를 통해 클래스를 수행하려는 경우, 당신은 일반적인 기능을 통해 기능을 수행하려는 경우. 그 클래스는 물고기도 새도있는 기능을 가지고있다

단일 디자인 패턴

class S:
    __instance = None
    def __new__(cls, *args, **kwargs):
        if S.__instance is None:	#类属性通过类名访问
            S.__instance = super().__new__(cls)   #因为自己重写了__new__方法（分配内存的），所以必须调用父类的__new__()以分配内存
        return S.__instance   #ps:也可以写成：return cls.__instance


s1 = S()
s2 = S()
print(id(s1),id(s2))    #会发现两个对象的内存地址相同，即他们是同一个对象


#拓展：只初始化一次对象
class S:
    __instance = None
    __init_flag = False
    def __new__(cls, *args, **kwargs):
        if S.__instance is None:	#类属性通过类名访问
            S.__instance = super().__new__(cls)   #因为自己重写了__new__方法（分配内存的），所以必须调用父类的__new__()以分配内存
        return S.__instance   #ps:也可以写成：return cls.__instance
    def __init__(self,name):
    	if Dog.__init_flag == False:
    		self.name = name
    		Dog.__init_flag = True