python基础之 面向对象

1.什么是面向对象？

在大学学习c#的时候接触面向对象，知道好像有什么方法，属性，人狗大战啥的。但是都忘记了，也不知道面向对象到底是个啥！
在python中一切都是对象，linux中一切都是文件(突然想起来了)

什么是class？什么是对象？什么是属性？
人狗大战走起！！！
class People:
　　 a =1000   #静态变量，是所有对象共同使用的值，通过类名或方法名来调用，但是静态变量一般使用类名来调用
    def __init__(self, name, hp, ad, sex):  #执行__ini__等价于People()，实例化这个类，主动调用。谁在实例化这个类，self这个参数就属于谁
　　　　　#self指向了一块内存地址，里面存的是字典，用于接收传递进来的参数，然后自动返回给调用者
　　　　　#调用__init__,自动传入了self函数，其他参数都是按照顺序传递进来的，并且添加到这个字典中
　　　　  #执行__init__函数
　　　　　#返给给调用者self
        self.name = name   #实例变量 对象属性
        self.hp = hp
        self.ad  = ad
        self.sex = sex
    def fight(self, dog):  #动态变量 对象方法
        dog.hp -= self.ad
        print("%s打了%s,%s掉了%s血" % (self.name, dog.name, dog.name, self.ad))

class Dog():
    def __init__(self, name, hp, ad, sex):
        self.name = name
        self.hp = hp
        self.ad = ad
        self.sex = sex

    def bite(self, people):
        people.hp -= self.ad
        print("%s咬了%s,%s掉了%s血" % (self.name, people.name, people.name, self.ad))

jordan = People("alex", 300, 20, '男')  #创建一个对象也是在创建一个实例
james = Dog('hei', 400, 10, '女')
jordan.fight(james) #对象名调用类里面的函数，并将调用者的名字和参数传递到方法里面，jordan=self
jordan.hp = 20000   #通过对象名添加属性,这个属性只是这个对象拥有
del jordan.sex      #通过对象名删除属性
print(james.__dict__) #通过dict查看对象中的变量

1.class：用于定义一个具有相同方法和属性的一类事物
2.对象：根据一个模板(class)刻画出来的一个实体，具有模板里面的一切方法和属性
3.不同的对象有不同的属性，比如我们都有手，但是我的手比你的好看，这就是属性

查看类当中的所有变量：print(类名.__dict__)
查看对象当中的指定变量：
　　方法一：print(对象.__dict__['变量'])
　　方法二：print(对象.变量) ---常用

面向对象编程：把属性和动作封装到一个类型当中，就是面向对象编程(通过Dog类生成好多具有Dog类属性和方法的狗)

2.类的加载顺序

class A:
    def __init__(self):     #初始化函数是在对象实例化的时候执行
        print('执行我了')

    def func(self):
        print('')

    def func(self):
        print('',A.country)

    country = 'China'
    country = 'English'

a = A()   #执行初始化函数
a.func()

#按照类的加载顺序来看，内存中先是开辟一个__init__的空间，然后开辟函数func的空间，看见第二个函数func的名字和第一个相同，就将第一个func的指向断掉，将func指向第二个内存地址
#然后接受两个country，所以打印出来的就是初始化函数的print()，第二个func函数，其中A.country的值是第二个country的值

注意类的加载顺序如下：
　　1.类内部的一个缩进的所有代码块都是在py文件从上到下解释的时候就已经被执行了
　　2.类中的代码永远是从上到下依次执行的

3.类的对象的命名空间

class B:
    l = [0]    #可变变量
    def __init__(self,name):     #类在实例化是被执行
        self.name = name
b1 = B('科比')
b2 = B('jordan')
print(B.l)
print(b1.l)
print(b2.l)
b1.l[0] += 1   #相当于使用类B里面的静态变量可变的L，并且为L的第0个元素赋值为1，所以所有使用类B实例化的对象都会随之改变
print(b2.l[0]) #是对象b2调用类里面的可变的数据变量l，再上一步中b1已经修改过了此变量，所以结果为1
b1.l = [123]   #相当于在b1的空间里面新定义了一个l，并且赋值为123，和类B没有关系，和使用类B进行实例化的对象也没有关系
print(b2.l)    #所以b2.l还是为1

