Python面向对象编程三大特性
面向对象编程三大特性
-
- 一.对象和类
- 二.面向对象三大特性：
- 1.封装特性
- 2.继承特性
- 3.多态特性
- 三.项目案例：栈与队列的封装
一.对象和类
类（Class）是现实或思维世界中的实体在计算机中的反映，它将数据以及这些数据上的操作封装在一起。是是创建实例的模板
对象（Object）是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概念。是一个一个具体的实例。
实例化（instance）是指在面向对象的编程中，把用类创建对象的过程称为实例化。是将一个抽象的概念类，具体到该类实物的过程。实例化过程中一般由类名 对象名 = 类名（参数1，参数2…参数n）构成。
类:鱼.
对象:?三文鱼.
实例化(instance):三文鱼?和剁椒配一起做一道小菜
二.面向对象三大特性：
1.封装特性
封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。
所以，在使用面向对象的封装特性时，需要：
1). 将内容封装到某处
2). 从某处调用被封装的内容
-
通过对象直接调用被封装的内容：对象.属性名
-
通过self间接调用被封装的内容：self.属性名
-
通过self间接调用被封装的内容：self.方法名()
（构造方法：__init__与其他普通方法不同的地方在于，当一个对象被创建后，会立即调用构造方法。自动执行构造方法里面的内容。）
封装特性：对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容。
Exercise
'''
创建一个类People,拥有的属性为姓名,性别和年龄,拥有的方法为购物,玩游戏,学习;实例化对象,执行相应的方法。 显示如下:
小明,18岁,男,去西安赛格购物广场购物
小王,22岁,男,去西安赛格购物广场购物
小红,10岁,女,在西部开源学习
提示:
属性:name,age,gender
方法:shopping(), playGame(), learning()
'''
class People(object):
def __init__(self,name,gender,age):
self.name=name
self.gender=gender
self.age=age
def shopping(self):
print('%s,%s,%s,去西安赛格购物广场购物' % (self.name,self.gender,self.age))
def playGame(self):
print('玩王者荣耀')
def learning(self):
print('%s,%s,%s,在西部开源学习' % (self.name,self.gender,self.age))
p1=People('小明','男',18)
p2=People('小王','男',22)
p3=People('小红','女',10)
p1.shopping()
p2.shopping()
p3.learning()
--------------------------------------------------------------------------------
小明,男,18,去西安赛格购物广场购物
小王,男,22,去西安赛格购物广场购物
小红,女,10,在西部开源学习
2.继承特性
- 继承
- 多继承
- 私有属性与私有方法
继承描述的是事物之间的所属关系,当我们定义一个class的时候,可以从某个现有的class
继承,新的class称为子类、扩展类(Subclass),而被继承的class称为基类、父类或超类(Baseclass、Superclass)。
问题一: 如何实现继承?
子类在继承的时候,在定义类时,小括号()中为父类的名字
问题二: 继承的工作机制是什么?
父类的属性、方法,会继承给子类。
举例: 如果子类没有定义__init__方法,父类有,那么在子类继承父类的时候这个方法就被继承了,所以只要创建对象,就默认执行了那个继承过来的__init__方法。
Exercise
# 定义类的过程
# Father: 父类/基类
class Father(object):
goal = "先挣它1个亿"
# 如果类里面的方法以双下划线开头/结尾, 魔术方法;
def __init__(self, name, age, money):
# 封装
self.name = name
self.age = age
self.money = money
def eat(self):
print("%s正在吃大餐" %(self.name))
# Son: 子类/扩展类
# 代表Son类的父类为Father;
class Son(Father):
# Son没有构造方法, 父类Father有， 自动调用父类的构造方法;
#重写父类方法: 就是子类中,有一个和父类相同名字的方法,在子类中的方法会覆盖掉父类中同名的方法。
goal = "先挣它10个亿"
def eat(self):
#调用父类的方法一:
#Father.eat(self)
#调用父类的方法二(建议): 获取Son对应的父类,并执行该父类的eat方法,再执行自己的eat方法
super(Son, self).eat()
print("%s正在吃xxxxxx" %(self.name))
# 实例化的过程: 通过类创建对象的过程
wjl = Father("王健林", 68, 1000000000000)
wsc = Son("王思聪", 35, 600000000)
#print(wjl.money)
#print(wsc.money)
wsc.eat()
wjl.eat()
print(wjl.goal)
print(wsc.goal)
--------------------------------------------------------------------------------
王思聪正在吃大餐
王思聪正在吃xxxxxx
王健林正在吃大餐
先挣它1个亿
先挣它10个亿
多继承,即子类有多个父类,并且具有它们的特征。
在Python 2及以前的版本中，由任意内置类型派生出的类，都属于“新式类”，都会获得所有“新式类”的特性；反之，即不由任意内置类型派生出的类，则称之为“经典类”。
在Python 3.x之后的版本，因为所有的类都派生自内置类型object(即使没有显示的继承object类型)，即所有的类都是“新式类”。
两者最明显的区别在于继承搜索的顺序不同，即：
经典类多继承搜索顺序(深度优先算法):先深入继承树左侧查找，然后再返回，开始查找右侧。
新式类多继承搜索顺序(广度优先算法):先在水平方向查找，然后再向上查找。
#python3中都是新式类
#广度优先
A --> B --> C --> D
"""
class D(object):
def test(self):
print('test in D.....')
class B(D):
pass
class C(D):
def test(self):
print('test in C.....')
class A(B,C):
pass
#先继承B，若B也没有 继承C
a=A()
a.test()
----------------------------------------------------------------------------
test in C.....
私有属性与私有方法：在 Python 中,实例的变量名如果以 __ 开头,就变成了一个私有变量/属性(private),实例的函数名如果以 __ 开头,就变成了一个私有函数/方法(private)只有内部可以访问,外部不能访问。
若要从外部访问私有属性，可以通过 _类名__属性名 来访问 __属性名。
私有属性与私有方法的优势：
- 确保了外部代码不能随意修改对象内部的状态,这样通过访问限制的保护,代码更加健壮。
- 如果又要允许外部代码修改属性怎么办?可以给类增加专门设置属性方法
#私有属性和私有方法只能在类的内部调用
class Student(object):
#构造方法：魔术方法（创建对象时会自动执行）
def __init__(self,name,age):
self.name=name
self.__age=age ##私有属性：原有的属性名前面添加下划线
#私有方法
def __get_info(self):
print("%s 's age is %s" % (self.name, self.__age))
def get_age(self):
print('年龄仍然是%s' % (self.__age))
#如何正确修改私有属性：可以给类增加专门设置属性方法。
def set_age(self,age):
if 0<age<150:
self.__age = age
print("修改年龄为%s成功" % (age))
else:
raise Exception("年龄超出范围")
student1=Student("小明",10)
#1.如何访问私有属性和私有方法
#私有属性和私有方法把__属性名/方法名改为_类名__属性名
print(student1.name)
#print(student1.__age)##类的外部无法调用私有属性
#student1.__get_info()##类的外部无法调用私有方法
print(student1._Student__age)
student1._Student__get_info()
'''
私有属性/方法的好处在于：不能在外部随意修改参数
'''
#修改私有属性/私有方法是否成功
student1.__age=100#即使在这里修改 类里面的参数值其实并没有被修改
#print(student1.__age)
student1.get_age()
#如果又要允许外部代码修改属性怎么办？可以给类增加专门设置属性方法。
# 为什么大费周折？因为在方法中，可以对参数做检查，避免传入无效参数。
student1.set_age(120)
3.多态特性
多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。通俗来说： 同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
#多态：同一个操作作用于不同的对象，可以有不同的解释，产生不同的执行结果
class Student(object):
def get_score(self):
print("获取学生的成绩")
class MathStudent(object):
def get_score(self):
print("获取数学系学生的成绩")
class EnglishStudent(object):
def get_score(self):
print("获取英语系学生的成绩")
student1=Student()
student2=MathStudent()
student3=EnglishStudent()
student1.get_score()
student2.get_score()
student3.get_score()
三.项目案例：栈与队列的封装
1.栈
栈是限制在一端进行插入操作和删除操作的线性表（俗称堆栈），允许进行操作的一端称为“栈顶”，
另一固定端称为“栈底”，当栈中没有元素时称为“空栈”。向一个栈内插入元素称为是进栈，push；
从一个栈删除元素称为是出栈，pop。特点 ：后进先出（LIFO）
"""
栈的封装
"""
# self是对象 Stack是类名，对象来调用方法。 self.Stack是个列表，所以可以增加或者删除。
class Stack(object):
"""
FILO stack:使用python中的列表进行封装的栈
"""
def __init__(self):
# 创建一个空栈
self.stack = []
# 魔术方法__len__:求栈的长度
def __len__(self):
return len(self.stack)
def top(self):
# [1,2,3,4,5]
# 获取栈顶元素
if not self.is_empty():
return self.stack[-1]
raise Exception('栈为空') # return后可以写else也可以省略，因为return就代表返回 后面的东西不再执行。
def bottom(self):
# 获取栈底元素
if not self.is_empty():
return self.stack[0]
raise Exception('栈为空')
def is_empty(self):
# 判断栈是否为空,返回的是布尔值
return len(self.stack) == 0
def push(self, element):
'''
:param elemant: 入栈元素
:return:
'''
self.stack.append(element)
def pop(self):
# 出栈元素
if self.is_empty():
raise Exception('栈为空')
else:
# pop函数的返回值就是删除的元素内容
item = self.stack.pop()
return item
# 1.实例化：类--->对象
stack = Stack()
# 2.入栈两次
stack.push(1)
stack.push(2)
# 3.查看栈的长度
# print(stack.__len__())魔术方法可以简略写成下面的形式
print(len(stack))
# 4.出栈一次 item在这里是局部变量，因此不能在函数外部进行访问。解决方法有二：1.变为全局变量 2.在外部重新返回一次，再打印
item=stack.pop()
print("出栈元素为%s" % (item))
#5.查看栈顶元素和栈底元素
print(stack.top())
print(stack.bottom())
#6.判断栈是否为空
print(stack.is_empty())
stack.pop()
print(stack.is_empty())
#7.如果栈为空，出栈就会报错
stack.pop()
2.队列
队列是限制在一端进行插入操作和另一端删除操作的线性表，允许进行插入操作的一端称为“队尾”，允许进行删除操作的一端称为“队头”，，当队列中没有元素时称为“空队”。特点 ：先进先出（FIFO）。
#队列的封装
class Queue(object):
"""
通过列表封装队列
"""
def __init__(self):
self.queue = [] # 默认产生一个空队列 [1,2,3,4,5] 此时认为1是队头 5是队尾
# 入队操作 ，在队尾里面添加
def enqueue(self, item):
self.queue.append(item)
# 出队操作
def dequeue(self):
if not self.is_empty():
item = self.queue.pop(0) # 若队不为空，将队头元素删除.用不用写else?
return item
# 获取队头元素
def first(self):
if not self.is_empty():
return self.queue[0]
# 获取队尾元素
def last(self):
if not self.is_empty():
return self.queue[-1]
# 获取队列的长度
def __len__(self):
return len(self.queue)
# 判断队列是否为空,对象可以调用方法
def is_empty(self):
return len(self.queue) == 0
def show(self):
print("队列元素：", self.queue)
# 首先判断一下当你不是被别人导入时执行这个代码。就是以上代码可不可以被打包让别人使用
if __name__ == '__main__':
queue = Queue() # 首先实例化一个队列
# 1.先执行三次入队操作
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
queue.show() # 显示队中的三个元素
print(queue.is_empty())
print(len(queue)) # 注意在使用魔术方法时的这种写法
#实现两次的出队操作
queue.dequeue()
queue.dequeue()
queue.show() # 显示队中元素
print(queue.is_empty())
print(len(queue))
#队头与队尾的查看
print(queue.first())
print(queue.last())
------------------------------------------------------------------------
队列元素： [1, 2, 3]
False
3
队列元素： [3]
False
1
3
3
```