Python之面向对象基础

1.面向对象编程与面向过程编程

　　面向对象编程，其本质是以建立模型体现出来的抽象思维过程和面向对象的方法。通过把真实的物体抽象成对象，然后赋予对象属性、方法等特性，然后去解决问题。

　　面向过程编程，本质是面向结果编程，通过函数解决问题。

2. 面向对象基础

　　a. 类：具有相同竖向和方法的一类事物

　　b. 对象：具有具体属性的事物

　　c. 静态属性：所有的对象共有的属性，可以直接调用

　　d. 对象属性/方法：是属于某一个对象的，只能在实例化之后对象调用

class 类名:    # 类名首字母大写
    属性 = "功能"    # 类的属性：静态属性，不是必须要定义的，当多有的对象都用的时候去定义
    def __init__(self,参数):    # self是不需要传的
        #__init__这里是定义了一个该类对象共有的属性
        # 这里的属性是对象属性，
        self.key = 参数    # 这里self.key就相当于字典的key,参数就相当于value
    def 方法(self):  # 类里面的方法本质上就是函数--函数必须要传一个参数self
        pass

print(类名.属性)
# 实例化一个对象，对象就是实例
对象 = 类名("参数")    # 参数是传到__init__函数里

对象.函数名()    # 调用成功，传入的self就是对象，当用一个对象去调用对他的方法的时候，自动传入的一个参数，这个参数就是对象本身

 　　示例1：计算长方形的面积

class Rectangle:
    role = "retangle"
    def __init__(self,long,wide):
        self.long = long
        self.wide = wide
    def length(self):
        return 2*(self.long+self.wide)
    def area(self):
        return self.long*self.wide

rect = Rectangle(3,4)
ret_l = rect.length()
print(ret_l)
ret_a = rect.area()
print(ret_a)

 　　示例2：计算圆的面积

from math import pi
class Circle:
    rloe = "circle"
    def __init__(self,r):
        self.r = r
    def length(self):
        return 2*pi*self.r
    def area(self):
        return pi*self.r*self.r


val = Circle(10)
val_l = val.length()
print(val_l)
val_s = val.area()
print(val_s)

 

3. 命名空间

　　a. 类的命名空间和对象的命名空间是分开的，且每个对象都有独立的命名空间，公用一个类的命名空间

　　b. 调用静态属性：调用的就是类中的属性

　　c. 调用动态属性：对象和类去调用的时候，表现出来的地址是不一样的，但实际是一样的

　　d. 调用类的静态属性：类调用的就是类中的属性，对象调用先从自己内存空间里找名字，找到了就用自己的，没有找到就用类的，类中也没有的话就报错

　　e. 调用类的动态属性：这个方法本身就存在类中，并不会存在对象的内存中，但是在对象调用类中的方法的时候，要依赖于一个地址薄去类中寻找对应的方法

　　f. 类的外面可以添加静态属性或对象属性，动态属性(方法)不可以添加

　　g. 关于对象的属性：
　　　　*. 对象的属性就存在类的命名空间中
　　　　*. 只能被对象调用修改
　　　　*. 不能被类调用

class Birthday:    # 定义一个生日类，
    role = "birthday"   # 静态属性
    def __init__(self,year,month,day):  # 定义一些生日共有的属性
        self.year = year    # 对象属性
        self.month = month
        self.day = day

class Course:   # 定义一个课程类
    role = "course"     # 静态属性
    def __init__(self,name,period,teacher,price):
        self.name = name       # 对象属性
        self.period = period
        self.teacher = teacher
        self.price = price

class Person:   # 定义一个人类
    role = "person"     # 静态属性
    def __init__(self,name,haijiao_birth):
        self.name = name    # 静态属性
        self.birth = haijiao_birth

python = Course("python",5,"Teacher Li",200000)   # 实例化python到Course类中
john_birth = Birthday(1999,2,22)     # 实例化john_birth到Birthday类中
john = Person("john",john_birth)   # 实例化john到Person类中
print(john.birth.month)      # john.birth等价于Person类中的self.birth，而self.birth 等于 john_birth，所以就等价于john_birth.month
print(john_birth.month)    # 从类的外部去调用类内的对象属性
john_class = python      # 在外部添加对象属性，在john的小空间里
print(john_class.name)
print(john_birth.day)

4. 组合

　　组合：一个类的对象是另一个类的属性，增强了代码的重用性

from math import pi
class Circle:
    def __init__(self,r):
        self.r = r

    def perimeter(self):
        return 2*pi*self.r

    def area(self):
        return pi*self.r*self.r

