my python day6

一、类的相关知识

类：把一类事物具有相同特征和动作整合到一起

对象：基于类而创建的一个具体的实例

实例化：类生成对象的过程

关键字 class 类名：

　　　　类的文档字符串

　　　　类体

python2 中python class类名 是经典类

　　　　　　class类名（object) 是新式类

python3中都是新式类

类的属性:

数据属性、函数属性

都存在类的属性字典中— 

实例：只有数据属性

用.的方式访问就是类属性或实例属性

class School:
    '''这是一个学校类''' #类的文档字符串
    number =100  #类的数据属性
    def __init__(self,name,addr,type):
        #初始化构造函数
        self.name = name   #self.name 存在实例的属性字典中，name是key 后面的name是传入的变量
        self.addr = addr
        self.type = type
    def create_exam(self):
        print("%s%s正在举行考试"%(self.type,self.name))
s1 = School("Ezhizen","中国","私立")  #实例化一个对象
# print(s1)
print(School.number)
print(School.__dict__)
School.x = 10#添加类数据属性
print(School.__dict__)
del  School.x  #删除类属性
print(School.__dict__)
def zhao_sheng(self):
    print("%s%s正在招生"%(self.type,self.name))
School.zhao = zhao_sheng  #添加类的函数属性
print(School.__dict__)  #类的属性字典
print(s1.__dict__)  #字典的属性字典
s1.create_exam()
School.zhao(s1)   #类调用方法时要把实例传进去  
print(s1.name)

class Person:
    number = 10
    def __init__(self,name,age,sex):
        self.name = name
        self.age= age
        self.sex = sex
    @property  #静态属性
    def learn(self):
        print("%s正在学python"%self.name)

    def play_ball(self,ball):
        print("%s正在打%s"%(self.name,ball))
    @classmethod  #类方法
    def run(cls):
        print(cls.number)
    @staticmethod  #静态方法
    def test(a):
        print(a)
p1 = Person("Ezhizen",18,"boy")
# p1.learn()
p1.learn  #当函数变成静态属性时，运行函数不需要加()，就可以封装逻辑
Person.run()  #不跟实例捆绑，只跟类捆绑
p1.run() #但实例也可以调用
Person.test(10) #静态方法，类调用，实例不能调用。只是名义上归类管理，不能使用类变量和实例变量，是类的工具包

#普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
#类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
#静态方法：由类调用；无默认参数；

class Coat:
    def __init__(self):
        #原价
        self.original_price = 100
        #折扣
        self.discout = 0.7
    @property
    def price(self):
        new_price = self.original_price*self.discout
        return new_price
    @price.setter
    def price(self,value):
        self.original_price=value
        print("11")
    @price.deleter
    def price(self):
        del self.original_price
        print(222)
c1 = Coat()
new_price = c1.price  #获得商品价格
print(new_price)
c1.price = 80   #修改商品价格
del c1.price  #删除商品价格

import time
class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    @staticmethod
    def now():
        t=time.localtime()
        return Date(t.tm_year,t.tm_mon,t.tm_mday)

class EuroDate(Date):
    def __str__(self):
        return 'year:%s month:%s day:%s' %(self.year,self.month,self.day)

e=EuroDate.now()
print(e) #我们的意图
import time
class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    # @staticmethod
    # def now():
    #     t=time.localtime()
    #     return Date(t.tm_year,t.tm_mon,t.tm_mday)

    @classmethod #改成类方法
    def now(cls):
        t=time.localtime()
        return cls(t.tm_year,t.tm_mon,t.tm_mday) #哪个类来调用,即用哪个类cls来实例化

class EuroDate(Date):
    def __str__(self):
        return 'year:%s month:%s day:%s' %(self.year,self.month,self.day)

e=EuroDate.now()
print(e) #我们的意图是想触发EuroDate.__str__,此时e就是由EuroDate产生的,所以会如我们所愿

组合：一个类中存在另一个类，而且是他的组成部分

class School:
    def __init__(self,name,addr):
        self.name = name
        self.addr = addr

class Course:
    def __init__(self,name,price,school):
        self.name = name
        self.price = price
        self.school = school
    
s1 = School("Ryoma School","China")
c1 = Course("python",1500,s1)
print(c1.school.name)

二、面向对象的三大特性1.封装2.多态3.继承

1.继承

继承是一种创建新类的一种方式，新建的类可以继承一个或多个父类（多继承），父类可以称为基类或超类，新建的类可以称为子类或派生类。

 

class A:
    '''我是A类'''
    pass
class B(A):
    '''我是B类'''
    pass
print(A.__bases__)  #查看基类
print(B.__bases__)
print(A.__name__)  #查看类名
print(A.__doc__)  #查看文档
print(A.__module__)  #__main__
print(A.__class__)  #type

 

class Vehicles:
    def __init__(self,name,power,num):
        self.name= name
        self.power = power
        self.num = num
    def run(self):
        print("%s开动了"%self.name)
class Railway(Vehicles):
    def __init__(self,name,power,num,s):
        #子类调用父类的构造函数
        # super().__init__(name,power,num)
        super(Railway,self).__init__(name,power,num)
        # Vehicles.__init__(self,name,power,num)
        self.s = s
    def run(self):
        #在子类中自己定义run函数
        print("%s%s开动了"%(self.power,self.name))
rail = Railway("Ezhizen","氢能",100000,15000)
rail.run()

当类之间有明显的不同，而且较小的类是较大类的的一个组成部分，用组合比较好

当类之间存在很大的相同，提取它们公共的部分做成基类，用继承

接口继承

定义一个类 ，提供接口函数，子类继承，去实现该方法。归一化设计。 不需要关心类是什么，只需要知道哪些功能

