A-18-类和对象

高渐飞

1. <font size="3">#coding=UTF-8
   
2. 
   
3. #知识点总结
   
4. """
   
5. 1. 类：用来描述具有相同属性和方法的对象的集合， 包括属性（变量）和方法（函数）。
   
6. 2. 对象：是类的实例化，例如， 类是一个模具， 则对象为通过这个模具制造出来的实体; 类是抽象的， 而对象是具体的
   
7. 3. 对象的三个特征：
   
8.    a.封装：对外部隐藏对象的工作细节
   
9.    b.继承：子类自动共享父类之间数据和方法的机制
   
10.    c.多态：可以对不同类的对象调用相同的方法， 产生不同的结果
    
11. 
    
12. 4. 在类中定义方法（函数）时， 需传入self参数， 作为类实例化后的唯一标志（地址指针）
    
13.      -- 在内部调用属性时， 要加上self.  例如： self.length
    
14. 5. 公有,私有:
    
15.    a. 类里的属性和方法都是公有的
    
16.    b. 私有变量用__变量名定义,对象名.__私有变量名访问,或对象名._类名__私有变量名
    
17. 6. __init()__方法,被称作魔法方法.在类里定义一个init方法,那么就可以在实例化的时候,对对象进行初始化
    
18. 
    
19. 7.继承,class A(class B):pass,这时候A就继承了B类,A就是B的子类."""
    
20. 
    
21. #1.类的创建（第一个字母要大写）：
    
22. class  Rectangle:
    
23.     length = 5.00
    
24.     width = 4.00            #属性
    
25. 
    
26.     def  setRect(self):               #方法
    
27.         print("请输入矩形的长和宽： ")
    
28.         self.length = float( input('长：') )
    
29.         self.width = float( input('宽： ') )
    
30. 
    
31.     def  getRect(self):               #方法
    
32.         print("这个矩形的长是： %.2f, 宽是： %.2f" % (self.length, self.width) )
    
33. 
    
34.     def  getArea(self):               #方法
    
35.         area = self.length * self.width
    
36.         return area
    
37. 
    
38. #2.对象的创建
    
39. a = Rectangle()   #此时a为一个对象
    
40. 
    
41. 
    
42. #3.综合练习
    
43. """
    
44. 假设游戏场景为范围（x, y）为0<=x<=10，0<=y<=10
    
45. 游戏生成1只乌龟和10条鱼，它们的移动方向均随机
    
46. 乌龟的最大移动能力是2（Ta可以随机选择1还是2移动），鱼儿的最大移动能力是1
    
47. 当移动到场景边缘，自动向反方向移动
    
48. 乌龟初始化体力为100（上限），乌龟每移动一次，体力消耗1
    
49. 当乌龟和鱼坐标重叠，乌龟吃掉鱼，乌龟体力增加20
    
50. 鱼暂不计算体力
    
51. 当乌龟体力值为0（挂掉）或者鱼儿的数量为0游戏结束"""
    
52. import random as r
    
53. 
    
54. legal_x = [0, 10]
    
55. legal_y = [0, 10]
    
56. 
    
57. class Turtle:
    
58.     def __init__(self):
    
59.         # 初始体力
    
60.         self.power = 100
    
61.         # 初始位置随机
    
62.         self.x = r.randint(legal_x[0], legal_x[1])
    
63.         self.y = r.randint(legal_y[0], legal_y[1])
    
64. 
    
65.     def move(self):
    
66.         # 随机计算方向并移动到新的位置（x, y）
    
67.         new_x = self.x + r.choice([1, 2, -1, -2])
    
68.         new_y = self.y + r.choice([1, 2, -1, -2])
    
69.         # 检查移动后是否超出场景x轴边界
    
70.         if new_x < legal_x[0]:
    
71.             self.x = legal_x[0] - (new_x - legal_x[0])
    
72.         elif new_x > legal_x[1]:
    
73.             self.x = legal_x[1] - (new_x - legal_x[1])
    
74.         else:
    
75.             self.x = new_x
    
