Python语言基础面向对象编程进阶

Python语言基础面向对象编程进阶

倒计时计数器

class CountdownClock:
    def __init__(self, hour, minute, second):
        self.hour = hour
        self.minute = minute
        self.second = second
    def is_over(self):
        return self.hour == 0 and self.minute == 0 and self.second == 0
    def run(self):
        if not self.is_over():
            second -= 1
            if self.second < 0:
                self.minute -= 1
                self.second = 59
                if self.minute < 0:
                    self.minute = 59
                    self.hour -= 1
clock = CountdownClock(0, 0, 0)
print(clock.show())
while not clock.is_over():
    clock.run()
    print(clock.show())
print('倒计时结束，时间到！！！')

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

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, other):
        return ((self.x - other.x)**2 + (self.y - other.y)**2)**0.5
    # 为了在打印对象的时候能够看到自定义的内容，用到了以下两种方式
    def __repr__(self):
        return f'({self.x},{self.y})'
    def __str__(self):
        return f'<{self.x},{self.y}>'
class Line:
    def __init__(self, start:Point, end:Point):
        self.start = start
        self.end = 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 = self.start.x, self.start.y, self.end.x, self.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))
p1 = Point(2, 3)
p2 = Point(4, 5)
p3 = Point(8, 9)
p4 = Point(10, 12)
line1 = Line(p1, p2)
line2 = Line(p3, p4)
# 求线段长度
print(p1.length(p2))
# 判断两条线段是否相交
print(line1.intersect(line2))

写一个描述三角形的类(求周长和面积)

import math
class Triangle:
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c
     # 定义静态方法在执行程序之前判断是否属于三角形这个类，是，则运行程序，否则结束程序
    @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
        return math.sqrt(p*(p-self.a)*(p-self.b)*(p-self.c))
# 一行输入三个数字
def main():
    a, b, c = map(float, input('请输入三条边的长度：').split())  # split里面指定切割方式
    if Triangel.check_sides(a, b, c):
	    tri = Triangle(a, b, c)
         print(f'三角形的周长是：{tri.perimeter()}')
         print(f'三角形的面积是：{tri.area()}')
if __name__ =='__main__':
    main()

扑克牌游戏

牌 - 属性（花色，点数）；行为（显示牌面）
扑克 - 装54张牌的列表；  洗牌，发牌
玩家 - ID、昵称、手牌；摸牌、打牌、整理手牌

import random
# 定义牌类
SPADE, HEART, CLUB, DIAMOND = range(4)
class Card:
    def __init__(self, suite, face):
        self.suite = suite
        self.face = face
    def show(self):
        faces = ('', 'A', '2' ,'3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K')
        suites = ('黑桃', '红心', '梅花', '方块')
        return f'{suites[self.suit]}{faces[self.face]}'
# 定义扑克类
class Poker:
    def __init__(self):
        self.cards=[Cards(suite, face)
                   for suite in range(4)
                   for face in range(1, 14)]
    # 行为抽象化
    def shuffle(self):
        self.index = 0
        random.shuffle(self.cards)  # 将扑克牌进行洗牌
    # 判断是否有牌
    def has_more(self):
        return self.index < len(self.cards)
    
    # 发牌
    def deal(self):
        if has_more():
            # 取牌
            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 x:x.suite) # 根据花色比较大小，再自定义进行排序
 

创建对象

# 洗牌
poker = Poker()
poker.shuffle()

玩家摸牌

# 玩家摸牌
names = ('妲己', '狄仁杰', '赵云', '孙悟空')
players = [Player(name) for name in names] # 构造器语法，通过遍历一次性产生四个玩家
# 通过遍历控制使得每个玩家拿到13张牌
for _ in range(13):
    for player in players:
        card = pocker.deal()  # 获得扑克牌
        player.get_card(card)  # 将拿到的牌添加给每一个玩家
for player in players:
    player.arrange()
    # 循环遍历打印每个玩家拿到的牌
    print(player.nickname, end=':')
    print(player.cards)

继承

继承：通过已有的类创建新的类，子类会得到父类的继承信息；
父类（基类）：提供继承信息（公共部分）
子类：得到继承的信息（派生类）
公共的部分放在父类中，特有的部分写在子类中，子类通过继承父类，得到那些公共的部分，继承也是代码复用的一种方式
python语言允许多重继承，子类会得到父类的继承信息
单一继承：一个类只能有一个父类（提倡单一继承）

由人类衍生出学生类和老师类

class Person:
    def __init__(self, name, 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):
        super().__init__(name, age)
        self.grade = grade
    def study(self, course_name):
        print(f'{self.name}正在学习{course_name}')
 class Teacher(Person):
    def __init__(self, name, age, title):
        super()>__init__(name, age)
        super.title = title
    def teacher(self, course_name):
        print(f'{self.name}正在讲授{course_name}')
teacher = Teacher('洛', 41, '大神')
student = Student('晓', 18, '初学')
student.study('python')
student.eat()