day18-类：父类和子类

定义类描述平面上的点，提供移动点，计算一个点到另一个点的距离

import math


class Point:
    """平面上的点"""
    
    def __init__(self, x, y):
        """初始化方法
        :param x: x坐标
        :param y: 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, other):
        """两点间的距离"""
        return math.sqrt((self.x - other.x) ** 2 + (self.y - other.y) ** 2)
    
    # def __str__(self):
    def __repr__(self):
        return f'({self.x},{self.y})'
    

p1 = Point(3, 5)
p2 = Point(6, 1)
print(p1, p2)		# (3, 5) (6, 1)
print(p1.distance(p2))		# 5.0
p1.move_to(0, 0)
p2.move_to(1, -1)
print(p1, p2)		# (0,0) (7,0)
print(p1.distance(p2))		# 7.0


# 定义类描述平面上的线段，提供计算线段长度，判断一个线段与另一个线段是否相交的方法


class Line:
    """线段"""
    
    def __init__(self, start: Point, end: Point):
        """初始化方法
        :param start: 线段起点
        :param end: 线段终点
        """
        self.start = start
        self.end = end
        
    def __str__(self):
        return f'线段：({self.start}~{self.end})'
    
    def length(self):
        """线段长度"""
        return self.start.distance(self.end)
    
    def intersected(self, other):
        """判断两条线段是否相交"""
        sx1, sy1, ex1, ey1 = self.start.x, self.start.y, self.end.x, self.end.y
        sx2, sy2, ex2, ey2 = other.start.x, other.start.y, other.end.x, other.end.y
        return not (
        	max(sx1, ex1) < min(sx2, ex2) or
            max(sx2, ex2) < min(sx1, ex1) or
            max(sy1. ey1) < min(sy2, ey2) or
            max(sy2, ey2) < min(sy1, ey1)
        )
    
    
line1 = Line(p1, p2)
print(line1.length())		# 7.0
p3 = Point(-1, -2)
p4 = Point(6, 2)
line2 = Line(p3, p4)
print(line2.length())		# 8.06225774829855
print(line1.insersected(line2))		# True

p3.move_to(4, 5)
print(line1.insersected(line2))		# False

三角形

import math


class Triangle:
    """三角形"""
    
    def __init__(self, a, b, c):
        """初始化方法
        :param a: 边1
        :param b: 边2
        :param c: 边3
        """
        self.a = a
        self.b = b
        self.c = c
        
    # 类方法	-	发给类的消息（比静态方法多一个参数，代表接收消息的类）
    # @classmethod		# 类方法：cls-》类的信息
    # def is_valid_sides(cls,a , b, c):
    #     return (a + b > c and a + c > b and b + c > a)
    
    # 静态方法	-	不是三角形对象的消息，而是发给三角形类的消息
    @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):
        """三角形面积"""
        p = self.perimeter() / 2
        a, b, c = self.a, self.b, self.c
        return math.sqrt(p * (p - a) * (p - b) * (p - c))
    
    def main():
        a, b, c = map(float, input('请输入三条边的长度：').split())
        if Triangle.check_sides(a, b, c):
            tri = Triangle(a, b, c)
            print(f'三角形的周长：{tri.perimeter()}')
            print(f'三角形的面积：{tri.area()}')
        else:
            print('不能构成三角形')
            
            
if __name__ = '__main__':
    main()

扑克游戏

牌 - 花色/点数（牌面）；显示牌面

扑克 - 装54张牌的列表；洗牌/发牌

玩家 - ID/昵称/手牌；摸牌/打牌/整理手牌

less than - __lt__

great than - __gt__

equal to - __qt__

less than or equal to - __le__

import random

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


class Card:
    """牌"""
    
    def __init__(self, suite, face):
        """初始化方法
        :param suite: 花色
        :param face: 牌面（点数）
        """
        self.suite = suite
        self.face = face
        
    def __repr__(self):
        return self.show()
    
    def __lt__(self, other):		# less than
        """比较牌面花色"""
        if self.face != other.face:
            return self.face < other.face
        return self.suite < other.suite
    
    def show(self):
        """显示牌面"""
        suites = ('♠', '♥', '♣', '♦')
        faces = ['', '', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
        return f'{suites[self.suite]}{faces[self.face]}'
    
    
class Poker:
    """扑克"""
    
    def __init__(self):
        self.cards = [Card(suite, face)
                     for face in range(2, 15)
                     for suite in range(4)]
        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):
        """初始化方法
        :param nickname: 昵称
        """
        self.nickname = nickname
        self.cards = []
        
    def get_card(self, card):
        """摸牌"""
        self.cards.append(card)
        
    def arrange(self):
        """整理手牌"""
        self.cards.sort()
        
        
# card1 = Card(HEART, 13)
# card2 = Card(DIAMOND, 5)
# card3 = Card(SPADE, 1)
# card4 = Card(CLUB, 10)
# print(card1, card2, card3, card4)      # ♥K ♦5 ♠A ♣10
        
        
poker = Poker()
poker.shuffle()

names = ('妲己', '狄仁杰', '赵云', ’孙悟空)
players = [Play[name] for name in names]

# 给四个人发牌，每个人发13张牌
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)

继承：父类和子类

继承：通过已有的类创建新的类，子类会得到父类的继承信息（也是一种复用代码的方式）

父类(基类，超类) - 提供继承信息的类

子类(派生类) - 得到继承信息的类

• 公共的部分放在父类中，特有的部分写在子类中，子类通过继承父类，得到那些公共的部分

建议使用继承的时候使用单一继承

单一继承：一个类只能有唯一的父类

练习：

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

class Person:
    """人"""
    
    def __init__(self, name, age):
        """初始化方法
        :param name: 姓名
        :param age: 年龄
        """
        self.name = name
        self.age = age
        
    def eat(self):
        """吃饭"""
        return f'{self.name}正在吃饭'
    
    def play(self):
        """玩耍"""
        return 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: 课程名称
        """
        return f'{self.name}正在学习{self.course_name}'
    
    
