面向对象编程的三大特性

对象和类

• 类（Class）是现实或思维世界中的实体在计算机中的反映，它将数据以及这些数据上的操作封装在一起。
• 对象(Object)是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概念。

如何将类装换为对象

实例化是指在面向对象的编程中，把用类创建对象的过程称为实例化。是将一个抽象的概念类，具体到该类实物的过程。实例化过程中一般由类名 对象名 = 类名（参数1，参数2…参数n）构成。

面向对象的三大特性

封装

定义：封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

_ _ init_ _ 构造方法

构造方法__init__与其他普通方法不同的地方在于，当一个对象被创建后，会立即调用构造方法。自动执行构造方法里面的内容。

示例：创建一个类People,拥有的属性为姓名， 性别和年龄， 拥有的方法为购物,玩游戏,学习;实例化对象,执行相应的方法。 显示如下:
小明,18岁,男,去西安赛格购物广场购物
小王,22岁,男,去西安赛格购物广场购物
小红,10岁,女,在西部开源学习

代码：

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

    def shopping(self):
        print("%s,%d岁,%s去西安购物广场购物" % (self.name, self.age, self.sex))

    def learning(self):
        print('%s,%d岁,%s去西部开源学习' % (self.name, self.age, self.sex))


people1 = People('小明', '男', 18)
people2 = People('小王', '男', 22)
people3 = People('小红', '女', 10)
people1.shopping()
people1.shopping()
people1.learning()

测试：

继承

继承描述的是事物之间的所属关系,当我们定义一个class的时候,可以从某个现有的class继承，新的class称为子类、扩展类(Subclass),而被继承的class称为基类、父类或超类(Baseclass、Superclass)。
object 是所有类的父类

继承的工作机制

父类的属性、方法,会被继承给子类。 举例如下: 如果子类没有定义__init__方法,父类有,那么在子类继承父类的时候这个方法就被继承了,所以只要创建对象,就默认执行了那个继承过来的__init__方法。

示例：
代码：

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

    def learning(self):
        print('年龄为%d的%s正在学习' % (self.age, self.name))


class Mathstudent(Student):
    pass


m = Mathstudent('snji', 18)
print(m.name)
m.learning()

测试：

如何调用父类的方法

方法1：父类名.方法名(self)

方法2：super()方法自动去找父类的方法

多继承

多继承,即子类有多个父类,并且具有它们的特征
在Python3.0以后的版本，都是新式类，新式类多继承的搜索算法是广度优先的算法

私有方法和私有属性

在 Python 中,实例的变量名如果以 __ 开头,就变成了一个私有变量/属性(private),实例的函数名如果以 __ 开头,就变成了一个私有函数/方法(private)只有内部可以访问,外部不能访问。
示例：

多态

多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。通俗来说： 同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。

面向对象编程的实例

队列的封装

队列是限制在一端进行插入操作和另一端删除操作的线性表，允许进行插入操作的一端称为“队尾”，允许进行删除操作的一端称为“队头”，，当队列中没有元素时称为“空队”。特点 ：先进先出（FIFO）
实现代码：

class Queue(object):
    def __init__(self):
        self.queue = []

    def first(self): # 队头
        if not self.is_empty():
            print('队头是', self.queue[0])
        else:
            raise Exception('空队列')

    def enqueue(self, value): # 添加元素
        self.queue.append(value)
        print('%d添加成功,添加后的队列为%s' % (value, self.queue))

    def dequeue(self): # 删除队列元素
        if not self.is_empty():
            item = self.queue.pop(0)
            print('%s被删除，删除后的队列为%s' % (item, self.queue))
        else:
            raise Exception('空队列')

    def is_empty(self): #判断是否为空队
        return self.__len__() == 0

    def __len__(self): # 求队的长度
        return len(self.queue)


if __name__ == '__main__':
    q = Queue()
    q.enqueue(5)
    q.enqueue(3)
    print(len(q))
    q.dequeue()
    q.first()

测试：

二分搜索算法

在计算机科学中，二分搜索（英语：binary search），也称折半搜索（英语：half-interval search）、对数搜索（英语：logarithmic search），是一种在有序数组中查找某一特定元素的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。

实现代码：

import random


def haha(num, l, left, right):
    mid = (left + right) // 2
    if num > l[mid]:
        if right == mid:
            return '该数找不到'
        else:
            left = mid + 1
            return haha(num, l, left, right)
    if num < l[mid]:
        if left == mid:
            return '该数找不到'
        else:
            right = mid - 1
            return haha(num, l, left, right)
    else:
        return mid


li = [random.randint(1, 100) for i in range(15)]  # 随机生成的一个15个元素的列表
li = sorted(li)
print(li)
while True:
    number = int(input('NUM:'))
    print(haha(number, li, 0, len(li) - 1)) # 最后返回的是搜素元素在该列表的索引值

测试：