python day7 面向对象基础(上)

面向对象介绍

面向过程：根据业务逻辑从上到下写代码
函数式：将某功能代码封装到函数中，日后无需重复编写，仅调用函数即可
面向对象：将数据与函数绑定到一起，进行封装，减少重复代码的重写过程
面向对象编程：oop:object oriented programming

面向过程

while True:
    if cpu利用率 > 98%:
        连接邮件服务器
        发送邮件
        关闭连接
    if 硬板利用率 > 90%:
        连接邮箱服务器
        发送邮件
        关闭连接
    if 内存占用 > 90%:
        连接邮箱服务器
        发送邮件
        关闭连接

函数式

def 发送邮件(内容)
    连接邮箱服务器
        发送邮件
        关闭连接
while True:
    if cpu利用率 > 90%:
        发送邮件('cpu报警')
    if 硬盘利用率 > 90 %:
        发送邮件('硬盘报警')
    if 内存利用率 > 90 %:
        发送邮件('内存报警')

面向过程与面向对象对比

   第一种洗车方式
        自己某宝买洗车工具
        买抹布，水泵，清洁剂
        等了一周东西到了，开始洗车
        洗到一半，水泵坏了，没洗干净
    第二种洗车
        找一家靠谱洗车店
        给钱洗车

面向过程在思考问题，要想怎么按照步骤去实现问题，每一步都要思考，将问题拆解成若干，一步一步实现（怎么做）
面向对象关注点在于设计思维（谁来做）

类和对象

类：具有一组相同或者相似特征（属性）和行为（方法）的一系列对象组合
类相当于制造汽车的图纸
对象是实实在在的，类的具象化
对象相当于对着图纸制造的汽车

类的构成
类的名称：类名（人名）
类的属性：一组数据（身高，体重）
类的方法：允许对进行操作的方法（吃，跑）

定义类和创建对象

类的结构
class 类名:
属性
方法

创建一个人的类

class Person:
   name = '小明'
   age = '18'
   def eat(self):
       print('吃大碗饭')
       pass
   def run(self):
       print('快跑')
       pass

对象的结构
对象名 = 类名（）

xm = Person()
xm.eat()    # 调用函数eat
xm.run()    #调用函数run
print('{}的年龄是：{}'.format(xm.name,xm.age))

实例方法和属性

在类的内部，使用def可以定义一个实例方法，与一般函数定义不同，类方法必须包含参数self，且为第一个参数
名字标识可以是其他，但是这个位置必须被占用
实例方法是归于类的实例所有
属性：在类的内部定义的变量
实例属性：定义在实例类中的属性叫做实例属性

init

init :python自带的函数
是一个初始化方法，用来定义实例属性，和初始化数据，创建对象时自动使用，不需要手动调用
利用传参的机制可以动态使用对象

未使用init方法，需要一条一条添加

class People:
    def eat(self):
        print('吃大碗饭')
    pass
xm = People()
xm.name = '小明'  # 添加属性姓名
xm.age = '18'   #添加属性年龄
xm.eat()
print('{}的年龄是{}'.format(xm.name,xm.age))

xw = People()   #新的对象，独立于xm
xm.name = '小明'  # 添加属性姓名
xm.age = '18'   #添加属性年龄
xm.eat()
print('{}的年龄是{}'.format(xw.name,xw.age))

问：当有多个对象还要一条一条添加属性吗？
答：用init方法

init(self)方法，初始化方法，实例化对象的时候自动调用，完成一些初始化设置，一次定义多次使用

class People:
    def __init__(self):
        self.name = '小明'
        self.age = '18'
        pass
    def eat(self):
        print('吃大碗饭')
    pass
xm = People()   # 创建新对象的时候，就自动执行
print(xm.name)
xm.name = '王小明' # 修改属性
print(xm.name)

__init__传参

class Preson:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def eat(self,food):
        print(self.name+'喜欢吃'+food)
        pass
zp = Preson('张鹏', '18')
zp.eat('香蕉')
print(zp.name,zp.age)
lh = Preson('李辉', '28')
lh.eat('橘子')
print(lh.name, lh.age)

理解self

self和对象指向同一个内存地址，可以认为self就是对象的引用

class Person:
    def eat(self,name,food):
        print('self = %s', id(self))
        print('%s 喜欢吃 %s' %(name,food))
    pass

xw = Person()
print('xw = %s',id(xw))
xw.eat('小王','榴莲')

小结
self只有在类中定义实例方法时才有意义，在调用的时候不必传入相应参数而是由解释器自动指向
self的名字可以更改，但不建议
self指的是类实例对象本身，不是其他

魔术方法

python中有一些内置好的特定方法，方法名时“xxx”,在进行特定的操作时会自动被调用，称之为魔术方法
下面介绍几种常见的魔法方法
init:初始化一个类，在创建实例对象为其赋值时使用
str:再将对象转换为字符串str(对象)测试的时候，打印对象的信息
new:创建并返回一个实例对象，调用了一次，就会得到一个对象
class:获得已知对象的类(对象.class)
del:对象在程序运行结束后进行对象销毁，用以释放资源
str:方法

首先给出不用这个方法

class Animal:
    def __init__(self, name, colour):
        self.name = name
        self.colour = colour