class Ring:
    def __init__(self,r_out,r_in):
        self.r_out = Circle(r_out)    # 组合
        self.r_in = Circle(r_in)

    def perimeter(self):
        return self.r_out.perimeter() + self.r_in.perimeter()

    def area(self):
        return self.r_out.area() - self.r_in.area()


val = Ring(10,5)
perimter = val.perimeter()
print(perimter)
area = val.area()
print(area)

5. 面向对象特性之封装

　　a. 封装：将同一类方法属性封装到类中，通过构造方法，将数据封装到对象中

　　b. 私有属性，私有方法（双下划线+属性名/方法名）

class Teacher:
    __identifier = "Teacher"    # 私有静态属性
    def __init__(self,name,pwd):
        self.name = name
        self.__pwd = pwd    # 私有属性
        self.__p()  # 调用私有方法

    def pwd(self):
        print(self.__pwd)

    def __p(self):  # 私有方法
        print(self.__pwd)


wu = Teacher("Wu","3714")
wu.pwd()
print(wu.__dict__)    # 打印属于wu的属性

# 类外调用私有属性(_类名__私有属性名)--不要去使用这个方法
print(wu._Teacher__pwd)

# 类外调用私有方法
wu._Teacher__p()

# 类外调用私有静态属性
print(Teacher._Teacher__identifier)

# 类外定义私有属性形式的属性，没有任何意义，就跟普通属性一样的

　　c. 私有方法的意义：

　　　　*. 有一些方法的返回值只是用来作为中间结果

　　　　*. 父类的方法不希望子类继承

class Teacher:
    __identifier = "Teacher"
    def __init__(self,name,pwd):
        self.name = name
        self.__pwd = pwd
        self.__p()

    def __p(self):
        return hash(self.__pwd)

    def judge(self,password):
        return hash(password) == self.__p()


wu = Teacher("wu","3714")
ret = wu.judge("3417")
print(ret)

 　　d. 私有属性

class Person:
    def __init__(self,name,height,weight):
        self.name = name
        self.__height = height
        self.__weight = weight

    def get_bmi(self):
        return self.__weight /(self.__height * self.__height)

    def change_weigth(self,new_weight):
        if new_weight > 20:
            self.__weight = new_weight
        else:
            print("体重过轻")

ha = Person("ha",1.81,94)
print(ha.get_bmi())
ha.change_weigth(80)
print(ha.get_bmi())

　　示例

class Host:
    def __init__(self,owner,length,width):
        self.owner = owner
        self.__length = length
        self.__width = width
    def area(self):
        return self.__length * self.__width

host = Host("lu",50,30)
print(host.area())

 　　e. property方法：把类中的方法假装成一个属性

class Person:
    def __init__(self,name,height,weight):
        self.name = name
        self.__height = height
        self.__weight = weight

    @property
    def bmi(self):
        return self.__weight /(self.__height * self.__height)


lu= Person("lu",1.81,94)
print(lu.name,lu.bmi)    # 这里去调用的时候，就是相当于调用一个属性

 　　　　*. @要伪装的方法名.setter，这样就更加像属性

class Shop:
    discount = 0.75
    def __init__(self,name,price):
        self.name = name
        self.__price = price

    @property
    def price(self):
        return self.__price * Shop.discount

    @price.setter
    def price(self,new_price):
        self.__price = new_price

    @price.deleter  # 一般不会用到
    def price(self,):
        del self.__price

apple = Shop("apple",5)
print(apple.price)
apple.price = 6     # @price.setter,用了这个方法之后，就可以修改了
print(apple.price)
print(apple.__dict__)
del apple.price
print(apple.__dict__)

 　　f. staticmethod：静态方法，函数不需要依赖对象的属性和类的属性，就可以使用staticmethod装饰

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

    def ah(self):   # self就是形式参数，ah就是普通方法，绑定（对象）方法
        print("ah")

    @staticmethod   # 静态方法
    def func():
        print("func")

# a = A("a")
# A.func(a)   #和a.func()一样
A.func()

 　　g. 类方法：对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

class A:
    role = "a"
    @classmethod
    def class_metood(cls):  #这里必须叫cls，默认的
        print(cls.role)

A.class_metood()
# A.role

 　　h. 小结

　　　　*. 静态方法--没有必须传的参数，不需要用对象的属性和类的属性

　　　　*. 类方法--必须传一个类，不能使用对象属性，但可以使用类属性

　　　　*. 普通方法--必须传一个参数，可以使用对象的属性和类的属性

 

6. 面向对象特性之继承

