10月13日学习总结

10月13日学习总结

一、面向对象的应用

练习一、定义类描述平面上的点，提供移动点、计算一个点到另一个点距离的方法。

1. def _ _ repr _ _(self) / def _ _ str _ _(self)：显示自定义的内容

   

"""
example01 - 定义类描述平面上的点，提供移动点、计算一个点到另一个点距离的方法
"""


class Point:

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def move_to(self, x, y):
        self.x = x
        self.y = y

    def move_by(self, dx, dy):
        self.x += dx
        self.y += dy

    def distance(self, the_other):
        return ((self.x - the_other.x) ** 2 + (self.y - the_other.y) ** 2) ** 0.5

    def __str__(self):
        return f'({self.x},{self.y})'


p1 = Point(3, 5)
p2 = Point(6, 1)
print(p1, p2)
print(p1.distance(p2))
p1.move_to(0, 0)
p2.move_by(1, -1)
print(p1, p2)
print(p1.distance(p2))

#### 练习二、输入三角形三条边的长度，求它的周长和面积

"""
类方法 - 发给类的消息（比静态方法多一个参数，代表接收消息的类） ---> @classmethod
静态方法 - 不是三角形对象的消息，而是发给三角形类的消息  --->  @staticmethod
Triangle.check_sides(a,b,c)
"""

class Triangle:

    def __init__(self,a,b,c):
        self.a = a
        self.b = b
        self.c = c

    @classmethod
    def is_valid_sides(cls, a, b, c):
        return a + b > c and b + c > a and a + c > b

    # @staticmethod
    # def check_sides(a,b,c):
    #     return a + b > c and a + c > b and b + c > a


    def perimeter(self):
        return self.a+self.b+self.c

    def area(self):
        return (self.perimeter()/2*(self.perimeter()/2-self.a)*(self.perimeter()/2-self.b)*(self.perimeter()/2-self.c)) ** 0.5

# triangle1 = Triangle(5,10,16)
# if not triangle1.is_Triangle():
#     print('无法构成三角形')
# else:
#     print(triangle1.perimeter())
#     print(triangle1.area())
def main():
    a,b,c = map(float,input('请输入三条边的长度:').split())
    if Triangle.is_valid_sides(a,b,c):
        tri = Triangle(a,b,c)
        print(f'三角形周长是{tri.perimeter()}')
        print(f'三角形面积是{tri.area()}')
    else:
        print('不能构成三角形')


if __name__ == '__main__':
    main()

#### 练习三、扑克游戏

"""
example - 扑克游戏，请大家思考一下这里面有哪些类？对应的对象有哪些属性和方法？

牌 - 花色/点数；显示牌面
扑克 - 装54张牌的列表；洗牌/发牌
玩家 - ID/昵称/手牌；摸牌/打牌/整理手牌

比较的魔术方法
less than ---> __lt__ ---> <
great than ---> __gt__ ---> >
equal to ---> __eq__ ---> <
less than or equal to ---> __le__ ---> <=

"""

# 经验：符号常量优于字面常量!!!
SPADE,HEART,CLUB,DIAMOND = range(4)

import random

class Card:
    """牌"""

    def __init__(self,suite,face):
        self.suite = suite
        self.face = face

    def __repr__(self):
        return self.show()

    def __lt__(self, other):
        if self.suite != other.suite:
            return self.suite < other.suite
        face1 = 14 if self.face == 1 else self.face
        face2 = 14 if other.face == 1 else other.face
        return face1 < face2

    def show(self):
        """显示牌面"""
        suites = ('♠','♥','♣','♦')
        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 = [Card(suite,face)
                      for suite in range(4)
                      for face in range(1,14)]
        self.index = 0

    def shuffle(self):
        """洗牌"""
        self.index = 0
        random.shuffle(self.cards)

    def has_more(self):
        """有没有牌可以发出"""
        return self.index < len(self.cards)

    def deal(self):
        """发牌"""
        card = self.cards[self.index]
        self.index += 1
        return card

class Player:
    """玩家"""

    def __init__(self,nickname):
        self.nickname = nickname
        self.cards = []

    def get_card(self,card):
        """摸牌"""
        self.cards.append(card)

    def arrange(self):
        """整理手牌"""
        # self.cards.sort(key=lambda card:card.face)
        self.cards.sort()



poker = Poker()
poker.shuffle()
print(poker)
names = ('奥特曼','威震天','孙悟空','李小龙')
players = [Player(name) for name in names]
for _ in range(13):
    for player in players:
        card = poker.deal()
        player.get_card(card)

for player in players:
    player.arrange()
    print(player.nickname,end=':')
    print(player.cards)

二. 面向对象的继承

1. 父类
   提供继承信息的基类 / 超类
2. 子类
   得到继承信息的派生类
3. 继承（复用代码的方式）
   定义：通过已有的类创建新的类，子类得到父类的继承信息
   方法：公共的部分写在父类中，特有的部分写在子类中，子类通过继承父类，得到公共的部分
   Python语言允许多重继承，一个类可以有多个父类
   建议使用单一继承：一个类只能有唯一的父类

"""
example05 -

学生：姓名/年龄/年级；吃饭/玩耍/学习
老师：姓名/年龄/职称；吃饭/玩耍/授课

Martin Fowler - 代码有很多种很坏的味道，但重复是最坏的一种

Author: Hao
Date: 2021/10/13
"""


class Person:

    def __init__(self, name, age):
        """初始化方法
        :param name: 姓名
        :param age: 年龄
        """
        self.name = name
        self.age = age

    def eat(self):
        """吃饭"""
        print(f'{self.name}正在吃饭.')

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


class Student(Person):
    """学生"""

    def __init__(self, name, age, grade):
        """初始化方法
        :param grade: 年级
        """
        super().__init__(name, age)
        self.grade = grade

    def study(self, course_name):
        """学习
        :param course_name: 课程名称
        """
        print(f'{self.name}正在学习{course_name}.')


class Teacher(Person):
    """老师"""

    def __init__(self, name, age, title):
        """初始化方法
        :param title: 职称
        """
        super().__init__(name, age)
        self.title = title

    def teach(self, course_name):
        """授课"""
        print(f'{self.name}{self.title}正在讲{course_name}.')


student = Student('王大锤', 18, '大一')
teacher = Teacher('骆昊', 41, '叫兽')
student.play()
student.study('Python程序设计')
teacher.eat()
teacher.teach('数据库原理')