python22期第7天课程总结(面向对象编程二)

课程大纲：

　　1. 接口类，抽象类。
　　2. 封装。
　　3. 字段，方法，静态属性。
　　4. 私有成员公有成员（反射）。其他方法。

一：接口类，抽象类

概念：接口类和抽象类是一种：是一种规范，写代码时的规范

第一版：支付方式不统一

class QQpay:
    def pay(self,money):
        print('您已经通过qq支付了%s元' %money)

class Alipay:
    def pay(self, money):
        print('您已经通过支付宝支付了%s元' % money)

a = QQpay()
a.pay(100)
b = Alipay()
b.pay(200)

第二版，归一化设计，统一你的支付方式

class QQpay:
def pay(self,money):
print('您已经通过qq支付了%s元' %money)

class Alipay:
def pay(self, money):
print('您已经通过支付宝支付了%s元' % money)

def pay(obj,money):
obj.pay(money)

a = QQpay()
b = Alipay()

pay(a,100) # 归一化设计，统一你的支付方式
pay(b,1200)

第三版：野生程序员的一天

class QQpay:
def pay(self,money):
print('您已经通过qq支付了%s元' %money)

class Alipay:
def pay(self, money):
print('您已经通过支付宝支付了%s元' % money)

class Wechatpay:
def fuqian(self, money):
print('您已经通过支付宝支付了%s元' % money)

def pay(obj,money):
obj.fuqian(money)

a = QQpay()
b = Alipay()
c = Wechatpay()
# pay(a,100) # 归一化设计，统一你的支付方式
# pay(b,1200)
pay(c,10000)

第四版本：接口类，抽象类，是一种规范，写代码时的规范。

class Payrole: # 抽象类或者接口类，制定规范，统一方法名。
def pay(self): pass

class QQpay(Payrole):
def pay(self,money):
print('您已经通过qq支付了%s元' %money)

class Alipay(Payrole):
def pay(self, money):
print('您已经通过支付宝支付了%s元' % money)

class Wechatpay(Payrole):
def pay(self, money):
print('您已经通过支付宝支付了%s元' % money)

def pay(obj,money):
obj.pay(money)

a = QQpay()
b = Alipay()
c = Wechatpay()
pay(a,100) # 归一化设计，统一你的支付方式
pay(b,1200)
pay(c,10000)

最终版本：接口类，抽象类，是一种规范，写代码时的规范强制性的规定。

from abc import ABCMeta,abstractmethod
class Payrole(metaclass=ABCMeta): # 抽象类或者接口类，制定规范，统一方法名。
@abstractmethod
def pay(self): pass

class QQpay(Payrole):
def pay(self,money):
print('您已经通过qq支付了%s元' %money)

class Alipay(Payrole):
def pay(self, money):
print('您已经通过支付宝支付了%s元' % money)

class Wechatpay(Payrole):
def pay(self, money):
print('您已经通过支付宝支付了%s元' % money)

def pay(obj,money):
obj.pay(money)

# a = QQpay()
# b = Alipay()
c = Wechatpay()
# pay(a,100) # 归一化设计，统一你的支付方式
# pay(b,1200)
pay(c,10000)

二：封装

class A:

    def __init__(self):
        self.__func()

    def __func(self):
        print('in A')


class B:

    def __func(self):
        print('in B')


b1 = B()

三：字段，方法，静态属性

类方法:一般是由类名调用.

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('天', 95,1.83)
print(p1.bmi)
# property 属性将你的一些方法伪装成属性,虽然在代码上没有什么提高,让其看起来更合乎情理.

class People:
    def __init__(self, name, age, sex):
        self.name = name
        self.__age = age
        self.__sex = sex

    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self,new_age):
        if type(new_age) == int:
            self.__age = new_age
        else:
            print('请输入一个整数')

    @age.deleter
    def age(self):
        print(666)

p1 = People('天', 28, '男')
print(p1.name)
p1.name = '地'
print(p1.name)
print(p1.age)  # p1.age 触发 @property装饰的方法
p1.age = '1234' # p1.age = '1234'  触发 @age.setter装饰的方法
print(p1.age)
del p1.age  # del p1.age 触发  @age.deleter装饰的方法


class Goods:

    def __init__(self,name,origin_price,discount):
        self.name = name
        self.__origin_price = origin_price
        self.__discount = discount

    @property
    def price(self):
        return self.__origin_price*self.__discount

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

# p1 = Goods('apple',5,0.8)
# print(p1.price)
# p1.price = 8
# print(p1.price)

