python语言是面向对象的编程_python学习之面向对象编程---类

待我称王封你为后i 2022-11-05 14:57 272阅读 0赞

python学习之面向对象编程---类

发布时间：2020-08-29 14:31:24

来源：51CTO

阅读：67

作者：霍金181

面向过程编程:

特性:

模块化 流程化

优点:

性能比面向对象高, 因为类调用时需要实例化,开销比较大,比较消耗资源;

单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发,性能是最重要的因素。

缺点:

没有面向对象易维护、易复用、易扩展

函数式编程:

函数式编程是种编程方式,它将电脑运算视为函数的计算。函数编程语言最重要的基础是λ

演算(lambda calculus),而且λ演算的函数可以接受函数当作输入(参数)和输出(返回值)。

主要思想: 把运算过程尽量写成一系列嵌套的函数调用。

面向对象编程

面向对象是按人们认识客观世界的系统思维方式,把构成问题事务分解成各个对象,建立对

象的目的不是为了完成一个步骤,而是为了描叙某个事物在整个解决问题的步骤中的行为

面向对象编程

特性: 抽象 封装 继承 多态

优点: 易维护、易复用、易扩展,由于面向对象有封装、继承、多态性的特性,

可以设计出低耦合 的系统,使系统更加灵活、更加易于维护

缺点:

性能比面向过程低

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) 是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概

念。

对象和类

如何定义类?

class 类(): pass

如何将类转换成对象?

实例化 是指在面向对象的编程中,把用类创建对象的过程称为实例化。是将一个抽象的概

念类,具体到该类实物的过程。实例化过程中一般由类名 对象名 = 类名(参数1,参数2...参数n)

构成。

对象和类

类(Class) 是是创建实例的模板

对象(Object) 是一个一个具体的实例

02\_类的定义.py

\#class 类名称: 定义类的方式

class Person:

\#占位关键字， 什么也不做

pass

print(Person) \# 存储于当前脚本的Person类

\#对象：将类实例化/具体化产生的值

personObj = Person()

\#<\_\_main\_\_.person object at>

\#当前脚本的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')"""

继承特性

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

继承

多继承

私有属性与私有方法

继承描述的是事物之间的所属关系,当我们定义一个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类型),即所有的类都是“新式类”。

最明显的区别在于继承搜索的顺序不同,即:

经典类多继承搜索顺序(深度优先算法):先深入继承树左侧查找,然后再返回,开始查找右侧。

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

![9b117925a9cecdd6289fade074bf4aa8.png][]

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)。

![301b2ca2ca4c6fc226cfec6cab2b0c76.png][]

队列的封装

队列是限制在一端进行插入操作和另一端删除操作的线性表,允许进行插入操作的一端称为“队尾”,

允许进行删除操作的一端称为“队头”,,当队列中没有元素时称为“空队”。特点 :先进先出(FIFO)

![2211d6b36ffdde0343a7e87109baf7f7.png][]

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' % (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)

[9b117925a9cecdd6289fade074bf4aa8.png]: /images/20221023/a18a34d5ad5c439ebc98e0d7f95994a2.png
[301b2ca2ca4c6fc226cfec6cab2b0c76.png]: /images/20221023/699d70a032434e189928db09898175ce.png
[2211d6b36ffdde0343a7e87109baf7f7.png]: /images/20221023/7afcbf8041184a7c97be833bf23513e6.png