Python面向对象

class Person：

类名，首字母要大写

实例方法：对象.方法名()

方法间调用，使用self.方法名()

class A:
    def test(self):
        print('1111')

    def test2(self):
        self.test()    
        print('22222')

a=A()
a.test2()
#1111
#22222

类方法：类名.方法名()  ，对象.方法名()

class A:
    @classmethod
    def run(cls):
        print('类方法')


a=A()
A.run()
a.run()

静态方法：类名.方法名()  ，对象.方法名()

class A:
    @staticmethod
    def run(cls):
        print('静态方法')


a=A()
A.run()
a.run()

区别：

类方法：调用类属性

静态不调用任何self，cls

实例方法，操作数据

实际应用：

class Test:
    count=0

    def sum(self,num):
        Test.count+=int(num)
        print('实例方法')

    @staticmethod
    def info():
        print('静态方法')

    @classmethod
    def show(cls):
        print(cls.count)
        print('类方法')

t=Test()
t.info()
t.sum(5)
t.show()
# 静态方法
# 实例方法
# 5
# 类方法

魔术方法：

__init__  实例化时调用的初始方法
__str__ 打印对象名调用
__new__  开辟空间
__call__ 对象当作函数用
__del__ 没有指针引用调用

class Test:

    # def __new__(cls, *args, **kwargs):
    #     print('-----------new---------')

    def __init__(self, name):
        self.name = name
        print('==============init')

    def __call__(self, *args, **kwargs):
        print('--------call-----------')

    def __str__(self):
        print('---------str----------')
        s=self.name
        return s

    def __del__(self):
        print('---------del------------')

    # def __new__(cls, *args, **kwargs):
    #     print('==============new')

t = Test('tom')
print(t)
t()
# ==============init
# ---------str----------
# tom
# --------call-----------
# ---------del------------

开发模式：单例

#单例模式
#单例例模式就是确保一个类只有一个实例
#重写__new__方法实现
# 应用场景：
# client--->访问AppConfig()类读取配置文件信息
# 很多地方同时调用就会实例多个浪费server资源
# 单例模式就可以解决！
class Singleton:
    __intance=None  #私有化地址存放
    def __new__(cls, *args, **kwargs):
        if cls.__intance is None:
            cls.__intance=object.__new__(cls)
            return cls.__intance
        else:
            return cls.__intance

s=Singleton()
s1=Singleton()
print(s==s1)    #True

私有化

封装

• __属性，将属性私有化，只能在类中调用

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

    def __str__(self):
        return 'name:{},age:{}'.format(self.name, self.__age)

p=Person('tom',18)
print(p)
print(p.name)
#print(age) 不能调用私有

• 使用get/set方法私有化

#使用get和set操作
def setAge(self, age):
    self.__age = age

def getAge(self):
    return self.__age

p.setAge(19)
print(p.getAge())

print(p.__dir__())
print(p._Person__age)   #只是间接系统改名，还是可以访问

• 使用装饰器

@property
def age(self):
    return self.__age

@age.setter
def age(self, age):
    self.__age = age

p=Person('tom',10)
p.age=20
print(p.age)

继承

1.has a  一个类调用另外一个自定义的类

2.is a   父子类

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

    def a(self):
        print('------fa')

    def b(self):
        print('--------fb')


class Son1(Father):
    def __init__(self, name, age):
        # 調用父類
        super().__init__(name)
        self.age = age

    # override重写(覆盖)
    def a(self,xxx):
        super().a()
        print('----Son1.a_{}'.format(xxx))


class Son2(Father):
    def __init__(self, name, color):
        super().__init__(name)
        self.color = color


s1 = Son1('tom', 18)
s1.a('tttt')
s2 = Son2('jimmy', 'red')
s2.b()

多继承和顺序

经典类：从左到右，深度优先 python2
新式类：广度优先  python3

class P1:
    def foo(self):
        print('p1---foo')


class P2:
    def foo(self):
        print('p2--foo')
    def bar(self):
        print('p2--bar')

class C1(P1,P2):
    pass

class C2(P1,P2):
    def bar(self):
        print('c2---bar')


class D(C1,C2):
    pass

#查看顺序
import inspect
print(inspect.getmro(D))
print(D.__mro__)


d=D()
d.foo()
d.bar()
# p1---foo
# c2---bar

多态

多态：同一种事物的多种形态，动物分为人类，猪类（在定义角度） 

class Animal:
	pass
class Person(Animal):
	pass
class Pet(Animal):
	pass

多态性：一种调用方式，不同的执行效果（多态性）

def func(obj):
    obj.run()
 
func(peo1)
func(pig1)
func(d1)