一面向对象特性之继承

1.1 基本继承语法

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。

通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类。

继承语法

class 派生类名(基类名)
    ...

# 无继承方式

# class Dog:
#     def run(self):
#         print("running...")
#
#     def sleep(self):
#         print("sleep...")
#
#     def toshetou(self):
#         print("toshetou...")
#
# class Cat:
#     def run(self):
#         print("running...")
#
#     def sleep(self):
#         print("sleep...")
#
#     def climb_tree(self):
#         print("climb_tree...")


# 继承方式

class Animal:

    def run(self):
        print("running...")

    def sleep(self):
        print("sleep...")


class Dog(Animal):

    def toshetou(self):
        print("toshetou...")

class Cat(Animal):

    def climb_tree(self):
        print("climb_tree...")


alex=Dog()
alex.run()

这里一定一定要注意查找变量的顺序！

面试题：

class Base:
    def __init__(self):
        self.func()
    def func(self):
        print('in base')

class Son(Base):
    def func(self):
        print('in son')

s = Son()

1.2 多重继承

如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。

语法：

派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后，如下所示：

class SubClassName (ParentClass1[, ParentClass2, ...]):
    ...

多继承有什么意义呢？还拿上面的例子来说，蝙蝠和鹰都可以飞，飞的功能就重复定义了。

class Animal:

    def run(self):
        print("running...")

    def sleep(self):
        print("sleep...")


class Dog(Animal):

    def toshetou(self):
        print("toshetou...")

class Cat(Animal):

    def climb_tree(self):
        print("climb_tree...")

##########################################


class Eagle(Animal):

    def fly(self):
        print("fly...")

class Bat(Animal):

    def fly(self):
        print("fly...")

有同学肯定想那就放到父类Animal中，可是那样的话其他不会飞的动物还怎么继承Animal呢？

所以，这时候多重继承就发挥功能了：

class Fly:
    def fly(self):
        print("fly...")

class Eagle(Animal,Fly):
    pass

class Bat(Animal,Fly):
    pass

是不是很棒呢

补充

说到多重继承，就不得不提一下c3算法了。mro即 method resolution order (方法解释顺序)，主要用于在多继承时判断属性的路径(来自于哪个类)。

在python2.2版本中，算法基本思想是根据每个祖先类的继承结构，编译出一张列表，包括搜索到的类，按策略删除重复的。但是，在维护单调性方面失败过（顺序保存），所以从2.3版本，采用了新算法C3。

为什么采用C3算法

C3算法最早被提出是用于Lisp的，应用在Python中是为了解决原来基于深度优先搜索算法不满足本地优先级，和单调性的问题。

本地优先级：指声明时父类的顺序，比如C(A,B)，如果访问C类对象属性时，应该根据声明顺序，优先查找A类，然后再查找B类。
单调性：如果在C的解析顺序中，A排在B的前面，那么在C的所有子类里，也必须满足这个顺序。

c3算法详细玩法

二面向对象特性之封装

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：将变化隔离、便于使用、提高重用性、提高安全性

封装原则：将不需要对外提供的内容都隐藏起来、把属性都隐藏，提供公共方法对其访问。

使用封装有三大好处：

1、良好的封装能够减少耦合。

2、类内部的结构可以自由修改。

3、可以对成员进行更精确的控制。

4、隐藏信息，实现细节。

2.1 私有化变量

在Class内部，可以有属性和方法，而外部代码可以通过直接调用实例变量的方法来操作数据，这样，就隐藏了内部的复杂逻辑。

但是，从前面Student类的定义来看，外部代码还是可以自由地修改一个实例的name、score属性：

class Student(object):

    def __init__(self, name, score):
        self.name = name
        self.age = score

alex=Student("alex",12)
yuan=Student("yuan",34)


alex.age=1000
print(alex.age)

如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问，所以，我们把Student类改一改：

class Student(object):

    def __init__(self, name, score):
        self.__name = name
        self.__age = score

alex=Student("alex",12)
yuan=Student("yuan",34)

print(alex.__age)

改完后，对于外部代码来说，没什么变动，但是已经无法从外部访问实例变量.__name和实例变量.__score了。

这样就确保了外部代码不能随意修改对象内部的状态，这样通过访问限制的保护，代码更加健壮。