　　a. 继承：当两个类有相同的方法或属性的时候，把这些相同的方法属性封装到基类类中，只实现一次，其它类去继承

　　b. 继承是A类是B类子类的关系，而组合是A类中有B类的关系

　　　　*. 父类/超类/基类，子类/派生类

　　　　*. object是所有类的基类，type是所有类的类型，metaclass可以指定类的类型

　　　　*. 对象可以调用自己本类和父类所有的方法和属性，先调用自己的.

　　　　*. 先抽象在继承
　　　　　　抽象---从小类到大类
　　　　　　继承---从大类到小类

　　c. 单继承，多继承

class Animal:   # 父类
    def eat(self):
        pass
    def drink(self):
        pass
    def sleep(self):
        pass

class Bnimal:   # 父类
    def eat(self):
        pass

    def drink(self):
        pass

    def sleep(self):
        pass

class Dog(Animal):   # 单继承
    pass

class Cat(Animal,Bnimal):   # 多继承
    pass

print(Dog.__bases__)    # (查看所有父类)
print(Cat.__base__)     # (查看从左到右的第一个父类)

 　　d. super()方法

　　　　*. 在继承中，子类可以继承父类所有的属性和方法，当父类和子类中有同名方法的时候，一定调用子类的。如果想使用父类的该方法的功能，需要借助super方法。

class A:
    def hahaha(self):
        print("A")

class C:
    def hahaha(self):
        print("C")

class B(A,C):
    def hahaha(self):
        # B.hahaha(self)    # 经典类的调用父类中方法的方式

        # super--新式类，当多个父类有同名方法时，先从前面找，优先使用第一个找到的
        # super(B,self).hahaha()   # 里面这里可以传，或者不传，
        super().hahaha()    # 一般不传,因为在子类里边，很容易就知道是哪个类
        print("B")

b = B()
b.hahaha()  # 调用了自己的hahaha()
super(B,b).hahaha()    # 相当于A.hahaha()，外部的时候，必须传参

　　示例

class Animal:   #---父类
    def __init__(self,name):
        self.name = name
    def eat(self):
        print("%s is eating %s"%(self.name,self.food))
    def drink(self):
        print("%s is drinking %s" % (self.name, self.food))
    def sleep(self):
        print("%s is sleeping %s" % (self.name))


class Dog(Animal):#---单继承
    def __init__(self,name):
        self.food = "狗粮"
        super().__init__(name)
    def say(self):
        print("汪汪汪")

class Cat(Animal):
    def __init__(self,name):
        self.food = "猫粮"
        super().__init__(name)
    def say(self):
        print("喵喵喵")

wang = Dog("wang")
wang.eat()A

c = Cat("egon")
c.eat()

class Animal:
    def __init__(self,name,food):
        self.name = name
        self.food = food
        self.family = "大森林"
    def eat(self):
        print("%s is eating %s"%(self.name,self.food))
    def drink(self):
        print("%s is drinking"%(self.name))
    def sleep(self):
        print("%s is sleeping"%(self.name))
    def call(self):
        print("%s is calling %s" % (self.name,self.calling))

class Dog(Animal):#游泳
    def __init__(self,name):
        super().__init__(name, "骨头")
        self.calling = "汪汪汪"
        self.family = "小破屋"
    def swim(self):
        print("%s swimming"%self.name)

class Bird(Animal): #飞
    def __init__(self,name):
        super().__init__(name,"虫子")
        self.calling = "布谷"
    def fly(self):
        print("%s flying"%self.name)


erha = Dog("erha")
erha.call() #调用父类的方法
erha.swim() #调用自己的方法
print(erha.family)  #优先使用自己的
print("******************************")
cuckoo  = Bird("cuckoo")
cuckoo.call()
print(cuckoo.family)#因为他本身没有，所以直接用父类的

　　e. 派生属性和派生方法

　　　　*. 派生属性--在父类没有的基础上，子类自己有的属性

　　　　*. 派生方法--在父类没有的基础上，子类自己的方法

class Animal:   #父类,人和动物都有的一些属性
    def __init__(self,name,blood,aggr):
        self.name = name
        self.blood = blood
        self.aggr = aggr

class Person(Animal):   #继承的语法，Person是子类，继承了父类Animal的属性
    def __init__(self,name,blood,aggr,money):
        super(Person,self).__init__(name,blood,aggr)    #在子类执行父类的方法
        self.money = money      #派生属性
    def attack(self,dog):   #派生方法
        dog.blood -= self.aggr

