python : github 面向对象进阶

"""
属性的使用
- 访问器/修改器/删除器
- 使用__slots__对属性加以限制

"""
class Car:
    
    __slots__ = ('_brand','_max_speed') #不管是不是字符串，都要加 ' ' 符号

    def __init__(self,brand,max_speed):
        self._brand = brand
        self._max_speed = max_speed

    @property
    def brands(self):
        return self._brand  #属性的访问器，用return ，不用print，因为方便外部使用数值

    @brands.setter           #属性的修改器
    def brands(self,brand):
        self._brand = brand
        
    @brands.deleter          #属性的删除器
    def brands(self):
        del self._brand

    @property
    def max_s(self):
        return self._max_speed
    @max_s.setter
    def max_s(self,max_speed):
        if max_speed > 0:
            self._max_speed = max_speed
        else:
            raise ValueError('Invaild max speed for car')
    @max_s.deleter
    def max_s(self):
        del self._max_speed

    def __str__(self):  #重写__str__ ，原本的return是返回的要打印的数据/类型，这里修改return的东西
        return 'the max speed of %s is %s'%(self._brand,self._max_speed)

car = Car('benz',150) #不管参数的类型，因为python没有定义变量类型
print(car)

#car.max_s = -100  #调用max_s，记得用等号，而不是（）
#ValueError: Invaild max speed for car
del car.brands
del car.max_s

"""
属性的使用
- 使用已有方法定义访问器/修改器/删除器

"""
class Car(object):

    def __init__(self, brand, max_speed):
        self.set_brand(brand)
        self.set_max_speed(max_speed)

    def get_brand(self):
        return self._brand

    def set_brand(self, brand):
        self._brand = brand
    def del_brand(self):
        del self._brand

    def get_max_speed(self):
        return self._max_speed

    def set_max_speed(self, max_speed):
        if max_speed < 0:
            raise ValueError('Invalid max speed for car')
        self._max_speed = max_speed

    def __str__(self):
        return 'Car: [品牌=%s, 最高时速=%d]' % (self._brand, self._max_speed)

    # 类属性 property(方法名1(fget),方法名2(fset),方法名3(fdel),"属性描述信息"(__doc__))
    brands = property(get_brand,set_brand,del_brand,'汽车品牌')
    max_s = property(get_max_speed,set_max_speed)
    
car = Car('QQ', 120)

car.brands  #自动调用brands的第一个参数指定的方法
car.brands = "Benz"  #自动调用brands的第2个参数指定的方法
del car.brands #自动调用brands的第3个参数指定的方法
print(Car.brands.__doc__) #注意，这里为类名Car，而非对象名car

car.max_s = 320 #自动调用max_s的第2个参数指定的方法

#在之前时钟的基础上改进，通过类方法（classmethod）修饰

import time as t
import os

class Count():
    def __init__(self,hour,minite,second): 
            self._hour = hour
            self._minute = minite
            self._second = second

    @classmethod
    def inits(cls): #定义类方法，类方法的第一个参数约定名为cls，它代表的是当前类相关的信息的对象
        timetuple = t.localtime()
        return cls(timetuple[3],timetuple[4],timetuple[5])

    def timerun(self):
        self._second+=1
        if self._second==60:
            self._second=0
            self._minute+=1
            if self._minute==60:
                self._minute=0
                self._hour+=1

    def timeshow(self):
        print('%d -- %d -- %d'%(self._hour,self._minute,self._second))

if __name__ == '__main__':
    
    # 通过类方法创建对象并获取系统时间
    count=Count.inits()
    while True:
        os.system('cls')  
        count.timeshow()
        t.sleep(1)        #程序延时一秒
        count.timerun()

#运算符的重载，即通过魔法方法重写

class Compare1:
    def __init__(self,x):
        self.x=x
    #大于：greater than ----> gt
    def __gt__(self,other):  #self指向对象自身(左边) > other表示另外一个对象（右边）
        return abs(self.x) > abs(other.x)
    #小于：less-than  ------>lt
    def __lt__(self,other):
        return abs(self.x) < abs(other.x)
    
com1=Compare1(-5)
com2=Compare1(4)

print(com1 > com2) #True
print(com1 < com2) #False

class A(object):

    def foo(self):
        print('foo of A')


# super()采用C3算法，广度优先而非深度优先
        
class B(A):
    pass


class C(A):

    def foo(self):
        print('foo fo C')


class D(B, C):
    pass


class E(D):

    def foo(self):
        print('foo in E')
        super().foo()        #执行父类中的同名方法
        super(B, self).foo() #父类D继承与B，这里执行B中的同名方法
        super(C, self).foo() #父类D继承与C，这里执行C中的同名方法


if __name__ == '__main__':
    d = D()
    d.foo()
    print('===========')
    e = E()
    e.foo()

'''
foo fo C
===========
foo in E
foo fo C
foo fo C
foo of A

'''

#抽象类

from abc import ABCMeta,abstractmethod

class Employee(metaclass=ABCMeta): #ABCMeta是用来生成抽象基础类的元类。由它生成的类可以被直接继承
    def __init__(self,name):
        self._name=name #注意不能写成self.name，即传入的参数与类内部的参数名字不能一样
    @property
    def name(self):
        return self._name
    @abstractmethod
    def get_salary(self):
        pass
    
class Manager(Employee):
    def __init__(self,name):
        super().__init__(name)

    def get_salary(self):
        return 100000

class Worker(Employee):
    def __init__(self,name):
        super().__init__(name)
    def set_working_hours(self,hours):
        self.hours=hours
    def get_salary(self):
        return 1000*self.hours

hr_lists=[Manager('奥巴马'),Worker('anger translator')]
for ppl in hr_lists:  #这样可以通过循环定义类的对象，比如第一次循环时，ppl=Manager('奥巴马'),相当于定义了一个对象
    if isinstance(ppl,Manager): #ppl为对象名，Manager为类名，这里判断一个对象是否属于一个类
        print(ppl.get_salary())
    else:
        hourss=float(input('enter the hours:'))
        ppl.set_working_hours(hourss)
        print(ppl.get_salary())
    

#静态方法

class Cal:
    def __init__(self,x,y,z):
        self._x=x
        self._y=y
        self._z=z

    @staticmethod
    def decide(x,y,z): #静态方法，用于判断，其参数为x,y,z。不为self,因为使用它时，类还没有实例化，self是指向实例对象的
        return (x>0 and y>0 and z>0)

    def mu(self):
        self._x+=1
        self._y+=1
        self._z+=1
        return self  #返回的是一个类的实例化对象，具体见python踩坑收藏

    def adds(self):
        self._x*=2
        self._y*=2
        self._z*=2
        return self  #返回的是一个类的实例化对象
    
    def __str__(self):
        return '结果为：%f %f %f'%(self._x,self._y,self._z)

x,y,z=map(float,input('请输入三个数:').split()) #map的一般用法：map(函数，序列)。map函数的用法之一，这里是把输入的三个数都变成浮点数

if Cal.decide(x,y,z):  #静态方法，在定义类对象之前可以调用
    cal=Cal(x,y,z)
    cal.mu().adds().mu() #链式调用。前面的self在这里用到
    print(cal)
    
'''
请输入三个数:5 4 6
结果为：13.000000 11.000000 15.000000

'''