但是如果外部代码要获取name和score怎么办？可以给Student类增加get_name和get_score这样的方法：

class Student(object):

    def __init__(self, name, score):
        self.__name = name
        self.__age = score

    def get_name(self):
        return self.__name

    def get_age(self):
        return self.__age

alex=Student("alex",12)
yuan=Student("yuan",34)

print(alex.get_name())
print(alex.get_age())

如果又要允许外部代码修改age怎么办？可以再给Student类增加set_age方法：

class Student(object):

    def __init__(self, name, score):
        self.__name = name
        self.__age = score

    def get_name(self):
        return self.__name

    def get_age(self):
        return self.__age

    def set_age(self,age):
        self.__age=age

alex=Student("alex",12)
print(alex.get_age())
alex.set_age(1000)
print(alex.get_age())

你也许会问，原先那种直接通过bart.score = 99也可以修改啊，为什么要定义一个方法大费周折？因为在方法中，可以对参数做检查，避免传入无效的参数：

class Student(object):
    ...
    def set_age(self,age):
        if isinstance(age,int) and 0 <= age <= 100:
            self.__age = age
        else:
            raise ValueError('bad age!')

需要注意的是，在Python中，变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能用__name__、__score__这样的变量名。

注意：

1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N

2.变形的过程只在类的内部生效,在定义后的赋值操作，不会变形

3.单下划线、双下划线、头尾双下划线说明：

__foo__: 定义的是特殊方法，一般是系统定义名字，类似 __init__() 之类的。

_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问。（约定成俗，不限语法）

__foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

2.2 私有化方法

在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

#正常情况
>>> class A:
...     def fa(self):
...         print('from A')
...     def test(self):
...         self.fa()
... 
>>> class B(A):
...     def fa(self):
...         print('from B')
... 
>>> b=B()
>>> b.test()
#把fa定义成私有的，即__fa
>>> class A:
...     def __fa(self): #在定义时就变形为_A__fa
...         print('from A')
...     def test(self):
...         self.__fa() #只会与自己所在的类为准,即调用_A__fa
... 
>>> class B(A):
...     def __fa(self):
...         print('from B')
... 
>>> b=B()
>>> b.test()

2.3 property属性

什么是特性property

property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值

例一：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）

成人的BMI数值：
过轻：低于18.5
正常：18.5-23.9
过重：24-27
肥胖：28-32
非常肥胖, 高于32
　　体质指数（BMI）=体重（kg）÷身高^2（m）
　　EX：70kg÷（1.75×1.75）=22.86
#####################################
class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height
    @property
    def bmi(self):
        return self.weight / (self.height**2)

p1=People('egon',75,1.85)
print(p1.bmi)

import math
class Circle:
    def __init__(self,radius): #圆的半径radius
        self.radius=radius

    @property
    def area(self):
        return math.pi * self.radius**2 #计算面积

    @property
    def perimeter(self):
        return 2*math.pi*self.radius #计算周长

c=Circle(10)
print(c.radius)
print(c.area) #可以向访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值
print(c.perimeter) #同上
'''
输出结果:
314.1592653589793
62.83185307179586
'''
#################################################
#注意：此时的特性area和perimeter不能被赋值
c.area=3 #为特性area赋值
'''
抛出异常:
AttributeError: can't set attribute
'''

为什么要用property

将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则在C++里一般会将所有的所有的数据都设置为私有的，然后提供set和get方法（接口）去设置和获取，在python中通过property方法可以实现。

class Foo:
    def __init__(self,val):
        self.__NAME=val #将所有的数据属性都隐藏起来

    @property
    def name(self):
        return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置)

    @name.setter
    def name(self,value):
        if not isinstance(value,str):  #在设定值之前进行类型检查
            raise TypeError('%s must be str' %value)
        self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME

    @name.deleter
    def name(self):
        raise TypeError('Can not delete')

f=Foo('egon')
print(f.name)
# f.name=10 #抛出异常'TypeError: 10 must be str'
del f.name #抛出异常'TypeError: Can not delete'

一个静态属性property本质就是实现了get，set，delete三种方法

class Foo:
    @property
    def AAA(self):
        print('get的时候运行我啊')

    @AAA.setter
    def AAA(self,value):
        print('set的时候运行我啊')

    @AAA.deleter
    def AAA(self):
        print('delete的时候运行我啊')