76.         # 检查移动后是否超出场景y轴边界
    
77.         if new_y < legal_y[0]:
    
78.             self.y = legal_y[0] - (new_y - legal_y[0])
    
79.         elif new_y > legal_y[1]:
    
80.             self.y = legal_y[1] - (new_y - legal_y[1])
    
81.         else:
    
82.             self.y = new_y
    
83.         # 体力消耗
    
84.         self.power -= 1
    
85.         # 返回移动后的新位置
    
86.         print('乌龟坐标是:%d,%d' % (turtle.x,turtle.y))
    
87.         return (self.x, self.y)
    
88. 
    
89.     def eat(self):
    
90.         self.power += 20
    
91.         if self.power > 100:
    
92.             self.power = 100
    
93. 
    
94. class Fish:
    
95.     def __init__(self):
    
96.         self.x = r.randint(legal_x[0], legal_x[1])
    
97.         self.y = r.randint(legal_y[0], legal_y[1])
    
98. 
    
99.     def move(self):
    
100.         # 随机计算方向并移动到新的位置（x, y）
     
101.         new_x = self.x + r.choice([1, -1])
     
102.         new_y = self.y + r.choice([1, -1])
     
103.         # 检查移动后是否超出场景x轴边界
     
104.         if new_x < legal_x[0]:
     
105.             self.x = legal_x[0] - (new_x - legal_x[0])
     
106.         elif new_x > legal_x[1]:
     
107.             self.x = legal_x[1] - (new_x - legal_x[1])
     
108.         else:
     
109.             self.x = new_x
     
110.         # 检查移动后是否超出场景y轴边界
     
111.         if new_y < legal_y[0]:
     
112.             self.y = legal_y[0] - (new_y - legal_y[0])
     
113.         elif new_y > legal_y[1]:
     
114.             self.y = legal_y[1] - (new_y - legal_y[1])
     
115.         else:
     
116.             self.y = new_y
     
117.         # 返回移动后的新位置
     
118.         return (self.x, self.y)
     
119. 
     
120. turtle = Turtle()   #创建实例化对象,1只乌龟
     
121. fish = []
     
122. for i in range(10):   #10条鱼
     
123.     new_fish = Fish()
     
124.     fish.append(new_fish)
     
125. 
     
126. while True:
     
127.     if not len(fish):
     
128.         print("鱼儿都吃完了，游戏结束！")
     
129.         break
     
130.     if not turtle.power:
     
131.         print("乌龟体力耗尽，挂掉了！")
     
132.         break
     
133. 
     
134.     pos = turtle.move()
     
135.     # 在迭代器中删除列表元素是非常危险的，经常会出现意想不到的问题，因为迭代器是直接引用列表的数据进行引用
     
136.     # 这里我们把列表拷贝给迭代器，然后对原列表进行删除操作就不会有问题了^_^
     
137.     n=1
     
138.     for each_fish in fish[:]:
     
139.         if each_fish.move() == pos:
     
140.             # 鱼儿被吃掉了
     
141.             turtle.eat()
     
142.             fish.remove(each_fish)
     
143.             print("鱼%d被吃掉了..."%n,"\n")
     
144.         print('鱼%d的坐标是:%d,%d' % (n,each_fish.x,each_fish.y))
     
145.         n=n+1
     
146.     print("\n")
     
147. 
     
148. 
     
149. #4.
     
150. class Ticket():
     
151.     def __init__(self, weekend=False, child=False):
     
152.         self.exp = 100
     
153.         if weekend:
     
154.             self.inc = 1.2
     
155.         else:
     
156.              self.inc = 1
     
157.         if child:
     
158.              self.discount = 0.5
     
159.         else:
     
160.              self.discount = 1
     
161.     def calcPrice(self, num):
     
162.         return self.exp * self.inc * self.discount * num
     
163. 
     
164. adult = Ticket()  #实例化对象
     
165. child = Ticket(child=True)
     
166. print("2个成人 + 1个小孩平日票价为：%.2f" % (adult.calcPrice(2) + child.calcPrice(1)))</font>

复制代码