class Goods:

    __discount = 0.8

    def __init__(self,name,origin_price):
        self.name = name
        self.__origin_price = origin_price

    @property
    def price(self):
        return self.__origin_price * Goods.__discount

    @classmethod
    def discount(cls,new_discount):
        Goods.__discount = new_discount

p1 = Goods('apple',5)
print(p1.price)
# p1.discount(0.85)
Goods.discount(0.85)
print(p1.price)

# 类方法:一般是由类名调用.有些情况,对于类内部的方法，无需对象直接调用，而类名直接调用即可。

class A:

def __init__(self):
pass

@staticmethod
def login(username,password):
print(username,password)

A.login('alex',123)
# 静态方法:不需要传入对象,和类名,直接调用即可.

四：反射

反射非常重要：

1. 类中使用：

class A:
    role = 'Teacher'

    def func(self):
        print(666)


msg = input('>>>')
print(A.role)
print(A.__dict__[msg])

反射
getattr(A,msg)(111)  # *****
getattr(A,msg)(111)  # 通过字符串 去到 类名 中获取对应的值.
print(getattr(A,msg))
hasattr() *****
print(hasattr(A,msg))
if hasattr(A,msg):
    print(getattr(A,msg))
else:
    print('不存在此值')

setattr() 增加或者修改 **
setattr(A,'name','alex')
setattr(A,'role','student')
print(A.__dict__)

delattr(A,'role')  # 删除*
print(A.__dict__)

2. 对象中使用：

class A:
    role = 'Teacher'

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


a1 = A('太白', 18)

print(hasattr(a1,'name'))
print(hasattr(a1,'sex'))
print(getattr(a1, 'name'))

在python 中一切皆对象,凡是通过 什么.什么 通过 反射都能取到

3. 模块中使用：

import time

print(time.time())

# print(getattr(time,'time'))

print(getattr(time,'time')())

import oldboy

print(getattr(oldboy,'func'))
getattr(oldboy,'func')()
方式一
print(getattr(oldboy,'A'))
print(getattr(oldboy,'A').role)
getattr(oldboy,'A').func1(11)

方式二
print(getattr(getattr(oldboy,'A'),'role'))

4.当前模块中

def login():
    print(666)

msg = input('>>>')
import sys

getattr(sys.modules[__name__],msg)()

__len__

l1 = list([1, 2, 3])
print(len(l1))

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __len__(self):
        return len(self.__dict__)



a = A()
print(len(a))

class A:

    def __init__(self):
        self.a = 1
        self.b = 2

    def __hash__(self):
        return hash(self.a+self.b)
a = A()
print(hash(a))
print(hash([1,2,3]))

类中如有__str__方法,print(对象),str(a) print('%s' % a)
class A:
    def __init__(self):
        pass
    def __str__(self):
        return '太白'
a = A()
# print(str(a))
print('%s' % a)

class A:
    def __init__(self):
        pass
    def __repr__(self):
        return '太白'
a = A()
print(repr(a))
print('%r'%a)

对象() 自动执行类中的__call__方法
class Foo:

    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):
        print('__call__')


obj = Foo()  # 执行 __init__
obj()  # 执行 __call__

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __eq__(self,obj):
        if  self.a == obj.a and self.b == obj.b:
            return 666
a = A()
b = A()
print(a == b)

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __del__(self):  # 析构方法
        print(222)
        return 666

obj1 = A()

5. 设计模式：单例模式

一个类只能实例化一个对象.

class A:
    def __init__(self):
        pass
a = A()
b = A()
print(a)
print(b)

class A:

    __intance = None
    def __new__(cls, *args, **kwargs):
        if cls.__intance is None:
            obj = object.__new__(cls)
            cls.__intance = obj
        return cls.__intance

a = A()
b = A()
print(a)
print(b)

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

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        print(key,value)
        self.__dict__[key]=value
    def __delitem__(self, key):
        print('del obj[key]时,我执行')
    #     self.__dict__.pop(key)

f1 = Foo('sb')
# f1['name']  # 对对象进行字典式的查询操作 触发 __getitem__
# f1['age'] = 18  # 对对象进行字典式的更改 触发 __setitem__
f1['age1']=19
# del f1.age1
del f1['age']  # 对对象进行字典式的del删除 触发 __delitem__
f1['name']='alex'
print(f1.__dict__)

posted @ 2018-06-28 19:16 MR_dy 阅读(115) 评论(0) 收藏举报

刷新页面返回顶部

MR_dy

python22期第7天课程总结(面向对象编程二)

公告