python基本语法（面向对象编程、三大特性）

最新推荐文章于 2020-11-27 19:25:56 发布

徐一435

最新推荐文章于 2020-11-27 19:25:56 发布

阅读量230

点赞数 1

分类专栏： python 文章标签： python linux 运维多态

本文链接：https://blog.csdn.net/weixin_46268244/article/details/107668343

版权

python 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

一、面向对象编程

1.面向过程编程

【1】概念
“面向过程”(Procedure Oriented)是一种以过程为中心的编程思想。分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。
【2】特性
模块化、流程化
【3】优点
性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源；单片机、嵌入式开发、liinux/unix等一般采用面向过程开发，性能是最重要的因素。
【4】缺点
没有面向对象易维护、易复用、易扩展

2.函数式编程

函数式编程是种编程方式，它将电脑运算视为函数的计算。函数编程语言最重要的基础是λ 演算（lambda calculus），而且λ演算的函数可以接受函数当作输入（参数）和输出（返回值）。

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

3.面向对象编程

【1】概念
面向对象是按人们认识客观世界的系统思维方式，把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
【2】特性
抽象、封装、继承、多态
【3】优点
易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护
【3】缺点
性能比面向过程低

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

对象和类

【1】概念

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

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

【3】举例

如何定义类：

  
  #1. 如何定义类(新式类和经典类在py2和py3中不同)
class People:
    pass

print(People)
print(type(People))

在这里插入图片描述
在当前文件夹中，由一个类名为People：

如何通过类实例化创建对象：

#1. 如何定义类(新式类和经典类在py2和py3中不同)
class People:
    pass

#2. 如何通过类实例化创建对象
p = People()
print(p)

在这里插入图片描述
在当前脚本中有一个People 类，该类实例化出的对象存在于0x7f4ec2f8d3c8

类的三大特性

指封装、继承、和多态

1.封装

【1】将内容封装到某个地方，以后再去调用被封装在某处的内容。
所以，在使用面向对象的封装特性时，需要：

1）将内容封装到某处
2）从某处调用被封装的内容
- 1）通过对象直接调用被封装的内容：对象.属性名
- 2）通过self间接调用被封装的内容：self.属性名
- 3）通过self间接调用被封装的内容：self.方法名()

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

对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容。
一般情况下，只有调用才会执行，但是此函数会直接执行
【3】举例
如何通过类实例化创建对象：

#1. 如何定义类(新式类和经典类在py2和py3中不同)
class People:
    def __init__(self):
        print("正在执行构造方法init,在实例化对象时自动执行")

#2. 如何通过类实例化创建对象
p = People()
print(p)

在这里插入图片描述

把对象和对象的属性信息封装起来：
self是实例化对象本身，在python解释器中，会自动将对象作为第一个参数传递过来给self

#1. 如何定义类(新式类和经典类在py2和py3中不同)
class People:
    def __init__(self, name, age):
        # 把对象和对象的属性信息封装起来
        self.name = name
        self.age = age
        # self是实例化对象本身，在python解释器中，会自动将对象作为第一个参数传递过来给self
        print ("self:", self)
        print("正在执行构造方法init,在实例化对象时自动执行")

#2. 如何通过类实例化创建对象
p = People("小名", 18)
print("名称:", p.name)
print("年龄:", p.age)

在这里插入图片描述

如何获取封装属性的信息？

#1. 如何定义类(新式类和经典类在py2和py3中不同)
class People:
    def __init__(self, name, age):
        # 3-1)把对象和对象的属性信息封装起来
        self.name = name
        self.age = age
        # self是实例化对象本身，在python解释器中，会自动将对象作为第一个参数传递过来给self
        print ("self:", self)
        print("正在执行构造方法init,在实例化对象时自动执行")
    #在类里面的函数不叫函数，叫方法
    def get_name(self):
        print ("正在获取封装的数据，姓名: ", self.name)

#2. 如何通过类实例化创建对象
p = People("小名", 18)
# 3-2) 如何获取封装属性的信息？
print("p: ", p)
print("名称: ", p.name)
print("年龄: ", p.age)
p.get_name()
p1 = People("xiaoli", 30)
print("名称: ", p1.name)
print("年龄: ", p1.age)

在这里插入图片描述

2.继承特性

【1】继承描述的是事物之间的所属关系，当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类、扩展类（Subclass），而被继承的clas称为基类、父类或超类（Baseclass、Superclass）
1.继承
2.多继承
3.私有属性与私有方法
【2】实现继承的方法
子类在继承的时候，在定由义类时，小括号( )中为父类的名字。
【3】继承的工作机制
父类的属性、方法，会被继承给子类。例如：如果子类没有定义__init__方法，父类有，那么子类继承父类的时候这个方法就被继承了，所以只要创建对象，就默认执行科那个继承过来的__init__方法。
【4】举例

Mathstudent作为子类，继承于Student.

# 父类（基类）->子类（扩展类）