class Teacher(Person):
    """老师"""
    
    def __inin__(self, name, age, title):
        """初始化方法
        :param title: 职称
        """
        super().__init__(name, age)
        self.title = title
        
    def teach(self, course_name):
        """授课
        :param course_name: 课程名称
        """
        return f'{self.name}正在教授{self.course_name}'
    
    
student = Student('王大锤', 18, '大一')
teacher = Teacher('张三', 41, '叫兽')
print(student.play())
print(teacher.eat())
print(student.study('Python程序设计'))
print(teacher.teach('Java面向对象程序设计'))

作业：工资（月薪）结算系统

公司有三类员工，结算月薪的方式是不一样的：
部门经理 manager - 15000元 / 月
程序员 programmer- 计算公时，200元 / 小时 * 本月工时
销售员 salesman- 底薪+提成：1800元+销售额5%提成

给出员工的信息，自动结算月薪。

class Employee:
    """职员"""
    
    def __init__(self, name, job_num):
        """初始化方法
        :param name: 名字
        :param job_num: 工号
        """
        self.name = name
        self.job_num = job_num
        
    def work(self):
        """工作"""
        return f'{self.name}正在工作'
    
    
class Manager(Employee):
    """部门经理"""
    
    def __init__(self, name, job_num, position):
        """初始化方法
        :param position: 职位
        """
        super().__init__(name, job_num)
        self.position = position
        
    def salary(self):
        """结算当月工资"""
        return f'{self.name}的职位是{self.position},当月结算工资15000元'
   

class Programmer(Employee):
    """程序员"""
    
    def __init__(self, name, job_num, position):
        """初始化方法
        :param position: 职位
        """
        super().__init__(name, job_num)
        self.position = position
        
    def salary(self, work_time):
        """结算当月工资"""
        return f'{self.name}的职位是{self.position},当月结算工资{work_time * 200}元'
    

class SalesMan(Employee):
    """销售员"""
    
    def __init__(self, name, job_num, position):
        """初始化方法
        :param position: 职位
        """
        super().__init__(name, job_num)
        self.position = position
        
    def salary(self, sales):
        """结算当月工资"""
        return f'{self.name}的职位是{self.position},当月结算工资{1800 + sales * 0.05}'
    
    
employee1 = Employee('伍六七', 'gs9527')
print(employee1.work())

manager1 = Manager('张三', 'gs001', '部门经理')
programmer = Programmer('李四', 'gs002', '程序员')
salesman = SalesMan('王五', 'gs003', '销售员')

print(manager1.salary())
print(programmer1.salary(120))
print(salesman1.salary(300000))