欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

python全栈开发-面向对象-进阶2

程序员文章站 2023-01-19 13:27:36
python_day_19 今日主要内容: 1.抽象类,接口类 2.多态 3.封装 1.抽象类,接口类 经理看了,然后让你改进,让你支付的方式一样 第二版: 2.多态. python面向对象的三大特征之一:多态: python处处是多态. 流程图; 结果图; 流程图; 执行过程: A(B,C,D) ......

python_day_19

今日主要内容:

  • 1.抽象类,接口类
  • 2.多态
  • 3.封装

1.抽象类,接口类

python 没有接口这个概念
接口类,抽象类: 制定一个规范.

举个栗子:
你的项目经理提一个需求,让你做一个支付功能.
第一版:
class Alipay:
    def __init__(self,money):
        self.money = money

    def pay(self):
        print('使用支付宝支付了%s' %self.money)


class Jdpay:
    def __init__(self, money):
        self.money = money

    def pay(self):
        print('使用京东支付了%s' % self.money)

a1 = Alipay(200)
a1.pay()

j1 = Jdpay(100)
j1.pay()

python全栈开发-面向对象-进阶2

python全栈开发-面向对象-进阶2

 

经理看了,然后让你改进,让你支付的方式一样

第二版:

class Alipay:
    def __init__(self,money):
        self.money = money

    def pay(self):
        print('使用支付宝支付了%s' %self.money)


class Jdpay:
    def __init__(self, money):
        self.money = money

    def pay(self):
        print('使用京东支付了%s' % self.money)

def pay(obj):
    obj.pay()

a1 = Alipay(200)
j1 = Jdpay(100)
pay(a1)  # 归一化设计
pay(j1)

python全栈开发-面向对象-进阶2

第三版,野生程序员来了.......要增加一个微信支付的功能.
class Alipay:
    def __init__(self,money):
        self.money = money

    def pay(self):
        print('使用支付宝支付了%s' %self.money)

class Jdpay:
    def __init__(self, money):
        self.money = money

    def pay(self):
        print('使用京东支付了%s' % self.money)

class Wechatpay:

    def __init__(self,money):
        self.money = money

    def weixinpay(self):
        print('使用微信支付了%s' % self.money)


def pay(obj):
    obj.pay()

a1 = Alipay(200)
j1 = Jdpay(100)
pay(a1)  # 归一化设计
pay(j1)

w1 = Wechatpay(300)
w1.weixinpay()

python全栈开发-面向对象-进阶2

 

经理看了觉得很乱,打回去重新修改,制定规则,抽象类,接口类
第四版:
from abc import ABCMeta,abstractmethod

class Payment(metaclass=ABCMeta):  # 抽象类(接口类):
    @abstractmethod
    def pay(self): pass  # 制定了一个规范


class Alipay(Payment):
    def __init__(self,money):
        self.money = money

    def pay(self):
        print('使用支付宝支付了%s' %self.money)


class Jdpay(Payment):
    def __init__(self, money):
        self.money = money

    def pay(self):
        print('使用京东支付了%s' % self.money)

class Wechatpay(Payment):

    def __init__(self,money):
        self.money = money

    def pay(self):
        print('使用微信支付了%s' % self.money)


def pay(obj):
    obj.pay()
w1 = Wechatpay(200)
a1 = Alipay(200)
j1 = Jdpay(100)
pay(a1)  # 归一化设计
pay(j1)
pay(w1)

python全栈开发-面向对象-进阶2

 

python全栈开发-面向对象-进阶2

 

2.多态.

python面向对象的三大特征之一:
多态: python处处是多态.

python:弱类型语言
python 不管什么类型,传入函数,封装到对象中都可以.
python的鸭子类型.
鸭子类型 : 看着像鸭子,他就是鸭子.
以下这些类 都互称为鸭子.
class Str:
    def index(self):
        pass

class List:
    def abc(self):
        pass

class Tuple:
    def rrr(self):
        pass