1.类中的内容和对象中的内容是分别存储的，是存储在两个不同的内存空间
2.类是全部加载完整个类之后，类名才指向给类开辟的内存地址
　而函数不是，函数从Python解释器解释到定义函数之后，就将函数名和参数一起分配一个内存地址了，但是函数内部代码在函数被调用的时候才会分配内存地址
3.在对象的内存空间的上方有一个指向类的内存地址的指针，叫类指针，是一个变量
4.对象去类空间中找名字:通常是在自己的空间中没有这个名字的时候，通过类指针找到类的内存地址然后在类中去找变量

注意：在操作类里面的静态变量的时候，应该尽量使用类名操作而不是对象名
　　对于可变的数据类型，最好使用对象名来进行调用
　　对于不可变的数据类型最好使用类名来进行调用

结论：只要是一个[对象.名字]直接赋值，那么就是在这个对象的空间内创建了一个新的属性
　　　只要是对一个可变的数据类型内部进行改变，那么会改变所有的通过该类进行实例化的属性

other:(重要)
　　1.如果有同名的方法和属性，总是后面的先执行
　　2.对象的命名空间在对象初始化的时候就已经开始创建
　　　　　类指针：__init__初始化之间就存在了
　　　　　对象的属性：在__init__初始化之后执行的
　　　　

 4.组合：一个类的对象是另一个类的属性(往往表达的什么里面有什么)

class Student:
    def __init__(self,name,num,course):
        self.name = name
        self.num = num
        self.course = course
class Course:
    def __init__(self,name,price,period):
        self.name = name
        self.price = price
        self.period = period
python = Course('python',20000,'6 months')
s1 = Student('kobe',10086,python)   #s1中的python是使用Course实例化出来的对象，s1.course.(name|price|period) 是s1这个学生的课程具有了python对象的name,price,period属性
ju = Student('james',10010,python)
s3 = Student('jordan',10011,python)
# print(s1.name)
# print(s1.num)
# print(s1.course.period)
print(s1.__dict__)   #打印这个对象的变量，可以看到course里面存放的是python对象的内存地址(一个类的对象可以传给另一个类的属性)

类和类嵌套的组合


组合的好处：能够减少重复代码，最重要的是能够"松耦合"

 5.面向对象的三大特性

继承(往往表达的什么是什么的关系)

继承：
　　继承实现了 IS-A 关系，例如 Cat 和 Animal 就是一种 IS-A 关系，因此 Cat 可以继承自 Animal，从而获得 Animal 非 private 的属性和方法。
　　继承应该遵循里氏替换原则，子类对象必须能够替换掉所有父类对象。
　　Cat 可以当做 Animal 来使用，也就是说可以使用 Animal 引用 Cat 对象。父类引用指向子类对象称为 向上转型 。

继承的好处是：
　　1.提高代码的利用率，减少代码的冗余
　　2.继承最大的好处是子类获得了父类的全部功能(属性和方法)
　　3.继承的另一个好处是多态
　　　　当子类和父类同时都存在run()方法的时候，通常都是子类的方法覆盖父类的方法，在代码运行的时候，总是执行子类的方法，这样就获得了另外一个好处：多态

为什么要学习继承？
　　单继承：可以有效的帮助我们提高代码的重用性
　　多继承：规范复杂的功能与功能之间的关系，多继承的工作原理能够帮助我们看源码

单继承
　　class A(要继承的类的名字B):------>括号必须写要继承的类的名字
　　　　#B:--->父类，基类，超类
　　　　#A:--->子类，派生类

class Animal(object):              #创建一个类，python中所有的类都默认基于object，叫新式类。
    def __init__(self,name,kind):  #Animal类的初始化方法，会和所有缩进4个空格的内容一起写进内存
        self.name = name           #Animal的属性
        self.kind = kind

    def eat(self,food):            #Animal类的方法
        print('%s eat %s'%(self.name,food))

