面向对象基础(OOP)-上

1. 面向对象概述

面向过程：根据业务逻辑从上到下写代码
函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
面向对象(object oriented programming)：将数据与函数绑定到一起，进行封装，这样能够更快速的开发程序，减少了重复代码的重写过程。

在进行面向过程编程时，将问题拆解成几个步骤，并将这些步骤一步一步实现。
在进行面向对象时，关注的是设计的过程，类似于甲方，给个方案让别人实现。
面向过程不适合大项目，关注点是怎么做。
面向对象适合大项目，关注点是谁来做。

面向对象编程是一种解决软件复用的设计合编程方法。这种方法把软件系统中相似的操作逻辑合操作应用数据、状态，以类的形式描述出来，以对象实例的形式在软件系统中复用，以达到提高软件开发效率的作用。

2.类和对象

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

类相当于制造汽车的图纸，用这个图纸制造的汽车相当于对象。

类的组成部分：
1.类名
2.类的属性：一组数据
3.类的方法：允许对象进行操作的方法
如：
类名：人
属性：身高、体重...
方法：吃、跑...

类是具有一组相同或相似属性和方法的一系列对象的集合，是对象的抽象化。对象是类的实例。

3.定义类和对象

格式：

创建类：
class 类名:
		属性
		方法
实例化对象：
对象名=类名()

#定义类
class Person:
    '''
    属性和对象几个都行
    '''
    name='属性'
    age=20
    def eat(self):
        print('方法')
        pass
    def run(self):
        print('方法2')
        pass
    pass
#创建对象,实例化对象
person=Person()
person.eat()
person.run()
print(person.name,person.age)

4.实例方法和属性

在类的内部，使用def关键字可以定义一个实例方法，与一般函数定义不同，类方法必须包含参数self(名字标识可以是其他的，但是位置必须存在)且为第一个参数。
实例方法：每个实例都可以调用。
属性：类里面方法外面定义的变量称为类属性，定义在方法内部使用self引用的属性称为实例属性。

#定义类
class Person:
    '''
    属性和对象几个都行
    '''
    age=20
    def eat(self):
        print('方法')
        pass
    def run(self):
        print('方法2')
        pass
    def __init__(self):
        self.name='实例属性'
    pass
#创建对象,实例化对象
person=Person()
person.eat()
person.run()
print(person.name,person.age)

5.init方法

5.1 引入

class People:
    def eat(self):
        '''
        实例方法
        :return:
        '''
        print('喜欢吃东西')
        pass
    pass
p1=People()
p1.name='同学1'   #也属于实例属性
p1.sex='女'
p1.age=22
p1.eat()
print(p1.name,p1.sex,p1.age)
p2=People()
p2.name='同学2'   #也属于实例属性
p2.sex='女'
p2.age=22
print(p2.name,p2.sex,p2.age)
#如果有n个对象被实例化，就需要重复以上很多次
#故而引入init函数

init函数主要做一些实例属性的声明和初始化的工作，这个函数由系统创建对象时自动执行。
5.2 使用
init方法可以👇

class People:
    #凡是用双下划线圈起来的方法都是python的魔术方法
    def __init__(self):
        '''
        声明实例属性
        '''
        self.name='梨花'
        self.sex='女'
        self.age=11
        pass
    def eat(self):
        '''
        实例方法
        :return:
        '''
        print('喜欢吃东西')
        pass
    pass
p=People()
print(p.name,p.age,p.sex)
#此时如果想重新赋值直接“p.name='新名字'”操作即可

也可以传参👇

class People:
    #凡是用双下划线圈起来的方法都是python的内置方法
    def __init__(self,name,sex,age):
        '''
        声明实例属性
        '''
        self.name=name
        self.sex=sex
        self.age=age
        pass
    def eat(self,food):
        '''
        实例方法
        :return:
        '''
        print(self.name+'喜欢吃'+food)
        pass
    pass
p=People('丽华','南',19)
p.eat('小龙虾')
print(p.name,p.age,p.sex)
#在实例化对象的时候将值传进去，灵活性很高

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