#只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter
f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA

#################################################


class Foo:
    def get_AAA(self):
        print('get的时候运行我啊')

    def set_AAA(self,value):
        print('set的时候运行我啊')

    def delete_AAA(self):
        print('delete的时候运行我啊')
    AAA=property(get_AAA,set_AAA,delete_AAA) #内置property三个参数与get,set,delete一一对应

f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA

怎么用？

class Goods:

    def __init__(self):
        # 原价
        self.__original_price = 100
        # 折扣
        self.__discount = 0.8

    @property
    def price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.__original_price * self.__discount
        return new_price

    @price.setter
    def price(self, value):
        self.__original_price = value

    @price.deleter
    def price(self):
        del self.__original_price


obj = Goods()
print(obj.price)         # 获取商品价格
obj.price = 200   # 修改商品原价
print(obj.price)
del obj.price     # 删除商品原价

2.4 classmethod方法与staticmethod方法

classmethod

class Classmethod_Demo():
    role = 'dog'

    @classmethod
    def func(cls):
        print(cls.role)

Classmethod_Demo.func()

staticmethod

class Staticmethod_Demo():
    role = 'dog'

    @staticmethod
    def func():
        print("当普通方法用")

Staticmethod_Demo.func()

练习：

class Foo:
    def func(self):
        print('in father')


class Son(Foo):
    def func(self):
        print('in son')

s = Son()
s.func()
# 请说出上面一段代码的输出并解释原因？

class A:
    __role = 'CHINA'
    @classmethod
    def show_role(cls):
        print(cls.__role)

    @staticmethod
    def get_role():
        return A.__role

    @property
    def role(self):
        return self.__role

a = A()
print(a.role)
print(a.get_role())
a.show_role()
# __role在类中有哪些身份？
# 以上代码分别输出哪些内容？
# 这三个装饰器分别起了什么作用？有哪些区别？

三面向对象特性之多态

3.1 归一化设计

预备知识

l=[123,456,789]
info={"name":"alex","age":1000}
s="hello"
print(len(l))
print(len(info))
print(len(s))

支付接口归一化

##################### 归一化设计 #####################

# 支付宝 微信 银行卡 nfc支付

class AliPay(object):
    def __init__(self,name,money):
        self.money=money
        self.name=name
    def pay(self):
        # 支付宝提供了一个网络上的联系渠道
        print('%s通过支付宝消费了%s元'%(self.name,self.money))

class WeChatPay(object):
    def __init__(self,name,money):
        self.money=money
        self.name=name
    def pay(self):
        # 微信提供了一个网络上的联系渠道
        print('%s通过微信消费了%s元'%(self.name,self.money))

def pay_func(pay_obj):
    pay_obj.pay()

alipay=AliPay("alex",100)
wechatpay=WeChatPay("yuan",200)

pay_func(alipay)
pay_func(wechatpay)

3.2 规范化方法

'''

规范化方法
支付宝 微信 银行卡 nfc支付
同事协作之间的代码规范问题
规定:Payment 就是一个规范类,这个类存在的意义不在于实现实际的功能,而是为了约束所有的子类必须实现pay的方法
Payment : 抽象类
    pay = Payment() # 抽象类: 不能实例化
    抽象类主要就是作为基类/父类,来约束子类中必须实现的某些方法
    抽象类的特点:
        必须在类定义的时候指定metaclass = ABCMeta
        必须在要约束的方法上方加上@abstractmethod方法
'''



from abc import ABCMeta,abstractmethod #(抽象方法)

class Payment(metaclass=ABCMeta):   # metaclass 元类  metaclass = ABCMeta表示Payment类是一个规范类
    def __init__(self,name,money):
        self.money=money
        self.name=name

    @abstractmethod      # @abstractmethod表示下面一行中的pay方法是一个必须在子类中实现的方法
    def pay(self,*args,**kwargs):
        pass

    @abstractmethod
    def back(self):
        pass

class AliPay(Payment):

    def pay(self):
        # 支付宝提供了一个网络上的联系渠道
        print('%s通过支付宝消费了%s元'%(self.name,self.money))

class WeChatPay(Payment):

    def pay(self):
        # 微信提供了一个网络上的联系渠道
        print('%s通过微信消费了%s元'%(self.name,self.money))

