python 课堂13 面向对象1

面向对象1

面向过程&面向对象

面向过程：过程，就是问题解决的步骤，大问题拆解为小问题。小问题继续拆解为可以解决的问题。

优点：即复杂问题流程化，简单化。
缺点：每个单元都牵涉其他单元，牵一发而动全身，修改和维护的难度大。
使用场景：简单的脚本，和一次性的任务。

面向对象：一切皆对象的思想，注重对现实世界的模拟，而不是过程的模拟。面向对象的程序设计主要用于解决程序扩展问题。

优点：可扩展性强
缺点：编程复杂度高，容易出现过度设计，在扩展要求低的地方使用面向对象，徒增难度。
使用场景：复杂的，需要扩展的任务。

类&对象

类：是对一系列相似的实物的描述，人类，并不是指具体的人，而是描述所有人，其中包含所有人都会有的特征和技能。

对象：是类中具体的实例。某人，不是指全体的人，而是指全体人中的具体的一个人。包含所有人共有的特征和技能，还有自己的独特性。

现实世界中，是先有具体的对象，然后将对象分类。

计算机中，必须先创建类，然后由类派生具体的对象。

类的定义：

创建类：

class OldBoyStudent(object):
    '''
    .....文档内容，doc.....
    解释类的作用。
    '''
    school = 'old boy'

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def learn(self):
        print('%s is learning' % self.name)

    def eat(self):
        print('%s is eating' % self.name)

    def sleep(self):
        print('%s is sleeping' % self.name)

类的使用： 可以直接使用类名调用类中的属性和方法

print(OldBoyStudent.school)  # 查看属性
print(OldBoyStudent.__dict__['school'])  # 可以通过属性字典查看属性

OldBoyStudent.school = 'old boy school'  # 修改属性
print(OldBoyStudent.school)

# OldBoyStudent.__dict__['school'] = 'oldboy school'  # 不可以通过字典修改和增加类属性
# print(OldBoyStudent.school)

OldBoyStudent.teacher = 'alex'  # 增加属性
print(OldBoyStudent.teacher)

# OldBoyStudent['IT_teacher'] = 'wusir'  # 不可以通过字典修改和增加类属性
# print(OldBoyStudent.IT_teacher)

del OldBoyStudent.teacher   # 删除属性
del OldBoyStudent.IT_teacher

print(OldBoyStudent.__dict__)  # 查看类属性字典

类字典内容：

模块

{'module': 'main',

类中的文档信息

'doc': '\n .....文档内容，doc.....\n 解释类的作用。\n ',

类 属性

'school': 'old boy school',

类中包含的 方法

'init': <function OldBoyStudent.__init__ at 0x000001E289EE2510>,
'learn': <function OldBoyStudent.learn at 0x000001E289EE2598>,
'eat': <function OldBoyStudent.eat at 0x000001E289EE2620>,
'sleep': <function OldBoyStudent.sleep at 0x000001E289EE26A8>,

类内置属性，字典 可以调用，包含所有属性和方法

'dict': <attribute 'dict' of 'OldBoyStudent' objects>,

弱引用？？？

'weakref': <attribute 'weakref' of 'OldBoyStudent' objects>}

对象的创建和使用：

创建：和函数调用的方式一样，变量就相当于该类的对象。

其中传入的参数，就是对象独特的属性

具体流程：

1、先产生空对象 qianlei ,
2、然后调用 OldBoyStudent.__init__(qanlei,'qianlei','23','male')
init(self,name,age,sex) 中self处传入的是实例qianlei本身
所以对象 qianlei.name ===> self.name

qianlei = OldBoyStudent('qianlei', '23', 'male')
print(qianlei.school)  # 对象可以调用类的属性
==> old boy
print(qianlei.name)  # 对象还可以调用自己的属性
==> qianlei
qianlei.sleep()  # 对象还可以调用类中定义的对象方法
==> qianlei is sleeping

