day17-面向对象作业

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

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

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

   class dogs():
       def bark(self,name,gender,breed):
           self.name = name
           self.gender = gender
           self.breed = breed
   
   class person():
       def walk_dog(self,name,age,dog):
           self.name = name
           self.age = age
           self.dog = dog
   
   
   dog = dogs()
   dog.name = 'wangcai'
   print(dog.name)
   
   pepole = person()
   pepole.name = 'zhangsan'
   print(pepole.name)
   

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

   class rectangle():
   
       def __init__(self,length ,width):
           self.length = length
           self.width = width
       def perimeter(self):
           return 2 * (self.length + self.width)
       def area(self):
           return self.length * self.width
   
   rectangle1 = rectangle(10,5)
   print(rectangle1.perimeter())
   print(rectangle1.area())
   

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

   class TwoDimensionalPoint():
       def __init__(self,A:tuple,B:tuple):
           self.A = A
           self.B = B
   
       def distance(self):
           return (((abs(self.A[0]) - abs(self.B[0])) ** 2) + ((abs(self.A[1]) - abs(self.B[1])) ** 2)) ** 0.5
   
   TwoDimensionalPoint1 = TwoDimensionalPoint((1,1),(3,3))
   print(f'{TwoDimensionalPoint1.distance():.2f}')
   

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

   class circle():
       pi = 3.14
       def __init__(self,A_p:tuple,A_r:float,B_p:tuple,B_r:float):
           self.A_p = A_p
           self.A_r = A_r
           self.B_p = B_p
           self.B_r = B_r
   
       def perimeter(self):
           A_perimeter = 2 * circle.pi * self.A_r
           B_perimeter = 2 * circle.pi * self.B_r
           print(f'A圆的周长是{A_perimeter:.2f},B圆的周长是{B_perimeter:.2f}')
           return A_perimeter,B_perimeter
   
       def area(self):
           A_area = circle.pi * self.A_r ** 2
           B_area = circle.pi * self.B_r ** 2
           print(f'A圆的面积是{A_area:.2f},B圆的面积是{B_area:.2f}')
           return A_area,B_area
   
       def comparative(self):
           distance = (((abs(self.A_p[0]) - abs(self.B_p[0])) ** 2) + ((abs(self.A_p[1]) - abs(self.B_p[1])) ** 2)) ** 0.5
           if distance == self.A_r + self.B_r:
               print('这两个圆是外切圆')
           else:
               print('这两个圆不是外切圆')
           return distance
   
   circle1 = circle((1,3),5,(5,7),10)
   circle1.perimeter()
   circle1.area()
   circle1.comparative()
   

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

   class segment():
       def __init__(self,start:float,end:float):
           self.start = start
           self.end = end
       def leng(self):
           if self.end >= self.start:
               length = self.end - self.start
               print(f'线段的长度是{length:.2f}')
           else:
               print('不符合线段的规则')
           return length
   
   segment1 = segment(20,31.4)
   segment1.leng()
   

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

   from random import shuffle,choice
   class FightLd():
   
       sum_player = 3
       # 1.创建54张顺序从小到大的牌
       @classmethod
       def creat_poker(self):
   
           colors = ['♥', '♣', '♦', '♠']
           sequences = [str(i) for i in range(2,11)] + ['J','Q','K','A']
           bomb_king = ['joker', 'JOKER']
           poker = []
           for color in colors:
               for sequence in sequences:
                   poker.append(color + sequence)
           poker += bomb_king
   
           return poker
   
       # 2.洗牌
       def shuffle_poker(self,poker):
           self.poker = poker
           shuffle(poker)
           lord = '地' + poker.pop(poker.index(choice(poker)))
           poker.append(lord)
           return poker
   
   
       # 3.发底牌
       def deal_c_poker(self,new_poker):
           self.new_poker = new_poker
           i_poker = iter(new_poker)
           cards = []
           for _ in range(3):
               # print(next(poker))
               cards.append(next(i_poker))
           print(f'三张底牌分别是{cards}')
   
           return i_poker
   
       # 4.给剩余三个玩家发牌
       def deal_poker(self,i_poker):
           self.i_poker = i_poker
           player1 = []
           player2 = []
           player3 = []
           self.player1 = player1
           self.player2 = player2
           self.player3 = player3
           for _ in range(17):
               player1.append(next(i_poker))
               player2.append(next(i_poker))
               player3.append(next(i_poker))
   
           return player1,player2,player3
   
       # 5.理牌
       def clear_poker(self,player1,player2,player3):
           table = {str(x):x for x in range(3,11)}
           table.update({'J':11,'Q':12,'K':13,'A':14,'2':15,'oker':16,'OKER':17})
           print(table)
           player1.sort(key=lambda item:table[item[2:]] if item.startswith('地')else table[item[1:]],reverse=True)
           player2.sort(key=lambda item: table[item[2:]] if item.startswith('地') else table[item[1:]], reverse=True)
           player3.sort(key=lambda item: table[item[2:]] if item.startswith('地') else table[item[1:]], reverse=True)
   
   
   
           self.player1 = player1
           self.player2 = player2
           self.player3 = player3
   
   
           return player1,player2,player3
   
   # 调用创建牌的类方法函数
   poker = FightLd.creat_poker()
   print(f'创建一副新扑克{poker}')
   
   # 创建对象
   fight_ld = FightLd()
   
   # 调用洗牌的对象方法函数
   new_poker = fight_ld.shuffle_poker(poker)
   print(f'洗过牌的扑克顺序是{new_poker}')
   
   #  调用发底牌的对象方法函数并且返回剩余迭代器的变量值i_poker并且给i_poker变量赋值
   i_poker = fight_ld.deal_c_poker(new_poker)
   
   #  给剩余三个玩家发牌
   player = fight_ld.deal_poker(i_poker)
   print(f'小花的牌是{fight_ld.player1}')
   print(f'小明的牌是{fight_ld.player2}')
   print(f'小张的牌是{fight_ld.player3}')
   
   #  调用理牌的对象方法函数
   sorted_player = fight_ld.clear_poker(player1=fight_ld.player1,player2=fight_ld.player2,player3=fight_ld.player3)
   print(f'小花理顺后的牌是{fight_ld.player1}')
   print(f'小明的牌是{fight_ld.player2}')
   print(f'小张的牌是{fight_ld.player3}')