面向对象

类(Class):

用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。

对象是类的实例。
对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。 实例化:创建一个类的实例，类的具体对象。 

2 class 类名:
3     '类的文档字符串'
4     类体
5 '''

类的用法：

• 实例化产生对象
• 属性引用:数据属性；函数属性

class Chinese:

    country = ‘china’.    #数据属性

    def __init__(self,name,color,age):
        #初始化，但是一定不能有返回值
        if not isinstance(name,str):
            raise TypeError #挑起异常
        
        self.name = name
        self.color = color
        self.age = age
   def talk(self):        #函数属性
        print('talk')

    def eat(self):
        print('eat')

    def sleep(self):
        print('sleep')

p1 = Chinese('mona','pink',18) ===》 p1-对象

类的数据属性可以增删查改

对象的数据属性可以增删查改

对象本身并没有函数属性，但是可以访问类的--对象的绑定方法。对象里通用的数据和函数是引用类的名称空间

对象的属性，优先从自己的__dict__字典里找，如果自己的字典里没有，访问类里的，如果类里也没有，报错。自己定义的属性对其他引用了类的相同属性没有影响

实例化会做两件事：

1:先创建对象，赋值给p

2.把括号后的参数传给__init__执行初始化，__init__执行初始化时，会给对象创建名称空间。对象本身只有数据属性

属性调用：Chinese.name == Chinese.__dict__[‘country’]

 

类和对象名称空间：

    类的名称空间：定义时就产生名称空间

    对象的名称空间：实例化时产生对象的名称空间

 

继承：

继承是一种创建类的方式，遗传父类所有的属性

派生：衍生出新的属性

Super().talk   继承用父类的属性，并扩展

class People:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age 
        self.sex = sex
        
class Student(People):#继承People
    school = 'oldboy'
    #派生出新的属性
    def __init__(self,name,age,sex,group):
        super().__init__(name,age,sex) #内置函数super（）
        # == People.__init__(self,name,age,sex) 调用类的函数
        self.group = group
        
t = Student('mona',18,'female',9)

在python3中，所有类默认继承object类

但凡继承了object的类都称为新式类（在python3中所有类都为新式类）

没有继承object的类都称为经典类

 

继承顺序：从下而上，从左至右

        新式类：广度优先

        经典类：深度优先

       Class.mro()查看类的继承循序

print(Student.mro())

#[<class '__main__.Student'>, <class '__main__.People'>, <class 'object'>]

 

继承：解决代码重用的问题，减少代码冗余

继承是类与类之间的关系，是一种什么是什么的关系

组合：是什么有什么的关系，也是为了减少重复代码

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

class Student(People):#继承People
    school = 'oldboy'
    #派生出新的属性
    def __init__(self,name,age,sex,group,year,mon,day):
        super().__init__(name,age,sex) #内置函数super（）
        # == People.__init__(self,name,age,sex) 调用类的函数
        self.group = group
        self.birth = Date(year,mon,day)  #组合Date类，创建self.birth

class Date:
    def __init__(self,year,mon,day):
        self.year = year
        self.mon = mon
        self.day = day

    def __str__(self):
        return '%s-%s-%s'%(self.year,self.mon,self.day)


t = Student('mona',18,'female',9,1993,3,25)
print(t.birth)     #1993-3-25

抽象类：

父类限制：

   子类必须要有父类的方法

    子类实现的方法必须跟父类的方法名字一样 

import abc
class File(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def read(self):
        pass
    def write(self):
        pass
class Txt(File):
    #read & write 这两个函数必须要有
    def read(self):
        pass
    def write(self):
        pass
    
t = Txt()

封装：

语法：__开头的属性，在定义阶段发生变形，__属性   ====> _类名__属性

_Self.__name  隐藏属性，用户无法直接访问该属性。另外提供接口供用户使用

@property  类装饰器  把被装饰的函数伪装成一个数据属性 

class People:
    def __init__(self,name,age,sex,weight,height):
        self.name = name
        self.age = age
        self.sex = sex
        self.__height = height
        self.__weight = weight
    @property
    def BMI(self):
        return self.__height/(self.__weight**2)

s = People('mona',18,'female',1.60,50)
print(s.BMI)

多态：同一种事物的不同形态

例如：同一类产生的不同的对象，对象可以共用该类的属性。即是多态

import abc
class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def talk(self):
        pass
class People(Animal):
    def talk(self):
        print('say hello')
class Pig(Animal):
    def talk(self):
        print('哼哼哼')
class Dog(Animal):
    def talk(self):
        print('汪汪汪')
alex=People()
yuanhao=Pig()
wupeiqi=Dog()

# alex.talk()
# wupeiqi.talk()
# yuanhao.talk()

def talk(obj):
    obj.talk()

绑定方法：绑定给谁就是给谁用的

凡世在类中定义的函数（没有被任何装饰器修饰），都是绑定给对象的，即给对象用

特点：obj.bar（）自动把obj当作第一个参数传入，因为bar()中的处理逻辑就是要处理obj

class People:
    def __init__(self,name):
        self.name = name
    def bar(self):
        print('--->',self.name)

绑定类的方法：

定义：在类中定义的，被classmethod装饰的函数是绑定到类的方法

特点：自动把类当作第一个参数传入

#seetings.py 文件内容：IP= 10.10.10.10 
#                    port = 8080

class Mysql:
    def __init__(self,ip,port):
        self.ip = ip
        self.port = port

    @classmethod
    def from_conf(cls):
        import settings #导入模块
        obj = cls(settings.ip,settings.port)
        return obj
    
s = Mysql.from_conf()
print(s.ip,s.port)
# 10.10.10.10   8080

非绑定方法：staticmethod

非绑定方法就是一个函数，不需要类，也不需要对象

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

    def bar(self):
        print('--->',self.name)

    @staticmethod
    def calculate(x,y):
        return x+y

s = People('mona')
print(s.calculate(2,8))   #10

面向对象的软件开发：

OOA:：面向对象分析；

OOD：面向对象设计；

OOP：面向对象编程；

OOT：面向对象测试；

 OOSM ：面向对象维护

反射：主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）

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

s = People('mona',18,'female')
print(hasattr(s,'name'))         判断是否是对象或类的属性
print(getattr(s,'name'))         对属性取值
setattr(s,'group','group9')      添加或更改属性
print(getattr(s,'group'))
delattr(s,'group')              删除属性
print(s.__dict__)

'''True
mona
group9
{'name': 'mona', 'age': 18, 'sex': 'female'}'''

面向对象内置方法：如：__str__

class Student:
    school = 'oldboy'
    def __init__(self,name,age):
        self.name = name
        self.age = age

    # 控制打印对象名时显示的信息，必须有return 返回值
    def __str__(self):
        return self.name

    # 程序执行完后，对象已经在内存中清除完后，自动运行，一般写些关闭其他程序的操作
    def __del__(self):
        #做些与这个对象有关的清理操作
        print('===========>')

    #模拟与列表操作,查看值
    def __getitem__(self, item):
        return getattr(self,item)

    #修改
    def __setitem__(self, key, value):
        # setattr(self,key,value)
        self.__dict__[key] = value
    #删除
    def __delitem__(self, key):
        delattr(self,key)