class Interface:
    def read(self):
        #定义接口函数
        pass
    def write(self):
        #定义接口函数
        #
        pass
class Tex(Interface):
    def read(self):
        #实现接口函数
        print("文本读")
    def write(self):
        #实现接口函数
        print("文本写")
class Sata(Interface): #磁盘，具体实现read和write
    def read(self):
        print('硬盘数据的读取方法')

    def write(self):
        print('硬盘数据的读取方法')

class Process(Interface):
    def read(self):
        print('进程数据的读取方法')

    def write(self):
        print('进程数据的读取方法')

经典类中，继承顺序：深度优先.  新式类中 广度优先

class A:
    def test(self):
        print("in A")
class B(A):
    # def test(self):
    #     print("in B")
    pass
class C(A):
    # def test(self):
    #     print("in C")
    pass
class D(B):
    # def test(self):
    #     print("in D")
    pass
class E(C):
    # def test(self):
    #     print("in E")
    pass
class F(D,E):
    # def test(self):
    #     print("in F")
    pass
f = F()
f.test()  #F-D-B-E-C-A  #新式类中广度优先 经典类中深度优先
print(F.__mro__)  #查看继承顺序

2.多态

不同类得到的实例化对象，调用同一种方法

 

import abc
class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def talk(self):
        pass
class Dog(Animal):
    def talk(self):
        print("talk")
    pass
class Pig(Animal):
    def talk(self):
        print("ddd")
Dog()
Pig()

 

import abc
class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def talk(self):
        pass
class Dog(Animal):
    def talk(self):
        print("talk1")
    pass
class Pig(Animal):
    def talk(self):
        print("talk2")
class Bird(Animal):
    def talk(self):
        print("talk3")
d1 = Dog()
p1 = Pig()
b1 = Bird()
d1.talk()   #调用同一个方法
p1.talk()
b1.talk()

def run(obj):
    obj.talk()
run(d1)         #多态  不同类的实例对象调用同一个方法
run(p1)
run(b1)

3.封装

-单下划线 被隐藏起来的属性，外部不能调用，只是一种约定（私有属性）一般非公共名称用单下划线

__双下划线 私有属性，外部无法调用，只是一种约定.可以通过_类名__属性访问 如 a._P__b 如果涉及到子类，并且有些内部属性应该在子类中隐藏起来。 在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

封装 明确区分内外，内部实现逻辑，外部无法知晓，并且为限制到内部的逻辑提供一个接口给外部使用.

私有属性在import * 时不能运行  但导入具体方法时可以运行

 

__import__("m1.t")  #导入顶层m1模块
import importlib
importlib.import_module("m1.t")  #导入底层t模块

 

 

 

class Room:
    def __init__(self,name,length,width,height):
        self.name = name
        self.length = length
        self.width = width
        self.height = height
    def show_area(self):
        return self.length * self.width

r1 = Room("Ezhizen",12,12,12)
area = r1.show_area()
print("Ezhizen住的面积",area)
class Room:
    def __init__(self,name,length,width,height):
        self.name = name
        self.__length = length
        self.__width = width
        self.height = height
    def __show_area(self):
        return self.__length * self.__width
    def show_area(self):
        #提供接口函数
        return self.__show_area()
r1 = Room("Ezhizen",12,12,12)
r1.show_area()
print("Ezhizen住的面积",area)

 

4.自省/反射

class A:
    pass
a = A()
print(isinstance(a,A))  #判断a是否是A的对象
class B(A):
    pass

print(issubclass(B,A))  #判断B是否为A的子类

自省：主要是指程序可以访问、检测和修改它本身状态或行为的一种能力.通过字符串的形式操作对象相关的属性

hasattr(obj,name).  判断object中有没有一个name字符串对应的方法或属性

 

getattr(obj,name,default=None)

setattr(x,y,v). 等价于 x.y= v

delattr(x,y)。等价于 del x.y

 

class Student:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def  show_info(self):
        print("%s的年龄为%s"%(self.name,self.age))
s1 = Student("Ezhizen",18,"boy")
print(hasattr(s1,"name"))  #判断是否存在name这个属性
print(getattr(s1,"name"))  #获得name属性值
print(getattr(s1,"q","error"))
setattr(s1,"hobby","tennis")  #设置属性
print(s1.__dict__)
delattr(s1,"hobby")  #删除属性
print(s1.__dict__)

 

__setattr__ \ __getattr__\__delattr__

class Foo:
    x=1
    def __init__(self,y):
        self.y = y
    def __getattr__(self, item):
        print("你找的属性不存在")
    def __setattr__(self, key, value):
        # self.key = value  #进入无限递归
        print("执行setattr方法")
        self.__dict__[key] = value
    def __delattr__(self, item):
        print("执行delattr方法")
        # del  self.item  #进入无限递归
        self.__dict__.pop(item)
f = Foo(10)  #执行init函数 执行setattr
print(f.x) #属性存在时获得该属性值
f.q   #属性不存在，执行getattr方法
del f.y  #执行delattr方法

class Foo:
    x=1
    def __init__(self,y):
        self.y = y
    def __getattribute__(self, item):
        print('1111')
        raise AttributeError("不存在")
    def __getattr__(self, item):
        print("你找的属性不存在")

    def __setattr__(self, key, value):
        # self.key = value  #进入无限递归
        print("执行setattr方法")
        self.__dict__[key] = value
    def __delattr__(self, item):
        print("执行delattr方法")
        # del  self.item  #进入无限递归
        self.__dict__.pop(item)
f = Foo(10)  #执行init函数 执行setattr
# print(f.x) #属性存在时获得该属性值
f.q   #属性不存在，执行getattr方法 
#如果getattribute也存在，先执行getattribute 抛出attributeerror，执行getattr
# del f.y  #执行delattr方法