3.封装
广义的封装: 实例化一个对象,给对象空间封装一些属性.
狭义的封装: 私有制.
私有成员:私有静态字段,私有方法,私有对象属性
私有静态字段
class B:
    __money = 100000

class A(B):
    name = 'alex'
    __age = 1000

    def func(self):
        print(self.__age)
        print(A.__age)    # 对于私有静态字段,类的内部可以访问.
        print('func....')
    def func1(self):
        print(self.__money)
        print(A.__money)
a1 = A()
print(a1.name)
print(A.name)

print(a1.__age)  # 实例化对象不能访问私有静态字段
print(A.__age)  # 类名不能访问私有静态字段
对于私有静态字段,类的外部不能访问.

a1.func()

#对于私有静态字段,类的内部可以访问.

a1.func1()

#对于私有静态字段来说,只能在本类中内部访问,类的外部,派生类均不可访问.

#可以访问,但是工作中千万不要用.
print(A._A__age)
print(A.__dict__)

#私有方法

class B:
    __money = 100000
    def __f1(self):
        print('B')

class A(B):
    name = 'alex'

    def __func(self):
        print('func....')

    def func1(self):
        # self.__func()   # 类的内部可以访问
        self.__f1()
a1 = A()
a1.__func()  # 类外部不能访问
a1.func1()  # 类的内部可以访问
a1.func1()  # 类的派生类也不能访问.

python全栈开发-面向对象-进阶2

 


私有对象属性同私有方法和私有静态字段,类外部不能访问,类的内部可以访问,类的派生类也不能访问.

补充一个面试题:
3,下面代码执行结果是什么?为什么?
class Parent:
    def func(self):
        print('in Parent func')

    def __init__(self):
        self.func()

class Son(Parent):
    def func(self):
        print('in Son func')

son1 = Son()

流程图;

python全栈开发-面向对象-进阶2

结果图;

python全栈开发-面向对象-进阶2

 

原因:

因为Son(),是实例化过程,然后自动执行__init__函数,Son类里没有,去父类里找,然后执行父类的__init__方法,执行func方法,先从自己的类中找,有func,执行func,
打印in Son func

补充知识点:
MRO-C算法-python多继承原理
class H:

    def bar(self):
        print('F.bar')
class G(H):

    def bar(self):
        print('F.bar')
class F(H):

    def bar(self):
        print('F.bar')
class E(G):

    def bar(self):
        print('E.bar')

class D(F):

    def bar(self):
        print('D.bar')


class C(E):
    def bar(self):
        print('C.bar')


class B(D):

    def bar(self):
        print('B.bar')


class A(B, C, D):

    def bar(self):
        print('A.bar')

a = A()
print(A.mro())

python全栈开发-面向对象-进阶2

流程图;

python全栈开发-面向对象-进阶2

执行过程:

A(B,C,D)

首先找到A继承的三个类的深度继承顺序,放到一个列表中
L[B] = [B,D,F,H] #B往上面的继承顺序
L[C] = [C,E,G,H] #C往上面的继承顺序
L[D] = [D,F,H] #D往上面的继承顺序

第二步:A自己的广度,第一层
L[A] = [B,C,D]

每个列表的第一个元素为头部,从第一个列表的头部开始找,找其他列表中尾部是否含有
这个类名,如果没有,提取出来放到一个列表中,如果有,找下一个列表的头部,循环下去
只要提取来一个,我们就从第一个列表的头部接着重复上面的操作.
1 [B,D,F,H] [C,E,G,H] [D,F,H] [B,C,D]
2 [D,F,H] [C,E,G,H] [D,F,H] [C,D] #提取了头部的B,然后将其他列表头部的B删除,并将B放到list中
3 [D,F,H] [E,G,H] [D,F,H] [D] #因为第一个列表的D在其他列表的尾部存在,所以跳过D,然后找第二个列表的头部C,提取了头部的C,然后将其他列表头部的B删除,并将B放到list中

.......

4 [H] [H] [H] []

list = [A,B,C,D,F,E,G,H,O]

python全栈开发-面向对象-进阶2


2018-07-26  17:41:25