Python对象是什么

这篇文章主要讲解了“Python对象是什么”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“Python对象是什么”吧！

类和对象的概念

类是对我们要处理的客观事物的抽象。类用来描述具有相同的属性和方法的对象的集合，它定义了该集合中每个对象所共有的属性和方法。对象是类在内存的实例，一个类可以实例化为多个对象。类是抽象的，不占用内存，而对象是具体的，占用存储空间。

类的成员

作为Python初学者，大可不必把精力花费在令人费解的概念上，只需要掌握使用类的基本要素就可以了。未来的日子里，你有足够多的时间慢慢体会OOP的博大精深。随着经验的积累，OOP会自然而然地成为你的思维工具。

下面的代码，定义了一个名为A的类。所有的类，都有构造函数和析构函数，此外，还可以包含成员函数和成员变量。我喜欢把成员函数叫做类的方法，把成员变量叫做类的属性。

当类被实例化为对象时，首先执行构造函数，当对象被销毁时，会自动执行析构函数。一般的，我们会在构造函数中进行初始化工作，在析构函数中进行清理工作。

读到这里，有很多初学者一定会说：我定义类的时候，写过构造函数，但从没有写过析构函数，你为什么说所有的类都有构造函数和析构函数呢？没错，定义类的时候，即便我们不写构造函数和析构函数，这两个方法也照样存在（析构函数稍微有点特殊，我们不能直接看到它——除非是我们自己定义的）。如果我们自己定义了构造函数和析构函数，则将会取代系统自动赋予的这两个函数。下面的例子清晰地说明了其中的奥秘：类A既没有构造函数，也没有析构函数，类B只有析构函数，两个类都可以生成类实例，也都可以销毁，且 del b 时首先调用了自定义的析构函数。

新式类和旧式类

在PY2中，类有新式类和旧式类两种。新式类需要继承自虚类Object，旧式类则不需要。PY2中类的写法有三种：

在PY3中，只有新式类，不再支持旧式类。你如果习惯继承Object的写法，也完全没有问题。上面三种写法在PY3中都被解释成新式类。新式类和旧式类的主要区别是：

• 新式类可以继承Object的构造函数和析构函数，如果类的构造和析构函数没有特别的工作，可以省略。而旧式类则不能：

此时用PY2运行，会出现错误：AttributeError: class A has no attribute '__init__'，使用PY3不会出现此错误。若改成新式类写法：

仍然用PY2运行，则都不会出错。

• 新式类可以使用super:

• 多重继承时，各父类的初始化和函数查找顺序不同：旧式类为深度优先继承，新式类为广度优先继承。

静态变量和实例变量

在构造函数中定义的变量，我们称之为实例变量。实例变量只能在实例化后使用<对象名.变量名>的方式访问。静态变量一般定义在类的开始位置，独立于构造函数之外。静态变量既可以<对象名.变量名>的方式访问，也可以<类名.变量名>的方式访问。通常，类的静态变量一般用于保存类的静态属性，该属性可被类的方法使用，但不应该被类的方法修改。

静态函数

与其他语音的静态函数不同，Python的静态函数有两种，都是用装饰器实现的：

Staticmethod 函数不能使用Self参数，因此不成访问任何成员变量，只能通过类名访问类的静态变量。

Classmethod 函数也不能使用Self参数，因此不成访问任何成员变量，但它有cls参数。cls参数不是对象的引用，而是类的引用，可以通过cls参数访问类的静态变量。

面向对象三要素

面向对象，有三大要素：继承、封装、多态。这里面概念非常多，往往越讲越糊涂。为了不至于误导读者，我尽可能不做解释，只给出例子，请自行揣摩。

(1) 继承

如果派生类只有一个父类，就是单继承。这是最常见的类定义形式。

如果派生类有多个父类，就是多继承。

不管是单继承还是多继承，都可以在派生类中重写父类的函数——这叫做覆盖。

(2) 封装

所谓封装，就是将类的成员变量、成员函数整合在一起，并对关键的信息进行保护或隐藏。信息保护或隐藏有三个级别：公有、保护、私有。如果你有C++的使用经验，我们先来回顾一下C++的信息隐藏规则：

1. 公有成员：对类外部的任何代码可见;

2. 保护成员：对类外部的任何代码都不可见，但对派生类可见;

3. 私有成员：对类外部及派生类都不可见。

对应这三个级别，Python 是这样定义的：

1. 以英文字母开头的成员为公有成员

2. 以一个下划线开头的成员为保护成员

3. 以两个下划线开关的成员为私有成员

下面我们试试 Python 的信息保护或隐藏规则是否有效。

试试访问公有成员：

公有成员访问规则与C++相同。先跳过保护成员，看看私有成员：

私有成员的访问规则也与C++相同。那我为什么跳过保护成员了？来试试吧：

看到这里就已经不对了，应该只有类内部的代码和派生类能使用啊，怎么可以直接用了呢？是的，Python的保护成员访问规则与C++的确实不一样。那 Python 的保护成员是什么样的机制呢？原来，在 Python 的OOP中，保护成员公有成员没有任何区别。保护规则仅适用于 from xxx import * 这一种情况。

testA.py

class A(object):
 pass
class _B(object):
 pass

testB.py

from testA import *
a = A()
b = _B()

执行testB.py时：

Traceback (most recent call last): File "testB.py", line 4, inb = _B()NameError: name '_B' is not defined

此时，保护成员_B被保护了。但这种情况仅适用于from xxx import *这一种情况。如果testB.py这样写：

testB.py

from testA import A, _B
a = A()
b = _B()

或者：

import testA
a = testA.A()
b = testA._B()

则是没有任何问题的。

(3) 多态

当父类有多个派生类，且派生类都实现了同一个成员函数，则可以实现多态：

class H2O(object):
 def what(self):
 print("I am H2O")
class Water(H2O):
 def what(self):
 print("I am water")
class Ice(H2O):
 def what(self):
 print("I am ice")
class WaterVapor(H2O):
 def what(self):
 print("I am water vapor");
def what(obj):
 obj.what()
objs = [H2O(), Water(), Ice(), WaterVapor()]
for obj in objs:
 what(obj)

抽象类

抽象类不能被实例化，只能作为父类被其它类继承，且派生类必须实现抽象类中所有的成员函数。抽象类应用场景是什么呢？我曾经做过很多下载数据的脚本插件，不同的数据源使用不同的脚本，所有这些脚本要求必须有名字相同的方法，此时，抽象类就派上用场了。

单例模式

单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时（如软件配置类，无论在软件的什么地方实例化，永远都是那一个对象），单例模式就能派上用场。比如，Python 日志模块中的日志对象，或者异步通讯框架Twisted 里面的反应堆(reactor)，都是典型的单例模式——尽管它们不一定是下面这种方法实现的。

Python可以使用装饰器的方法使用单例模式：

>>> import abc>>> class A(object, metaclass=abc.ABCMeta): @abc.abstractmethod def a(self): pass @abc.abstractmethod def b(self): pass>>> class C(A): def a(self): print("a")>>> c = C()Traceback (most recent call last): File "", line 1, inc = C()TypeError: Can't instantiate abstract class C with abstract methods b

感谢各位的阅读，以上就是“Python对象是什么”的内容了，经过本文的学习后，相信大家对Python对象是什么这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是亿速云，小编将为大家推送更多相关知识点的文章，欢迎关注！