def pay_func(pay_obj):
    pay_obj.pay()

alipay=AliPay("alex",100)
wechatpay=WeChatPay("yuan",200)

pay_func(alipay)
pay_func(wechatpay)

当子类和父类都存在相同的pay()方法时，我们说，子类的pay()覆盖了父类的pay()，在代码运行的时候，总是会调用子类的pay()。这样，我们就获得了继承的另一个好处：多态。

3.3 多态的概念

要理解什么是多态，我们首先要对数据类型再作一点说明。当我们定义一个class的时候，我们实际上就定义了一种数据类型。我们定义的数据类型和Python自带的数据类型，比如str、list、dict没什么两样：

a = list() # a是list类型
b = Animal() # b是Animal类型
c = Dog() # c是Dog类型

判断一个变量是否是某个类型可以用isinstance()判断：

>>> isinstance(a, list)
True
>>> isinstance(b, Animal)
True
>>> isinstance(c, Dog)
True

看来a、b、c确实对应着list、Animal、Dog这3种类型。

但是等等，试试：

>>> isinstance(c, Animal)
True

看来c不仅仅是Dog，c还是Animal！

不过仔细想想，这是有道理的，因为Dog是从Animal继承下来的，当我们创建了一个Dog的实例c时，我们认为c的数据类型是Dog没错，但c同时也是Animal也没错，Dog本来就是Animal的一种！

所以，在继承关系中，如果一个实例的数据类型是某个子类，那它的数据类型也可以被看做是父类。但是，反过来就不行：

>>> b = Animal()
>>> isinstance(b, Dog)
False

Dog可以看成Animal，但Animal不可以看成Dog。

所以，上面的支付的例子，如果我们再定义一个ApplePay类型，也从Payment类派生：

class ApplePay(Payment):
    def pay(self):
       print('%s通过苹果支付消费了%s元'%(self.name,self.money))

applepay=ApplePay("egon",800)

'''
你会发现，新增一个Payment的子类，不必对pay()做任何修改，实际上，任何依赖Payment作为参数的函数或者方法都可以不加修改地正常运行，原因就在于多态。

多态的好处就是，当我们需要传入AliPay、WeChatPay、ApplePay……时，我们只需要接收Payment类型就可以了，因为AliPay、WeChatPay、ApplePay……都
是Payment类型，然后，按照Payment类型进行操作即可。由于Payment类型有pay()方法，因此，传入的任意类型，只要是Payment类或者子类，就会自动调用实
际类型的pay()方法，这就是多态的意思：

对于一个变量，我们只需要知道它是Payment类型，无需确切地知道它的子类型，就可以放心地调用pay()方法，而具体调用的pay()方法是作用在AliPay、WeChatPay、
ApplePay哪个类对象上，由运行时该对象的确切类型决定，这就是多态真正的威力：调用方只管调用，不管细节，而当我们新增一种Payment的子类时，只要确保pay()方
法编写正确，不用管原来的代码是如何调用的。这就是著名的“开闭”原则：

      对扩展开放：允许新增Payment子类；
      对修改封闭：不需要修改依赖Payment类型的pay()等函数。
'''

3.4 鸭子类型

class CardPay(object):
    def __init__(self,name,money):
        self.money=money
        self.name=name
    def pay(self):
       print('%s通过银联卡支付消费了%s元'%(self.name,self.money))

def pay_func(pay_obj):
    pay_obj.pay()

cp=CardPay("alvin",1000)
pay_func(cp)

对于静态语言（例如Java）来说，如果需要传入Payment类型，则传入的对象必须是Payment类型或者它的子类，否则，将无法调用pay()方法。

对于Python这样的动态语言来说，则不一定需要传入Animal类型。我们只需要保证传入的对象有一个pay()方法就可以了：

这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。

四反射

反射函数

getattr(obj, name[, default]) : 访问对象的属性。
hasattr(obj,name) : 检查是否存在一个属性。
setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
delattr(obj, name) : 删除属性。

当操作属性是一个字符串时，不能在通过句点符进行操作，这时候，反射就可以发挥功能了！

class Animal(object):
    role="person"
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def run(self):
        print("%s is running"%self.name)

# alex=Animal("alex",34)
# print(alex.name)
# print(alex.age)
# alex.run()

