面向对象编程

类和对象

1.什么叫类：类是一种数据结构，就好比一个模型，该模型用来表述一类事物(事物即数据和动作的结合体)，用它来生产真实的物体(实例)。

2.什么叫对象：睁开眼，你看到的一切的事物都是一个个的对象，你可以把对象理解为一个具体的事物(事物即数据和动作的结合体)

    (铅笔是对象，人是对象，房子是对象，狗是对象，alex是对象，配齐是对象，元昊是对象)

3.类与对象的关系：对象都是由类产生的，上帝造人，上帝首先有一个造人的模板，这个模板即人的类，然后上帝根据类的定义来生产一个个的人

4.什么叫实例化：由类生产对象的过程叫实例化，类实例化的结果就是一个对象，或者叫做一个实例（实例=对象）

三大编程范式

编程范式即编程的方法论，标识一种编程风格

三大编程范式：

1.面向过程编程：捂裆派

2.函数式编程：峨美眉妹妹派

3.面向对象编程：少林蛋黄派

面向对象设计与面向对象编程

面向对象设计(Object oriented design)：将一类具体事物的数据和动作整合到一起，即面向对象设计

#用基于结构化的语言来实现面向对象设计
def wang(name,genle,type):
    def jiao(dog):
        print("%s正在叫"%dog["name"])
    def chi(dog):
        print("%s正在吃"%dog["name"])
    def init(name,genle,type):
        dog1 ={
            "name":name,
            "genle":genle,
            "type":type,
            "jiaoa":jiao,
            "chi":chi
        }
        return dog1
    return init(name,genle,type)

d1 = wang("yuanhao","gong","tianyuanquan")
print(d1)
d1["jiaoa"](d1)

面向对象编程(object-oriented programming):用定义类+实例/对象的方式去实现面向对象的设计

class Chinese:
    name = "abc"
    def chifan(self,x):
        print("姓名：%s喜欢吃%s"%(self.mingzi,x))
    def shuijiao(self):
        print("nianling:%s"%self.nianling)
    def __init__(self,name,age):
        self.mingzi = name
        self.nianling = age
f1 = Chinese("alex",18)
f1.chifan("eat")
f1.shuijiao()

类的声明

 1 大前提：
 2 1.只有在python2中才分新式类和经典类，python3中统一都是新式类
 3 2.新式类和经典类声明的最大不同在于,所有新式类必须继承至少一个父类
 4 3.所有类甭管是否显式声明父类，都有一个默认继承object父类（讲继承时会讲，先记住）
 5 在python2中的区分
 6 经典类：
 7 class 类名:
 8     pass
 9 
10 经典类：
11 class 类名(父类):
12     pass
13 
14 在python3中，上述两种定义方式全都是新式类


python3中声明类：

 1 '''
 2 class 类名:
 3     '类的文档字符串'
 4     类体
 5 '''
 6 
 7 #我们创建一个类
 8 class Data:
 9     pass
10 
11 #用类Data实例化出一个对象d1
12 d1=Data()

类的属性

类有数据属性跟函数属性（又称方法属性）

class Chinese:
    name = "abc"
    def chifan(self,x):
        print("姓名：%s喜欢吃%s"%(self.mingzi,x))
    def shuijiao(self):
        print("nianling:%s"%self.nianling)
    def __init__(self,name,age):#为实例定制数据属性，可以使用类的一个内置方法__init__()该方法，在类()实例化是会自动执行
        self.mingzi = name
        self.nianling = age
f1 = Chinese("alex",18)   #类的实例化，相当于运行__init__函数，将参数传给__init函数体中对应的位置，生成一个字典，其中self即代表f1自身
f1.chifan("eat")#通过.调用类的属性，首先会在__init__作用域内查找，若没找到会到类的属性中寻找，实例化生成的对象只具备数据属性，调用的方法为类的属性并非生成的对象所具备的属性
f1.shuijiao()

有两种方法查看类的属性

dir(类名)：查出的是一个名字列表

类名.__dict__:查出的是一个字典，key为属性名，value为属性值

class Chinese:
    name = "abc"
    def chifan(self):
        print(123)
    def shuijiao(self):
        print("456")
print(Chinese.name)#打印的是name属性对应的内容
print(Chinese.__dict__)#显示结果是一个字典,包含类的所有属性:属性值 
print(dir(Chinese))#显示结果是一个列表,包含类(包含内建属性在内的)所有的属性名

       特殊的类属性

__name__，类的名字

__doc__，查看类的文档字符串

  __module__，类定义所在的模块__class__，实例C对应的类(仅新式类中)                   

 类的方法属性的增删改查

