python面向对象-1

1.面向对象的思想优点

　　优点: 简化代码 ,构建公共模板 ,扩展性强

　　思想: 类作为模板 ,对象通过模板实例化对象 ,对象去做事 ,抽象将显示存在的事物使用代码体现

 

2.三大特性

　　封装(狭义) : 对属性的封装 ,对方法的封装

　　继承 

　　　　1.子类拥有父类除私有内容外所有

　　　　2.对象通过子类-父类-...找到自己所需要的属性方法

　　　　3.py3默认继承object是新式类 , 使用c3算法 ,print(类型.mro()) 判断类名,查看多继承的继承顺序

　　　　4.super().方法 ,可以调用父类的同名方法

class Base:
    def __init__(self):
        print('BASE')


class A(Base):
    def __init__(self):
        super().__init__()
        print('A')


class B(Base):
    def __init__(self):
        super().__init__()
        print('B')


class C(A, B):
    def __init__(self):
        super().__init__()
        print('C')


C()

print(C.mro())  # 按照这个算法顺序,确定某个类的继承顺序

　　多态

 

3.成员

　　属性 (__dict__查看)

　　　　对象的属性

　　　　类的属性

　　方法 (dir()查看)

　　　　普通方法

　　　　类方法 :@classmethod 

　　　　静态方法 :@staticmethod 放在类中的普通函数

　　属性 (方法伪装属性)

　　　　很多方法执行后获得的是一个结果 ,不像一个动作

　　　　@property　　　　　　#伪装属性

　　　　@方法名.setter　　　　#根据传入的values ,来改变属性的返回值

　　私有成员

　　　　仅内部可以调用的变量或方法 ,私有属性,私有类方法,私有对象属性

　　self与cls

　　　　self形参是对象本身 ,当对象实例化之后 ,调用时将对象的内存地址给self

　　　　cls形参是类本身

class Person:
    local = '地球'
    # 私有类属性
    __character__ = '积极向上'

    def __init__(self, name, ad, hp, character):
        self.name = name
        self.ad = ad
        self.hp = hp
        # 私有对象属性
        self.__character__ = character

    # 私有类方法
    def __local__(cls):
        print(cls.__character__)

    # 类方法
    @classmethod
    def Dict(cls):
        return cls.__dict__

    # 静态方法
    @staticmethod
    def Sum(n):
        return n + 2

    # 属性Info
    @property
    def Info(self):
        return '{}-{}-{}'.format(self.name, self.ad, self.hp)

    # 修改属性Info
    @Info.setter
    def Info(self, values):
        if values < 100:
            self.ad = values


print(Person.__character__)
print(Person.Dict())
print(Person.Sum(2))

obj1 = Person('lucy', 10, 50, '积极向左')
print(obj1.Info)
obj1.Info = 99
print(obj1.Info)

 

4.对象的行为

　　实例化对象

　　　　1.__new__方法在内存开辟空间创建对象

　　　　2.执行__init__方法初始化对象

　　对象调用属性与方法的顺序

　　　　优先在内存中寻找-->对象内部封装-->类-->父类

 

5.类与类之间的关系

　　依赖关系 : 相互依存性较低 ,就是一个类中需要执行动作时 ,需要其他类中的方法属性去帮助完成 ,一般通过参数将对象进行调用

 

class Eat:
    def handler(self, *args):
        for i in args:
            i.eat()


class Apple:
    def eat(self):
        print('吃苹果')


class Pear:
    def eat(self):
        print('吃梨')


obj = Eat()
obj1 = Apple()
obj2 = Pear()
obj.handler(obj1, obj2)

 

　　关联关系 : 两种事物必须是互相关联的. 但是在某些特殊情况下是可以更改和更换的.

 

class Country:
    def __init__(self, name):
        self.name = name
        self.pro_list = []

    def add_pro(self, pro):
        self.pro_list.append(pro)

    def show_pro(self):
        for i in self.pro_list:
            print(i.name, i.cou)


class province:
    def __init__(self, name, country):
        self.name = name
        self.cou = country


C1 = Country('火星国')

p1 = province('省1', C1.name)
p2 = province('省2', C1.name)

C1.add_pro(p1)
C1.add_pro(p2)

C1.show_pro()

　　继承关系 :就是继承父类非私有属性方法 ,self会先从对象中寻找方法属性 ,当没有的时候会去父类中寻找

 

6.接口类(约束抽象)

　　接口类是继承的一个用法 ,继承可以让子类拥有父类的代码 ,防止代码重复 ,还可以定义一个接口类 ,仅定义接口名(函数名) ,由子类继承去写接口中的功能

　　接口类抽象规定了兼容接口 ,是的外部调用者不需要关心细节

# 接口类 ,约束子类必须拥有的方法,及参数
class Pay_Base:
    def pay(self, money):
        raise NotImplementedError('pay must be Implemented')


class ALpay(Pay_Base):
    def pay2(self, money):
        print('支付宝支付')


class WXpay(Pay_Base):
    def pay(self, money):
        print('微信支付')


class APpay(Pay_Base):
    def pay(self, money):
        print('苹果支付')

# 支付函数，执行对象的接口类约束函数
def pay(payobj, money):
    payobj.pay(money)


p1 = ALpay()

pay(p1, 100)

　　

 7.反射

　　反射是通过字符串去操作对象或者类或者是模块 ,第一参数是(对象或者类或者是模块)

　　常用:

　　　　getter()　　　　 getattr(参数1 ,'字符串')　　　　　　　　#获取内存地址

　　　　hasattr()　　　　hasattr(参数1 ,'字符串')　　　　　　　　#判断变量是否存在

import m1
class A:
    local = 'Beijing'

    def __init__(self):
        pass

    def datetime1(self):
        print('time')

a1 = A()

# 通过反射从对象获取属性
b = getattr(a1, 'local')

# 通过反射从类中拿属性
c = getattr(A, 'local')

# 通过反射从对象中拿方法
d = getattr(a1, 'datetime1')

# 通过反射从模块中拿到类B
B = getattr(m1,'B')

print(hasattr(m1,'B'))

e = B()

 

8.特殊双下方法

　　__str__与__repr__ ,不太理解,但是都可以把对象的内存地址转为可读字符串

　　__call__方法 ,当对象 + () 的情况就会执行 __call__方法

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

    def __str__(self):
        return self.name

    def __call__(self, *args, **kwargs):
        print(args, kwargs)
        return args, kwargs

    def __repr__(self):
        return '有str就不会执行repr'

a1 = A('lucy')

# 执行对象的__str__方法
print(a1)

# 执行__call__方法
a1(1, 2, 3, n=1, m=2)

# 直接执行对象的__repr__方法
print(repr(a1)) 

# 查看对象有多少个方法
print(dir(a1))

　　__new__方法 ,new方法是object基类中的方法 ,是构造方法 ,开辟内存 ,创建对象

class A:
    def __new__(cls, *args, **kwargs):
        print('1')
        cls.name = 'LOP'
        return object.__new__(cls)  # 引用obeject的c语言创建对象功能

    def __init__(self):
        print('2')


# 第一步执行__new__方法中的内容,将返回值给对象名a1
# 第二步执行__init__初始化对象
a1 = A()
print(a1.name)
a2 = A()
print(a1 is a2)　　　　# False 两个对象各用内存

##单例模式##

class A:
    __instance = None

    def __new__(cls, *args, **kwargs):
        if cls.__instance == None:
            cls.__instance = object.__new__(cls)
        
        # __instance从此记录单例对象的内存
        return cls.__instance

a1 = A()
a2 = A()
print(a1 is a2)