day15-面向对象作业

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

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

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

   class Dog:
       def __init__(self, name:str, gender:str, breed:str):
           self.name = name
           self.gender = gender
           self.breed = breed
   
       def bark(self):
           print(f'{self.name}: 汪汪！')
   
   
   class People:
       def __init__(self, name:str, age:int, dog: Dog):
           self.name = name
           self.age = age
           self.dog = dog
   
       def walk_the_dog(self):
           print(f'{self.name}陪{self.dog.name}逛街汪！')
   
   
   dog1 = Dog('小黄', '公', '哈士奇')
   dog1.bark()
   people1 = People('小明', 28, dog1)
   people1.walk_the_dog()
   

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

   class Rectangle:
       def __init__(self, x, y):
           if x > y:
               self.length = x
               self.width = y
           else:
               self.length = y
               self.width = x
   
       def area(self):
           return self.length*self.width
   
       def perimeter(self):
           return (self.length+self.width)*2
   

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

   class Point:
       def __init__(self, x, y):
           self.x = x
           self.y = y
   
       def distance(self, point):
           return ((self.x - point.x)**2+(self.y - point.y)**2)**0.5
   

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

   class Point:
       def __init__(self, x, y):
           self.x = x
           self.y = y
   
       def distance(self, point):
           return ((self.x - point.x)**2+(self.y - point.y)**2)**0.5
   
   
   class Circle:
       pi = 3.1415926535
   
       def __init__(self, p: Point, r):
           self.center = p
           self.radius = r
   
       def perimter(self):
           return Circle.pi*self.radius
       
       def circumscribed(self, circle1):
           return self.center.distance(circle1.center) == (self.radius+circle1.radius)
   

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

   class Point:
       def __init__(self, x, y):
           self.x = x
           self.y = y
   
       def distance(self, point):
           return ((self.x - point.x)**2+(self.y - point.y)**2)**0.5
   
   
   class LineSegment:
       def __init__(self, sp:Point, ep: Point):
           self.start = sp
           self.end = ep
           
       def extent(self):
           return self.start.distance(self.end)
   

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

   文件anti_lord.py（存放了制作牌堆的函数）

   import random
   
   
   def deal_cards():
       card_list = [x for x in range(0, 54)]
       random.shuffle(card_list)
       for y in card_list:
           yield y
   
   def creat_card_list():
       card_name_list = []
       for x in list(deal_cards()):
           card_name=''
           if x == 53:
               card_name='大王'
           elif x == 52:
               card_name='小王'
           else:
               if x % 4 == 0:
                   card_name += '红心'
               elif x % 4 == 1:
                   card_name += '方片'
               elif x % 4 == 2:
                   card_name += '黑桃'
               elif x % 4 == 3:
                   card_name += '梅花'
               if x // 4 == 12:
                   card_name += '2'
               elif x // 4 == 11:
                   card_name += 'A'
               elif x // 4 == 10:
                   card_name += 'K'
               elif x // 4 == 9:
                   card_name += 'Q'
               elif x // 4 == 8:
                   card_name += 'J'
               else:
                   card_name += f'{x//4+3}'
           card_name_list.append(card_name)
           return card_name_list
   

   文件sort_pork.py(存放了将扑克牌进行排序的函数)

def sort_anit_lord(list1):
    a = list1
    new_list = []
    for x in a:
        if x == '大王':
            new_list.append(x)
    for x in a:
        if x == '小王':
            new_list.append(x)
    for x in a:
        if str(x)[2:] == '2':
            new_list.append(x)
    for x in a:
        if str(x)[2:] == 'A':
            new_list.append(x)
    for x in a:
        if str(x)[2:] == 'K':
            new_list.append(x)
    for x in a:
        if str(x)[2:] == 'Q':
            new_list.append(x)
    for x in a:
        if str(x)[2:] == 'J':
            new_list.append(x)
    for x in a:
        if str(x)[2:] == '10':
            new_list.append(x)
    for x in a:
        if str(x)[2:] == '9':
            new_list.append(x)
    for x in a:
        if str(x)[2:] == '8':
            new_list.append(x)
    for x in a:
        if str(x)[2:] == '7':
            new_list.append(x)
    for x in a:
        if str(x)[2:] == '6':
            new_list.append(x)
    for x in a:
        if str(x)[2:] == '5':
            new_list.append(x)
    for x in a:
        if str(x)[2:] == '4':
            new_list.append(x)
    for x in a:
        if str(x)[2:] == '3':
            new_list.append(x)
    return new_list

玩家：有自己的名字，手牌和筹码，身份，玩家可以决定是否抢地主
斗地主：一局斗地主有三个玩家，一副牌（牌堆），先后顺序，可执行的操作有发牌和判断抢地主结果

斗地主的游戏类：

from sort_pork import sort_anit_lord
from random import *
from anti_lord import *


class Player:
    def __init__(self, name, card_list, score):
        self.name = name
        self.hand = card_list
        self.score = score
        self.chara = '农民'
        self.want_ll = False

    def want_landlord(self):
        self.want_ll = True


class Landlords:

    def __init__(self, p1: Player, p2: Player, p3: Player):
        self.player1 = p1
        self.player2 = p2
        self.player3 = p3
        self.card = creat_card_list()
        self.lastCards = []
        self.sequ = [self.player1, self.player2, self.player3]
        shuffle(self.sequ)

    def deal_card(self):
        self.player1.hand = sort_anit_lord(self.card[0:17])
        self.player2.hand = sort_anit_lord(self.card[17:34])
        self.player3.hand = sort_anit_lord(self.card[34:51])
        self.lastCards = self.card[51:54]

    def the_landlords(self):
        for i in self.sequ:
            if i.want_ll:
                i.chara = '地主'
                i.hand.append(self.lastCards)
                sort_anit_lord(i.hand)
                break