day10 面向对象编程

面向过程

面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

优缺点:

• 优点
  • 将问题流程化，
  • 从而分解简化问题
• 缺点
  • 因为流程分解完毕之后比较钉死，想要对程序进行扩展功能的话需要进行大规模改动

面向对象

优缺点：

面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

• 优点
  • 保证了程序的扩展性
• 缺点
  • 相对于面向过程而言复杂度要远高于面向过程
  • 交互式问题解决方式，无法准确预测结果

面对对象编程

oop(object oriented programming)

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

在python中，所有数据类型都可以视为对象，同时，我们也可以自定义对象。而定义了对象的类中的函数，则称为该对象对应的方法

demo：

如果要显示某学生信息中的成绩：

• 面对过程

students=[{'name':name,'id':id,'grade':grade}]  #用字典存储一个学生的信息
def find_student(id):
    """用于返回需要的学生对应的下标i"""
i=find_student(id)            #通过id确定学生并返回列表索引值
print(student[i]['grade'])    #通过字典的key来返回成绩

• 面对对象

class student:       #创建一个student类
    def __init__(self,name,id,grade):
        self.name=name
        self.id=id
        self.grade=grade
        
    def get_grade():  #get grade的方法
        print(self.grade)
stu1=Student('tom',100,55)        #创建一个student对象
stu1.get_grade()                  #调用student的get_grade()方法

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

和普通函数相比，类中定义的方法，第一个参数必须是self，除此之外与一般函数基本无二。（self指代实例）

• _init_ 方法
  • 是类的初始化方法，类似于C#或Java的构造函数。
  • 无返回值
  • 通过此方法初始化类之后可以直接通过self参数访问实例的属性

类的两个作用

• 属性引用
  • “类名.属性名”
• 实例化
  • 类名加上一个括号就是实例化，回直接调用"_init_"函数，从而初始化对象的每个属性

特殊的类属性

• ._name_ 返回类的名字
• ._doc_ 类的文档字符串
• ._base_ 类的第一个父类
• ._bases_ 类的所有父类构成的元组
• ._module_ 类定义所在的模块
• ._class_ 实例所对应的类
• ._dict_ 类的字典属性

两个对象之间的交互：

• 人与狗回合制

class Player:               #玩家
    def __init__(self,name,att,hp):
        self.name=name  #名字
        self.att=att    #攻击力
        self.hp=hp      #血量

    def att_dog(self,dog):  #对狗发动攻击
        dog.hp-=self.att


class Dog:
    def __init__(self, att, hp):
        self.att = att  #攻击力
        self.hp = hp    #血量

    def att_Player(self, player):   #对人发动攻击
        player.hp -= self.att

p1=Player('pro',10,100)
monster=Dog(10,50)
p1.att_dog(monster)
print(p1.hp,p1.att)
print(monster.hp)

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

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

类的属性有两种：

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

函数的三大特性

• 继承
• 多态
• 封装

继承

在面对对象编程中，当我们定义一个新类的时候，可以从某个现有的类继承，新的类就被称为子类（Subclass）

，而被继承的类则被称为基类（base） ，父类（father），超类（super）

单继承

class Animal:
    def run(self):
        print("Animal is running")

class Dog(Animal):
    # def run(self):
    #     print("Dog is running")
    pass
class Cat(Animal):
    # def run(self):
    #     print("Cat is running")
    pass

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

#Animal is running
#Animal is running

如果在子类中有父类中的同名方法，则会覆盖来源父类的方法

class Animal:
    def run(self):
        print("Animal is running")

class Dog(Animal):
    def run(self):
        print("Dog is running")

class Cat(Animal):
    def run(self):
        print("Cat is running")

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

#Dog is running
#cat is running

多重继承

• 所谓多重继承，是指python的类可以有两个以上父类，也即有类A，类B，类C，C同时继承类A与类B，此时C中可以使用A与B中的属性与方法。
• 其实在python2.2之后，多继承中基类的寻找顺序是一种广度优先算法

class A:
    def foo(self):
        print("A foo")
class B:
    def foo(self):
        print("B foo")
    def bar(self):
        print("B bar")

class C1(A,B):
    pass

class C2(A,B):
    def bar(self):
        print("C2 bar")
class D(C1,C2):
    pass

test=D()
test.bar()
test.foo()


#C2 bar
#A foo

多态

多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）

• 序列类型有多种形态：字符串，列表，元组
• 动物有多种形态：人，狗，猪

import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass
 
class People(Animal): #动物的形态之一:人
    def talk(self):
        print('say hello')
 
class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print('say wangwang')
 
class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print('say aoao')

私有属性

在类的内部，可以有属性和方法，而外部代码可以通过直接调用实例变量的方法来操作数据。

class Dog:
    def __init__(self, att, hp):
        self.att = att
        self.hp = hp

    def att_Player(self, player):
        player.hp -= self.att
monster=Dog(10,50)
monster.hp=40
print(monster.hp)

#40

从上可以看出，外部可以自由修改一个实例的属性，如果不想被外部访问，可以在属性名称之前加两个下划线（python中如果实例的变量以双下划线开头，就变成了一个私有变量，只有内部可以访问，外部不能访问）

写成私有属性之后再访问就需要在类里写对应的访问方法

class Dog:
    def __init__(self, att, hp):
        self.att = att
        self.__hp = hp

    def att_Player(self, player):
        player.hp -= self.att
    def get_hp(self):
        print(self.__hp)
monster=Dog(10,50)
monster.get_hp()

#50

封装

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

这样做的优点：

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

封装的原则：

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