Day 15 - 面向对象2习题

建立一个汽车类Auto，包括轮胎个数，汽车颜色，车身重量，速度等属性，并通过不同的构造方法创建实例。至少要求 汽车能够加速 减速 停车。 再定义一个小汽车类CarAuto 继承Auto 并添加空调、CD属性，并且重新实现方法覆盖加速、减速的方法

class Auto:
    stop_flag = '停车'
    accelerate_flag = '加速'
    slow_flag = '减速'

    def __init__(self, color, weight, speed, tires):
        self.tires = tires
        self.color = color
        self.weight = weight
        self.speed = speed

    def accelerate(self):
        return Auto.accelerate_flag

    @classmethod
    def slow(cls):
        return cls.slow_flag

    @staticmethod
    def stop():
        return Auto.stop_flag


class CarAuto(Auto):
    def __init__(self, air, CD, color, weight, speed, tires=4):
        super().__init__(color, weight, speed, tires)
        self.air = None
        self.cd = None

    def accelerate(self):
        return f'{CarAuto.accelerate_flag}->加速!'

    @classmethod
    def slow(cls):
        return f'{cls.slow_flag}->减速!'


c1 = CarAuto(True, True, 'white', 120, 300)
print(c1.accelerate_flag)
print(c1.color)
print(c1.stop())
print(c1.accelerate())
print(c1.slow())

创建一个Person类，添加一个类字段用来统计Perosn类的对象的个数

class Person:
    count = 0

    def __init__(self):
        Person.count += 1
        # print(Person.count)

    @classmethod
    def object_num(cls):
        return f'调用Person类的对象个数为：{cls.count}'


p1 = Person()
p2 = Person()
p3 = Person()
p4 = Person()
print(Person.object_num())

创建一个动物类，拥有属性：性别、年龄、颜色、类型 ，

要求打印这个类的对象的时候以’/XXX的对象: 性别-? 年龄-? 颜色-? 类型-?/’ 的形式来打印

import re


class Animal:
    def __init__(self, sex, age, color, species):
        self.sex = sex
        self.age = age
        self.color = color
        self.species = species

    def __repr__(self):
        r1 = re.compile(r':')
        r2 = re.compile(r',')
        strs = str(self.__dict__)
        str1 = re.sub(r1, '-', strs)
        str2 = re.sub(r2, ' ', str1)
        return f'/{self.__class__.__name__}的对象：{str2[1:-1]}/'


a1 = Animal('male', 20, 'yellow', 'Mammals')
print(a1)

写一个圆类， 拥有属性半径、面积和周长；要求获取面积和周长的时候的时候可以根据半径的值把对应的值取到。但是给面积和周长赋值的时候，程序直接崩溃，并且提示改属性不能赋值

class Round:
    pi = 3.14

    def __init__(self, radius):
        self.r = radius
        # self._perimeter = 0
        # self._area = 0

    @property
    def perimeter(self):
        return (self.r << 1) * Round.pi

    @property
    def area(self):
        return self.r**2 * Round.pi

    @perimeter.setter
    def perimeter(self, value):
        if value or value == 0:
            raise ValueError

    @area.setter
    def area(self, value):
        if value or value == 0:
            raise ValueError


o = Round(3)
print(o.perimeter)
print(o.area)

写一个扑克类， 要求拥有发牌和洗牌的功能(具体的属性和其他功能自己根据实际情况发挥)

import random


class Poker:
    colors = ['♦', '♣', '♥', '♠']
    numbers = ['J', 'Q', 'K', 'A', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

    @classmethod
    def poker(cls):
        pokers = [i + j for i in cls.colors for j in cls.numbers]
        pokers.extend(['Joker', 'joker'])
        # print(pokers)
        return pokers

    @classmethod
    def p_shuffle(cls):
        s_poker = cls.poker()
        random.shuffle(s_poker)
        return s_poker

    @classmethod
    def p_licensing(cls):
        i_poker = iter(cls.p_shuffle())
        A_cards = []
        B_cards = []
        C_cards = []
        for _ in range(18):
            A_cards.append(next(i_poker))
            B_cards.append(next(i_poker))
            C_cards.append(next(i_poker))
        return f'A的手牌为：{list(A_cards)}\nB的手牌为：{list(B_cards)}\nC的手牌为：{list(C_cards)}'


print(Poker.poker())
print(Poker.p_shuffle())
print(Poker.p_licensing())