day14-面向对象作业

定义一个狗类和一个人类：

狗拥有属性：姓名、性别和品种拥有方法：叫唤

人类拥有属性：姓名、年龄、狗拥有方法：遛狗

# 狗类
class Dog:
    def __init__(self, dog_name, gender='公', breed='哈士奇'):
        # 创建对象属性，可以随时修改的
        self.dog_name = dog_name
        self.gender = gender
        self.breed = breed

    def bark(self):    # 叫唤方法
        print(f'{
        
        self.dog_name}饿了，需要喂食!')

    def __repr__(self):
        return str(self.__dict__)


d = Dog('来福')
print(d)    # {'name': '来福', 'gender': '公狗', 'breed': '哈士奇'}
d.bark()    # 调用叫唤方法打印：饿了，需要喂食！


# 类2 - 人类拥有属性：姓名、年龄、狗   拥有方法：遛狗
class People:
    def __init__(self, name, age=80, dog = None):
        self.name = name
        self.age = age
        self.dog = dog

    def walk_dog(self):
        if self.dog:
            print(f'{
        
        self.name}牵着{
        
        self.dog.dog_name}散步')
        else:
            print('还没有狗')

    def __repr__(self):
        return str(self.__dict__)


p = People('小明', 19)
print(p)    # {'dog_name': '花花', 'gender': '母狗', 'breed': '萨摩耶', 'name': '小明', 'age': 19}
p.walk_dog()    # 遛狗狗了！
p.dog = Dog('旺财', '母')
p.walk_dog()

定义一个矩形类，拥有属性：长、宽拥有方法：求周长、求面积

class Rect:
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def perimeter(self):    # 周长
        return self.length * self.width

    def proportion(self):    # 面积
        return 2 * (self.length + self.width)

    def __repr__(self):
        return f'{
        
        str(self.__dict__)[1:-1]}'

r1 = Rect(5, 5)
print(r1)    # 'length': 5, 'width': 5
print(r1.perimeter(), r1.proportion())    # 25 20

r2 = Rect(9, 6)
print(r2.perimeter(), r2.proportion())    # 54 30

定义一个二维点类，拥有属性：x坐标、y坐标拥有方法：求当前点到另外一个点的距离

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def distance(self, A):
        return f'{
        
        ((A.x - self.x) ** 2 + (A.y - self.y) ** 2) ** 0.5:.2f}'

    def __repr__(self):
        return str(self.__dict__)[1:-1]


p1 = Point()    # 'x': 2, 'y': 5
p2 = Point(3, 4)
print(p1.distance(p2))    # 3.61

定义一个圆类，拥有属性：半径、圆心拥有方法：求圆的周长和面积、判断当前圆和另一个圆是否外切

class Circle:
    pi = 3.1415926   # 类属性

    def __init__(self, r, center=Point()):
        self.r = r    # 对象属性
        self.center = center   # 圆心

    def perimeter(self):    # 周长
        return f'{
        
        Circle.pi * self.r * 2:.2f}'

    def square(self):    # 面积
        return f'{
        
        Circle.pi* self.r ** 2:.2f}'

    # 判断是否与另一个圆外切
    def is_excircle(self, other):
        if self.center.distance(other.center) == f'{
        
        self.r + other.r:.2f}':
            return True
        return False

    def __repr__(self):
        return str(self.__dict__)[1:-1]


# 需要用到3题Point类
o1 = Point(3, 4)
o2 = Point(6,8)
cir1 = Circle(2, o1)
cir2 = Circle(3, o2)
print(cir1)    # 'r': 2, 'center': 'x': 3, 'y': 4
print(o1.distance(o2))    # 5.00
print(cir1.perimeter(), cir1.square())    # 12.57 12.57 True
print(cir1.is_excircle(cir2))    # False

定义一个线段类，拥有属性：起点和终点，拥有方法：获取线段的长度

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 __repr__(self):
        return str(self.__dict__)[1:-1]

# 需要用到3题Point类
start1 = Point(3, 8)
end1 = Point(4, 9)
l1 = Line(start1, end1)
print(l1.length())    # 1.41

写一个斗地主游戏类（根据生活经验添加类的内容）

# 只实现了发牌的功能
from random import shuffle    # 导入洗牌方法
class Poker:    # 扑克牌类
    all_color = ['♥', '♠', '♣', '♦']
    nums = [str(x) for x in range(2, 11)] +['J', 'Q', 'K', 'A', 'joker', 'JOKER']
    # 映射表排大小
    table = {
      
      str(x): x for x in range(3, 11)}
    table.update({
      
      'J': 11, 'Q': 12, 'K': 13, 'A':14, '2': 15, 'joker': 16, 'JOKER': 17})

    def __init__(self, color, num):
        self.color = color
        self.num = num

    @classmethod
    def create_cards(cls):
        """创建一幅新的牌"""
        cards = []
        for n in cls.nums[:-2]:
            for c in cls.all_color:
                cards.append(Poker(c, n))       # 添加花色和数字
        cards.append(Poker('', cls.nums[-2]))   # 小王
        cards.append(Poker('', cls.nums[-1]))   # 大王

        return cards

    def __repr__(self):
        return f'{
        
        self.color}{
        
        self.num}'


class LandOwnerGame:    # 斗地主游戏类
    def __init__(self):
        self.cards = Poker.create_cards()  # 有一副牌

    def deal_cards(self):    # 发牌
        # 1.洗牌
        shuffle(self.cards)

        # 2.发牌
        player1 = []
        player2 = []
        player3 = []

        cards = iter(self.cards)
        for _ in range(17):
            player1.append(next(cards))
            player2.append(next(cards))
            player3.append(next(cards))

        # 排序
        player1.sort(key=lambda item: Poker.table[item.num], reverse=True)
        player2.sort(key=lambda item: Poker.table[item.num], reverse=True)
        player3.sort(key=lambda item: Poker.table[item.num], reverse=True)

        return player1, player2, player3, list(cards)


game = LandOwnerGame()
p1, p2, p3, di = game.deal_cards()
print(p1)
print(p2)
print(p3)
print(di)

发牌效果
[JOKER, ♠A, ♣A, ♠K, ♣K, ♦Q, ♠Q, ♥J, ♣J, ♦J, ♦9, ♥8, ♣8, ♣7, ♥6, ♦5, ♥5]
[joker, ♠2, ♥A, ♦K, ♣10, ♦10, ♣9, ♥9, ♠9, ♠8, ♣6, ♦6, ♣4, ♠4, ♥3, ♦3, ♣3]
[♣2, ♥2, ♦2, ♦A, ♥K, ♣Q, ♠J, ♠10, ♦8, ♠7, ♥7, ♠6, ♠5, ♣5, ♥4, ♦4, ♠3]
[♥Q, ♥10, ♦7]

day14-面向对象作业

猜你喜欢