五、python学习-面向对象

1.面对对象程序开发基础（oop）

面对对象：高内聚 低耦合

面向过程：
    优点：效率高，执行速度快
    缺点：维护性，移植性差，表达不出一类的语义
面向对象：
    优点：可读性，可移植性，可维护性高
    缺点：执行效率捎慢

1.类的定义

class Car():
    pass
class Car(object):
    pass

2.类的实例化

class Car():
    pass
obj = Car()

3.类的基本结构:成员属性、成员方法

4.类的命名：大驼峰命名法（每个单词首字符大写）

1.面对对象的三大特征：封装 继承 多态

1.封装：对类中成员属性和方法的保护，控制内部成员的访问、修改、删除等操作

对象的相关操作

1.两个保护等级：
    public:
    private:在成员前面加上（ __成员）下划线，默认是
2.类中的绑定方法（类的内部）
    绑定到对象（对象调用方法，系统自动把该对象当成参数进行传递时）系统默认
    绑定带类：对象或者类调用方法时，系统自动把该类当成参数进行传递

3.例子
class MyCar():
    color = ""
    __logo = ""
    def drive(self):
        pass
    def __info():
        pass
# 实例化
obj = MyCar()
obj.drive()

4.实例化的对象动态添加公有成员属性和方法
obj.color = "红色"
#__dict__查看对象或者类中的成员，返回一个字典：对象.__dict__
(1)动态添加无参方法
def dahuangfeng():
    pass
# 对象.属性（自定义的） = 方法
obj.dahuangfeng = dahuangfeng
obj.dahuangfeng()
(2)动态添加有参方法
def qingtianzhu(name):
    pass
obj.qingtianzhu = qingtianzhu
obj.qingtianzhu("擎天柱")
(3)动态添加lambda 匿名函数
obj.weizhentian = lambda : print("weizhentian")
obj.weizhentian()

5.在类外，让系统自动帮助传递obj这个对象参数
import types
def qingtianzhu(self,name):
    pass
# 通过MethodType 来创建一个绑定方法，自动传递obj对象
obj.qingtianzhu = types.MethdType(qingtianzhu,obj)
obj.qingtianzhu("擎天柱")

类的相关操作

class MyCar():
    color = ""
    __logo = ""
    def drive(self):
        pass
    def __info():
        pass
1.定义的类访问公有成员属性和方法
MyCar.oil
MyCar.drive()
2.定义的类动态添加公有成员和属性
# 添加公有成员属性
MyCar.logo = ""
# 添加公有成员方法
(1)动态添加无参方法
def dahuangfeng():
    pass
# 类.属性（自定义的） = 方法
MyCar.dahuangfeng = dahuangfeng
MyCar.dahuangfeng()
(2)动态添加有参方法
def qingtianzhu(name):
    pass
MyCar.qingtianzhu = qingtianzhu
MyCar.qingtianzhu("擎天柱")
(3)动态添加lambda 匿名函数
MyCar.weizhentian = lambda : print("weizhentian")
MyCar.weizhentian()

##--**类和对象之间的注意点**

类中的成员只归属于当前这个类本身
对象可以调用其中的公有成员，但是没有修改和删除的权利，因为都归属于类，不是对象中的
类无法调用对象中的相关成员，但是对象可以调用类中的相关成员
    # 对象调用类中成员
    调用对象中的成员时，先看看自己有没有该成员
    如果有就先调用自己没，没有调用类的

私有成员和删除成员