########################################
alex=Animal("alex",34)
while 1:
    attr=input("查询alex的什么属性>>>")
    if hasattr(alex,attr):
        print(getattr(alex,attr))
    else:
        print("alex没有该属性")

# 当然类对象也可以反射
print(getattr(Animal,"role"))

# 模块也可以反射
from sys import modules
print(modules[__name__])
print(getattr(modules[__name__],"Animal"))

反射应用

class FTP(object):

    def __init__(self):
        self.run()

    def run(self):
       print('''
           提示:
               上传:   put 路径/文件名称
               下载:   get 路径/文件名称

       '''
       )
       while 1:
           input_str=input(">>>")
           action,params=input_str.split(" ")
           if hasattr(self,action):
               getattr(self,action)()
           else:
               print("不存在该方法")

    def put(self):
        print("上传...")
    def get(self):
        print("下载...")


ftp=FTP()

五类的魔法方法

# 1 初始化方法:__init__
class A(object):
    def __init__(self):
        print("初始化执行方法")
A()

# 2 构造方法:__new__
class B(object):

    def __new__(cls,*args,**kwargs):
        print("我是用来开辟一块空间的")
        obj=super().__new__(cls)
        return obj

    def __init__(self):
        print("self就是__new__开辟的空间地址")

B()

# 应用:比如单例模式

# 3 __str__

class C(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):  # 必须返回字符串类型
        return self.name

c1=C("c1",20)
c2=C("c2",23)
print(c1)
print(c2)

# 4 __call__
class D(object):

    def __call__(self, *args, **kwargs):
        print("call 被调用...")

print(callable(D))
d1=D()
print(callable(d1))
d1()

# 5 析构方法 __del__

class F(object):
    def __del__(self):
        print("删除对象时被调用!")

f=F()
# del f # 思考:注释掉为什么也会调用__del__
# import time
# time.sleep(100)

# 应用

class Filehandler(object):
    file="a.text"
    def __init__(self):
        self.f=open(self.file)

    def __del__(self):
        self.f.close()



# 6 __getitem__


class G(object):
    def __init__(self):
        pass

    def __getitem__(self,item):
        print("__getitem__被调用")

    def __setitem__(self, key, value):
        print("__setitem__被调用")

    def __delitem__(self, key):
        print("__delitem__被调用")

g=G()
g["name"]="alex"
print(g["name"])
del g["name"]

# 7 __getattr__

class H(object):
    def __init__(self):
        pass

    def __getattr__(self, item):
        print("__getattr__被调用")

    def __setattr__(self, key, value):
        print("__setattr__被调用")

    def __delattr__(self, item):
        print("__delattr__被调用")

h=H()
h.name="alex"
print(h.name)
del h.name


# 8 __eq__

class I(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __eq__(self, other):

        if self.name==other.name and self.age==other.age:
            return True
        else:
            return False

i1=I("alex",30)
i2=I("alex",30)
print(i1==i2)


# __len__

class G(object):
    def __len__(self):
        return 100

g=G()
print(len(g))

六面向对象作业

学生管理系统

面向对象编程(2)

一面向对象特性之继承

1.1 基本继承语法

1.2 多重继承

二面向对象特性之封装

2.1 私有化变量

2.2 私有化方法

2.3 property属性

2.4 classmethod方法与staticmethod方法

classmethod

staticmethod

三面向对象特性之多态

3.1 归一化设计

预备知识

支付接口归一化

3.2 规范化方法

3.3 多态的概念

3.4 鸭子类型

四反射

反射函数

反射应用

五类的魔法方法

六面向对象作业

推荐阅读

面向对象编程(2)

一 面向对象特性之继承

1.1 基本继承语法

1.2 多重继承

二 面向对象特性之封装

2.1 私有化变量

2.2 私有化方法

2.3 property属性

2.4 classmethod方法与staticmethod方法

classmethod

staticmethod

三 面向对象特性之多态

3.1 归一化设计

预备知识

支付接口归一化

3.2 规范化方法

3.3 多态的概念

3.4 鸭子类型

四 反射

反射函数

反射应用

五 类的魔法方法

六 面向对象作业

推荐阅读

一面向对象特性之继承

二面向对象特性之封装

三面向对象特性之多态

四反射

五类的魔法方法

六面向对象作业