面向对象初识
类的概念:具有相同属性和技能的一类事物
对象的概念:对一个类的具体描述
使用面向对象的好处:
1.使得代码之间的角色关系更加明确
2.增强了代码的可扩展性
3.规范了对象的属性和性能
面向对象的特点:
结局的不确定性
类的内部各个部分说明和结构:
class 类名(首字母大写):
#引用静态变量
#1.类名.__dict__['静态变量名'] #可以查看,但是不能删改
#2.类名.静态变量名 #直接就可以访问,可以删改
#删除一个静态变量:del 类名.静态变量名
#引用动态变量
#1.类名.方法名 #查看这个方法的内存地址
#2.类名.方法名(实参) #调用了这个方法,必须传一个 实参,这个实参传给了self
#创造一个对象 -示例化
#产生一个实例(对象)的过程
#格式: 对象 = 类名()
下面写一个简单的类,跟上面的概念进行对应:
class Person: role = 'person' def __init__(self,name,sex,hp,ad): self.name = name self.sex = sex self.hp = hp self.ad = ad def attack(self): print('%s发起了一次攻击'%self.name) alex = Person('a_sb','不详',1,5) boss_jin = Person('金老板','女',20,50)
类中实例化的过程:
1.创造一个实例,将会作为一个实际参数
2.自动触发一个__list__方法,并且把实例以参考的形式传递给__init__方法中的self形参
3.执行完__init__方法之后的,会将self自动返回给alex
__init__方法:初始化方法,给一个对象添加一些基础属性的方法,一般情况不是self的赋值
对象:
1.在类的内部self是本的一个对象
2.在类的外部,每个对象都对应着一个名字,这个对象指向一个对象的内存空间
属性的调用:(两种调用方式)
1.对象名.属性名
2.对象名.__dict__['属性名']
方法的调用:(两种方式)
1.类名.方法名(对象名) # 那么方法中的self参数就指向这个对象
2.对象名.方法名() # 这样写 相当于 方法中的self参数直接指向这个对象
面向对象的传参和交互输出
class Person: role = 'person' def __init__(self,name,sex,hp,ad): self.name = name self.sex = sex self.hp = hp self.ad = ad def attack(self,user): user.hp -= self.ad print('%s 发起一次攻击%s,%s掉了%s点血' %(self.name,user.name,user.name,self.ad)) class Dog: def __init__(self,name,kind,hp,ad): self.name = name self.sex = kind self.hp = hp self.ad = ad def bite(self,ani): print('%s 发起一次攻击%s,%s掉了%s点血' %(self.name,ani.name,ani.name,self.ad)) ani.hp -= self.ad tom = Person('塔姆','男',60,45) teddy = Dog('笨笨','teddy',50,10) tom.attack(teddy) teddy.bite(tom) print(tom.hp) print(teddy.hp)
结果:
塔姆 发起一次攻击笨笨,笨笨掉了45点血
笨笨 发起一次攻击塔姆,塔姆掉了10点血
50
5
命名空间和作用域
总结:
对象属性是独有的,静态属性和方法是共享的
对象使用的名字:先找自己的内存空间中的,再找类的内存空间中的
类名.静态变量名:对于静态属性的修改,应该使类名直接修改
例子代码:
展示现在一共有多少钱?
本例中 money为不可变数据类型,self.money相当于在对象内存空间中创建了一个叫money的属性,并不能引用
类内存空间中的静态变量
class Person: money = 0def __init__(self,name): self.name = name def work(self): print(self.name,'工作,赚了1000块钱') self.money += 1000 father = Person('father') mother = Person('mother') mother.work() father.work() print(Person.money)
变成可变数据类型,就能够对money进行索引引用,由于是可变类型,对象空间不能完成创建,只能引用类空间的money
class Person: money = [0] def __init__(self,name): self.name = name def work(self): print(self.name,'工作,赚了1000块钱') self.money[0] += 1000 father = Person('father') mother = Person('mother') mother.work() father.work() print(Person.money)
面向对象的组合用法
软件重用的重要方式除了继承之外还有另外一种方式，即：组合
组合指的是:在一个类中以另外一个类的对象作为数据属性，称为类的组合
下面例:
class Person: def __init__(self,name,sex,hp,ad): self.name = name self.sex = sex self.hp = hp self.ad = ad self.money = 0 def attack(self.dog): dog.hp -= self.ad print(%s攻击了%s，%s掉了%s点血' %(self.name,d.name,d.name,self.ad)) def pay(self): money = int(input('请输入您要充值的金额: ')) self.money += money print("余额是:%s" %self.money) def wear(self,weapon): #weapon 为Weapon类的引用的形参 if self.money >= weapon.price self.weapon = weapon #组合 给人装备了武器 self.money -= weapon.price print('购买成功,您已经顺利装备了 %s' %weapon.name) else: print('余额不足,请充值') def attack_with_weapon(self,dog): if 'weapon' in self._dict_: self.weapon.skill(dog) else: print('请先装备武器') class Dog: def __init__(self,name,kind,hp,ad): self.name = name self.kind = kind self.hp = hp self.ad = ad def bit(self,p): p.hp -= self.ad print('%s咬了%s一口,%s掉了%s点血' % (self.name, p.name, p.name, self.ad)) class Weapon: def __init__(self,name,price,ad,level): self.name = name self.price = price self.level = level self.ad = ad * self.level def skill(self,dog): dog.hp -= self.ad print('%s受到了%s的伤害，%s掉了%s点血'%(dog.name,self.name,dog.name,self.ad))
例2 ,通过对圆柱进行计算,实现类的组合
from math import pi class In_circle: def __init__(self,r): self.r = r def area(self): return pi*self.r ** 2 def perimeter(self): return pi*self.r * 2 class Ring: def __init__(self,big_r,small_r): self.big_r = In_circle(big_r) #一个类中以另外一个类的对象作为属性 self.small_r = In_circle(mall_r)#一个类中以另外一个类的对象作为属性
def n_area(self):
return self.big_r.area - self.small_r.area
def n_perimeter(self):
return self.big_r.perimeter + self.small_r.perimeter
r2 = Ring(8,3)
print(r2.n_area())
print(r2.n_perimeter())