【Python知识点梳理】6.面向对象基础(上)

6.面向对象基础(上)

---

---

1、面向对象介绍

  1.面向过程编程：根据业务逻辑从上到下写代码，怎么按照步骤去实现，然后见问题拆解为若干个步骤，并将这些步骤对应成方法，一步一步的完成最终功能，不适合做大项目。
  2.函数式：将某功能代码封装到函数中，无需重复编写，仅调用函数即可。
  3.面向对象编程(Object Oriented Programming,OOP)：是一种Python的编程思想，关注的是顶层设计的思维。将数据与函数捆绑到一起，进行封装，可以快速开发程序，减少了代码重复，适合做更大项目设计。
  4.概念：
a.面向对象：按人类认识客观世界的系统思维方式，采用基于对象(实体)的概念建立模型，模拟客观世界的分析、设计、实现软件功能的方法。
b.面向对象：一种解决软件复用的设计和编程方法。这种方法把软件系统中相类似的操作逻辑、应用数据、状态等，以类的形式描绘出来，以对象实例的形式在软件系统中进行复用，已到达提高软件开发效率的作用。

# 面向过程(怎么安装步骤去实现，将问题拆解为若干步骤，并一一对应成方法)
while True:
    if CUP利用率 > 90 %:
        # 发送邮件提醒
        连接邮件服务器
        发送邮件
        关闭连接
    if 硬盘利用率 > 90 %:
        # 发送邮件提醒
        连接邮件服务器
        发送邮件
        关闭连接
    if 内存占用率 > 90 %:
        # 发送邮件提醒
        连接邮件服务器
        发送邮件
        关闭连接

# 函数式
def 发送邮件(内容): # 相同功能进行封装
    # 发送邮件提醒
    连接邮件服务器
    发送邮件
    关闭连接


while True:
    if CUP利用率 > 90 %:
        发送邮寄("CPU报警")  # 调用函数
    if 硬盘利用率 > 90 %:
        发送邮寄("硬盘报警")  # 调用函数
    if 内存占用率 > 90 %:
        发送邮寄("内存报警")  # 调用函数

  1.面向对象编程(Object Oriented Programming,OPP)是一种解决软件复用的设计和编程方法。
  2.这种方法把软件系统中相近相似的操作逻辑和操作应用以及数据、状态等，以类的形式描述出来。
  3.以对象实例的形式在软件系统中复用，以达到提高软件开发效率的作用
  4.万事万物皆对象！！！(类：类对象、类的实例：实例对象)

---

2、类和对象的概念

  1.类：具有一组相同或者相似特征(属性)和行为(方法)的一系列(多个)对象的集合。
  2.对象：对象是实实在在具体存在的东西，类的实例化。
  3.类是对象的抽象，对象是类的一个实例。
  4.类的抽象：具有相同(类似)属性和行为的一系列对象的集合都可以抽象出一个类。

例1：抽象坦克大战中的类：
坦克：
 类名：Tank
 属性：血量、类型
 方法：发射子弹
墙：
 类名：Wall
 属性：血量、类型
 方法：阻挡
子弹：
 类名：Bullet
 属性：杀伤力

类的组成部分(格式)：
1.类的名称：类名
2.类的属性：一组数据(对象的特征)
3.类的方法：允许进行操作的方法(行为)

# 创建一个类：
class Foo(object):
    属性列表
    方法列表
    
# 创建一个对象：
对象名 = 类名()

例2：创建一个人的类：
事物名称(类名)：人(Preson)
属性：身高(height)、年龄(age)…
方法：吃(eat)、跑(run)…

---

3、定义类和对象

# 类的定义(类的结构、类名、属性、方法)
class Preson(object):  # 类名(大驼峰命名法)
    
    # 属性：对应人的特征
    name = "Tom"  # 类属性
    age = 18      # 类属性

    # 方法：对应人的行为
    def eat(self):  # 实例方法
        print("好好吃饭！") # 功能

    def run(self):
        print("热爱跑步！")
        
# 当创建完一个类后，这个类实际上是没有意义的(不在内存中创建任何空间的)
# 只有当这个类创建对象的时候，才会在内存空间中给对象分配一个空间

# 对象名 = 类名()
# 创建对象，对象就是类的实例化

people = Preson()   

