迈向大神day 19 接口和抽象 多态 封装 反射

##回顾

-要看self 指向谁

多继承 ：新式类 广度优先 经典类深度优先

.mro 查看广度优先 继承顺序

接口

设计模式；

接口类：python 原生不支持 没有内置接口类

抽象类：python 原生支持

from abc import abstractmethod,ABCMeta
class Payment(metaclass=ABCMeta):   #父类
	@abstractmethod
	def pay(self,money)
		raise NotImlemented  #没有实现 
#上述 接口或抽象类      
# 接口类   默认多继承      所有方法不实现
#抽象类    不支持多继承    有些代码可以实现


def pay(pay_obj,money)
	pay_obj.pay(money)
	
	

##接口类的多继承 接口不实现 接口隔离原则

from abc import abstractmethod,ABCMeta
class Walk_animal(metaclass=ABCMeta):
	@abstractmethod
	def walk(self):
		pass
class swim_animal:
	def swim(self):
		pass		
class Tiger(Walk_animal,):
	def walk(self)

抽象类的单继承

单继承 能实现功能都一样的

All_File 增删改查

多继承

python 没有接口类 一般单继承 接口 《都是一种规范 >

多态

一类事物拥有多种形态

python 动态强类型的语言

##封装

保护代码 只能自己的对象能调用自己的类中对象

class Person:
    def __init__(self,name,passwd):
        self.name=name
        self.__passwd=passwd
    def get_passwd(self):
        return self.__passwd  #类的内部才能使用   #私有属性   私有方法   不能在类的外部使用  
alex=Person("tom",'alse1000')
print(alex.get_passwd())



self__passwd     #私有属性
alex.__dict__   <===>   _Person.__passwd   _类型__属性名

class Person:
    def __init__(self,name,passwd):
        self.name=name
        self.__passwd=passwd
    def get_passwd(self):
        return self.__passwd
    def set_passwd(self,newPass):
        self.__passwd=newPass

###三个内置函数 property classmethod staticmethod

property 内置装饰器函数 方法伪装属性

from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    @property   #方法伪装属性 把括号去掉了 
    def perimeter(self):
        return 2*pi*self.r
    @property
    def area(self):
        return self.r**2*pi
c1 = Circle(5)
print(c1.area)     # 圆的面积
print(c1.perimeter) # 圆的周长

修改私有属性方法

class Person:
    def __init__(self,name):
        self.__name = name
    @property
    def name(self):
        return self.__name + 'sb'
    @name.setter   ###name 名字要一直
    def name(self,new_name):
        self.__name = new_name

tiger = Person('小哥哥')
print(tiger.name)
tiger.name = '全班'
print(tiger.name)

苹果打折优惠

class Goods:
    discount = 0.8
    def __init__(self,name,price):
        self.name = name
        self.__price = price
    @property
    def price(self):
        return self.__price * Goods.discount
apple = Goods('苹果',5)
print(apple.price)

###属性删除

属性删除

class Person:
    def __init__(self,name):
        self.__name = name
        self.price = 20
    @property
    def name(self):
        return self.__name
    @name.deleter
    def name(self):
        del self.__name
    @name.setter
    def name(self,new_name):
        self.__name = new_name
brother2 = Person('二哥')
del Person.price
brother2.name = 'newName'
brother2
del brother2.name
print(brother2.name)

###类属性和

method 方法

staticmathod 静态的方法 ***

classmethod 类方法 ****

class Goods:
    __discount = 0.8
    def __init__(self,name,price):
        self.name = name
        self.__price = price
    @property
    def price(self):
        return self.__price * Goods.__discount
    @classmethod   # 把一个方法 变成一个类中的方法，这个方法就直接可以被类调用，不需要依托任何对象
    def change_discount(cls,new_discount):  # 修改折扣     cls  别忘了
        cls.__discount = new_discount
apple = Goods('苹果',5)
print(apple.price)
Goods.change_discount(0.5)   # Goods.change_discount(Goods)     
print(apple.price)
# 当这个方法的操作只涉及静态属性的时候 就应该使用classmethod来装饰这个方法

staticmathod

class Login:
    def __init__(self,name,password):
        self.name = name
        self.pwd = password
    def login(self):pass

    @staticmethod#  不需要传self  
    def get_usr_pwd():   # 静态方法
        usr = input('用户名 ：')
        pwd = input('密码 ：')
        Login(usr,pwd)

Login.get_usr_pwd()
#在完全面向对象的程序中，
# 如果一个函数 既和对象没有关系 也和类没有关系 那么就用staticmethod将这个函数变成一个静态方法
#静态方法 没有默认的参数 就象函数一样    #对症下药就可以   最切当的方法实现

反射

三个内置函数 hasattr getattr delattr

class Teacher:
    dic = {'查看学生信息':'show_student','查看讲师信息':'show_teacher'}
    def show_student(self):
        print('show_student')
    def show_teacher(self):
        print('show_teacher')

class Teacher:
    dic = {'查看学生信息':'show_student','查看讲师信息':'show_teacher'}
    def show_student(self):
        print('show_student')
    def show_teacher(self):
        print('show_teacher')
    @classmethod
    def func(cls):
        print('hahaha')
alex=Teacher()
ret=getattr(Teacher,'dic') #字符串拿到值   #Teacher.dic
ret2 = getattr(Teacher,'func')   #拿到的是个地址      # 类.方法  teacher.func
ret2()

if hasattr(Teacher,'dic4'):   #有才取出来  没有就不取出来
   ret = getattr(Teacher,'dic')
print(ret)

for k in Teacher.dic:
    print(k)
key = input('输入需求 ：')
print(Teacher.dic[key])

func = getattr(alex, Teacher.dic[key])
func()

普通方法 self

静态方法 @staticmethod

类方法 @classmethod

属性方法 @property

class Teacher:
    pass
class Course:
    def __init__(self,name,price,period):
        self.name = name
        self.price = price
        self.period = period
python = Course('python',19800,'6 months')
class Classes:
    def __init__(self,name,course):
        self.name = name
        self.course = course
        # self.course_name = 'python'
pys9 = Classes('python_s9',python)
print(pys9.course.name)
python.name = 'python全栈'
print(pys9.course.name)

# 多态 ： （面试）
    # 多态和鸭子类型
# 封装 :   *** (面试)
    # 私有的
    # __名字
    # 只能在类的内部调用 子类都无法继承
# 三个装饰器
    # @property         ****   规范 面试   #@name.setter

时间计划书