0729_面向对象

• 面向过程
• 函数式编程
• 面向对象

面向过程

所谓过程就是我们解决问题的步骤，一步步的按照流程走，有先后之分。整个设计就好比流水线，思维上比较机械化

优缺点：

• 优点

  • 复杂的问题流程化，将问题分解简化

• 缺点

  • 扩展性不好

面向对象

• 核心是对象
• 对象是一个数据以及相关行为的集合
• 面对对象时功能上指向建模对象
• 通过数据和行为方式来描述交互对象的集合
• 在Python中，一切皆为对象

优缺点：

• 优点

  • 解决程序的扩展性

• 缺点

  • 复杂度远高于面向过程
  • 交互式解决问题，无法准确预测结果

object1:
    Tom
    
    特征：
    school = zucc
    name = Tom
    age = 20
    sex = male
    
    技能：
    eat
    study
    sleep
    
object2:
    Jack
    
    特征：
    school = zucc
    name = Jack
    age = 18
    sex = male

类就是类别、种类

对象就是特征和技能的统一体

类则是这一系列相似对象的特征和技能的结合

对于现实世界，现有个体（即对象），才有类别；但对于程序，必须先有类然后才有对象

面向对象编程

OOP（object oriented programming）

其是一种程序设计思想。oop把对象作为程序的一个基本单元，一个对象就包含了数据和操作数据的函数

在Python中，所有数据类型，都可以视为对象，同时，我们也可以自定义对象

自定义的对象的数据类型就是面向对象中类（class）的概念

demo：

假如要处理我们的成绩，为了表示学生的成绩：

• 面向过程的方式

stu1 = {"name": "Tom", "score": 99}
stu2 = {"name": "Jack", "score": 82}

• 利用函数来实现

def find_score(stu):
    print(stu["name"], ":", stu["score"])

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score
    

    def find_score(self):
        print(self.name, ":", self.score)

stu1 = Student("Tom", 99)
stu1.find_score()

#Tom:99

常见概念

• 类(Class) ：用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 方法：类中定义的函数。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 局部变量：定义在方法中的变量，只作用于当前实例的类。
• 实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• 实例化：创建一个类的实例，类的具体对象。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。

Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。

对象可以包含任意数量和类型的数据。

类的定义和使用

面向对象设计的思想，先抽象出类，再根据类创建实例

类的定义

class ClassName(object):
    '''docstring'''
    class_statement

类的命名，大驼峰式，首字母大写

创建一个类

class MyFirstClass:
    pass

类的作用是一个模板，我们在创建实例的时候，把一些我们认为必须要绑定的属性填进去。这时就通过特殊的__init__方法。在创建实例的时候

和普通函数相比，在类中定义方法时，第一个参数必须是self。除第一个参数外，其他的和普通参数没什么区别。

self 代表的是实例，而非类。

__init__方法

• 为对象初始化自己独有的特征

• 该方法中可以有任意的代码，但是一定不可以有返回值

数据封装

我们通过__init__让stu1 实例本身就拥有了相关数据，如果要访问这些数据，我们可以直接在Student类的内部定义相关的函数来访问数据，以此“封装”数据

这些封装数据的函数和Student类本身是关联起来的，他们被称之为方法。

import math

class Point:
    # def __init__(self, x, y):
    #     self.move(x, y)

    def move(self, x, y):
        self.x = x
        self.y = y

    def reset(self):
        self.move(0, 0)

    def cal_distance(self, other_point):
        return math.sqrt(
            (self.x - other_point.x) ** 2 +
            (self.y - other_point.y) ** 2
        )

p1 = Point()
p2 = Point()
p3 = Point()

p1.reset()
p2.move(3, 4)
p3.move(6, 8)

print(p2.cal_distance(p1))
print(p2.cal_distance(p3))

# 5.0
# 5.0

类的两个作用：

• 属性引用

  • 类名.属性

• 实例化

  • 类名加上一个括号就是实例化，他能自动触发__init__

函数的运行，进而为每个实例定制自己的特征

类属性的查看

• dir（类名）

  • 返回一个列表

• 类名.__dict__

  • 返回一个字典，key为属性名，value为属性值

特殊的类属性

类名.__name__   #返回类的名字
类名.__doc__    #返回类的文档字符串
类名.__base__   #类的第一个父类
类名.__bases__  #类的所有父类构成的元组
类名.__module__ #类定义所在的模块
类名.__class__  #实例所对应的类
类名.__dict__   #类的字典属性

总结：

class ClassName:
    def __init__(self, para1, para2, ...):
        self.对象属性1 = para1
        self.对象属性2 = para2
        
    def 方法名1(self):
        pass
    
    def 方法名2(self):
        pass
    
obj = ClassName(para1, para2)
# 对象的实例化，代表具体的东西
# ClassName()：调用具体的__init__
# 括号内传参，无需传入self，参数一一对应
# 结果返回对象obj
 
obj.对象属性1  #查看对象的属性
obj.方法名1    #调用类方法

对象之间的交互

class Person:

    def __init__(self, name, atk, life_value):
        self.name = name
        self.atk = atk
        self.life_value = life_value

    def attack(self, dog):
        dog.life_value -= self.atk

class Dog:

    def __init__(self, name, bread, atk, life_value,):
        self.name = name
        self.bread = bread
        self.atk = atk
        self.life_value = life_value

    def bite(self, people):
        people.life_value -= self.atk

per = Person("Jack", 10, 1000)
dog = Dog("Jerry", "Husky", 8, 1000)

print(dog.life_value)
per.attack(dog)
print(dog.life_value)