# 对象具备类的一些属性和方法
# 调用函数(方法)
people.eat()
people.run()

# 调用类属性
print("{}的年龄是{}。".format(people.name,people.age))

---

4、实例方法与属性

  实例方法：
 1.在类的内部，使用def关键字可以定义一个实例方法。
 2.实例方法必须包含参数self，且为第一个参数(名字表示可以是其它，但是位置必须被占用)。
 3.实例方法归属于实例所有。

  属性：
 1.类里面定义的变量。
 2.定义在类里面，方法外面的属性为类属性；
 3.定义在方法里面使用’self.变量名’引用的属性为实例属性

# 定义在类里面，方法外面的属性--->类属性
# 定义在方法里面使用self引用的属性--->实例属性

class Animal(object):

    color = "白色"  # 类属性

    def __init__(self):
        self.name = "旺财"  # 实例属性(使用'self.变量名'引用的属性)

    def test(self):  # 实例方法，使用def关键字定义，第一个形参默认传实例对象本身(self)
        print("实例方法！")

    # 一个类里面可以有多个实例方法
    def show(self):
        print("Animal.show方法")


dog = Animal()
print(dog.color)
print(dog.name)
dog.test()
dog.show()

---

5、__ init__()方法

  1.Python自带的内置函数(魔术方法)，双下滑线。
  2.是一个初始化方法，用来定义实例属性，在创建对象的时候自动调用。
  3.利用传参机制可以让功能更加强大、方便。

# 创建一个Animal类，并实例化一个dog对象和cat对象。
# 没有类属性、实例属性
class Animal(object):
    def eat(self):  # 实例方法
        print("吃饭")


# 每创建一个对象(dog)都要重新添加属性
dog = Animal()  # 创建一个对象
dog.color = "Black"  # 添加实例属性(给实例对象添加属性的方法)
dog.name = "Herry"  # 添加实例属性
dog.eat()
print(dog.name, dog.color)

# 每创建一个对象(cat)都重新要添加属性
cat = Animal()  # 创建一个对象
cat.color = "Red"  # 添加实例属性
cat.name = "Jarry"  # 添加实例属性
cat.eat()
print(cat.name, cat.color)

  1.__init__()方法可以认为是一种初始化的方法，实例化对象的时候自动调用，完成一些初始化设置。该方法在创建一个对象时默认调用，不需要显式操作调用。
  2.如果__init__()方法里面的属性固定了，每个类创建出来的对象属性都一样，这个时候可以将属性当作参数在实例化的时候传进去！！！

# __init__()方法可以认为是一种初始化的方法
class Animal(object):
    # 创建一个初始化方法
    def __init__(self):
        self.name = "旺财"    # 实例属性(属性固定)
        self.color = "Black"  # 实例属性(属性固定)

    def eat(self):
        print("{}的{}快来吃饭！".format(self.color, self.name))


dog = Animal()
dog.eat()
print("dog直接输出的是默认值：", dog.name, dog.color)  # 访问name和color属性

# 对实例属性进行修改
cat = Animal()
cat.eat()
print("cat输出没有修改后的值：", cat.name, cat.color)

cat.name = "Tom"
cat.color = "Yellow"
cat.eat()
print("cat输出修改后的值：", cat.name, cat.color)

  __init__(self)方法中，默认有1个参数名字为self，如果还需要另外的实参，可以写成__init__(self,x, y)

# 如果有多个对象，每创建一个对象都要添加属性，可以进行初始化设置！
# __init__()方法进行传参(魔术方法)
class Animal(object):
    # 创建一个初始化方法
    def __init__(self, name, color):  # 统一声明实例属性
        self.name = name    # 实例属性(使用'self.变量名'引用的属性)
        self.color = color  # 实例属性(使用'self.变量名'引用的属性)

    def eat(self,food):
        print("{}的{}快来{}！".format(self.color, self.name,food))
        
dog = Animal("旺财", "金色")  # 创建一个对象(dog),自动执行__init__()方法
print(dog.name)  # 访问属性
print(dog.color)
dog.eat("狗粮")  # 访问方法


cat = Animal("小花", "白色")  # 创建一个对象(cat),自动执行__init__()方法
print(cat.name)  # 访问属性
print(cat.color)
cat.eat("猫粮")  # 访问方法

---

