Python——多态和静态方法

继承

里氏替换原则 ： 任何情况子类都能替换父类

方法重写（override）- 覆盖/置换/覆写

• 子类在继承父类方法之后，对方法进行了重新实现
• 当我们给子类对象发送消息时，执行的是子类重写的方法

多态

#Python没有从语言层面支持抽象类的概念
#我们可以通过abc模块来制造抽象类的效果
#在定义类的时候通过指定metaclass=ABCMeta可以将类声明为抽象类
#抽象类是不能创建对象的 抽象类存在的意义是专门拿给类继承
#abc模块中还有一个包装器abstractmethod
#通过这个包装器可以将方法包装为抽象方法 必须要求子类进行重写
#抽象类如果没有抽象方法，那这个抽象类依然可以创建抽象方法
from abc import ABCMeta, abstractmethod #抽象类 ABCMeta 元类


class Employee(object, metaclass=ABCMeta):#让Employee变成抽象类，只能用于继承，不能创建对象
    """
    员工
    """

    def __init__(self, name):#魔法方法
        """初始化方法"""
        self._name = name

    @property
    def name(self):
        return self._name

    @abstractmethod #抽象方法，强制子类必须重写这个方法
    def get_salary(self):
        """获得月薪
        """
        pass


class Manager(Employee):
    """部门经理"""

    def get_salary(self):
        return 15000


class Programmer(Employee):
    """程序员"""
    def __init__(self, name):
        super().__init__(name)
        self._working_hour = 0

    @property
    def working_hour(self):
        return self._working_hour

    @working_hour.setter
    def work_hour(self, working_hour):
        self._working_hour = working_hour if \
            working_hour > 0 else 0

    def get_salary(self):
        return 150 * self._working_hour

class Salesman(Employee):
    """销售员"""
    def __init__(self, name):
        super().__init__(name)
        self._sales = 0

    @property
    def sales(self):
        return self._sales

    @sales.setter
    def sales(self, sales):
        self._sales = sales if sales > 0 else 0

    def get_salary(self):
        return 1200 + self._sales * 0.05


def main():
    emps = [
        Manager('刘备'), Programmer('诸葛亮'),
        Manager('曹操'), Salesman('荀彧'),
        Salesman('吕布'), Programmer('张辽'),
        Programmer('赵云')
    ]
    for emp in emps:
        #判断对象是否是后面的类型，返回布尔型
        if isinstance(emp, Programmer):
            emp.working_hour = int(input('请输入%s本月工作时间' % emp.name))
        elif isinstance(emp, Salesman):
            emp.sales = int(input('请输入%s本月销售额' % emp.name))
        #同样是接收get_salary这个消息，但是不同的员工表现出了不同的行为
        #因为三个子类都重写get_salary方法 所以此处有多态行为
        print('%s本月工资为：%.2f'%
                (emp.name, emp.get_salary()))




if __name__ == '__main__':
    main()

"""
定义一个类
描述银行账户
属性：
账号
余额
方法：
查询余额
取钱
存钱
转账
"""

class Account(object):

    def __init__(self, account_num, balance=0):
        self._account_num = account_num
        self._balance = balance

    @property
    def account_num(self):
        return self._account_num

    @property
    def balance(self):
        return self._balance

    def deposit(self, money):
        if money > 0:
            self._balance += money
            return True
        return False

    def withdrawal(self, money):
        if 0 < money <= self._balance:
            self._balance -= money
            return True
        return False

    def transfer(self, money, other):
        if self.withdrawal(money):
            other.deposit(money)
            return True
        return False


def main():
    a1 = Account('65201102', 10000)
    a2 = Account('63111901', 10000)
    print(a1.balance)
    print(a2.balance)
    a1.deposit(1000)
    a2.withdrawal(15000)
    a2.withdrawal(10000)
    print(a1.balance)
    print(a2.balance)
    a1.transfer(12000, a2)
    a1.transfer(10000, a2)
    print(a1.balance)
    print(a2.balance)



if __name__ == '__main__':
    main()

10000
10000
11000
0
1000
10000

静态方法

from math import sqrt


class Triangle(object):

    def __init__(self, a, b, c):
        self._a = a
        self._b = b
        self._c = c
    
    #@classmethod 发给类的方法 除了需要在输入参数时（cls,a.b.c），其他的使用和静态方法一样
    @staticmethod  #静态方法
    def is_valid(a, b, c):
        return a + b > c  and a + c > b and b + c > a

    def primeter(self):
        return self._a + self._b + self._c

    def area(self):
        half = self.primeter() / 2
        return sqrt(half * (half - self._a) * \
               (half - self._b) * (half - self._c))
    
    
def main():
    a = b = c = 1
    if Triangle.is_valid(a, b, c):
        t = Triangle(a, b, c)
        print(t.primeter())
        #print(Triangle.primeter(t)) 这种写法和上面写法是一样的
        print(t.area())
    else:
        print('不能构成三角形')
        
        
if __name__ == '__main__':
    main()

3
0.4330127018922193

提示 安装Pygame,可以在命令行提示符下通过 pip install Pygame 或者python -m pip install Pygame ,在PyCharm的虚拟环境安装需要在当前项目得file/setting/当前项目名/Project Interpreter,中点右方加号，搜索Pygame添加

"""

1.类
描述一个分数 3分之2 fractions python里的包名
方法：
加 减 乘 除 化简
属性
分子 分母
2.
21点游戏做完
"""

class Fraction(object):

    def __init__(self, numerator, denumerator):
        self._numerator = numerator
        self._denumerator = denumerator
        self.simplify()

    @property
    def numerator(self):
        return self._numerator

    @property
    def denumerator(self):
        return self._denumerator

    def simplify(self):
        a = abs(self._numerator) if abs(self._numerator) < abs(self._denumerator) \
            else abs(self._denumerator)
        for x in range(a , 0, -1):
            if self._denumerator % x == 0 and self._numerator % x == 0:
                break
        self._numerator //= x
        self._denumerator //= x

    def add(self, other):
        numerator = self._denumerator * other.numerator + \
                    self._numerator * other.denumerator
        denumerator = self._denumerator * other.denumerator
        return Fraction(numerator, denumerator)

    def minus(self, other):
        numerator = self._numerator * other.denumerator - \
                    self._denumerator * other.numerator
        denumerator = self._denumerator * other.denumerator
        return Fraction(numerator, denumerator)

    def multiplication(self, other):
        numerator = self._numerator * other.numerator
        denumerator = self._denumerator * other.denumerator
        return Fraction(numerator, denumerator)

    def divide(self, other):
        if other.numerator != 0:
            numerator = self._numerator * other.denumerator
            denumerator = self._denumerator * other.numerator
            return Fraction(numerator, denumerator)

    def show(self):
        return '%d / %d' % (self._numerator, self._denumerator)


def main():
    f1 = Fraction(-4, 12)
    f2 = Fraction(3, 5)
    print(f1.show())
    f3 = f1.add(f2)
    print(f3.show())
    f4 = f1.minus(f2)
    print(f4.show())
    f5 = f1.multiplication(f2)
    print(f5.show())
    f6 = f1.divide(f2)
    print(f6.show())





if __name__ == '__main__':
    main()

dict1 = {}
dict1.update(name='wxz')
print(dict1)

{'name': 'wxz'}