class Cat(Animal):                 #基于Animal类创建Cat类，Cat类继承Animal
    def __init__(self,name,kind,eyes_color):  #Cat类中的初始化方法
        # super(Cat,self).__init__(name,kind)
        # super().__init__(name,kind)   # 相当于执行父类的init方法，必须要将Cat类获得的值传递给Cat的父类，只要传递共同拥有的就行，剩下子类中有的属性而父类中没有的属性是子类的私有属性
        # Animal.__init(self,name,kind)
        self.eyes_color = eyes_color    #派生属性,是Cat这个类的特有属性
        Animal.__init__(self,name,kind) # 在子类和父类有同名方法的时候，默认只执行子类的方法，如果想要执行父类的方法和获得父类的属性，可以在子类的方法中再 指名道姓 的调用父类的方法

    def climb(self):              # 派生方法，Cat这个类的特有方法
        print('%s climb tree'%self.name)
hua = Cat('小花','橘猫','蓝色')
print(hua.__dict__)               #当Cat自己拥有__init__的时候，就不再调用父类的了

单继承类的继承顺序：
　　1.如果子类和父类都有相同的方法，默认子类的方法覆盖父类的方法：子类的对象会优先使用子类的方法
　　2.如果即想使用子类的方法，又想使用父类的方法，就要在子类中指名道姓的调用父类的方法，但是子类的派生类和派生方法只能自己拥有
　　　　super().方法名(arg1,arg2)
　　　　父类名.方法名(self，agr1,agr2)

other:
　　1.python3中所有的类都是新式类，因为默认所有类都继承object类
　　2.python2中的类如果【类名()】扩号里面不写object，就是经典类(只有py2.x中存在)，加上object就是新生类
　　3，也可以说父类是object的类都是新式类

多继承
　　多继承是python种特有的一种继承方式，虽然java，c#等都有继承，但是不支持多继承，c++支持多继承
多继承中的继承顺序
　　1.如果对象使用名字(方法和属性)是子类中存在的，就和单继承一样，使用子类中有的名字
　　　如果子类中没有，就去父类中寻找，如果父类中也没有，就是报错
　　2.如果多个父类中都有，那么使用哪一个父类的那？
　　　　a.砖石继承问题
　　　　

　　　　上面的1234就是多继承类的继承顺序。
　　　　首先子类D先在自己的空间内寻找func()方法，如果有的话，就使用自己的方法，如果没有的话寻找父类的func()方法
　　　　其次D类继承了两个父类B,C。在python3中多继承的继承顺序默认是用广度优先的排序算法，又因为在继承的时候C在B的前面所以先继承C
　　　　其次继承B，最后在继承A，A类中也没有的话，就去A的父类中object寻找，object也没有的话就报错。
　　　　所以继承顺序为D-->C-->B-->A--object(如没有就报错)
　　　　b.乌龟继承问题
　　　　
　　　　上面的123456就是继承顺序
　　　　首先F类先在自己的空间内寻找func()方法，如果有，就继承自己空间内的方法，如果没有就寻找父类的空间内的func()方法
　　　　其次F类继承了D,E两个父类，由于在python3中多继承的继承顺序默认是广度优先，又因为在F继承的时候D在E前面，所以先继承D的分支
　　　　依次向下继承顺序为F-->D-->B-->E-->C-->A-->object(如果没有就报错)

other：
　　print(B.mro())    #用来显示类的继承顺序
　　print(B.__bases__)  #用来显示B继承了多少个类
　　
　　先抽象，在继承。
　　应该是先从具体的东西往不具体的东西走，叫做抽象。
　　　　对象-->类-->父类
　　越往基类上走就越抽象
　　　　基类-->继承-->子类-->实例化-->对象

Python2.x
　　默认不继承object，是经典类，除非在扩号里面申明，才是新式类
　　多个类之间寻找继承关系的时候，遵循深度优先的算法
　　经典类没有super()方法和mro()方法

C3算法：
　　#提取第一个点
　　# 如果从左到右第一个类，
　　# 在后面的继承顺序中也是第一个，或者不再出现在后面的继承顺序中
　　# 那么就可以把这个点提取出来，作为继承顺序中的第一个类
　　https://blog.csdn.net/u011467553/article/details/81437780

注意：
　　1.单继承中，super()方法找的是子类的父类
　　2.多继承中，super()方法找的是mro的顺序，和子类父类无关
　　

经典的累的继承顺序问题