class Dog(Animal):  #继承的语法，Dog是子类，继承了父类Animal的属性
    def __init__(self,name,blood,aggr,breed):
        super().__init__(name,blood,aggr)
        self.breed = breed
    def attack(self, person):
        person.blood -= self.aggr



alex = Person("alex",2000,250,1000000)
erha = Dog("erha",2000,250,"金毛")

　　f. 经典类，新式类

　　　　*. 经典类和新式类的区别：

　　　　　　1. 定义顺序

　　　　　　2. 子类执行父类中的同名方法

　　　　　　3. 继承问题
　　　　*. python2里有经典类和新式类之分

　　　　　　经典类--深度优先

　　　　　　新式类--广度优先 

class A:　　# 经典类
    pass
class B(object):　　# 新式类
    pass

 　　　　*. 在python3中，object是所有类的基类 

　　g. 钻石继承：python的新式类和经典类在继承顺序上的不同

class F:
    def test(self):
        print("F")

class E(F):
    pass
    def test(self):
        print("E")

class D(F):
    pass
    def test(self):
        print("D")

class C(E):
    pass
    def test(self):
        print("C")

class B(D):
    pass
    def test(self):
        print("B")

class A(B,C):
    pass
    def test(self):
        print("A")

a = A()
a.test()
A-B-D-C-E-F

class D():
    pass
    def test(self):
        print("D")

class C():
    pass
    def test(self):
        print("C")

class B(D):
    pass
    def test(self):
        print("B")

class A(B,C):
    pass
    def test(self):
        print("A")

a = A()
a.test()

# 这个的继承是A-B/C，B-D，C没有父类
# 这种情况下，A中没有时,先找B,B中没有时先找D，D里边没有的时候，就找C

7. 多态

　　a. 多态指的是一类事物有多种形态，python天生支持多态，不同的类可以有一样的方法，但是功能是不一样。
　　b. 鸭子模型
　　　　对于一个对象来说，只要它能鸭子叫，就是鸭子，不管它是什么形态，这就是多态
　　　　对于一个对象来说，只要能使用一个方法，就不管他是什么形态的

8. 抽象类和接口类

　　a. 接口类：归一化设计

from abc import abstractmethod,ABCMeta


class Payment(metaclass=ABCMeta):    # 接口类/抽象类,子类的规范（约束子类必须要有这个里的方法，不然就抛异常）
    @abstractmethod     # 加了一个装饰器
    def payment(self,money):
        raise NotImplemented
class Applepay(Payment):
    def payment(self,money):
        print("apple 支付了 %d元"%money)

class Alipay(Payment):
    def payment(self,money):
        print("支付宝 支付了 %d元"%money)

class Wechatpay(Payment):
    def huaqian(self,money):
        print("微信 支付了 %d元"%money)

def payment(pay_obj,money):
    pay_obj.payment(money)

apple = Applepay()
ali = Alipay()
payment(apple,200)
payment(ali,100)
wechat = Wechatpay()
wechat.payment(wechat,100)
# 因为他没有payment方法，所以会报错
# TypeError: Can't instantiate abstract class Wechatpay with abstract methods payment

 　　b. 抽象类：抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化。如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。

from abc import abstractmethod,ABCMeta


class Foo(metaclass=ABCMeta):  # 抽象类
    @abstractmethod
    def read(self): # 抽象类去实现了方法
        f = open()
        f.read()
        f.close()
    def write(self):
        f = open()
        f.write()
        f.close()
class File(Foo):
    def read(self):
        super().read()
    def write(self):
        super().write()

class Disk(Foo):
    def read(self):
        super().read()
    def write(self):
        super().write()

　　c. 对比

　　　　a. 接口类不实现具体的方法，并且可以多继承；抽象类可以做一些基础实现，并且不推荐多继承

　　　　b. 在抽象类中，我们可以对一些抽象方法做出基础实现；而在接口类中，任何方法都只是一种规范，具体的功能需要子类实现

　　d. 小结

　　　　*. 编程思想：为子类做规范
　　　　　　归一化设计：几个类都实现了相同的方法
　　　　　　抽象类：最好单继承，且可以简单的实现功能
　　　　　　接口类：最好多继承，且最好不实现具体功能

　　　　*. 开放封闭原则：扩展是开放的，修改是封闭的

　　　　*. 依赖倒置原则：高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该应该依赖细节；细节应该依赖抽象。换言之，要针对接口编程，而不是针对实现编程

　　　　*. 接口隔离原则：使用多个专门的接口，而不使用单一的总接口。即客户端不应该依赖那些不需要的接口。