python学习第七天

Posted 2020-10-12

  面向对象

一、面向对像概念

　　面向对象概念的关键是对象。与面向过程不同，面向过程是针对问题，将解决问题的方式按步骤一步一步罗列。而面向对象则是，创建对象，然后对象之间交互。针对对象而不针对过程。那么什么是对象?对象是特征（静态属性）与技能（动态属性）的结合体。如游戏中的人物，有皮肤、姓名等属性，也有各种攻击技能等。

　　优点：解决了程序的扩展性。

　　缺点：1、复杂度提高；2、无法准确的预测处理流程与结果

二、类与对象

　　2.1类与对象的示例

class Dog:
    role=‘dog‘
    counter=0
    def __init__(self,name,age,kind,atc,hd):
        self.name=name
        self.age=age
        self.kind=kind
        self.hd=hd
        self.atc=atc
    def dog_func(self,pers):
        pers.hd-=self.atc
        print(‘%s bite %s ; %s hd  lost %s still have %s ‘% (self.name,pers.name,pers.name,self.atc,pers.hd))
# #注意：
#   1.类中可以有任意python代码，这些代码在类定义阶段便会执行
#   2.因而会产生新的名称空间，用来存放类的变量名与函数名，可以通过Dog.__dict__查看
#   3.对于经典类来说我们可以通过该字典操作类名称空间的名字（新式类有限制），但python为我们提供专门的.语法
#   4.点是访问属性的语法，类中定义的名字，都是类的属性

#程序中类的用法
# .:专门用来访问属性，本质操作的就是__dict__
Dog.role #等于经典类的操作Dog.__dict__[‘name‘]
Dog.role=‘Oldboy‘ #等于经典类的操作Dog.__dict__[‘name‘]=‘Oldboy‘
Dog.counter=1 #等于经典类的操作Dog.__dict__[‘age‘]=1
del Dog.counter #等于经典类的操作Dog.__dict__.pop(‘conuter‘)


#程序中的对象
#调用类，或称为实例化，得到对象
# d1=Dog()
# d2=Dog()
# d3=Dog()

#如此，d1、d2、d3都一样了，而这三者除了相似的属性之外还各种不同的属性，这就用到了__init__
#注意：该方法是在对象产生之后才会执行，只用来为对象进行初始化操作，可以有任意代码，但一定不能有返回值


d1=Dog(‘dog1‘,18,‘二哈‘,1000,2000) #先调用类产生空对象s1，然后调用Dog.__init__(‘dog1‘,18,‘二哈‘,1000,2000)
d2=Dog(‘dog2‘,18,‘金毛‘,800,2600)
d3=Dog(‘dog3‘,18,‘柯基‘,600,1800)


#程序中对象的用法
#执行__init__,s1.name=‘牛榴弹‘，很明显也会产生对象的名称空间
d2.__dict__
{‘name‘: ‘dog2‘, ‘age‘: 18, ‘kind‘: ‘金毛‘, ‘hd‘: 2600, ‘atc‘: 800}

d2.name #s2.__dict__[‘name‘]
d2.name=‘dog222‘ #s2.__dict__[‘name‘]=‘王三炮‘
d2.course=‘python‘ #s2.__dict__[‘course‘]=‘python‘
del d2.course #s2.__dict__.pop(‘course‘)

# 在程序中：先定义类，后产生对象

 

　　2.2python 中为类内置的特殊属性

#python为类内置的特殊属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类(在讲继承时会讲)
类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)

　　2.3 对象（obj）查找属性的顺序

　　在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常  

三、继承与派生

　　继承是一种创建新类的方式，python 中创建新类可以继承一个或多个父类，父类成为基类或超类，新建的类称为派生类或子类

　　在开发程序的过程中，如果我们定义了一个类A，然后又想新建立另外一个类B，但是类B的大部分内容与类A的相同时,我们不可能从头开始写一个类B，这就用到了类的继承的概念。通过继承的方式新建类B，让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，实现代码重用。

　　不仅可以重用自己的类，也可以继承别人的，比如标准库，来定制新的数据类型，这样就是大大缩短了软件开发周期，对大型软件开发来说，意义重大.

　　注意：像g1.life_value之类的属性引用，会先从实例中找life_value然后去类中找，然后再去父类中找...直到最顶级的父类。

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
    pass

class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
    pass

　　3.1查看继承

>>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
(<class ‘__main__.ParentClass1‘>,)
>>> SubClass2.__bases__
(<class ‘__main__.ParentClass1‘>, <class ‘__main__.ParentClass2‘>)

　　3.2经典类与新式类

　　　　1）.只有在python2中才分新式类和经典类，python3中统一都是新式类
　　　　2）.在python2中，没有显式的继承object类的类，以及该类的子类，都是经典类
　　　　3）.在python2中，显式地声明继承object的类，以及该类的子类，都是新式类
　　　　3）.在python3中，无论是否继承object，都默认继承object，即python3中所有类均为新式类
　　ps 如果没有指定基类，python的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法（如__str__）的实现。

　　

 

>>> ParentClass1.__bases__
(<class ‘object‘>,)
>>> ParentClass2.__bases__
(<class ‘object‘>,)

 

class Hero:
    def __init__(self,nickname,aggressivity,life_value):
        self.nickname=nickname
        self.aggressivity=aggressivity
        self.life_value=life_value

    def move_forward(self):
        print(‘%s move forward‘ %self.nickname)

    def move_backward(self):
        print(‘%s move backward‘ %self.nickname)

    def move_left(self):
        print(‘%s move forward‘ %self.nickname)

    def move_right(self):
        print(‘%s move forward‘ %self.nickname)

    def attack(self,enemy):
        enemy.life_value-=self.aggressivity
class Garen(Hero):
    pass

class Riven(Hero):
    pass

g1=Garen(‘草丛伦‘,100,300)
r1=Riven(‘锐雯雯‘,57,200)

print(g1.life_value)
r1.attack(g1)
print(g1.life_value)

‘‘‘
运行结果
‘‘‘

 

 

 

 

　　3.3 派生

　　　　当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。

　　　　在子类中，新建的重名的函数属性，在编辑函数内功能的时候，有可能需要重用父类中重名的那个函数功能，应该是用调用普通函数的方式，即：类名.func()，此时就与调用普通函数无异了，因此即便是self参数也要为其传值

 

class Riven(Hero):
    camp=‘Noxus‘
    def __init__(self,nickname,aggressivity,life_value,skin):
        Hero.__init__(self,nickname,aggressivity,life_value) #调用父类功能
        self.skin=skin #新属性
    def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
        Hero.attack(self,enemy) #调用功能
        print(‘from riven‘)
    def fly(self): #在自己这里定义新的
        print(‘%s is flying‘ %self.nickname)

r1=Riven(‘锐雯雯‘,57,200,‘比基尼‘)
r1.fly()
print(r1.skin)

‘‘‘
运行结果
锐雯雯 is flying
比基尼

‘‘‘

 

四、组合　　

　　软件重用的重要方式除了继承之外还有另外一种方式，即：组合

　　组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合

 

>>> class Equip: #武器装备类
...     def fire(self):
...         print(‘release Fire skill‘)
... 
>>> class Riven: #英雄Riven的类,一个英雄需要有装备,因而需要组合Equip类
...     camp=‘Noxus‘
...     def __init__(self,nickname):
...         self.nickname=nickname
...         self.equip=Equip() #用Equip类产生一个装备,赋值给实例的equip属性
... 
>>> r1=Riven(‘锐雯雯‘)
>>> r1.equip.fire() #可以使用组合的类产生的对象所持有的方法
release Fire skill