【Python基础】13、面向对象基础

一、面向对象基础

1、面向对象的三大特性：

• 封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式，将变化隔离，便于使用，提高复用性和安全性。
• 继承：提高代码复用性；继承是多态的前提。
• 多态：父类或接口定义的引用变量可以指向子类或具体实现类的实例对象。提高了程序的拓展性。

2、五大基本原则：

（1）、单一职责原则SRP
类的功能要单一，不能包罗万象，跟杂货铺似的。
（2）、开放封闭原则OCP
一个模块对于拓展是开放的，对于修改是封闭的，想要增加功能热烈欢迎，想要修改，哼，一万个不乐意。
（3）、里式替换原则LSP
子类可以替换父类出现在父类能够出现的任何地方。比如你能代表你爸去你姥姥家干活。哈哈~~
（4）、依赖倒置原则DIP
高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象。抽象不应该依赖于具体实现，具体实现应该依赖于抽象。就是你出国要说你是中国人，而不能说你是哪个村子的。比如说中国人是抽象的，下面有具体的xx省，xx市，xx县。你要依赖的是抽象的中国人，而不是你是xx村的。
（5）、接口分离原则ISP
设计时采用多个与特定客户类有关的接口比采用一个通用的接口要好。就比如一个手机拥有打电话，看视频，玩游戏等功能，把这几个功能拆分成不同的接口，比在一个接口里要好的多。

3、面向对象与面向过程的区别：

          面向过程：侧重于怎么怎么做

• 把完成某一个需求的 所有步骤 从头到尾 逐步实现
• 根据开发要求，将某些功能独立的代码封装成一个又一个函数
• 最后完成的代码，就是顺序的调用不同的函数

特点：

•     注重步骤和过程，不注重职责分工
•     如果需求复杂，代码变得非常复杂
•     开发复杂的项目的时候，没有固定的套路，开发难度很大

          面向对象：侧重于谁来做

• 在完成某一个需求前，首先确定职责--要做的事(方法)
• 根据职责确定不同的对象，在对象内部封装不同的方法(多个)
• 最后完成代码，就是顺序的让不同的对象调用不同的方法

特点：

•     注重对象和职责，不同的对象承担不同的职责
•     更加适合对复杂的需求变化，是专门应对复杂项目的开发，提供固定的套路
•     需要在面向过程的基础上，再学习一些面向对象的语法  

总结：根据以上所述，可以粗略总结为：面向对象的思想适合大型项目，注重方法，面向过程的思想适合小型项目，注重目的实现过程。

二、类和对象

简单的说，类是对象的蓝图和模板，而对象是类的实例。可以看出，类是抽象的概念，而对象是具体的东西。

对象：面向对象编程的世界中，一切皆为对象，对象都有属性和行为，每个对象都是独一无二的，而且对象一定属于某个类（型）。

类：当我们把一大堆拥有共同特征的对象的静态特征（属性）和动态特征（行为）都抽取出来后，就可以定义一个类。

1、类的初始化

类名() 就可以创建一个对象
类名() 创建对象的时候，python解释器会自动执行以下操作
    1.为对象在内存中分配空间--创建对象
    2.调用初始化方法为对象的属性设置初始值
这个初始化方法是内置方法，是专门用来定义一个类据有哪些属性和方法的

class Cat:  
# __init__是一个特殊方法用于在创建对象时进行初始化操作
    def __init__(self,new_name):    
        #print('这是一个初始化方法')
        self.name = new_name
    def eat(self):
        print('%s 爱吃鱼' %(self.name))
        #pass
    def drink(self):
        print('猫要喝水')

tom = Cat('Tom')   #由于类有了初始化，所以在定义对象的时候，直接传进参数
print(tom)
tom.eat()
hk = Cat('Hellokitty')
print(hk)
hk.eat()

2、__str__：用来描写对象

使用print输出对象变量时候，默认情况下
会输出这个变量引用的对象是由哪一个类创建的对象以及在内存中的地址
eg:
<__main__.Cat object at 0x7fa56b670128>

所以当需要print输出时，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据

注意：
      __str__方法需要返回一个字符串，当做这个对象的描写

class Cat:
    def __init__(self,name):
        self.name = name

    def __str__(self):
        # 返回必须是一个字符串
        return '我是 %s' %(self.name)

tom = Cat('tom')
print(tom.name)
print(tom)

addr = id(tom)
print(addr)
# 十六进制
print('%x' %(addr))
# 十进制
print('%d' %(addr))

3、__del__销毁对象的方法

当程序不再需要一个 Python 对象时，系统必须把该对象所占用的内存空间释放出来，这个过程被称为垃圾回收（GC，Garbage Collector），Python 会自动回收所有对象所占用的内存空间，因此开发者无须关心对象垃圾回收的过程。

__del__：如果希望在对象被销毁之前，再做一些事情，可以考虑一下__del__
当一个对象被从内存中销毁前(把这个对象从内存中删除掉)，
会自动调用 __del__方法

class Cat:
    def __init__(self,name):
        self.name = name
        print('%s 来了' %(self.name))
    def  __del__(self):
        print('%s 走了' %(self.name))
tom = Cat('tom')
print(tom.name)   
# del tom
print(tom.name)   

输出：
tom 来了   #执行类中的初始化方法
tom
tom
tom 走了   #执行完两个输出函数后，此时默认执行类中__del__方法

4、面向对象实现栈和队列

栈：

class Stack:
    def __init__(self):
        self.stack = []  #在init方法里，初始化一个列表
    def _push(self,value):   #入栈
        self.stack.append(value)
        return True
    def pop(self):   #进行出栈        # self.stack.pop()
        if self.stack:
            out = self.stack.pop()
            return out   #返回弹出的栈顶元素
        else:
            return False
    def top(self):  #取栈顶元素
        if self.stack:
            return self.stack[-1]   #如果栈里边有元素，则返回最后一个
        else:
            return False
    def length(self):
        return len(self.stack)
    def show(self):
        return ' '.join(self.stack)

yyz=Stack()

yyz._push('34')
print(yyz.pop())
print(yyz.show())

队列：

class Duilie:
    def __init__(self):
        self.duilie = []
    def i(self,value):
        self.duilie.append(value)
    def o(self):
        if self.duilie:
            self.duilie.reverse()   #进行反转列表，再使用pop相当于先进先出
            shuchu = self.duilie.pop()
            return shuchu
        else:
            return False
    def show(self):
        return ''.join(self.duilie)
s=Duilie()
s.i('1')
s.i('2')
print(s.o())
print(s.show())    #注意，调用方法的时候，必须得加括号