6、理解self

  1.self只是在定义类中定义实例方法的时候才会有(必须要有)，在调用的时候不必传入self参数(解释器自动指向)，定义普通方法的时候不需要self。
  2.self的名字表示可以更改为其它的任何名字，只是约定俗成的认为是self。
  3.self和对象指向同一个内存地址，可以认为self就是对象的引用，指向类实例对象本身。

# self和对象指向同一个内存地址，可以认为self就是对象的引用(self就是一个对象)。
# 可以认为self就是实例对象
# 创建一个Car类
class Car(object):
    # 创建一个方法，打印self的id地址
    def getself(self):
        print(self)
        print("self=%s" % (id(self)))


bmw = Car()  # 一个实例化对象
print("bmw=%s" % (id(bmw)))  # 打印对象的id地址
bmw.getself()

  所谓的self，可以理解为对象自己，某个对象调用其方法时，Python解释器会把这个对象作为第一个参数传递给self，所以开发者只需要传递后面的参数即可。

# 创建一个类
class Car(object):
    def __init__(self, name, color):
        self.name = name
        self.color = color
    # 创建一个方法，打印self的id

    def getself(self,people):
        print("这是一辆{}的{}{}的汽车！".format(people,self.color, self.name))
        print("self=%s" % (id(self)))


bmw = Car("宝马", "黑色")
# 实例化对象时，self不需要开发者传参，python自动将对象传递给self
print("bmw=%s" % (id(bmw)))
bmw.getself("Tracy")

# 推荐使用官方默认的self，不建议使用自定义名称(混乱)
class Person(object):
    def __init__(self, pro):
        self.pro = pro  # 实例属性的定义

    def info(a, name, sex):
        print("{}的性别是：{}，专业是：{}".format(name, sex, a.pro))  # 将self更改为其它的任何名字


Tom = Person("计算机科学与技术")
Tom.info("Tom", "男")

---

7、魔法方法

  在Python中，有一些内置好的特定的方法，方法名是"__xxx___()",在进行特定的操作时会自动被调用，这些方法称之为魔术方法。
1.__init___()方法:初始化一个类，在创建实例对象时为其赋值使用。
2.__str___()方法:在将对象转换成字符串str(对象)测试的时候，打印对象的信息。
3.__new___()方法:创建并返回一个实例对象，调用一次，就会得到一个对象。
4.__class___()方法:获得已知对象的类(对象.__class___())
5.__del___()方法:对象在程序运行结束后进行对象销毁的时候调用这个方法，来释放资源。
6.__call__()方法：Python中把类的实例变成一个可调用对象。
  定义了__str__()方法，在打印对象的时候会执行__str__()方法。__str__()方法只能return一个字符串。

# __str__方法 直接打印对象，输出结果只是一串类似id的地址信息
# 创建一个动物类
class AnimalA(object):
    # 创建一个初始化方法
    def __init__(self, name, color):
        self.name = name
        self.color = color


# 实例化对象
dog = AnimalA("旺财", "黄色")
print("打印实例对象dog：", dog) # 输出内存的地址



# 在类中定义__str__方法
class AnimalB(object):
    # 创建一个初始化方法
    def __init__(self, name, color):
        self.name = name
        self.color = color
    # 在打印对象的时候，会执行该方法，该方法只能return一个字符串

    def __str__(self): # 打印对象的信息
        return "{}的{}快来吃饭！".format(self.color, self.name)


# 实例化对象
cat = AnimalB("旺财", "白色")
print("打印实例对象cat：", cat)

# 当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据
# __str__()方法需要返回一个字符串，当做这个对象的描写

class Cat(object):
    """定义一个猫类"""

    def __init__(self, new_name, new_age):
        """在创建完对象之后 会自动调用, 它完成对象的初始化的功能"""
        # self.name = "汤姆"
        # self.age = 20
        self.name = new_name
        self.age = new_age  # 它是一个对象中的属性,在对象中存储,即只要这个对象还存在,那么这个变量就可以使用
        self.num = 100  # 它是一个局部变量,当这个函数执行完之后,这个变量的空间就没有了,因此其他方法不能使用这个变量

    def __str__(self):
        """返回一个对象的描述信息"""
        # print(num)
        return "名字是:%s , 年龄是:%d" % (self.name, self.age)

    def eat(self):
        print("%s在吃鱼...." % self.name)

    def drink(self):
        print("%s在喝可乐..." % self.name)

    def introduce(self):
        # print("名字是:%s, 年龄是:%d" % (汤姆的名字, 汤姆的年龄))
        # print("名字是:%s, 年龄是:%d" % (tom.name, tom.age))
        print("名字是:%s, 年龄是:%d" % (self.name, self.age))