　1.Son()是在实例化一个对象，但是没有接受的变量
　2.在执行Son()的时候，会先寻找__init__函数，没有的话回去寻找父类中的__init__方法
　3.在执行父类中的__init__的时候会调用self.func(),但是这个self指的是类实例化的对象的
　4.所以会执行Son()函数的print()方法

 6.经典类和新式类的区别？

经典类：
    1. 是py2.x版本才有的
    2. py2.x里面的类默认不继承object，需要默认在类后面的括号里面添加(object)
    3. 经典类的多继承的继承顺序使用的是深度优先的排序算法 c3算法
　　 4.没有super()方法和mro方法
新式类：
    1. 是py3.x才有的
    2. py3.x默认都是继承的object类
    3. 新式类的多继承的继承顺序使用的是广度优先的排序算法
    4. 新式类具有super()方法
            在单继承中super()寻找的时父类
            在多继承中super()是根据mro排序来寻找累的顺序
    5. 新式类具有mro()方法，用来查看多继承中类的继承顺序

 7.type和抽象类

什么是type类型？什么是元类？

class Course:
    def __init__(self,name,price):
        self.name = name
        self.price = price

python = Course('python',20000)
print(type(python))     #type一个对象时，结果返回的总是这个对象实例化的类
print(type(123))        #返回一个整形
print(type(Course))     #返回一个type类型
print(type(int))　　　　 #返回一个type类型
print(type(str))        #返回一个type类型

注意：
　　1.type在type一个对象的时候，返回的是这个对象所属的类
　　2.type一个类的时候，类也变成了对象，所有用class创造出来的类都是type类型
　　3.类也是一个'对象'，类是一个'类(type)'类型的对象
　　4.所有类的鼻祖是type类型，object也的类型也是type
　　5.对象是被创造出来的：被类实例化出来的
　　　类也是被创造出来的：特殊的方法创造类
　　　　　常规创造的类的特性：
　　　　　　1.能够被实例化
　　　　　　2.能有属性
　　　　　　3.能有方法
　　　　　元类：创造出来的不同寻常的类
　　　　　　特殊需求一：不能实例化
　　　　　　特殊需求二：只能有一个实例
　　

抽象类

from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta):    #抽象类，相当于是子类的模板，告诉子类必须要按照我这个类里面的来写
    @abstractmethod   #约束所有子类，加上这个而装饰器以后，后面所有继承我的子类必须要有该方法，否则不能实例化
    def pay(self):
        pass   # 创建的这个pay并没有内容,
               # 之所以写一个pay是为了提醒所有子类，一定要实现一个pay方法
    @abstractmethod
    def back(self):
        pass
class Wechatpay(Payment):
    def __init__(self,name,money):
        self.name = name
        self.money = money
    def pay(self):
        print('%s通过微信支付了%s元'%(self.name,self.money))

class Alipay(Payment):
    def __init__(self,name,money):
        self.name = name
        self.money = money
    def pay(self):
        print('%s通过支付宝支付了%s元'%(self.name,self.money))
　　 def back(self):
　　　　　print("退款")
#归一化设计
def pay(persion): #--->实例化的一个类的对象
　　persion.pay()
alp = Alipay('p0st',2000000)
pay(alp)

抽象类的特点：
　　1.class Payment(metaclass=ABCMeta):有metclass=ABCmeta的都是抽象类
　　2.抽象类约束所有子类，必须要实现abstractmethod装饰的方法，给我们的代码指定规范
　　3.抽象类最主要的特点：不能被实例化，只是作为子类的规范
　　抽象类中不一定包含抽象方法，包含抽象方法的类一定是抽象类。
文档

8.多态

python中处处是多态，一切皆对象

# 鸭子类型
    python当中写程序的一种特殊的情况
    其他语言中 正常的我们说一个数据类型具有某个特点,通常是通过继承来实现
        继承迭代器类,来证明自己本身是个迭代器
        继承可哈希的类,来证明自己本事是可哈希的
    但是所有的这些都不是通过继承来完成的
        我们只是通过一种潜规则的约定,如果具有__iter__,__next__就是迭代器
        如果具有__hash__方法就是可哈希
        如果具有__len__就是可以计算长度的
    这样数据类型之间的关系并不仅仅是通过继承来约束的
    而是通过约定俗成的关系来确认的
