Python-面向对象（类相关）

基本定义

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 方法：类中定义的函数。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 局部变量：定义在方法中的变量，只作用于当前实例的类。
• 实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
  继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• 实例化：创建一个类的实例，类的具体对象。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

类的声明

Python中，类的声明会依次调用以下两个函数：

1. __new__(cls, *args, **kwargs) 分配内存
2. __init__(self) 初始化值

下面通过例子来进行类的创建

class Cat:
    #分配内存，通常可省略
    def __new__(cls,*args, **kwargs):
        print("__new__")
        return super().__new__(cls)

    #Ptyhon的构造函数，在创建对象的时候自动调用
    def __init__(self, color,name):
        """
        函数在类里面称为方法，self指的是当前对象，即调用方法的对象
        :param color: 
        :param name: 
        """
        print("__init__")
        self.color=color
        self.name=name
        self.__heigh = 15

    def catch_rat(self):
        print(self.name+"抓到了老鼠")

#创建类的实例
tom =Cat("blue","Tom")
tom.catch_rat()
>>>
__new__
__init__
Tom抓到了老鼠

属性

1. 类属性
Python在类里直接定义的属性，称为类属性，类属性由所有对象共享，在类方法中通过类名，在外部通过类名或对象实例来访问

2. 实例属性
通过“self.变量名”来定义实例属性，实例属性在内部用self访问，在外部用对象实例访问

class Cat:
    name1="类属性"
    def __init__(self,name):
        self.name=name

x=Cat("实例属性")
print(Cat.name1)
print(Cat.name)
print(x.name1)
print(x.name)
>>>
类属性
AttributeError: type object 'Cat' has no attribute 'name'
类属性
实例属性

3. 私有属性
由两个下划线‘_’开头，在外部不能直接访问的属性，本质是将变量名改变为 _+类名+__+属性，不管在内外都可以通过调用改变后的名字访问，在内部还可以通过原名字直接调用
通常也约定变量名前加一个’‘默认为私有，尽量不要改变，但这靠的是大家的自觉

class Cat:
    def __init__(self, color,name):
        self.color=color
        self.name=name
        self.__heigh = 15

    def catch_rat(self):
        print(self.__heigh)

tom =Cat("blue","Tom")
print(tom.__dict__)
print(tom._Cat__heigh)
tom.catch_rat()
print(tom.__heigh)
>>>
{'color': 'blue', 'name': 'Tom', '_Cat__heigh': 15}
15
15
AttributeError: 'Cat' object has no attribute '__heigh'

4. @修饰器
修饰器的作用就是动态的为旧函数增加新的语句，把旧函数“装饰”一番。或者说修饰器本身就是一个提前设计好的函数，其参数为下一行的函数，通过修饰符可以给原函数添加新的功能。
以下是几个目前见到的修饰符

• @property
  修饰一个返回属性值的函数，修饰后该函数就是返回的属性，可以通过类名.函数名直接调用该属性。但此时不能属性是只读属性，若要可写可以与@.setter连用

• @方法名.setter
  由@property创建，setter方法可以将一个属性变成属性赋值，即可写

class Student:
    def __init__(self,age):
        self.__age=age

    @property
    def age(self):
        print("读属性")
        return self.__age

    @age.setter
    def age(self,age):
        print("写属性")
        if age>0 and age<100:
            self.__age=age
        if age<0 or age>100:
            print("年龄不对")

s=Student(20)
s.age=5
print("**********")
print(s.age)
print("-----------")
s.age=150
>>>
写属性
**********
读属性
5
-----------
写属性
年龄不对

• @classmethod
  该修饰符修饰的是类方法，使得类方法可以通过类名调用，无需实例化。不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数

class User:
    def __init__(self,name):
        self.name=name

    @classmethod
    def create_user(cls,name,age):
        print("@classmethod")
        user =cls(name)
        user.age=age
        return user

u2 = User.create_user('ww',21)
print(u2.age)
print(u2.name)
>>>
@classmethod
21
ww

• @staticmethod
  该修饰符修饰的类方法为静态方法，可以通过类名直接调用，但与上者的区别是既不需要self也不需要cls，可当做普通函数，常用来做工具类

class User:
    @staticmethod
    def sum(a, b):
        print(a + b)

User.sum(5,6)
>>>
11

__str__

一般直接打印对象返回的是对象的内存地址，通过__str__，打印类的对象时会自动执行该方法并打印return的数据。通过对该方法的定义，可以修改打印类对象的结果

class User:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def __str__(self):
        print("__str__")
        _str=""
        for k,v in self.__dict__.items():
            _str+=str(k)
            _str+=":"
            _str+=str(v)
            _str+=','
        return _str


u2 = User('zhangsan',21)
print(u2)
>>>
__str__
name:lisi,age:44,

__dict__

类的dict里的存有类的静态函数、类函数、普通函数、全局变量以及一些内置的属性
对象的dict中存储了一些self.xxx的一些东西

class User:
    num=111111
    def __init__(self,name,age):
        self.name=name
        self.__age=age

    def FFFFFFFF(self):
        pass

u2 = User('zhangsan',21)
print(User.__dict__)
print(u2.__dict__)
>>>
{'__module__': '__main__', 'num': 111111, '__init__': <function User.__init__ at 0x01373C48>, 'FFFFFFFF': <function User.FFFFFFFF at 0x01373C90>, '__dict__': <attribute '__dict__' of 'User' objects>, '__weakref__': <attribute '__weakref__' of 'User' objects>, '__doc__': None}
{'name': 'zhangsan', '_User__age': 21}

类的继承

Python支持多继承，继承内容与继承顺序相关
所有类都会默认继承object类，存有类中通用的结构
继承时只需class C(B,A)

类的组合

即类的嵌套，通过在类中定义一个其他类的属性实现，通过对该属性的调用即可实现对其他类的调用，比继承更为灵活

class A:
    def print_test(self):
        print("AAAAAAAA")


class D:
    def __init__(self):
        self.a=A()

    def print_test(self):
        self.a.print_test()
        print("DDDDDDDD")

d=D()
d.print_test()
>>>
AAAAAAAA
DDDDDDDD