python中的面向对象编程的三大特性

一、面向对象编程的三大特性

面向对象的三大特性是指:封装、继承和多态

二、对象和类

类(Class) 是现实或思维世界中的实体在计算机中的反映,它将数据以及这些
数据上的操作封装在一起。
对象(Object) 是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概念。
1.如何定义类?
class 类(): pass
2.如何将类转换成对象?
实例化 是指在面向对象的编程中,把用类创建对象的过程称为实例化。是将一个抽象的概念类,具体到该类实物的过程。实例化过程中一般由类名 对象名 = 类名(参数1,参数2…参数n)构成。
类(Class) 是是创建实例的模板
对象(Object) 是一个一个具体的实例
举例：

class People:
    def __init__(self,name,age):
        print('self:',self)
        self.name = name
        self.age = age
    def eating(self):
        print('年龄为%s的%s正在吃.....' %(self.age,self.name))
    def learning(self):
        print("年龄为%s的%s正在学习....." %(self.age,self.name))
p1 = People('李四',25)
print("People:", People)
print("p1:", p1, p1.eating())
p2 = People('张三', 20)
print("p2:", p2, p2.learning())

测试：

三、封装特性

封装,顾名思义就是将内容封装到某个地方,以后再去调用被封装在某处的内容。所以,在使用面向对象的封装特性时,需要:
1). 将内容封装到某处
2). 从某处调用被封装的内容
1). 通过对象直接调用被封装的内容: 对象.属性名
2). 通过self间接调用被封装的内容: self.属性名
3). 通过self间接调用被封装的内容: self.方法名()
构造方法__init__与其他普通方法不同的地方在于,当一个对象被创建后,会立即调
用构造方法。自动执行构造方法里面的内容。

# 构造方法__init__与其他普通方法不同的地方在于,当一个对象被创建后(实例化),会立即调
# 用构造方法。自动执行构造方法里面的内容。
class Student:
    # 实例化对象的过程中自动执行的函数
    def __init__(self):         # self是形参还是实参? - 形参
        # self是什么? self实质上实例化出来的对象。系统自动将实例化的对象传递给构造方法。
        print("self: ", self)
        print("正在运行构造方法........")

print(Student)      # <class '__main__.Student'>
# 实例化产生对象的过程
stu1 = Student()
print("stu1: ", stu1)

注意：程序在运行的过程中，遇到class会先执行class中的内容
对于面向对象的封装来说,其实就是使用构造方法将内容封装到对象中,然后通过
对象直接或者self间接获取被封装的内容
举例：
创建一个类People拥有的属性为姓名，性别和年龄，拥有的方法为购物，玩游戏，学习，实例化对象，执行相应的方法，显示如下：
小明，18岁，男，去西安赛格购物广场购物
小王，22岁，男，去西安赛格购物广场购物
小红，10岁，女，在西部开源学习

class People(object):
    # 创建类的时候类的内容会执行
    print('正在创建类。。。')
    def __init__(self,name,gender,age):
        self.name = name
        self.gender = gender
        self.age = age
    def shopping(self):
        print('%s,%d,%s,去西安赛格购物广场' %(self.name,self.age,self.gender))
    def playing(self):
        print('%s,%d,%s,正在家里玩游戏' %(self.name,self.age,self.gender))
    def learning(self):
        print('%s,%d,%s,去西部开源学习' %(self.name,self.age,self.gender))
stu1 = People('小名','男',18)
stu2 = People('小王','男',22)
stu3 = People('小红','女',10)
stu1.shopping()
stu2.shopping()
stu3.learning()

四、继承特性

继承描述的是事物之间的所属关系,当我们定义一个class的时候,可以从某个现有的class
继承,新的class称为子类、扩展类(Subclass),而被继承的class称为基类、父类或超类
(Baseclass、Superclass)。
问题一: 如何让实现继承?
子类在继承的时候,在定义类时,小括号()中为父类的名字

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

重写父类方法: 就是子类中,有一个和父类相同名字的方法,在子类中的方法
会覆盖掉父类中同名的方法。
调用父类的方法:

class Student(object):
    def __init__(self,name,age):
        print('这是父类的构造方法...')
        self.name = name
        self.age = age
    def learning(self):
        print('正在执行父类的learning方法....')
        print('学生%s正在学习....' %(self.name))
        print(self.age)
class MathStudent(Student):
    def learning(self):
        print('正在执行子类的learning方法...')
        print('数学系学生%s正在学习' %(self.name))
        print(self.age)
m = MathStudent('杨森',19)
print('学生姓名：', m.name)
print('学生年龄：', m.age)
m.learning()

多继承
多继承,即子类有多个父类,并且具有它们的特征
在Python3.0以后的版本，都是新式类，新式类多继承的搜索算法是广度优先的算法
私有方法和私有属性
在 Python 中,实例的变量名如果以 __ 开头,就变成了一个私有变量/属性(private),实例的函数名如果以 __ 开头,就变成了一个私有函数/方法(private)只有内部可以访问,外部不能访问。

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

五、练习

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

class Stack(object):
    def __init__(self):
        self.stack = []
    def push(self, value):
        self.stack.append(value)
        print('元素%s入栈成功' %(value))
    def pop(self):
        if not self.is_empty():
            a = self.stack.pop(-1)
            print('%s出栈成功' %(a))
        else:
            raise Exception('栈为空')
    def top(self):
        if not self.is_empty():
            return self.stack[-1]
        else:
            raise Exception('栈为空，不能获取栈顶元素')
    def is_empty(self):
        return len(self.stack) == 0
    def __len__(self):
        return len(self.stack)
    def list(self):
        print(self.stack)
if __name__ == '__main__':
    s = Stack()
    s.push(5)
    s.push(3)
    print(len(s))
    s.pop()
    print(s.is_empty())
    s.list()

队列
队列是限制在一端进行插入操作和另一端删除操作的线性表，允许插入操作的一端称为队尾，允许删除的一端称为队头当队列中没有元素时称为空对，队列特点：后进后出

class List(object):
    def __init__(self):
        self.list = []
    def enqueue(self,value):
        self.list.append(value)
        print('%s成功进入队列' %(value))
    def dequeue(self):
        if not self.is_empty():
            b = self.list.pop(0)
            print('%s元素删除成功' %(b))
        else:
            raise Exception('队列为空')
    def is_empty(self):
        return len(self.list) == 0
    def first(self):
        if not self.is_empty():
            print(self.list[0])
        else:
            raise Exception('队列为空，无法获取第一个元素')
    def num(self):
        print(len(self.list))
    def ls(self):
        print(self.list)
if __name__ == '__main__':
    l = List()
    l.enqueue(5)
    l.enqueue(3)
    print(l.is_empty())
    l.first()
    l.num()
    l.dequeue()
    l.ls()

二分搜索算法
在计算机科学中，二分搜索（英语：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)) # 最后返回的是搜素元素在该列表的索引值