class math:
    country = "China"
    def chi(self,food):
        print("%s正在吃%s"%(self.mingzi,food))
    def __init__(self,name):
        self.mingzi = name
f1 = math("alex")
print(math.country)    #查看
# print(dir(math))
# print(math.__dict__)
def yundong(self,hobby):#增加
    print("%s正在%s"%(self.mingzi,hobby))
math.aihao = yundong
#print(math.__dict__)
f1.aihao("打篮球")
#del math.chi
#print(math.__dict__)
def aichi(self,food):#修改
    print("%s很开心的吃%s"%(self.mingzi,food))
math.chi =aichi
f1.chi("面")

     类的数据属性的增删改查

class math:
    country = "China"
    def chi(self,food):
        print("%s正在吃%s"%(self.mingzi,food))
    def __init__(self,name,age):
        self.mingzi = name
        self.nianling = age

f1 = math("alex",18)
print(f1.__dict__)   #查看
f1.mingzi = "eric" #修改
print(f1.__dict__)
f1.xingbie = "男"  # 增加
del f1.mingzi    #删除
print(f1.__dict__）

类属性与对象(实例)属性

1.实例化会自动触发init函数的运行，最后返回一个值即实例，我们要找的实例属性就存放在init函数的局部作用域里

2.类有类的属性字典，就是类的作用域，实例有实例的属性字典，即实例的作用域

3.综上，一个点代表一层作用域，obj.x先从自己的作用域找，自己找不到去外层的类的字典中找，都找不到，就会报错

4.在类中没有使用点的调用，代表调用全局变量

country = "China"
class Chinese:
    country = "japan"
    def __init__(self,name):
        self.mingzi = name
        print(country)#打印的是普通变量country，非类结构中的变量，要调用类中的变量要用"."调用
f1 = Chinese("alex")

 静态属性、类方法、静态方法

class Room:
    arg = 123
    def __init__(self,name,weith,lenth,height):
        self.mingzi = name
        self.kuandu = weith
        self.changdu = lenth
        self.gaodu = height
    @property#静态属性，将实例化对象变成类的数据属性,将该方法封装起来，作用可隐藏逻辑代码，直接用实例+"."调用该方法
    def tiji(self):
        return self.kuandu*self.changdu*self.gaodu

    @classmethod#类方法，专门供类使用，与实例无关，类方法只能访问类相关的属性，不能访问实例属性，与实例无关
    def tell_info(cls,x):#默认参数cls不可变，为类名，后边可接参数
        print(cls)
        print("------>",Room.arg,x)

    @staticmethod   #静态方法 ，类的静态方法，没有默认参数，不能使用类变量和实例变量
    def op(x,y,z):
        print(x,y,z)
f1 = Room("alex",10,50,20)
print(f1.tiji)#由于用了property方法封装该方法（已变成数据属性），故可直接调用该数据属性
Room.tell_info("abc")
Room.op(1,2,3)     #类传参数可以调用
f1.op(1,2,3)      #实例传参数可以调用

组合

作用：做关联

class School:
    def __init__(self,name,difang):
        self.name = name
        self.difang = difang
class Teacher:
    def __init__(self,name,sex,school):
        self.name = name
        self.sex = sex
        self.school = school
class Lesson:
    def __init__(self,name,price,period,techer):
        self.name = name
        self.price = price
        self.period = period
        self.techer = techer

p1 = School("old boy","北京")
t1 = Teacher("alex","male",p1)#将p1对象直接添加到t1对象属性中
L1 = Lesson("python班",10000,"4month",t1)

面向对象编程三大特性

（1）类的继承：类的继承跟现实生活中的父、子、孙子、重孙子、继承关系一样，父类又称为基类。

           python中类的继承分为：单继承和多继承

class ParentClass1:
    pass

class ParentClass2:
    pass

class SubClass(ParentClass1): #单继承
    pass

class SubClass(ParentClass1,ParentClass2): #多继承
    pass

子类继承了基类的所有属性

class Dad:
    money = 10
    def __init__(self,name):
        self.name = name
    def hit_son(self):
        print("打人")
class Son(Dad):#继承参数“类”的所有属性
    money = 5000#当子级类属性跟父级类属性重名时，调用当级类方法会先从当级寻找，找不到会去父级找
    pass
p1 = Son("eric")
print(p1.name)
p1.hit_son()
print(p1.money)

当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好

当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好

 继承同时具有两种含义：

       含义一.继承基类的方法，并且做出自己的改变或者扩展（代码重用）

含义二.声明某个子类兼容于某基类，定义一个接口类，子类继承接口类，并且实现接口中定义的方法

接口继承
import abc   #调用接口继承模块

class All_file(metaclass=abc.ABCMeta):#声明某个子类兼容于某基类，定义一个接口类，子类继承接口类，并且实现接口中定义的方法
    @abc.abstractclassmethod   #装饰器使方法具备接口继承特性
    def read(self):
        pass
    @abc.abstractclassmethod
    def write(self):
        pass

class Disk(All_file):#子类继承基类时，必须对基类的方法进行派生才可实例化
    def read(self):
        print("disk-read")
    def write(self):
        print("disk-write")
class Cd(All_file):
    def read(self):
        print("cd-read")
    def write(self):
        print("cd-write")
class Mem(All_file):
    def read(self):
        print("mem-read")
    def write(self):
        print("mem-write")
p1 = Disk()
p1.read()

继承顺序：python如果继承了多个类，遵循深度优先跟广度优先顺序

当类时经典类时，多继承情况下，会按照深度优先方式查找

当类是新式类时，多继承情况下，会按照广度优先方式查找

经典类与新式类的差别：新式类在定义时便自动继承了object类，而经典类没有

新式类继承顺序：对于你定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列表

为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。
而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:
1.子类会先于父类被检查
2.多个父类会根据它们在列表中的顺序被检查
3.如果对下一个类存在两个合法的选择,选择第一个父类

继承顺序


class A:
    def test(self):
        print("testA")
class B(A):
    def test(self):
        print("testB")
class C(A):
    def test(self):
        print("testC")
class D(B):
    def test(self):
        print("testD")
class E(C):
    def test(self):
        print("testE")
class F(D,E):
    def test(self):
        print("testF")
f1 = F()
print(F.__mro__)#(<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
f1.test()#实例调用方法时，遵循mro顺序，会优先从子级寻找，找不到往上，先广度优先，若还找不到会找最深一级，若还没有会报错

子类中调用父类方法

class jiaotong:
    def __init__(self,name,speed):
        self.name = name
        self.speed = speed
    def run(self):
        print("%srunning!"%self.name)
class bicycle(jiaotong):
    def __init__(self,name,speed,type):
        #jiaotong.__init__(self,name,speed)#第一种方法：类调用，子级继承父级，可以在调用父级方法的基础上进行派生，减少重复代码
        super().__init__(name,speed)#第二种方法：用内置super().调用父级方法
        self.type = type
    def run(self):
        jiaotong.run(self)
        print("%s开动了"%self.name)


f1 = bicycle("danche",10,"meilida")
print(f1.name,f1.speed,f1.type)
f1.run()

 多态、封装、

类的继承有两层意义：继承和扩展

多态实际上就是继承的过程体现

class Dt:
    def __init__(self,name,temputer):
        self.name = name
        self.temputer = temputer
    def fu(self):
        if self.temputer < 0:
            print("【%s】温度太低变成冰了！"%self.name)
        elif self.temputer > 0 and self.temputer < 100:
            print("【%s】变成水了！"%self.name)
        elif self.temputer > 100:
            print("【%s】温度太高变成蒸汽了！"%self.name)
w1 = Dt("water",-2)
ice = Dt("ice",5)
steam = Dt("steam",150)
w1.fu()
ice.fu()
steam.fu()

封装的概念就是隐藏

第一个层面的封装：类就是麻袋，这本身就是一种封装

例:略

第二个层面的封装：类中定义私有的，只在类的内部使用，外部无法访问，类中定义属性名时在其前面加上_或__可实现该属性的隐藏，但这种隐藏只是一种语言上的约定，python并不会从底层禁止你访问

class People:
    _population = "60亿"
    __star = "earth"
    def __init__(self,name,salary):
        self.name = name
        self.slary = salary
p1 = People("alex",1000)
print(p1._population)#对于第一种用_封装的属性，虽然是私有的，但仍然可以访问

print(p1._People__star)#对于第二种用__封装的属性，在其前面加上_类名仍然可以访问

python并不会真的阻止你访问私有的属性，模块也遵循这种约定，如果模块名以单下划线开头，那么from module import *时不能被导入,但是你from module import _private_module依然是可以导入的

其实很多时候你去调用一个模块的功能时会遇到单下划线开头的(socket._socket,sys._home,sys._clear_type_cache),这些都是私有的，原则上是供内部调用的，但通过特殊方法仍然可以调用

注意：双下滑线开头的属性在继承给子类时，子类是无法覆盖的（原理也是基于python自动做了双下滑线开头的名字的重命名工作）