python面向对象特性的介绍-创新互联

面向对象编程

面向对象(Object Oriented,OO)是当前计算机界关心的重点，它是90年代软件开发方法的主流。面向对象的概念和应用已超越了程序设计和软件开发，扩展到很宽的范围。如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。

延津ssl适用于网站、小程序/APP、API接口等需要进行数据传输应用场景，ssl证书未来市场广阔！成为创新互联的ssl证书销售渠道，可以享受市场价格4-6折优惠！如果有意向欢迎电话联系或者加微信：028-86922220（备注：SSL证书合作）期待与您的合作！

特性:

(1)对象唯一性

每个对象都有自身唯一的标识，通过这种标识，可找到相应的对象。在对象的整个生命期中，它的标识都不改变，不同的对象不能有相同的标识。

(2)分类性

分类性是指将具有一致的数据结构(属性)和行为(操作)的对象抽象成类。一个类就是这样一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容。任何类的划分都是主观的，但必须与具体的应用有关。

(3)继承性

继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。

继承性是面向对象程序设计语言不同于其它语言的最重要的特点，是其他语言所没有的。

在类层次中，子类只继承一个父类的数据结构和方法，则称为单重继承。

在类层次中，子类继承了多个父类的数据结构和方法，则称为多重继承。

在软件开发中，类的继承性使所建立的软件具有开放性、可扩充性，这是信息组织与分类的行之有效的方法，它简化了对象、类的创建工作量，增加了代码的可重性。

采用继承性，提供了类的规范的等级结构。通过类的继承关系，使公共的特性能够共享，提高了软件的重用性。

(4)多态性(多形性)

多态性是指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。

多态性允许每个对象以适合自身的方式去响应共同的消息。

多态性增强了软件的灵活性和重用性。

优点: 易维护、易复用、易扩展,由于面向对象有封装、继承、多态性的特性,
可以设计出低耦合 的系统,使系统更加灵活、更加易于维护
缺点:
性能比面向过程低

01_面向对象理解.py

class Student(object):
   """封装学生类"""
   def __init__(self, sid, name, score1, score2):
     """封装了学生属性信息"""
     self.sid = sid
     self.name = name
     self.score1 = score1
     self.score2 = score2

   def show(self):
     pass

   def compute_sum_score(self):
     return self.score1 + self.score2

   def compute_avg_score(self):
     return  (self.score1 + self.score2)/2

stu1 = Student(sid='001', name='张三', score1=100, score2=90)
print(stu1.compute_sum_score())
stu2 = Student(sid='002', name='张三', score1=100, score2=100)
print(stu2.compute_avg_score())"""

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

1. 如何定义类?
   class 类(): pass
2. 如何将类转换成对象?
   实例化 是指在面向对象的编程中,把用类创建对象的过程称为实例化。是将一个抽象的概
   念类,具体到该类实物的过程。实例化过程中一般由类名 对象名 = 类名(参数1,参数2...参数n)
   构成。
   对象和类
   类(Class) 是是创建实例的模板
   对象(Object) 是一个一个具体的实例

   02_类的定义.py

#class 类名称:   定义类的方式
class Person:
   #占位关键字， 什么也不做
   pass
print(Person)    #  存储于当前脚本的Person类

#对象：将类实例化/具体化产生的值
personObj = Person()
#<__main__.Person object at 0x7f28164b04d0>
#当前脚本的Person类实例化出来的对象存储的内存地址是0x7f28164b04d0
print(personObj)

#Python自带的类
from datetime import  datetime
from datetime import date
from collections import  defaultdict

03_构造方法的理解.py

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

print(Student)    # 
#实例化产生对象的过程
stu1 = Student()
print("stu1: ", stu1)

封装特性
面向对象的三大特性是指:封装、继承和多态
封装,顾名思义就是将内容封装到某个地方,以后再去调用被封装在某处的内容。
所以,在使用面向对象的封装特性时,需要:
1). 将内容封装到某处
2). 从某处调用被封装的内容
1). 通过对象直接调用被封装的内容: 对象.属性名
2). 通过self间接调用被封装的内容: self.属性名
3). 通过self间接调用被封装的内容:
self.方法名()
构造方法init与其他普通方法不同的地方在于,当一个对象被创建后,会立即调
用构造方法。自动执行构造方法里面的内容。
对于面向对象的封装来说,其实就是使用构造方法将内容封装到 对象 中,然后通过
对象直接或者self间接获取被封装的内容

04_如何实现数据的封装.py

class Student:
   def __init__(self, name, score1, score2):
     # 将对象和属性封装在一起
     self.name = name
     self.score1 = score1
     self.score2 = score2
     #print("self.name: ", self.name)

   def compute_sum_score(self):
     #获取封装的属性信息方法一: ， 通过对象名.属性名的方式获取。
     return  self.score1 + self.score2

stu1 = Student(name="张三", score1=100, score2=100)

#获取封装的属性信息方法二: ， 通过对象名.属性名的方式获取。
print("学生姓名: ",  stu1.name)
sum_scores = stu1.compute_sum_score()
print("总分数: ", sum_scores)

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

05_封装练习题目.py

class People:
   print("正在创建类对象..........")
   def __init__(self, name, age, gender):
     self.name = name
     self.age = age
     self.gender = gender

   def shopping(self):
     print("%s,%d岁,%s,去西安赛格购物广场购物" %(self.name, self.age, self.gender))
   def playGame(self):
     pass
   def learning(self):
     pass

#当定义类的时候， 类内容是否会执行?  会执行
#stu1 = People('xx', 10, 'xxx')"""

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