同一个类，可以创建多个对象，且互相不影响。

alex = OldBoyStudent('alex', '33', 'male')
wusir = OldBoyStudent('wusir', '32', 'female')
alex.eat()
wusir.learn()
==>alex is eating
==>wusir is learning

对象字典

qianlei = OldBoyStudent('qianlei', '23', 'male')
print(qianlei.__dict__)
==> {'name': 'qianlei', 'age': '23', 'sex': 'male'}
qianlei.__dict__['job'] = 'teacher'  # 对象可以直接在字典中对属性增删改查。
print(qianlei.job)
print(qianlei.__dict__)
{'name': 'qianlei', 'age': '23', 'sex': 'male', 'job': 'teacher'}
# OldBoyStudent.__dict__['jobs--'] = 'teacher'  # 类不可以在字典中修改和添加属性。
TypeError: 'mappingproxy' object does not support item assignment
print(OldBoyStudent.job)

类属性和实例属性

属性分为 数据属性和函数属性

类数据属性是所有实例共享的属性：

class OldBoyStudent(object):
    '''
    .....文档内容，doc.....
    解释类的作用。
    '''
    school = 'old boy'  # 类数据属性

    def __init__(self, name, age, sex):
        self.name = name  # 实例数据属性
        self.age = age
        self.sex = sex

    def learn(self):  # 类函数属性
        print('%s is learning' % self.name)

    def eat(self):
        print('%s is eating' % self.name)

    def sleep(self):
        print('%s is sleeping' % self.name)

s1 = OldBoyStudent('s1', 22, 'male')
s2 = OldBoyStudent('s2', 22, 'male')
s3 = OldBoyStudent('s3', 22, 'male')
类数据属性，所有对象共享，内存id相同
print(s1.school,id(s1.school))
print(s2.school,id(s2.school))
print(s2.school,id(s2.school))
old boy 2101643339176
old boy 2101643339176
old boy 2101643339176

函数属性，类中的函数属性是属于类的，可以被类直接调用。但是self参数需要传入实例。

OldBoyStudent.learn(s1)
s1 is learning
对象调用函数属性，本质上就是类调用该函数，并传入对应实例。
s1.learn()  # ====》 OldBoyStudent.learn(s1)
s1 is learning
对象调用函数属性时，self，传入了实例本身，所以函数也被实例绑定。
print(s1.learn)
print(s2.learn)
print(s3.learn)
<bound method OldBoyStudent.learn of 0x0000020CF28038D0>>
<bound method OldBoyStudent.learn of 0x0000020CF2803908>>
<bound method OldBoyStudent.learn of 0x0000020CF2803940>>

数据类型，类型本身就是类。

list 列表类，
创建list 实例 l
l = list([1,2,3])
l.append('this is list')  # 使用实例调用类的函数属性
list.append(l,'qianlei')    # 使用类调用类的函数属性，需要传入实例。
print(l)

练习：创建游戏英雄类，实例化两个英雄，互殴，血掉完，判定死亡。

class Hero(object):
    def __init__(self, name, atk, health):
        self.name = name
        self.atk = atk
        self.health = health

    def attack(self,obj):
        print('%s 打了%s 一拳,让他掉了%s 血,他还剩%s 血' \
              % (self.name, obj.name,self.atk,obj.health))

    def damage(self,obj):

        if self.health > 0:
            self.health -= obj.atk
        if self.health < 0:
            self.health = 0
            print('%s 被打了一拳,损失了%s的血,还剩 %s 血' \
                % (self.name, obj.atk, self.health))
            print('%s 被打死了' % self.name)
            print('%s 获胜了' % obj.name)
            exit()


superman = Hero('超人', 15, 100)
batman = Hero('蝙蝠侠', 10, 100)
while True:
    superman.attack(batman)
    batman.damage(superman)
    batman.attack(superman)
    superman.damage(batman)