1 # class Person:
2 # def __init__(self,name,blood,aggr,sex):
3 # self.name = name
4 # self.blood = blood
5 # self.aggr = aggr
6 # self.sex = sex
7 # def attack(self,dog):
8 # # 人打狗，狗掉血
9 # jin.blood -= self.aggr
10 # if jin.blood <= 0:
11 # print("%s打了%s,%s被打死了"%(self.name,dog.name,dog.name))
12 #
13 # class Dog:
14 # def __init__(self,name,blood,aggr,kind):
15 # self.name = name
16 # self.blood = blood
17 # self.aggr = aggr
18 # self.kind = kind
19 # def bite(self,person):
20 # # 狗咬人，人掉血
21 # person.blood -= self.aggr
22 # if person.blood <= 0:
23 # print("%s咬了%s,%s被咬死了"%(self.name,person.name,person.name))
24 #
25 # jin = Dog("laoban",100,200,"buxiang")
26 # alex = Person("alex",200,10,"不详")
27 # # print(jin.name)
28 # jin.bite(alex)
29 # print(alex.blood)
30 # alex.attack(jin)
31 # print(jin.blood)
32
33
34 # 练习
35 """
36 小明，10岁，男，上山去砍柴
37 小明，10岁，男，开车去东北
38 小明，10岁，男，最爱大保健
39 老李，90岁，男，上山去砍柴
40 老李，90岁，男，开车去东北
41 老李，90岁，男，最爱大保健
42 """
43
44 # class Person:
45 # def __init__(self,name,age,sex):
46 # self.name = name
47 # self.age = age
48 # self.sex = sex
49 # def shangshan(self):
50 # print("%s, %s岁, %s, 上山去砍柴"%(self.name,self.age,self.sex))
51 #
52 # def drive(self):
53 # print("%s, %s岁, %s, 开车去东北"%(self.name,self.age,self.sex))
54 #
55 # def hobby(self):
56 # print("%s, %s岁, %s, 最爱大保健"%(self.name,self.age,self.sex))
57 #
58 # min = Person("小明","10","男")
59 # min.shangshan()
60 # min.drive()
61 # min.hobby()
62 # li = Person("老李","90","男")
63 # li.shangshan()
64 # li.drive()
65 # li.hobby()
66
67 # circle 属性 半径 ， 两个方法：求周长和面积
68 # from math import pi
69 # class Circle:
70 # def __init__(self,r):
71 # self.r = r
72 # def area(self):
73 # return pi*(self.r**2)
74 # def circleMeter(self):
75 # return 2*pi*self.r
76 # c1 = Circle(5)
77 # print(c1.area())
78 # print(c1.circleMeter())
79
80 """
81 class 里面
82 函数： 就是方法 动态属性 # 类中可以定义方法，方法都有一个必须传的参数self
83 变量： 就是类属性 静态属性 # 类中可以定义静态属性
84
85 __init__方法 初始化方法
86 python帮我们创建了一个对象self
87 每当我们调用类的时候就会自动触发这个方法。默认传self
88 在init方法里面可以对self进行赋值
89
90 self是什么 self拥有属性都属于对象
91 在类的内部，self就是一个对象
92
93 实例化
94 对象 = 类(参数是init方法的) 这就是实例化
95
96 实例、对象
97 实例就是对象，对象就是实例
98 完全没有区别
99
100 对象查看属性
101 对象.属性名
102
103 对象调用方法
104 对象.方法名(参数)
105 """
106
107 # 类里 可以定义两种属性
108 # 静态属性
109 # 动态属性
110
111
112 # class Course:
113 # language = "Chinese"
114 # def __init__(self,teacher,course_name,period,price):
115 # self.teacher = teacher
116 # self.name = course_name
117 # self.period = period
118 # self.price = price
119 # def func(self,r):
120 # print("调用了")
121 # Course.language
122 # Course.language = "English" # 只能用这种方法去修改类里面的静态属性
123 # print(Course.language)
124 # print(Course.__dict__)
125 # Course.__dict__["language"] = "Russian" # 这行代码报错 不能通过__dict__来修改静态属性
126 # python1 = Course("egon","python","six_months",20000)
127 # print(python1.language)
128 # python1.language = "English" # 对象改变不了类中的属性
129 # print(python1.language)
130 # print(Course.language)
131 # 类中的静态变量 可以被对象和类调用
132
133
134 # 创建一个类，每实例化一个对象就记录下来
135 # 最终所有的对象共享这个数据
136 # class Foo:
137 # count = 0
138 # def __init__(self):
139 # Foo.count += 1
140 #
141 # f1 = Foo()
142 # f2 = Foo()
143 # print(f1.count)
144 # print(f2.count)
145 # f3 = Foo()
146 # print(f3.count)
147
148 # class Foo:
149 # def func(self):
150 # print("func")
151 #
152 # f1 = Foo()
153 # print(Foo.func)
154 # print(f1.func)
155
156
157
158 # 组合
159 class Dog:
160 def __init__(self,name,aggr,blood,kind):
161 self.name = name
162 self.aggr = aggr
163 self.blood = blood
164 self.kind = kind
165
166 def bite(self,person):
167 person.blood -= self.aggr
168
169 class Person:
170 def __init__(self,name,aggr,blood,sex):
171 self.name = name
172 self.aggr = aggr
173 self.blood = blood
174 self.kind = sex
175 self.money = 0
176
177 def attack(self,dog):
178 dog.blood -= self.aggr
179
180 def get_weapon(self,weapon):
181 if self.money >= weapon.price:
182 self.money -= weapon.price
183 self.weapon = weapon
184 self.aggr += weapon.aggr
185 else:
186 print("余额不足，请先充值")
187
188 class Weapon:
189 def __init__(self,name,aggr,njd,price): # aggr 攻击力 njd 耐久度
190 self.name = name
191 self.aggr = aggr
192 self.njd = njd
193 self.price = price
194 def hand18(self,dog):
195 if self.njd > 0:
196 dog.blood -= self.aggr * 2
197 self.njd -= 1
198
199
200 alex = Person("alex",1,100,"不详")
201 jin = Dog("老板",2,200,"不详")
202 w = Weapon("打狗棒",100,3,998)
203 # 怎么给alex装上打狗棒
204 alex.money += 1000
205 alex.get_weapon(w)
206 print(alex.weapon)
207 print(alex.aggr)
208
209 alex.attack(jin)
210 print(jin.blood)
211
212 alex.weapon.hand18(jin)
213 print(jin.blood)
214
215 # 装备
216 # 伤害
217 # 血量
218
219 # 组合 ：一个对象的属性值是另外一个类的对象
# 创建一个老师类
# 老师有生日
# 生日也可以是一个类
# 用组合
# class Birthday:
# def __init__(self,year,month,day):
# self.year = year
# self.month = month
# self.day = day
#
# class Course:
# language = ["Chinese"]
# def __init__(self,teacher,course_name,period,price):
# self.teacher = teacher
# self.name = course_name
# self.period = period
# self.price = price
#
# class Teacher:
# def __init__(self,name,age,sex,birthday):
# self.name = name
# self.age = age
# self.sex = sex
# self.birthday = birthday
# self.course = Course(self,"python","six_month",20002)
#
# b = Birthday(2018,1,16)
# egg = Teacher("egon",0,"女",b)
# print(egg.name)
# print(egg.birthday.year)
# print(egg.birthday.month)
# print(egg.birthday.day)
# print(egg.course.price)
# 定义一个老师类 在定义一个生日类
# b是生日类的一个实例化对象 然后把 b 当做参
# 数，传给 egg 这个老师类的实例对象，这样老
# 师里的对象就可以调用生日类里的属性了 这就是组合
# 面向对象的三大特性
# 继承
# 多态
# 封装
"""
什么是继承：
继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，
父类又可称为基类或者超类，新建的类称为派生类或子类
"""
# class Animal:
# def __init__(self,name,aggr,blood):
# self.name = name
# self.aggr = aggr
# self.blood = blood
#
# class Dog(Animal):
# def bite(self,person):
# person.blood -= self.aggr
#
# class Person(Animal):
# def attack(self,dog):
# dog.blood -= self.aggr
#
# jin = Dog("金老板",200,500)
# alex = Person("alex",200,700)
# alex.attack(jin)
# print(jin.blood)
# jin.bite(alex)
# print(alex.blood)
# class Animal:
# def __init__(self):
# print("执行Animal.__init__")
# self.func()
# def eat(self):
# print("%s eating"%self.name)
#
# def drink(self):
# print("%s drinking"%self.name)
# def func(self):
# print("Animal.func")
#
# class Dog(Animal):
# def guard(self):
# print("guarding")
# def func(self):
# print("Dog.func")
# dog = Dog()
# 执行后的结果
# 执行Animal.__init__
# Dog.func
# 注意 Dog()里有func()这个方法，所有就用Dog自己里的 不用父类里面的
# 子类里没有__init__方法 就用父类里面的
# class Animal:
# def __init__(self,name,aggr,blood):
# self.name = name
# self.aggr = aggr
# self.blood = blood
#
# def eat(self):
# print("吃药回血")
# self.blood += 100
#
# class Dog(Animal):
# def __init__(self,name,aggr,blood,kind):
# Animal.__init__(self,name,aggr,blood)
# self.kind = kind # 派生类
#
# def bite(self,person): # 派生方法（父类没有，子类有的）
# person.blood -= self.aggr
#
# class Person(Animal):
# def __init__(self,name,aggr,blood,sex):
# Animal.__init__(self,name,aggr,blood)
# self.sex = sex # 派生属性
# self.money = 0 # 派生属性 （父类里没有，子类里有的，就叫派生）
#
# def attack(self,dog):
# dog.blood -= self.aggr
#
# def get_weapon(self,weapon):
# if self.money >= weapon.price:
# self.money -= weapon.price
# self.weapon = weapon
# self.aggr += weapon.aggr
# else:
# print("余额不足，请先充值")
#
# jin = Dog("金老板",100,500,"不详")
# print(jin.name)
# jin.eat()
# print(jin.blood)
# 只要是子类的对象调用，子类中有的名字 一定用子类的，子类中没有才找父类的，如果父类中没有就报错
# 如果父类 子类都有 那么还是用子类的
# 如果就是想用父类的，就在子类中在调用父类的属性或方法
# class Animal:
# def __init__(self,name,aggr,blood):
# self.name = name
# self.aggr = aggr
# self.blood = blood
#
# def eat(self):
# print("吃药回血")
# self.blood += 100
#
#
# class Dog(Animal):
# def __init__(self,name,aggr,blood,kind):
# super().__init__(name,aggr,blood)
# self.kind = kind # 派生属性
# jin = Dog("金老板",200,500,"不详")
# print(jin.name)
# 父类中没有的属性，在子类中出现 叫做派生属性
# 父类中没有的方法 在子类中出现 叫做派生方法
# 如果是子类的对象调用，子类中的名字 一定用子类的，子类中没有才找父类中的，如果父类也没有 就报错
# 如果父类 子类都有 就用子类的
# 如果还是想用父类的，就单独在调用父类的：
# 第一种 父类名.方法名 不过需要自己传参数
# 第二种 super().方法名 不需要自己传self
# 注：本文是根据老男孩课程内容整理而成的，本文仅供个人笔记使用，如果有侵犯，请联系我，我立即撤销。