python之面向对象（后续）

面向对象三大特征： 封装 继承 多态：

1.封装 ：隐藏内部实现 提供外部接口 易修改
类的内部修改并不影响外部更好的保护类或对象的属性值的安全
类属性归属于类，是整个类共有的

案例： 类属性和对象属性区别：
class Person:
    cout=0
    def __int__(self):
        self.name='无名氏'
        self.age=18
    def show(self):
        print('姓名：'+self.name+'年龄：'+str(self.age))

if '__main__'==__name__:
    Person.phone='110'#类属性
    xiaohua=Person()
    xiaohua.name='小花'
    xiaohua.age=20
    xiaohua.show()
    xiaohua.gender='男'#对象属性
    print('性别'+xiaohua.gender)#对象属性
    print(xiaohua.__class__.phone) # 类属性

    xiaoming=Person()
    xiaoming.name = '小明'
    xiaoming.age = 30
    xiaoming.show()
   # print('性别'+xiaoming.gender)报错 即：对象属性仅限于某一个对象
    print(xiaoming.__class__.phone)# 类属性 即：类属性是共有的

如图：

报错：

总结：类属性和对象属性怎么使用;写属性时 共同属性用类属性，区分属性用对象。
类方法： @classmethod
class Person:
    cout=0
    def __int__(self):
        self.name='无名氏'
        self.age=18
    def show(self):
        print('姓名：'+self.name+'年龄：'+str(self.age))
    @classmethod
    def hello(cls):
        print('这是一个类方法')

if '__main__' == __name__:
        xiaohua = Person()
        #即；直接调用就可以
        # 类方法更倾向于 工具方法 不需要重复的创建对象
        Person.hello()

如图：

静态方法：@staticmethod,静态方法可以加参数，
静态方法和类、对象都没关系，但可以通过类或者对象调用
class Person:
    @staticmethod
    def num(name):
        print(name+'hi..你好啊')
if '__main__'==__name__:
    youran=Person()
    Person.num('悠然')
一般静态方法会单独放在一个模块里

继承： 子类继承父类: ()   子类可以使用父类的属性和方法，简化代码。
当生成子类对象时，先初始化父类对象，
所以如果父类有__init__()方法，并且有属性时，要通过子类的构造赋值
初始化时：在子类中，调用父类的属性时，在__init__()方法中使用
即： super().__init__(self,属性)或 self.属性
子类继承父类的特性：传递性
案例宠物：
class Pet:
    def __init__(self,name,love,health):
        self.name=name
        self.love=love
        self.health=health
    def show(self):
        print('宠物名:'+self.name+'健康值：',self.health,'忠诚度：',self.love)
class Dog(Pet):
    def __init__(self,name,love,health):
        super().__init__(name,love,health)#重点
        self.strain='拉布拉多'
    def eat(self):
        print(self.strain+'正在吃饭饭')
class cat(Dog):
    def __init__(self,name,love,health):
        super().__init__(name,love,health)
        self.strain = '折耳猫'
if __name__=='__main__':
    dog=Dog('旺财\t',50,100)
    dog.eat()
    dog.love+=20
    dog.show()

    maomi=cat('小妮\t',80,100)
    maomi.eat()
    maomi.show()

如图：

执行以下：

交通工具类

class traffic:
    def __init__(self,name):
        self.name=name
    def run(self):
        print('交通工具'+self.name+'正在行驶..')
class Truck(traffic):
   def __init__(self,name,weight):
       super().__init__(name)
       self.weight=weight
   def run(self):
        print('卡车'+self.name+'载重'+str(self.weight)+'在行驶')
class Train(traffic):
   def __init__(self,name,num):
       super().__init__(name)
       self.num=num
   def run(self):
        print('火车'+self.name+'车厢个数'+str(self.num)+'在行驶')
if __name__=='__main__':
     dongfen=Truck('东风',10)
     dongfen.run()
     hexie=Train('和谐001',50)
     hexie.run()

如图：

 总结 ：当子类继承父类时：
子类的构造放啊应该包含父类和子类共同的属性，
在__init__方法：将父类的属性传递给父类，子类的属性赋值给子类。
多继承：当有A,B 均有相同的方法，而子类又重写时，调用 （子类）
如果子类没有重写方法，则调用父类方法 （左侧的类 优先继承）

案例：
DVD:价格 名称 状态
class DVD:
    def __init__(self,name,price,state):
        self.name=name
        self.price=price
        self.state=state
if __name__=='__main__':

    youran=DVD('悠然的故事',200,1)#0：借出 1未借出
    chuntian=DVD('春天的风',200,0)#0：借出 1未借出
    dongtian=DVD('冬天的阳光',200,1)#0：借出 1未借出
    dvds = {youran.name:youran,chuntian.name:chuntian,dongtian.name:dongtian}
    while True:
        print('----DVD管理系统-----')
        print('1.查询说有DVD')
        print('2.增加DVD')
        print('3.借出DVD')
        print('4.归还DVD')
        print('5.退出')
        num=int(input('请选择：'))
        if num == 5:
            break
        elif num == 1:
            print('名字\t价格\t状态')
            for key in dvds.keys():
                if dvds.get(key).state==0:
                    print(key+'\t'+str(dvds.get(key).price)+'\t借出')
                else:
                    print(key+'\t'+str(dvds.get(key).price)+'\t未借出')
        elif num == 2:
            name=input('请输入DVD的名字：')
            while name in dvds.keys():
                name = input('DVD的名字已存在，请重新输入：')
            price = input('请输入DVD的价格')
            new_dvd =DVD(name,price,1)
            dvds[name] = new_dvd
            print('添加成功')
        elif num == 3:
            name = input('请输入要借出的DVD的名字：')
            while name not in dvds.keys():
                name = input('DVD不存在，请重新输入：')
            if dvds.get(name).state==0
                print(name+'已借出')
            else:
                dvds.get(name).state = 0
                print(name+'借出成功')
        elif num == 4:
            name = input('请输入要归还的DVD名字：')
            while name not in dvds.keys():
                name = input('DVD不存在，请重新输入：')
            if dvds.get(name).state == 1:
                print('DVD 未借出')
            else:
                days = int(input('请输入借出的天数：'))
                print('请刷卡：',int(dvds.get(name).price)*days,'.00元')
                dvds.get(name).state = 0
                print('归还成功！')

 运行一下如图：

 

单列模式 ：主要的目的是确保某一个类只有一个实例存在。
__new__：构造方法__init__:初始化方法
class singleton:
    __instace=None
    def __new__(cls, *args, **kwargs):
        print('__new__')
        if cls.__instace==None:#说明没有被创建过
            cls.__instace=object.__new__(cls)
            return cls.__instace
        else:#被创建过
            return cls.__instace
    def __init__(self):
        print('__init__')

s1 = singleton()
s2 = singleton()
s3 = singleton()
s4 = singleton()
s5 = singleton()

print(id(s1))
print(id(s2))
print(id(s3))
print(id(s4))
print(id(s5))

如图：

内存地址都一样

总结：单列模式：实例==》对象==》内存地址==》内存空间

  

嘿嘿 完毕！