　　多个相似的类具有相同的方法名，但是又不通过抽象类/或者继承父类的约束，这几个具有相同方法的类就是鸭子类型
# 多态
    广义的多态：
        一个类能表现出的多种形式
    狭义的多态
        在传递参数的时候,如果要传递的对象有可能是多个类的对象
        我们又必须在语言中清楚的描述出到底是那一个类型的对象
        我们就可以使用继承的形式,有一个父类作为这些所有可能被传递进来的对象的基类
        基础类型就可以写成这个父类
        于是所有子类的对象都是属于这个父类的
    在python当中,因为要传递的对象的类型在定义阶段不需要明确,所以我们在python中处处都是多态
        数据的类型不需要通过继承来维护统一
注意：
    python中多态体现的并不明显，但是Python中处处都是多态
    但是python中鸭子类型体现的明显

 9.namedtuple

from collections import namedtuple
Course = namedtuple('Course',['name','price','period'])
python = Course('python',20000,'6 month')
print(python.name)
print(python.price)
print(python.period)
print(type(python))

其中的Course相当于在创建一个类,python相当于实例化一个Course的对象
通过print(type(python))来看python的类型发现，python是Course的子类<class '__main__.Course'>
namedtuple实际上在帮助我们创建了一个类，这个类只有方法，没有属性.并且属性只能在初始化的时候写，不能修改，namedtuple是一个特别的元类
nametuple的使用场景：在我们需要描述一个只有属性并且不需要修改的时候，使用namedtuple是最好的：例如扑克牌。
站在面向对象的角度来看：namedtuple的本质就是：一个元类+元组的特性

 10.pickle

在以前学习的洗后，json能处理的是较为简单的，固定的数据类型，而pickle能处理任意的python的数据类型和对象，包括类
import pickle
class Course:
    def __init__(self,name,price,period):
        self.name = name
        self.price = price
        self.period = period

# python = Course('python',20000,'6 months')
# linux = Course('linux',15800,'5 months')
# import pickle
# with open('pickle_file','ab') as f:
#     pickle.dump(python,f)
#     pickle.dump(linux,f)

import pickle
with open('pickle_file','rb') as f:
    # obj1 = pickle.load(f)
    # obj2 = pickle.load(f)
    while True:
        try:
            obj = pickle.load(f)
            print(obj.__dict__)
        except EOFError:
            break

pickle可以序列化python中出现的所有的数据类型，甚至能序列化类的对象，和一些复杂的数据类型，相比于json，pickle的应用场景会更多！

11.封装 

封装：
　　私有化的封装：私有化的方法和属性，将属性封装起来
　　广义上的封装：把方法和属性根据类别封装到类中
私有化：
　　方法\静态变量\实例变量(对象属性)都可以私有化
　　什么是私有化：就是只能在类的内部可见，类的外部不可见，不能访问

class Goods:
　　__country = 'china' #静态变量的私有化
　　def __init__(self,name,price):
　　　　self.name =name
　　　　# self.price =price
　　　　self.__price =price #私有的属性，将价格变成类的私有化，只能在类的内部调用

　　def get_price(self):
　　　　print(self.__price)

　　def __get_name(self): #私有方法在外部不能被调用，只能在内部被使用
　　　　print(self.name)

#print(Goods.country)
apple = Goods('苹果',5)
apple._Goods__get_name() #通过对象名来调用类的变量(类名.__dict__)里面存的变量名
print(apple.name)
print(apple.price)
apple.get_price() #调用类内部方法获得私有化属性

1. python在私有化的时候，都是从python语法角度上做的了修改，在内部定义了一个私有属性,使用print(对象__dict__)能看到对象的变量
2. 所有的私有的变化都是类的内部定义的时候完成的，都是通过self所在的类名和私有化的名字存起来---> _类名__属性名,通过print(对象__dict__)

3.注意：私有的概念，但凡在类的外面，都不能用，是不可以被继承的
私有的所有内容：实例变量(对象属性)，静态属性(类变量)，方法等都不能被子类继承，只能在类的内部使用

4.私有化整体的逻辑：_类名__方法名()---》来调用私有方法，也是私有方法在内存中的变量名