# 创建了一个对象
tom = Cat("汤姆", 30)
tom.introduce()
# print(tom)

  1.__init___()方法：用来做数据属性的初始化工作，也可以认为是实例的构造方法，接受类的实例self，并对其进行构造。
  2.__nwe__()方法：类的实例化方法，必须要返回该实例，否则对象创建不成功，至少有一个参数cls，代表要实例化的类，__nwe__()方法执行的顺序早于__init___()方法。

# 在类中定义__nwe__()方法(单例模式中经常使用)
class Animal(object):
    # 创建一个初始化方法
    def __init__(self, name, color):
        self.name = name
        self.color = color
        print("__init__()方法的执行")
    
    # 在打印对象的时候，会执行该方法，该方法只能return一个字符串
    def __str__(self): # 打印对象的信息
        return "{}的{}快来吃饭！".format(self.color, self.name)
    
    # 创建对象实例的方法，每调用一次，就会生成一个新的对象，cls就是class的缩写
    def __new__(cls,*args,**kwargs):
        print("__new__()方法的执行")
        return object.__new__(cls) # 在这里创建对象实例
        


# 实例化对象
dog = Animal("旺财", "白色")
print("打印实例对象dog：", dog)
print(dog)

class People(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

    def __call__(self, friend):
        print("My name is %s" %self.name)
        print("My friend is %s" %friend)


Per = People('Tracy', 'Male')
Per.__call__('Tim')       # 调用方法一
Per('Tim')                # 调用方法二

# Python中可调用的对象可以通过内置函数callable来判断
# 如果类定义了__call__方法，那么它的实例可以变为可调用对象
print(callable(Per))

---

7、案例

1.两个人物：西门吹雪、叶孤城
2.属性：
    name   玩家姓名
    blood  玩家血量

3.方法：
    tongren() 捅对方一刀，对方掉10滴血
    kanren() 砍对方一刀，对方掉15滴血
    chiyao() 吃一颗药，补血10滴
    __str__ 打印玩家状态

# 定义一个类 --> 角色类
import time

class Role(object):
    # 构造初始化函数，定义实例属性(角色名、血量)
    def __init__(self, name, hp):
        self.name = name
        self.hp = hp

    def tongren(self, enemy):  # enemy敌人
        enemy.hp -= 10
        info = '【%s】捅了【%s】一刀' % (self.name, enemy.name)
        print(info)
        pass

    def kanren(self, enemy):  # enemy敌人
        enemy.hp -= 15
        info = '【%s】砍了【%s】一刀' % (self.name, enemy.name)
        print(info)
        pass

    def chiyao(self):
        self.hp += 10
        info = '【%s】吃了一颗血药，回复10滴血' % (self.name)
        print(info)
        pass

    def __str__(self):
        return "%s还剩下%s的血量!" % (self.name, self.hp)


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

while True:
    if xmcx.hp <= 0 or ygc.hp <= 0:
        break

    xmcx.kanren(ygc)
    print(xmcx)
    print(ygc)
    print("- -"*15)
    time.sleep(1)  # 休眠一秒钟
    ygc.tongren(xmcx)
    print(xmcx)
    print(ygc)
    print("- -"*15)
    time.sleep(1)  # 休眠一秒钟
    ygc.chiyao()
    print(xmcx)
    print(ygc)
    print("- -"*15)
    time.sleep(1)  # 休眠一秒钟
    pass

---

总结

  1.什么是类，什么是对象。
  2.Python中定义一个类的语法格式是什么。
  3.类（class）由哪三部分构成。
  4.__init__方法有什么作用，如何定义。
  5.方法中的"self"代表什么。
  6.在类中定义的__init__方法的时候第一个形参必须是self？self可以用其他东西替换？
  7.Python面向对象中的魔术方法，是如何定义的，魔术方法需要开发人员去调用吗？
  8.__str__方法需要return返回值？