1. 继承
2. 多继承
3. 私有属性与私有方法
   继承描述的是事物之间的所属关系,当我们定义一个class的时候,可以从某个现有的class
   继承,新的class称为子类、扩展类(Subclass),而被继承的class称为基类、父类或超类(Baseclass、
   Superclass)
   重写父类方法: 就是子类中,有一个和父类相同名字的方法,在子类中的方法
   会覆盖掉父类中同名的方法。

   06_单继承特性.py

问题一: 如何让实现继承?
     子类在继承的时候,在定义类时,小括号()中为父类的名字

问题二: 继承的工作机制是什么?
   父类的属性、方法,会被继承给子类。
   举例如下:
     如果子类没有定义__init__方法,父类有,那么在子类继承父类的时候这个方法就被继承了,
     所以只要创建对象,就默认执行了那个继承过来的__init__方法
#在Python代码中，没有指定父类， 默认继承object类。
#父类: object  子类: Student
class Student(object):
   def __init__(self, name, age, gender):
     self.name = name
     self.age = age
     self.gender = gender
   def learn(self):
     print("%s正在学习编程......." %(self.name))

#父类: Student  子类: MathStudent
class MathStudent(Student):
   # 重写父类的learn方法
   #重写父类方法: 就是子类中,有一个和父类相同名字的方法,在子类中的方法会覆盖掉父类中同名的方法。
   def learn(self):
     # 方法一: 调用父类的方法
     #Student.learn(self)
     #方法二: 调用父类的方法, 自动帮当前类寻找父类的名称
     super(MathStudent, self).learn()
     print("%s正在学习英语四级....." %(self.name))

#父类: Student  子类: EnglishStudent
class EnglishStudent(Student):
   pass

s1 = Student("粉条", 10, 'male')
print(s1.name)
#当实例化对象， 子类没有构造方法， 自动调用并执行父类的构造方法。
s2 = MathStudent("拉格朗日", 100, 'male')
#当子类调用的方法没有的时候， 自动去父类里面寻找并执行。
s2.learn()

07_单继承特性.py

问题一: 如何让实现继承?
     子类在继承的时候,在定义类时,小括号()中为父类的名字

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

#在Python代码中，没有指定父类， 默认继承object类。
#父类: object  子类: Student
class Student(object):
   def __init__(self, name, age, gender):
     self.name = name
     self.age = age
     self.gender = gender
   def learn(self):
     print("%s正在学习编程......." %(self.name))

