python 11 类与对象
2021-07-09 05:05
标签：冲突 大战 代码 hung 外观 classname 解决 一个人 同名 给大家介绍对象hhhh 封装 举个例子，把乱七八糟的数据仍到列表，数据层面的封装 把常用的代码打包成一个函数，封装 外观特征（静态） 能做什么（动态） 对象=属性（静态） + 方法（动态） 1.方法多用函数 2.类是图纸，对象是根据图纸制作的东西 3.类在整体结构中和函数很像，所以为了区分，类的开头字母大写，函数小写 class Turtle: #封装类 属性 方法 def climb() #方法中的一个例子 tt=Turtle() #创建类，与函数类似 tt.climd() #调用类中的函数 oo 面向对象 封装，信息隐蔽技术 list1.sort(),排序列表，并不知道过程 继承，子类自动共享父类之间数据和方法的机制 class Mylist(list): #继承list的方法和属性 pass #什么都不用做 list2 = Mylist() list2.append(0) list2 [0] 多态：对不同对象调用同一方法，结果因对象而变 class A: def fun(self): print(‘a‘) class B: def fun(self): print(‘b‘) a=A() b=B() a.fun #a b.fun #b 面向对象编程 self要写进第一个参数对象 self名称不是必须的，在python中self不是关键词，你可以定义成a或b或其它名字都可以,但是约定成俗（为了和其他编程语言统一，减少理解难度），不要搞另类，大家会不明白的。 self指的是类实例对象本身(地址) (注意：不是类本身)。 class中函数调用 在给出一个实例以后，我们调用类中的具体方法（即函数）时，默认传入了self参数（即实例地址） 这样对象不唯一，也会各自运行各自的结果 class Ba: def setname(self,name): #self为实例地址 self.name = name # 代入 实例.name = name def kick(self): print(‘%s‘ % self.name) #打印 实例.name a = Ba() a.setname(‘a‘) #self地址为a（实例地址） b = Ba() b.setname(‘b‘) c = Ba() c.setname(‘0‘) a.kick() #a c.kick() #0 构造函数 构造方法类似于类似init()这种初始化方法，来初始化新创建对象的状态，在一个对象类创建以后会立即调用 __init__(self,param1,param2.....) class Ba: def __init__(self,name) self.name = name def kick(self): print(‘%s‘ % self.name) b = Ba(‘b‘) b.kick() #b class Per: name= ‘a‘ >>p = Per() >>p.name #a class Per: __name= ‘a‘ def g(self): return self.__name >>p = Per() >>p.name #报错，__为私有 >>p.g #返回a >>p._Per__name #返回a _类名__变量名 继承 class Deribedclassname(baseclassname): #()中为父类，名字 class Pae: def hello(self): print(‘调用父类‘) class Chi(Pae): pass >>p = Pae() >>p.hello 调用父类 >>c = hello() >>c.hello() 调用父类 如果子类中定义与父类同名的方法或属性，则会自动覆盖父类对应的方法或属性 对父类不受影响 class Chi(Per): def hello(self): print("调用子类“） >>c = Chi() >>c.hello() 调用子类 >>p.hello() 调用父类 1.调用未绑定的父类方法 def __init__(Fish): Fish.__init__(self) #在子类执行的前面调用父类，self是子类的，Shark self.hugry = True 2.使用 super函数 def __init__(Fish): #这里的父类是Fish，super调用的就是父类的__init__() super().__init__() #有很多父类也不用一个个写，自动一层层找出__init__()的方法, self.hugry = True 多重继承，多写几个父类，尽量避免使用，可能出现不可预见的BUG（致命） 组合:在一个类中以另外一个类的对象作为数据属性，称为类的组合 Mix -in (转载） 用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系,比如教授有生日，教授教python课程 人狗大战（转载） 转载 类写完就是类对象，实例对象 class C: def x: count = 0 >>a=C() >>b=C() >>c.count+=10 #创建实例对象的属性 >>c.x() #报错，属性如果与方法名相同，属性覆盖方法 >>a.count 0 >>c.count 10 >>C.count #类对象 0 >>C.count += 100 >>a.count #增加100 100 >>c.count #实例对象的属性，不变 10 避免这种事发生，不要试图在一个类里边定义出所有能想到的特性和方法，应该理由继承和组合机制进行扩展。 用不同的词性命名，如属性名用名词，方法名用动词 关于绑定 class C: def set(self,x,y) self.x = x self.y = y def printXY(self): print(self.x,self.y) >>d = C() >>d.__dict__ {} >>C.__dice__ {.............数据，方法.} >>d.set(1,2) #静态的绑定类对象的方法里 >>d.__dice__ {‘y‘:2,‘x‘:1} >>def C >>e =C() #报错 >>d.printXY() #1 2 尽量用实例属性，self 不要用类属性 python 11 类与对象 标签：冲突 大战 代码 hung 外观 classname 解决 一个人 同名 原文地址：https://www.cnblogs.com/17s4029/p/9567423.htmlimport random as r
class Fish:
def __init__(self):
self.x = r.randint(0,10)
self.y = r.randint(0,10)
def move(self):
self.x -= 1
print("我的位置:",self.x,self.y)
class Gold(Fish):
pass
class Carp(Fish):
pass
class Sa(Fish):
pass
class Shark(Fish):
def __init__(self): #与父类冲突，覆盖父类，需要解决方案
self.hungry = True
def eat(self):
if self.hungry:
print("天天有吃的")
self.hungry = False
else:
print("太撑了")
实例.调入类.类中数据
class Turtle:
def __init__(self,x):
self.num = x
class Fishl:
def __init__(self,x):
self.num = x
class Pool:
def __init(self,x,y):
self.turtle = Turtle(x) #把T中数据调入self.turtle,可使用self.turtle.num
self.fish = Fish(y) #实例.调入类.类中数据
def print_num(self):
print("乌龟 %d,小鱼%d" % (self.turtle.num,self.fish.num))
class Weapon:
def prick(self, obj): # 这是该装备的主动技能,扎死对方
obj.life_value -= 500 # 假设攻击力是500
class Person: # 定义一个人类
role = ‘person‘ # 人的角色属性都是人
def __init__(self, name):
self.name = name # 每一个角色都有自己的昵称;
self.weapon = Weapon() # 给角色绑定一个武器;
egg = Person(‘egon‘)
egg.weapon.prick()
#egg组合了一个武器的对象，可以直接egg.weapon来使用组合类中的所有方法
class Person: # 定义一个人类
role = ‘person‘ # 人的角色属性都是人
def __init__(self, name, aggressivity, life_value, money):
self.name = name # 每一个角色都有自己的昵称;
self.aggressivity = aggressivity # 每一个角色都有自己的攻击力;
self.life_value = life_value # 每一个角色都有自己的生命值;
self.money = money
def attack(self,dog):
# 人可以攻击狗，这里的狗也是一个对象。
# 人攻击狗，那么狗的生命值就会根据人的攻击力而下降
dog.life_value -= self.aggressivity
class Dog: # 定义一个狗类
role = ‘dog‘ # 狗的角色属性都是狗
def __init__(self, name, breed, aggressivity, life_value):
self.name = name # 每一只狗都有自己的昵称;
self.breed = breed # 每一只狗都有自己的品种;
self.aggressivity = aggressivity # 每一只狗都有自己的攻击力;
self.life_value = life_value # 每一只狗都有自己的生命值;
def bite(self,people):
# 狗可以咬人，这里的狗也是一个对象。
# 狗咬人，那么人的生命值就会根据狗的攻击力而下降
people.life_value -= self.aggressivity
class Weapon: #装备
def __init__(self,name, price, aggrev, life_value):
self.name = name
self.price = price
self.aggrev = aggrev
self.life_value = life_value
def update(self, obj): #obj就是要带这个装备的人
obj.money -= self.price # 用这个武器的人花钱买所以对应的钱要减少
obj.aggressivity += self.aggrev # 带上这个装备可以让人增加攻击
obj.life_value += self.life_value # 带上这个装备可以让人增加生命值
def prick(self, obj): # 这是该装备的主动技能,扎死对方
obj.life_value -= 500 # 假设攻击力是500
lance = Weapon(‘长矛‘,200,6,100)
egg = Person(‘egon‘,10,1000,600) #创造了一个实实在在的人egg
ha2 = Dog(‘二愣子‘,‘哈士奇‘,10,1000) #创造了一只实实在在的狗ha2
#egg独自力战"二愣子"深感吃力，决定穷毕生积蓄买一把武器
if egg.money > lance.price: #如果egg的钱比装备的价格多，可以买一把长矛
lance.update(egg) #egg花钱买了一个长矛防身，且自身属性得到了提高
egg.weapon = lance #egg装备上了长矛
print(egg.money,egg.life_value,egg.aggressivity)
print(ha2.life_value)
egg.attack(ha2) #egg打了ha2一下
print(ha2.life_value)
egg.weapon.prick(ha2) #发动武器技能
print(ha2.life_value) #ha2不敌狡猾的人类用武器取胜，血槽空了一半
class BirthDate:
def __init__(self,year,month,day):
self.year=year
self.month=month
self.day=day
class Couse:
def __init__(self,name,price,period):
self.name=name
self.price=price
self.period=period
class Teacher:
def __init__(self,name,gender,birth,course):
self.name=name
self.gender=gender
self.birth=birth
self.course=course
def teach(self):
print(‘teaching‘)
p1=Teacher(‘egon‘,‘male‘,
BirthDate(‘1995‘,‘1‘,‘27‘), #把B中数据调入T中，实例p1
Couse(‘python‘,‘28000‘,‘4 months‘)
)
print(p1.birth.year,p1.birth.month,p1.birth.day)
print(p1.course.name,p1.course.price,p1.course.period)
‘‘‘
运行结果:
1995 1 27
python 28000 4 months
‘‘‘