# Student作为父类
class Student(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def exam(self):
        print("%s Examing......" %(self.name))

# Mathstudent作为子类，继承于Student.
class Mathstudent(Student):
    pass

# 实例化对象时，先判断类是否有构造方法，如果没有，判断父类是否有构造犯法.
m1 = Mathstudent("张三", 20)
print(m1)
print(m1.name, m1.age)
m1.exam()

在这里插入图片描述

执行exam方法时，如果子类有exam方法，优先执行子类的exam方法

# 父类（基类）->子类（扩展类）

# Student作为父类
class Student(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def exam(self):
        print("%s Examing......" %(self.name))

# Mathstudent作为子类，继承于Student.
class Mathstudent(Student):
    def exam(self):
        print("数学系的%s正在考试......" %(self.name))

# 实例化对象时，先判断类是否有构造方法，如果没有，判断父类是否有构造犯法.
m1 = Mathstudent("张三", 20)
print(m1)
print(m1.name, m1.age)
# 执行exam方法时，如果子类有exam方法，优先执行子类的exam方法
m1.exam()

在这里插入图片描述

在这里插入图片描述
重写父类方法：就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法。
【5】调用父类的方法

父类名.父类的方法名()
super():py2.2+的功能

方法一

# 父类（基类）->子类（扩展类）

# Student作为父类
class Student(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def exam(self):
        print("%s Examing......" %(self.name))

# Mathstudent作为子类，继承于Student.
class Mathstudent(Student):
    def exam(self):
    	#如何快速调用父类的方法并执行
        Student.exam(self)
        print("数学系的%s正在考试......" %(self.name))

# 实例化对象时，先判断类是否有构造方法，如果没有，判断父类是否有构造犯法.
m1 = Mathstudent("张三", 20)
print(m1)
print(m1.name, m1.age)
# 执行exam方法时，如果子类有exam方法，优先执行子类的exam方法
m1.exam()

在这里插入图片描述

方法二（该方法很重要）
先找到当前类的父类，在调用父类的方法

# 父类（基类）->子类（扩展类）

# Student作为父类
class Student(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def exam(self):
        print("%s Examing......" %(self.name))

# Mathstudent作为子类，继承于Student.
class Mathstudent(Student):
    def exam(self):
    	#先找到当前类的父类，在调用父类的方法
        super(Mathstudent, self).exam()
        print("数学系的%s正在考试......" %(self.name))

# 实例化对象时，先判断类是否有构造方法，如果没有，判断父类是否有构造犯法.
m1 = Mathstudent("张三", 20)
print(m1)
print(m1.name, m1.age)
# 执行exam方法时，如果子类有exam方法，优先执行子类的exam方法
m1.exam()

在这里插入图片描述

【5】多继承

多继承,即子类有多个父类,并且具有它们的特征
在Python 2及以前的版本中，由任意内置类型派生出的类，都属于“新式类”，都会获得所有“新式类”的特性；反之，即不由任意内置类型派生出的类，则称之为“经典类”。

1.新式类
class 类名(object): 
	pass

2.经典类
class 类名:
	pass

“新式类”和“经典类”的区分在Python 3之后就已经不存在，在Python 3.x 之后的版本，因为所有的类都派生自内置类型object(即使没有显示的继承 object类型)，即所有的类都是“新式类”。
最明显的区别在于继承搜索的顺序不同，即：
经典类多继承搜索顺序(深度优先算法):先深入继承树左侧查找，然后再返回，开始查找右侧。新式类多继承搜索顺序(广度优先算法):先在水平方向查找，然后再向上查找。（该结论面试经常问）

【6】私有属性与私有方法

默认情况下,属性在 Python 中都是“public”，大多数 OO 语言提供“访问控制符”来限定成员函数的访问。
在 Python 中,实例的变量名如果以 __ 开头,就变成了一个私有变量/属性 (private),实例的函数名如果以 __ 开头,就变成了一个私有函数/方法(private)只有内部可以访问,外部不能访问。
私有实行一定不可以从外部访问么？
python2版本不能直接访问 __属性名是因为 Python 解释器对外把 __属性名改成了 _类名__属性名 ,所以,仍然可以通过 _类名__属性名来访问 __属性名。
因为不同版本的 Python 解释器可能会把 __属性名改成不同的变量名。
优势
1.确保了外部代码不能随意修改对象内部的状态,这样通过访问限制的保护, 代码更加健壮。
2.如果又要允许外部代码修改属性怎么办?可以给类增加专门设置属性方法。为什么大费周折?因为在方法中,可以对参数做检查,避免传入无效的参数。
举例：
类的外部不能访问私有属性，因为python解释器自动将私有属性和私有方法改名了，_类名__属性名

class Student(object):
    def __init__(self, name, age):
        self.name = name
        # 私有属性
        self.__age = age
    def get_age(self):
        # 类的内部是可以访问私有属性的
        print("年龄: %s" %(self.__age))
    def __get_info(self):
        print(self.name, self.age)

s = Student("Coco", 18)
# 1.类的外部不能访问私有属性，因为python解释器自动将私有属性和私有方法改名了，_类名__属性名
print(s.__age)

在这里插入图片描述

在这里插入图片描述
修改后即可访问：

在这里插入图片描述

类的内部可以访问私有属性

在这里插入图片描述

类的外部不能执行私有方法，包括子类或者类的外面均不可访问：

3.多态

【1】概念
多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。通俗来说：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
【2】优点
多态的好处就是，当我们需要传入更多的子类，只需要继承父类就可以了，而方法既可以直接不重写（即使用父类的），也可以重写一个特有的。这就是多态的意思。调用方只管调用，不管细节，而当我们新增一种的子类时，只要确保新方法编写正确，而不用管原来的代码。这就是著名的“开闭”原则：

对扩展开放（Open for extension）：允许子类重写方法函数
对修改封闭（Closed for modification）：不重写，直接继承父类方法函数

项目案例

1.栈的封装

徐一435

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python基本语法（面向对象编程、三大特性）

面向对象编程1.面向过程编程【1】概念“面向过程”(Procedure Oriented)是一种以过程为中心的编程思想。分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。【2】特性模块化、流程化【3】优点性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源；单片机、嵌入式开发、liinux/unix等一般采用面向过程开发，性能是最重要的因素。【4】缺点没有面向对象易维护、易复用、易扩展2.函数式编程函数式编程是种编程方式，它
复制链接

扫一扫