5.凡是在类的内部定义的私有的就都是私有的(_类名__私有变量名)，但是在类的外部定义的时候就不是私有的了

关于私有化的经典面试题

　此题的结果打印的是is foo。在Son()实例化之前，会在内存中开辟两个类的内存空间和一个对象的内存空间，并且内存空间的类指针如上图所示。
在实例化Son()之后，由于此Son()没有__init__方法，所以会去父类中区寻找，找到父类中的__init__()函数之后，会执行self__fun(),但是此时
的__func是私有化函数，并且在Foo类里面的名字为_Foo_func(),但是其实例化的类中没有_Foo_func()方法，所以只再起父类中寻找，所以打印is foo

 13.@property

　@property 把装饰的一个方法伪装成一个属性

class Goods:
    discount = 0.8

    def __init__(self, name, price):
        self.name = name
        self.__price = price

    @property    # 只支持obj.price的方式查看这个结果,不支持修改,也不支持删除
    def price(self):
        p =  self.__price * self.discount
        return p

    @price.setter
    def price(self,value):
        if type(value) is int or type(value) is float:
            self.__price = value

apple = Goods('苹果', 5)
banana = Goods('香蕉', 10)
apple.price = 16    #对应的调用的是被setter装饰的price方法
print(apple.price)  #对应调用的是被property装饰的price方法

# 私有的 :通过过给__名字这样的属性或者方法加上当前所在类的前缀,把属性隐藏起来了
        # 只能在本类的内部使用,不能在类的外部使用,不能被继承
# property 把一个方法伪装成属性
# property和私有的两个概念一起用
    # 定义一个私有的
    # 再定义一个同名共有的方法,被property装饰

    # @方法名.setter
    # @方法名.deleter 

12.classmethod和staticmethod

classmethod是用来指定一个类的方法为类方法，没有此参数指定的类的方法为实例方法
@classmethod:修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数是需要表示类自身的cls参数，可以来调用类的属性，类的方法，实例化对象等。
class A(object):

    # 属性默认为类属性（可以直接被类本身调用）
    num = "类属性"

    # 实例化方法（必须实例化类之后才能被调用，对象方法）
    def func1(self): # self : 表示实例化类后的对象地址id
        print("func1")
        print(self)

    # 类方法（不需要实例化类就可以被类本身调用）
    @classmethod
    def func2(cls):  # cls : 表示没用被实例化的类本身
        print("func2")
        print(cls)
        print(cls.num)
        cls().func1()
    # 不传递默认self参数的方法（该方法也是可以直接被类调用的，但是这样做不标准）也叫普通方法，如果加上self的话，类在调用的时候必须要将类本身传递进去 A.func3(A),才不会报错，
    def func4():
        print("func4")
        print(A.num) # 属性是可以直接用类本身调用的

# A.func1() 这样调用是会报错：因为func1()调用时需要默认传递实例化类后的地址id参数，如果不实例化类是无法调用的
A.func2()
A.func4()

类方法总结：
　　1.类方法是给类来用的，是类的方法，类在使用的时候会将类本身传递给类方法的第一个参数，python为我们提供了classmethod内置方法来将类中的函数定义成类方法(也可以说成将对象方法(函数)变成类方法)
　　2.在类调用类方法的时候不需要实例化就可以直接调用，也不需要self参数
　　3.虽然说类的方法可以通过对象名来调用，但是通常都是使用类名来调用，因为是类的方法

总结：
　　　1、实例方法，该实例属于对象，该方法的第一个参数是当前实例，拥有当前类以及实例的所有特性。
　　　2、类方法，该实例属于类，该方法的第一个参数是当前类，可以对类做一些处理，如果一个静态方法和类有关但是和实例无关，那么使用该方法。
　　　　　　类方法的使用场景：在使用类之前，需要使用类中的方法来进行一些计算
　　　3、静态方法，该实例属于类，但该方法没有参数，也就是说该方法不能对类做处理，相当于全局方法
　　　　　　静态方法使用场景：编写类时需要采用很多不同的方式来创建实例，而我们只有一个__init__函数，此时静态方法就派上用场了

@staticmethod就是普通函数，也是静态函数

classmethod文章1
classmethod文章2 3

返回系列