dog = Animal('旺财', 'white')
print(dog)

使用__str__方法

class Animal:
    def __init__(self, name, colour):
        self.name = name
        self.colour = colour
    def __str__(self):
        return '我的名字时%s,我的颜色是%s'%(self.name,self.colour)
dog = Animal('旺财', 'white')
print(dog)

__new__方法
__new__和__init__的区别
__new__类的实例化方法，必须返回该实例对象，否则对象创建不成功，至少有一个参数是cls,优先于init
__init__用来做数据属性的初始化工作，也可以认为是实例的构造方法，接收类的实例，通过self并对其构造

class Animal:
    def __init__(self, name, colour):
        self.name = name
        self.colour = colour
        print('------init-----函数的执行')
    def __str__(self):
        return '我的名字时%s,我的颜色是%s'%(self.name,self.colour)
    def __new__(cls, *args, **kwargs):
        '''
        创建对象实例的方法，每调用一次生成一个新的对象
        :param args:
        :param kwargs:
        :return:
        '''
        print('-----new-----函数的执行')
        object.__new__(cls)
        return object.__new__(cls)  # 这里时真正创建实例对象的
        pass
    pass
dog = Animal('旺财', 'white')
print(dog)

案例：决战紫禁之巅

问题分析
两个人物，西门吹雪以及叶孤城
属性：
name 玩家的名字
blood 玩家血量
方法：
tong() 捅对方一刀，对方掉10滴血
kanren() 砍对方一刀，对方掉15滴血
chiyao() 吃一颗药，补10滴血
__str__打印玩家状态

import time     # 导入包
class Role:         # 对角色定义一个类
    def __init__(self,name,hp):
        '''
        初始化构造函数
        :param name:角色名字
        :param hp: 角色血量
        '''
        self.name = name
        self.hp = hp
        pass
    def tong(self,enemy):
        '''
        捅一刀
        :param enemy:敌人
        :return:
        '''
        enemy.hp -= 10       # 敌人减10滴血
        info = '[%s]捅了[%s]一刀'%(self.name,enemy.name)
        print(info)
        pass
    def kanren(self,enemy):
        '''
        砍人
        :param enemy: 敌人
        :return:
        '''
        enemy.hp -= 15      # 敌人减15滴血
        info = '[%s]砍了[%s]一刀' % (self.name, enemy.name)
        print(info)
        pass
    def chiyao(self):
        '''
        吃药补血
        :return:
        '''
        self.hp += 10
        info = '[%s]吃了一颗补血药，增加10滴血'%(self.name)
        print(info)
        pass
    def __str__(self):
        return '%s 还剩下 %s 的血量'%(self.name,self.hp)
        pass
    pass

xmcx = Role('西门吹雪',100)     # 创建两个实例化对象，叶孤城和西门吹雪
ygc = Role('叶孤城', 100)

while True:
    if xmcx.hp <= 0 or ygc.hp <= 0:
        break
    xmcx.tong(ygc)          # 西门吹雪捅叶孤城一刀
    print(ygc)          # 打印对象状态
    print(xmcx)
    print('---------------------------------------')
    ygc.chiyao()  # 叶孤城吃药
    print(ygc)  # 打印对象状态
    print(xmcx)
    print('---------------------------------------')
    ygc.kanren(xmcx)          # 叶孤城砍西门吹雪一刀
    print(ygc)          # 打印对象状态
    print(xmcx)
    print('---------------------------------------')
    xmcx.chiyao()          # 西门吹雪吃药
    print(ygc)          # 打印对象状态
    print(xmcx)
    print('---------------------------------------')

    time.sleep(1)   # 休眠一秒钟
    pass

print('对战结束............')

总结

类和对象的概念
类就是一个模板，模板里可以包含多个函数，函数里实现一些功能；
对象则是根据模板创建的实例，通过实例对象可以执行类中的函数。

定义类和对象
使用 class 语句来创建一个新类，class 之后为类的名称并以冒号结尾；
实例化类其他编程语言中一般用关键字 new，但是在 Python 中并没有这个关键字，类的实例化类似函数调用方式。

实例方法与属性
在类的内部，使用 def 关键字可以定义一个实例方法；
定义在类里面，方法外面的属性称之为类属性，定义在方法里面使用self引用的属性称之为实例属性。

__init__方法
构造初始化函数，在创建实例对象为其赋值时使用。

理解self
self和对象指向同一个内存地址，self就是对象的引用。

魔法方法
在python中，有一些内置好的特定的方法；方法名是“xxx”；在进行特定的操作时会自动被调用。

1.通过类创建一个对象,并定义一个方法

class Student:
    def run(self):
        print('学生每天跑2000米')
        pass
    pass
xiaoli = Student()  # 创建一个对象
xiaoli.run()

2.定义一个水果类，并创建苹果对象、橘子对象、西瓜对象并分别添加上颜色的属性

class Fruit:
    def __init__(self,name,color):
        self.color = color
        self.name = name
    pass
    def __str__(self):
        return '%s的颜色是%s' %(self.name, self.color)
    pass
pg = Fruit('苹果', '红色')
print(pg)
jz = Fruit('橘子', '黄色')
print(jz)
xg = Fruit('西瓜', '绿色')
print(xg)