#父类: Student  子类: MathStudent
class MathStudent(Student):
   pass

#父类: Student  子类: EnglishStudent
class EnglishStudent(Student):
   pass

s1 = Student("粉条", 10, 'male')
print(s1.name)
#当实例化对象， 子类没有构造方法， 自动调用并执行父类的构造方法。
s2 = MathStudent("拉格朗日", 100, 'male')
#当子类调用的方法没有的时候， 自动去父类里面寻找并执行。
s2.learn()

默认情况下,属性在 Python 中都是“public”, 大多数 OO 语言提供“访问控
制符”来限定成员函数的访问。
在 Python 中,实例的变量名如果以 开头,就变成了一个私有变量/属性
(private),实例的函数名如果以 开头,就变成了一个私有函数/方法(private)只
有内部可以访问,外部不能访问。

08_私有属性和私有方法.py

#私有属性和私有方法：

class Student(object):

   需求： 学生成绩保密， 外部不可以访问分数， 只可以访问分数的等级

   def __init__(self, name, age, score):
     self.name = name
     self.age = age
     #self.__score是私有属性， 只能在类的内部访问， 类的外部不可以访问。
     self.__score = score

   #__get_level是私有方法，只能在类的内部访问， 类的外部不可以访问。
   def __get_level(self):
     if 90 <= self.__score <= 100:
       return "优秀"
     elif 80 <= self.__score < 90:
       return "良好"
     elif 60 <= self.__score < 80:
       return "及格"
     else:
       return "不及格"

stu1 = Student("粉条", 10, 59)
#print(stu1.__score)                # 调用私有属性失败
#print("学生分数的等级: ", stu1.__get_level())     # 调用私有方法失败

#Python解释器自动将私有属性和私有方法重命名了， 命名方式一般是_类名__属性名、_类名__方法名
print(stu1._Student__score)
print(stu1._Student__get_level())

在Python 2及以前的版本中,由任意内置类型派生出的类,都属于“新式
类”,都会获得所有“新式类”的特性;反之,即不由任意内置类型派生出的类,
则称之为“经典类
“新式类”和“经典类”的区分在Python 3之后就已经不存在,在Python 3.x
之后的版本,因为所有的类都派生自内置类型object(即使没有显示的继承
object类型),即所有的类都是“新式类”。
最明显的区别在于继承搜索的顺序不同,即:
经典类多继承搜索顺序(深度优先算法):先深入继承树左侧查找,然后再返回,开始查找右侧。
新式类多继承搜索顺序(广度优先算法):先在水平方向查找,然后再向上查找,

09_多继承.py

class TeacherMajor(object):
   def __init__(self, students_count):
     self.student_count = students_count

class DoctorMajor(object):
   def __init__(self, patients_count):
     self.patients_count = patients_count

#子类Student拥有2个父类TeacherMajor和DoctorMajor
class Student(TeacherMajor, DoctorMajor):
   def __init__(self, name, students_count, patients_count):
     self.name = name
     TeacherMajor.__init__(self, students_count)
     DoctorMajor.__init__(self, patients_count)

##继承的顺序如何查看?
#print(Student.__mro__)
stu1 = Student("粉条", 0, 0)
print(stu1.patients_count)
print(stu1.student_count)

#coding:utf-8
#注意： Python2环境中做实验
#类D新式类.
class D(object):
   def hello(self):
     print("D...... hello")
class C(D):
   def hello(self):
     print("C...... hello")
class B(D):
   pass
class A(B, C):
   pass

#新式类多继承搜索顺序(广度优先算法):先在水平方向查找,然后再向上查找,
a = A()
a.hello()
#C...... hello

#coding:utf-8
#注意： Python2环境中做实验
#类D经典类.
class D:
   def hello(self):
     print("D...... hello")
class C(D):
   def hello(self):
     print("C...... hello")
class B(D):
   pass
class A(B, C):
   pass
#经典类多继承搜索顺序(深度优先算法):先深入继承树左侧查找,然后再返回,开始查找右侧。
a = A()
a.hello()
#D...... hello

