day17-面向对象作业

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

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

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

   class Dogs:
       """
       对象实例化时需要传入 姓名、性别和品种，
       三种属性的默认值均为Unknow
       """
   
       def __init__(self,Dogname='Unknow',Doggender= 'Unknow',Dogspecie='Unknow'):
           self.Dogname = Dogname
           self.Doggender = Doggender
           self.Dogspecie = Dogspecie
   
       def barking(self):
           print(f'{self.Dogname}在叫唤:汪、汪、汪')
   
   
   a = Dogs('uzi','male','Unknow')
   print(a.Dogname)
   a.barking()
   
   
   
   class Man(Dogs):
   
       """
       拥有属性 姓名、年龄、狗
       """
       def __init__(self,man_name='Unknow',age='Unknow',Dogname='Unknow',Doggender= 'Unknow',Dogspecie='Unknow'):
           super().__init__(Dogname,Doggender,Dogspecie)
           self.man_name = man_name
           self.age = age
           self.dog = f'名字叫{Dogname}性别为{Doggender}品种为{Dogspecie}的狗'
   
       def walk_dog(self):
           print(f'{self.man_name}正在溜{self.dog}')
   
   a = Man(man_name='污渍',Dogname='uzi')
   a.walk_dog()
   print(a.dog)
   

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

   class Rectangle:
       def __init__(self,length=0,width=0):
           self.length = length
           self.width = width
   
       def circ(self):
           return self.width*2+self.length*2
   
       def area(self):
           return self.length * self.width
   
   
   x = Rectangle(2,5)
   print(f'周长:{x.circ()},面积:{x.area()}')
   

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

   from math import dist
   
   
   class Points:
   
       """
       坐标参数为保存当前点x,y坐标的元组，当前点默认值为原点
       调用方法计算当前点到另一个点的距离需要提供另一点的坐标参数
       用(x,y)形式提供，不提供将默认计算当前点到原点的距离
       """
   
       def __init__(self,coordinate=(0,0)):
           self.coordinate = coordinate
           self.x = coordinate[0]
           self.y = coordinate[1]
   
       def point_dic(self,else_coo = (0,0)):
           return dist(self.coordinate,else_coo)
   
   
   a = Points((3,4))
   print(a.x)
   print(a.point_dic())
   
   

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

   from math import dist
   class Round:
       """
       实例化时需要两个参数 r,center:tuple
       默认值分别为 0,(0,0)
       outer_cut方法有参数 r2 center2:tuple
       默认值为 0 ,(0,0)
       """
   
       pi = 3.14
   
       def __init__(self,r=0,center = (0,0)):
           self.r = r
           self.center = center
   
       def circ(self):
           return 2*Round.pi*self.r
   
       def area(self):
           return Round.pi*self.r**2
   
       def outer_cut(self,r2=0,center2=(0,0)):
           return r2+self.r == dist(self.center,center2)
   
   b = Round(5,(0,0))
   print(b.outer_cut(5,(10,0)))
   

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

   from math import dist
   
   class Line:
       """
       这是一个任意维数线段的类,实例化时需要参数为 start:tuple,end:tuple
       元组中的元素均为数字
       len_line()方法的结果保留两位小数
       """
   
       def __init__(self,start,end):
           self.start = start
           self.end = end
   
       def len_line(self):
           return f'{dist(self.start, self.end):.2f}'
   
   c = Line((0,0,0),(2,5,8))
   print(c.len_line())
   

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

   import random
   class PlayPoker:
   
       """
       调用洗牌方法，会生成一个迭代器,里面装着一副被打乱顺序的牌
       """
   
   
       # 洗牌
   
       def shuffle_poker(self) -> iter:
           poker_list = []
           dict1 = {'♥': ['3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A', '2'],
                    '♠': ['3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A', '2'],
                    '♦': ['3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A', '2'],
                    '♣': ['3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A', '2']
                    }
           for i, j in dict1.items():
               for k in range(len(j)):
                   poker_list.append(i + j[k])
           poker_list.extend(['joker', 'JOKER'])
   
           random.shuffle(poker_list)
           poker_list = iter(poker_list)
           return poker_list
   
       # 发牌
       def distribute_poker(self):
           plyer_dict = {'player1': [],
                         'player2': [],
                         'player3': []
                         }
           a = PlayPoker().shuffle_poker()
           for i in plyer_dict:
               for _ in range(17):
                   plyer_dict[i].append(next(a))
   
           # 地主牌
           i = random.randint(1, 3)
           for _ in range(3):
               plyer_dict['player' + f'{i}'].append(next(a))
   
           return plyer_dict
           # 码牌
       def organize_poker(self):
           dict2 = {}
           for i in range(3, 11):
               dict2[str(i)] = i
           list1 = ['J', 'Q', 'K', 'A', '2', 'oker', 'OKER']
           for i in range(11, 18):
               dict2[list1[i - 11]] = i
   
           b = PlayPoker().distribute_poker()
           print(b)
           for j in b.keys():
               print(j)
               b[j].sort(key = lambda a:dict2[a[1:]])
           return b
   
   
   
   d = PlayPoker()
   
   d.shuffle_poker()
   print(d.organize_poker())