class Plane():
    captain = "guo"
    __airsister = 3
    def fly(self):
        pass
    def fly2():
        pass
    def __plane_info(self):
        print("%d" %(self.__airsister)
    def __plane_info2():
        print("%d" %(Plane.__airsister)

    def pub_info(self):
        self.__airsister

obj = Plane()
obj.fly()
obj.fly2()

1.私有成员的改名策略[_类名__成员名]
obj._Plane__airsister
Plane._Plane__airsister
obj._Plane__plane_info2
Plane._Plane__plane_info2

2.利用类内的公有方法简介调用私有成员（推荐）
obj.pub_info()
Plane.pub_info()

##--删除相关成员
3.实例化的对象删除公有成员属性和方法
obj.captain = "w"
del obj.captain
#
print(obj.captain)=>guo
# 删除方法
obj.func = lambda:pass
obj.func()
Plane.func()//error
del obj.func
obj.func()//error
4.定义的类删除公有成员属性和方法
del Plane.captain
#
print(obj.captain)=>error
# 删除方法
del Plane.fly
obj.fly()//error

类和对象的注意点

# 类空间和对象在内存中是两份空间
    a.类空间在内存栈中
    b.对象空间在内存堆中

__init__构造方法

# ###魔术方法(特定时机自动触发)
__doc__：
__name__：
__all__:指定类中方法(*)的范围 __all__ = ["a","测试"]

__init__魔术方法（构造方法）
    触发时机：实例化对象，初始化的时候触发
    功能：为对象添加成员
    参数：参数不固定，至少一个self参数
    返回值：无

#（1）基本语法
class MyClass():
    def __init__(self):
    self.name = "a"
obj = MyClass()
obj.name // "a"
# (2)多参数构造方法
class MyClass():
    def __init__(self,name):
        self.name = name
obj = MyClass(name = "ab")
obj.name // "ab"

2.继承：一个类除了自己所拥有的属性方法之外，还获取了另一个类的成员属性和方法

一个类继承另外一个类，该类是子类（衍生类），被集成的这个类叫做父类（基类，超类）

类都默认集成父类 object

1.单继承

子父继承之后，子类不可以调用父类的公有成员

子父继承之后，子类不可以调用父类的私有成员

子父继承之后，子类可以重写父类的同名方法

class Human(object):
    hair = "金色"
    sex = "男"
    def eat(self):
        pass
    def __makeboby(self):
        pass
class Man(Human):
    pass
obj = Man()

2.多继承

calss Father():
    property = "cac"
    def f_hobby(self):
        pass
calss Mother():
    property = "caaa"
    def m_hobby(self):
        pass
calss Daughter(Father,Mother):
    pass
obj = Daughter()
obj.property//cac

super(py3.0+：广度优先 py2.7+:深度优先)

super()只调用父类的相关公有成员

super()调用方法时，必须是绑定方法默认传递该类的对象

calss Father():
    property = "cac"
    def f_hobby():
        pass
calss Mother():
    property = "caaa"
    def m_hobby(self):
        pass
calss Son(Father,Mother):
    property = "son"
    //利用类来调用父类的成员
    def ski1(self):
        Mother.property
        Father.property
    //利用对象调用父类的属性方法
    def ski2(self):
        self.property//son
    //利用super调用父类的属性方法
    def ski3(self):
        super()//Son()
        super().m_hobby()
        super().property//cac
        super().f_hobby()//error

菱形继承（钻石继承）

# 结构：
#    a
# b     c
#    d
class a():
    pty = 4
    def f(self):
        print(1)
        print(self.pty)
class b(a):
    def f(self):
        print(2)
        super().f()
        print(3)
class c(a):
    def f(self):
        print(4)
        super().f()
        print(5)
class d(b,c):
    pty = 4
    def f(self):
        print(6)
        super().f()
        print(7)
obj = d()
obj.f()//6241537

mro列表(返回的是方法调用顺序的列表，针对于多继承下的同名方法，按照列表的顺序依次调用):类.mro()

issubclass:判断是否存在子父关系，只要在一个继承链上即可，应用范围在类身上（语法与isinstance的使用一模一样）

isinstance:判断类型

3. 多态

不同的子类对象，调用相同的父类的方法，产生不同的执行结果

2. 魔术方法

__init__构造方法

# ###魔术方法(特定时机自动触发)
__doc__：
__name__：
__all__:指定类中方法(*)的范围 __all__ = ["a","测试"]

__init__魔术方法（构造方法）
    触发时机：实例化对象，初始化的时候触发
    功能：为对象添加成员
    参数：参数不固定，至少一个self参数
    返回值：无

#（1）基本语法
class MyClass():
    def __init__(self):
    self.name = "a"
obj = MyClass()
obj.name // "a"
# (2)多参数构造方法
class MyClass():
    def __init__(self,name):
        self.name = name
obj = MyClass(name = "ab")
obj.name // "ab"

__new__魔术方法

魔术方法调用时，是按照触发时机排序，不是代码顺序

触发时机：实例化类生成对象的时候触发（触发时机在init之前）
功能：控制对象的创建过程
参数：至少一个cls接受当前的类，其他的根据情况决定
返回值：通畅返回对象或none

# 1. 基本语法
class MyClass():
    a = 1
    def __new__(cls):
        pass
obj = MyClass()//Node

class MyClass(object):
    a = 1
    def __new__(cls):
        # 借助父类object
        obj = object.__new__(cls)
        # 1.返回本类对象
        return obj
        # 2.返回其他类的对象
        return object
        # 3.不返回任何对象
        return None
obj = MyClass()

# 2.new方法的处罚时机要快于init

# 3.new方法的参数要和init方法参数一一对应
class a():
    def __new__(cls,name):
        return object.__new__(cls)
    def __init__(self,name):
        self.name=name
# 4.注意点
    如果返回的不是本类对象，不会调用init构造方法

__del__魔术方法（析构方法）

触发时机：当对象被内存回收的时候自动触发【1.页面执行完毕回收所有变量，2.所有对象被del的时候】
功能：对象使用完毕后资源回收
参数：一个self接受对象
返回值：无

class LangDog():
    food = "吃肉"
    def __init__(self.name):
        self.name=name
    def __del__(self):
        print("del")
# 1.页面执行完毕回收所有变量
obj = LangDog("a")
print(obj.name)//a 刀疤
# 2.所有对象被del的时候
# 当一个值，没有任何变量指向 引用，这个值才会被真正的释放
other_obj = obj
print("开始")
del obj #删除的是obj的指向链接
print("结束")
#--开始  结束  del
# other_obj obj内存地址为同一个

other_obj = obj
print("开始")
del obj #删除的是obj的指向链接
del other_obj
print("结束")
#--开始  del 结束 

# 3.模拟文件操作
#fp = open(文件，模式，编码)
#fp.read()
#fp.close()

class ReadFile():
    def __new__(cls,*args,**kwargs):
        # 判断文件存在不存在
        if os.path.exists(filename):
            return object.__new__(cls)
        else:
            return None
    def __init__(self,filename):
        self.fp = open(filename,"r","utf-8")
    def __del__(self):
        self.fp.close()
    def readcontent(self):
        return self.fp.read()
obj = ReadFile(filename="ceshi.txt")
obj.readcontent()

__str__魔术方法

触发时机：使用print(对象)或者str(对象)的时候触发
功能：查看对象
参数：一个self接受当前对象
返回值：必须返回字符串类型

calss Cat():
    gift = "传说中的小猫有九条命"

    def __init__(self,name):
        self.name = name
    def __str__(self):
        return "123456"
    def cat_info(self):
        pass
tom = Cat("tangmu")
# 1.print答应改对象
print(tom)#123456
# 2.str
str(tom)#123456

__repr__魔术方法

触发时机：使用repr(对象时候触发)
功能：查看对象，与魔术方法__str__相似
参数：一个self接受当前对象
返回值：必须返回字符串类型

__str__ = __repr__

calss Cat():
    gift = "传说中的小猫有九条命"

    def __init__(self,name):
        self.name = name
    def __repr__(self):
        return "123456"
    def cat_info(self):
        pass
tom = Cat("tangmu")
repr(obj)#"123456"
# __str__ = __repr__
# 1.print答应改对象
print(tom)#123456
# 2.str
str(tom)#123456

__call__魔术方法

触发时机：把对象当作函数调用的时候自动触发
功能：模拟函数花操作
参数：一个self接受当前对象
返回值：看需求

# 1.基本用法
class MyC():
    def  __call__(self):
        print("call")
obj = MyC()
obj()# call
# 2.模拟洗衣服的过程
calss Wash():
    def step1(self,name):
        print(name)
    def step2(self):
        print(2)
    def step3(self):
        print(3)
    def __call__(self,name):
        self.step1(name)//1
        self.step2()//2
        self.step3()//3
obj = Wash()
obj.step1("a")//a
obj.step2()//2
obj.step3()//3
obj("a")

# 3.模拟内置方法 int 实现myint
import math
class MyInt():
   def __call__(self,num):
        if isinstance(num,bool):
            if num ==True:
                return 1
            else:
                return
        elif isinstance(num,int):
            return num
        elif isinstance(num,float):
            # <!--# 方法一-->
            # <!--strvar = str(num)-->
            # <!--return strvar.split(",")[0]-->
            # <!--if num >= 0:-->
            # <!--    return math.floor(num)-->
            # <!--else:-->
            # <!--    return math.ceil(num)-->
            return  math.floor(num) if num >= 0 else math.ceil(num)
        elif isinstance(num,str):
            if (num[0] == "+" or num[0] == "-")and num[1:].isdecimal():
                if num[0] == "+":
                    sign = 1
                else:
                    sign = -1
                return eval((0 if num[1:].lstrip("0")=="" else num[1:].lstrip("0"))) * sign
            elif num.isdecimal():
                return eval((0 if num.lstrip("0") else num.lstrip("0")))
            else:
                return "error"
            pass
myint = MyInt()
print(myint("+00002155251"))

bool（int、float ）

触发时机：使用bool(对象)的时候触发
功能：强制对象
参数：一个self接受当前对象
返回值：必须是布尔类型

add(与之相关的__radd__反向加法)(sub:- mul