class Person:
    def eat(self):

        print('self的内存地址为%s',id(self))
        pass
    pass
p=Person()
print('p的内存地址为%s',id(p))
p.eat()

其实所谓的self就是对象自己，相当于Java中的this。某个对象调用其方法时，python解释器会把这个对象作为第一个参数传递给self，所以我们只用传递后面的参数即可。

class Person:
    def __init__(self,pro):
        self.pro=pro
        pass
    def eat(self,name,food):

        print('%s喜欢吃%s修的专业是%s'%(name,food,self.pro))
        pass
    pass
p=Person('计算机')  #初始化时给init中除了self的参数
p.eat('丽丽','龙虾')

6.魔术方法

6.1 __str__方法

class Person:
    def __init__(self,pro,name,food):
        self.pro=pro
        self.name=name
        self.food=food
        pass
    def __str__(self):
        '''

        :return: 自定义输出的数据内容
        '''
        return '%s喜欢吃%s修的专业是%s'%(self.name,self.food,self.pro)
    pass
p=Person('计算机','丽丽','龙虾')
print(p)

6.2 __new__方法

class Person:
    def __init__(self,pro,name,food):
        self.pro=pro
        self.name=name
        self.food=food
        print('init函数的执行')
        pass
    def __str__(self):
        '''

        :return: 自定义输出的数据内容
        '''
        return '%s喜欢吃%s修的专业是%s'%(self.name,self.food,self.pro)
    def __new__(cls, *args, **kwargs):
        '''
        cls:是class的缩写
        创建对象实例的方法，每调用一次会生成一个新的实例对象
        不声明系统也会默认调用
        可以控制创建对象的一些属性限定，经常用来做单例模式的时候使用
        :param args:
        :param kwargs:
        '''
        print('new函数的执行')
        return object.__new__(cls)   #不加这句话不创建对象
    pass

p=Person('计算机','丽丽','龙虾')
print(p)
#先执行new函数，如果new函数有创建对象的操作就执行init函数
#new和init的区别：
#new函数是类的实例化方法，必须有return实例，否则对象创建不成功
#init类似于Java中的构造函数，用来做数据属性初始化工作，接受类的实例self并对其进行构造
#new至少有一个参数cls表示要实例化的类，此参数在实例化时由python解释器自动提供

7.实践–决战紫禁之巅

import time  #导入时间的包
import random
#定义角色类
class Person():
    def __init__(self,name,blood):
        self.name=name
        self.blood=blood
        pass
    def tong(self,enemy):
        '''
        enemy表示敌人
        :param enemy:
        :return:
        '''
        enemy.blood-=10
        info='[%s]捅了[%s]一刀'%(self.name,enemy.name)
        print(info)
        pass
    def kanren(self,enemy):
        enemy.blood-=15
        info='[%s]砍了[%s]一刀'%(self.name,enemy.name)
        print(info)
        pass
    def chiyao(self):
        self.blood+=10
        info='[%s]吃了一个药丸增加10滴血'%(self.name)
        print(info)
        pass
    def __str__(self):
        return '%s的剩余血量是%d'%(self.name,self.blood)
    pass
xmcx=Person('西门吹雪',100)
ygc=Person('叶孤城',100)
while ygc.blood>0 and xmcx.blood>0:
    i=random.randint(1,6)
    if i==1:
        ygc.tong(xmcx)
        print(xmcx)
        print(ygc)
        pass
    elif i==2:
        xmcx.tong(ygc)
        print(xmcx)
        print(ygc)
        pass
    elif i==3:
        ygc.chiyao()
        print(xmcx)
        print(ygc)
        pass
    elif i==4:
        xmcx.chiyao()
        print(xmcx)
        print(ygc)
        pass
    elif i==5:
        ygc.kanren(xmcx)
        print(xmcx)
        print(ygc)
        pass
    elif i==6:
        xmcx.kanren(ygc)
        print(xmcx)
        print(ygc)
        pass
    print('--------------------')
    time.sleep(1)   #休眠1秒
    pass
if ygc.blood==0:
    print('叶孤城输了')
    pass
if xmcx.blood==0:
    print('西门吹雪输了')
    pass