Python 基础第十六---十九天(面向对象初识)

面向对象初识

类的概念:具有相同属性和技能的一类事物

对象的概念:对一个类的具体描述

使用面向对象的好处:

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())