多态特性
多态的好处就是,当我们需要传入更多的子类,只需要继承父类就可以了,而方法既可以直接
不重写(即使用父类的),也可以重写一个特有的。这就是多态的意思。调用方只管调用,不管
细节,而当我们新增一种的子类时,只要确保新方法编写正确,而不用管原来的代码。这就是著
名的“开闭”原则:
对扩展开放(Open for extension):允许子类重写方法函数
对修改封闭(Closed for modification):不重写,直接继承父类方法函数
栈的封装
栈是限制在一端进行插入操作和删除操作的线性表(俗称堆栈),允许进行操作的一端称为“栈顶”,
另一固定端称为“栈底”,当栈中没有元素时称为“空栈”。向一个栈内插入元素称为是进栈,push;
从一个栈删除元素称为是出栈,pop。特点 :后进先出(LIFO)。

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

12_stack.py

class Stack(object):
   """
   根据列表的数据结构封装栈的数据结构
   属性: 栈元素stack
   方法:
     get_top()
     get_bootom()
     push()
     pop()
   """
   def __init__(self):
     self.stack = [] # [1, 2, 3]

   def top(self):
     return self.stack[-1]

   def bootom(self):
     return self.stack[0]

   def push(self, item):
     """
     :param item: 入栈元素
     :return:
     """
     self.stack.append(item)
     return True

   def pop(self):
     item = self.stack.pop()
     return item

   def show(self):
     return self.stack

   #魔术方法, 使得代码运行更加简洁
   def __len__(self):
     return len(self.stack)

if __name__ == '__main__':
   stack = Stack()
   print(stack.show())
   #print(stack.top())
   #stack.push(1)
   #stack.push(2)
   #stack.push(3)
   #print("入栈后: ", stack.show())
   #item = stack.pop()
   #print("出栈元素为: ", item)
   #print("出栈后: ", stack.show())
   #print('栈元素个数: ', stack.__len__())
   print('栈元素个数: ', len(stack))

13_二叉树节点的封装.py

class Node(object):
   def __init__(self, data, lchild=None, rchild=None):
     self.data = data
     self.lchild = lchild
     self.rchild = rchild

   #魔术方法: len(), __len__. str(), __str__
   def __str__(self):  # 友好的字符串显示信息
     return 'Node<%s>' % (self.data)

def pre_view( root):
   """
   先序遍历: 根节点-左子树节点-右子树节点
   传递根节点
   :param root:
   :return:
   """
   if root == None:
     return
   print(root.data)
   pre_view(root.lchild)
   pre_view(root.rchild)
def last_view(root):
   """
   后序遍历: -左子树节点-右子树节点-根节点
   传递根节点
   :param root:
   :return:
   """
   if root == None:
     return
   last_view(root.lchild)
   last_view(root.rchild)
   print(root.data)

def mid_view(root):
   """
   中序遍历: -左子树节点--根节点-右子树节点
   传递根节点
   :param root:
   :return:
   """
   if root == None:
     return
   mid_view(root.lchild)
   print(root.data)
   mid_view(root.rchild)

if __name__ == '__main__':
   D = Node('D')
   B = Node('B', D)
   C = Node('C')
   A = Node('A', B, C)
   #print("A-left: ", str(A.lchild))
   #print("A-right: ", str(A.rchild))

   #先序遍历(根左右)、中序遍历(左根右)、后序遍历(左右根)
   print("先序遍历:")
   pre_view(A)
   print("后序遍历:")
   last_view(A)
   print("中序遍历:")
   mid_view(A)

另外有需要云服务器可以了解下创新互联cdcxhl.cn，海内外云服务器15元起步，三天无理由+7*72小时售后在线，公司持有idc许可证，提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案，具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势，专为企业上云打造定制，能够满足用户丰富、多元化的应用场景需求。

新闻标题：python面向对象特性的介绍-创新互联
本文URL：http://www.cdkjz.cn/article/ccpgih.html