2022.12.23-Python100day-day05-面向对象编程

1、面向对象编程  -----> 程序复杂  对象很多的时候
对象:接受消息的实体
对象的属性：
1、一切皆为对象；
2、对象都有属性和行为；
3、每个对象都是独一无二的；
4、对象一定属于某个类

给适当的对象发消息  给对象发消息 达到解决问题的目标
对象 = 数据 + 函数 ----> 对象将数据和操作数据的函数从逻辑上变成了一个整体
类：将一大类对象的 共同特征 抽取出来之后得到的一个抽象概念
简单的说：类就是对象的蓝图（模板）， 有了类才能创建出这种类型的对象

2、面向对象编程的过程：
1、定义类 -----> 驼峰命名法(每个单词的首字母大写)
   数据抽象：找到和对象相关的静态特征（属性）
   行为抽象：找到和对象相关的动态特征（方法）
2、造对象
3、发消息

# step1：定义类
class Student:
    """
    学生类  对象 = 数据+函数
    """
    # 数据抽象  数据
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 行为抽象  函数
    def eat(self):
        print(f'{self.name} 正在吃饭！')

    def study(self, course_name):
        print(f'{self.name}正在学习{course_name}.')

    def play(self,game_name):
        print(f'{self.name}正在玩{game_name}')

    def watch_TV(self):
        if self.age < 18:
            print(f'{self.name}未满18岁，只能看《熊出没》')
        else:
            print(f'{self.name}可以看甄嬛传！')

if __name__ == '__main__':
    stu1 = Student('王大锤', 15)
    stu2 = Student('faker', 26)

    stu1.study('python')
    stu1.eat()
    stu1.watch_TV()

    stu2.play('lol')
    stu2.watch_TV()

 3、面向对象编程示例

class Circle:

    def __init__(self, radius):
        self.radius = radius

    def perimeter(self):
        """
        计算周长
        :return:
        """
        return 2 * math.pi * self.radius

    def area(self):
        """
        计算面积
        :return:
        """
        return math.pi * self.radius ** 2


class Clock:

    def __init__(self, *, second=0, minute=0, hour=0):  # 默认值是0分0时0秒
        self.second = second
        self.minute = minute
        self.hour = hour

    def display(self):
        # 显示几分几时几秒  如果是 7 的话则显示 07
        return f'{self.hour:0>2d}:{self.minute:0>2d}:{self.second:0>2d}'

    def run(self):
        # 走字
        self.second += 1
        if self.second == 60:
            self.second = 0
            self.minute += 1
            if self.minute == 60:
                self.minute = 0
                self.hour += 1
                if self.hour == 24:
                    self.hour = 0

静态方法  我们在类里面写的函数 它们基本上是发给对象的消息
有的时候， 我们的消息并不想发给对象  而是希望发给这个类（类本省也是一个对象）
这个时候 我们可以使用静态方法 或者是一种类方法
静态方法 - 发给类的消息 ---> @staticmethod ----> 装饰器
类方法 - 发给类的消息 ----> @classmethod ----> 装饰器 ----> 第一个参数（cls）是接收消息的类

class Triangle:

    def __init__(self, edge1=0, edge2=0, edge3=0):
        if not Triangle.is_vaild(edge1, edge2, edge3):
            raise ValueError('无效的边长，无法构成三角形')
        self.edge1 = edge1
        self.edge2 = edge2
        self.edge3 = edge3

    @staticmethod
    def is_vaild(edge1, edge2, edg3):
        return edge1+edge2 > edg3 and edge2+edg3 > edge1 and edg3 + edge1 > edge2

    # 和上面的效果是一样的
    # @classmethod
    # def is_vaild(cls, edge1, edge2, edg3):
    #     return edge1+edge2 > edg3 and edge2+edg3 > edge1 and edg3 + edge1 > edge2

    def perimeter(self):
        return self.edge1 + self.edge2 + self.edge3

    def area(self):
        half = self.perimeter() // 2
        return (half * (half - self.edge1) * (half - self.edge2) * (half - self.edge3)) ** 0.5

class Card:

    # 初始化方法  在创建对象的时候 会被自动调用
    def __init__(self, suite, face):
        self.suite = suite
        self.face = face

    # 魔术方法 名字是固定的 有特殊的方法和意义的  获得对象的字符串表示的方法  在调用print输出对象时 会被自动调用
    def __str__(self):
        return self.show()

    # 获得对象的字符串表示 吧对象放到容器中调用print输出时会自动调用
    def __repr__(self):
        return self.show()

    def show(self):
        suites = {'S': '♠', 'H': '♥', 'C': '♣', 'D': '♦'}
        faces = ['', 'A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']
        return f'{suites[self.suite]}{faces[self.face]}'

class Poker:

    def __init__(self):
        self.cards = []
        for suite in 'SHCD':
            for face in range(1, 14):
                card = Card(suite, face)
                self.cards.append(card)

    def shuffle(self):
        """
        洗牌
        :return:
        """
        random.shuffle(self.cards)


    def deal(self):
        """
        发牌
        :return:
        """
        pass

def main():
    # card1 = Card('H', 1)
    # card2 = Card('S', 13)
    # card3 = Card('D', 9)
    # card4 = Card('C', 11)
    # print(card1.show())
    # print(card2.show())
    # print(card3.show())
    # print(card4.show())
    #
    # cards = [card1, card2, card3, card4]
    # print(cards)
    poker = Poker()
    print(poker.cards)

    poker.shuffle()
    print(poker.cards)

if __name__ == '__main__':
    main()

    # 对象的引用 放在前面的 都 指向了 同一个地址
    # 对象的引用

    card1 = Card('H', 1)
    card2 = Card('S', 13)
    card3 = Card('D', 9)
    card4 = Card('C', 11)
    print(card1.show())
    print(card2.show())
    print(card3.show())
    print(card4.show())

    cards = [card1, card2, card3, card4]
    print(cards)

    stu1 = Student('王大锤', 15)
    stu2 = Student('faker', 26)

    stu1.study('python')
    stu1.eat()
    stu1.watch_TV()

    stu2.play('lol')
    stu2.watch_TV()

    r = float(input('please input radius: '))

    c1 = Circle(r)
    c2 = Circle(r + 3)

    fence_price = c2.perimeter() * 38.5
    aisle_price = (c2.area() - c1.area()) * 58.5
    print(f'围墙的造价：{fence_price:.2f}元')
    print(f'过道的造价：{aisle_price:.2f}元')
    print(f'总计：{fence_price + aisle_price:.2f}元')

    clock = Clock(second=55, minute=59, hour=23)
    while True:
        print(clock.display())
        time.sleep(1)
        clock.run()

    try:
        t = Triangle(1, 2, 3)
        print(t.perimeter())
        print(t.area())
    except ValueError as err:
        print(err)