类命名空间与对象、实例的空间

创建一个类就会创建一个类的名称空间，用来存储我们定义的所有的变量名。这些名字就是属性。

类的属性有两种：

• 静态属性
  • 直接在类中定义的变量
• 动态属性
  • 在类中定义的方法

静态属性是共享给所有对象的

动态属性是绑定给所有对象的

函数的三大特性

• 继承
• 多态
• 封装

继承

在面向对象编程中，当我们定义一个新类的时候，可以从某个现有的类继承，新的类就被称为子类（SubClass），而被继承的类则被称为基类，父类，超类（Base Class, Father Class, Super Class）

比如，我们定义一个动物类（Animal），其有一个run（）方法如下：

class Animal(object):      #定义父类
    def run(self):
        print("Animal is running")

class Dog(Animal):         #单继承
    pass

class Cat(Animal):         #单继承
    pass

dog = Dog()
cat = Cat()

dog.run()

#Animal is running

继承的查看

ClassName.__bases__

print(Dog.__bases__)
print(Husky.__bases__)
print(Animal.__bases__)
print(Animal.__class__)
#如果不指定基类，python类会默认继承object类
#object是所有python类的基类，提供一些常见方法的实现

多态

当子类和父类存在相同的方法时，子类的方法回覆盖父类的方法，再运行行代码时，总会调用子类和父类同名的方法。这样，就是继承的另外一个好处，多态

class Animal(object):   #定义父类
    def run(self):
        print("Animal is running.")

class Animal2(object):   #定义父类
    pass

class Dog(Animal):  #单继承
    def run(self):
        print("Dog is running.")

class Cat(Animal):  #单继承
    def run(self):
        print("Cat is running.")

class Husky(Animal,Animal2):    #多继承，用逗号分开
    pass

dog = Dog()
cat = Cat()
dog.run()
cat.run()

理解多态，首先要对数据类型再进行说明。定义一个类的时候实际上就是定义了 一种数据类型。我们自定义的数据类型和Python自带的数据类型，比如str，list，dict，没什么区别

li = list()
print(isinstance(li,list))
print(isinstance(dog,Animal))
print(isinstance(dog,Dog))

用isinstance()来判断某个变量是否是某个类型

鸭子类型

鸭子类型不要求有严格的继承关系，一个对象，只要“看起来像鸭子，走起路来还是鸭子”

class Animal(object):   #定义父类
    def run(self):
        print("Animal is running.")

class Animal2(object):   #定义父类
    pass

class Dog(Animal):  #单继承
    def run(self):
        print("Dog is running.")

class Cat(Animal):  #单继承
    def run(self):
        print("Cat is running.")

class Husky(Animal,Animal2):    #多继承，用逗号分开
    pass

class Test:
    def run(self):
        print("多态测试")

dog = Dog()
cat = Cat()
test = Test()
dog.run()
cat.run()
test.run()


def run_twice(animal):
    animal.run()
    animal.run()

run_twice(test)

对于一个变量,我们只要知道他的父类型,无需确切知道子类型,就可以放心调用相关的方法.运行时具体的方法时作用在子类型上还是父类型上,由我们运行的对象决定

也就是说,调用时只管调用,不管细节

当我们新增一个子类时,只要保证相关的方法编写正确,就不用管原来的代码时如何调用的

----> "开闭"原则

• 对扩展开放:允许新增子类
• 对修改封闭:不需要修改依赖父类类型的函数

总结:

继承可以一级一级的继承下来,类比人类,就好比爷爷奶奶到父母,再到子女

任何类都可以追溯到跟类object

私有属性

在类的内部,可以有属性和方法,而外部代码可以通过直接调用实例变量的方法来操作数据.这样,隐藏内部的复杂逻辑

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def find_score(self):
        print(self.name, ":", self.score)

stu1 = Student("Tom", 99)
stu2 = Student("Jack", 89)

print(stu1.score)   #99
stu1.score = 97
print(stu1.score)   #97

从这可以看出,外部代码可以自由修改一个实例的属性(name, score)

如果要让内部属性不被外部访问,我们可以在属性名称前加两个下划线

在Python中,实例的变量名如果以双下划线开头,就变成一个私有变量,只有外部可以访问,外部不能访问

so,我们改一个Student类

class Student:
    def __init__(self, name, score):
        self.__name = name
        self.__score = score

    def get_name(self):
        return self.__name

    def get_score(self):
        return self.__score

    def find_score(self):
        print(self.__name, ":", self.__score)

stu1 = Student("Tom", 99)
stu2 = Student("Jack", 89)

print(stu1.get_name())     # Tom
print(stu2.get_score())    # 89
stu1.find_score()          # Tom : 99

封装

隐藏对象的属性和实现细节,仅对外提供公共访问的方式

这样做的优点在于:

• 可以将变化隔离
• 便于使用
• 提高安全性
• 提高重复性

封装的原则是:

• 将不需要对外提供的内容隐藏起来;
• 隐藏属性,提供公共方法对其进行访问

—> 私有方法,私有变量 —> 私有属性

用双下划线开头的方式将属性隐藏起来,设置为私有的

如果要编写现有对象的自定义版本,可以继承该对象,也可以创建一个外观和行为像的对象,但与其无任何关系的全新对象.

比方说,利用标准库中定义的各种"与文件类似的"的对象,尽管这些对象的工作方式像文件,但他们并没有继承内置文件对象的方法

class TestFile:
    def read(self):
        pass
    
    def write(self):
        pass
    
class OpenFile:
    def read(self):
        pass
    
    def write(self):
        pass