面向对象程序设计具都有哪些特性呢？

Posted 2023-04-04

面向对象程序设计具有的特性有：抽象性、封装性、继承性和多态性。

面向对象程序设计有4个主要特点，分别是：抽象、封装、继承、多态。以下是具体解释；

一、抽象和封装

类和对象体现了抽象和封装

抽象就是解释类与对象之间关系的词。类与对象之间的关系就是抽象的关系。一句话来说明：类是对象的抽象，而对象则是类得特例，即类的具体表现形式。

封装两个方面的含义：一是将有关数据和操作代码封装在对象当中，形成一个基本单位，各个对象之间相对独立互不干扰。二是将对象中某些属性和操作私有化，已达到数据和操作信息隐蔽，有利于数据安全，防止无关人员修改。把一部分或全部属性和部分功能（函数）对外界屏蔽，就是从外界（类的大括号之外）看不到，不可知，这就是封装的意义。

二、继承

面向对象的继承是为了软件重用，简单理解就是代码复用，把重复使用的代码精简掉的一种手段。如何精简，当一个类中已经有了相应的属性和操作的代码，而另一个类当中也需要写重复的代码，那么就用继承方法，把前面的类当成父类，后面的类当成子类，子类继承父类，理所当然。就用一个关键字extends就完成了代码的复用。

三、多态

没有继承就没有多态，继承是多态的前提。虽然继承自同一父类，但是相应的操作却各不相同，这叫多态。由继承而产生的不同的派生类，其对象对同一消息会做出不同的响应。 参考技术A 1、封装性，封装就是隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别，将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，以特定的访问权限来使用类的成员。面相对象的不就是使用程序处理事情时以对象为中心去分析吗，与面向过程不同，面向过程关心处理的逻辑、流程等问题，而不关心事件主体。而面向对象即面向主体，所以我们在解决问题时应该先进行对象的封装（对象是封装类的实例，比如张三是人，人是一个封装类，张三只是对象中的一个实例、一个对象）。比如我们日常生活中的小兔子、小绵羊都可以封装为一个类。比如兔子的属性有两只耳朵、四只腿、一双眼睛、三瓣嘴等；行为（功能）有跑、跳、吃素等。2、继承性，继承是面向对象的基本特征之一，继承机制允许创建分等级层次的类。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。类似下面这个图：我们在上面已经封装了兔子这个类，其他动物也一样可以进行封装。在封装过程中我们发现兔子、绵羊这两个类具有相似的功能或特性如吃草，所以我们可以抽取共有特征和方法形成高一层的类，如这里的食草动物、食肉动物。继承之间是子父类的关系。继承机制可以很好的描述一个类的生态，也提高了代码复用率，在Java中的Object类是所有类的超类，常称作上帝类。3、多态性，多态同一个行为具有多个不同表现形式或形态的能力。是指一个类实例（对象）的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。 参考技术B 1.面向对象程序设计的四大特征分别为【 封装性 】、【 继承性 】、【 多态性 】、【 】。

2.每个C++程序开始执行的函数是【 main函数 】。

3.在C++中enum类型中第一个枚举元素的缺省值为【 1 】。

4.C++中只有一条语句是关于函数头部的描述，没有函数体部分，这条语句被称做函数的【 预处理语句 】。

5.在C++中，允许不同的函数具有相同的名字，只有不同的类型和不同的参数个数，这种函数被称为【 构造函数 】。

6.初始化一个类的数据成员的专用成员函数是【 析构函数 】。

7.一个非成员函数必须声明为一个类的【 private 】，才有可能存取该类的私有数据成员。

8. 【 const final 】保留字表示在对象或变量初始化后是不可修改的。

9. C++提供了【内部类（innerClass）】机制，

10.所有函数模板都用【 template 】关键字定义，接着在<符号和>符号范围内列出函数模板的模板形参表。

11.当从一个带有public继承的基类中导出一个类时，这个基类的public成员就成为该导出类的【公共】成员，而这个基类的protected成员就成为该导出类的【私有】成员。

12. 【 operator 】关键字引入了重载运算符的函数定义。

13.在类内部定义的【 private 】数据不能被该类的函数来存取，定义为【 public 】的数据和函数则可以在类外部进行存取。

14.对于导出类的构造函数，在定义对象时构造函数的执行顺序为：先执行【构造函数】，再执行【 对象构造函数】 参考技术C 面向对象的程序设计（OOP：Object-Oriented Programming）是一种基于结构分析的、以数据为中心的程序设计方法。它的主要思想是将数据及处理这些数据的操作都封装（Encapsulation）到一个称为类（Class）的数据结构中，使用这个类时，只需要定义一个类的变量即可，这个变量叫做对象（Object）。通过调用对象的数据成员完成对类的使用。
如图：编制“五子棋”的游戏程序
面向过程程序设计方法 面向对象程序设计方法
1、开始游戏； 1、玩家系统类
2、黑子先走； ——负责接收用户的输入；
3、绘制画面； 2、棋盘系统类
4、判断输赢； ——负责绘制画面；
5、轮到白子； 3 、规则系统类
6、绘制画面； ——负责判定犯规、 输赢等。
7、判断输赢；
8、返回步骤2；
9、输出最后结果。
面向对象的三个重要特征，这在类中体现明显
(1) 封装性
开发人员并不需要完全了解类体内每句代码的具体含义，只需通过对象来调用类内某个属性和方法即可实现需要的功能，这就是类的封装性。
(2) 继承性
一个类可以拥有它继承的类的所有成员，而不需要重新定义，这种特性在面向对象编程技术中称作对象的“继承性。
(3) 多态性
多态性是指在基类中定义的属性或方法被派生类继承后可以进行更改。
类与对象
在面向对象的程序设计方法中，类是对具有相同特征的一类事物所做的抽象（或者说，归纳）。对象是类的实例，是现实存在的并且可唯一区分的。
类成员
类的具体成员有以下类型： 1、常量 2、变量 3、事件 4、类型 5、方法 6、 属性 7、索引指示器 8、 运算符 9、构造函数 10、析构函数

查找 Python 对象具都有哪些方法

【中文标题】查找 Python 对象具都有哪些方法

【英文标题】：Finding what methods a Python object has查找 Python 对象具有哪些方法

【发布时间】：2010-09-07 06:14:07

【问题描述】：

给定一个任何类型的 Python 对象，是否有一种简单的方法可以获取该对象具有的所有方法的列表？

或者，

如果这不可能，除了简单地检查调用方法时是否发生错误之外，是否至少有一种简单的方法可以检查它是否具有特定的方法？

【问题讨论】：

相关：***.com/q/46033277/1959808

您可以使用 dir(object) 将所有这些都放在一个列表中

【参考方案1】：

对于许多对象，您可以使用此代码，将“object”替换为您感兴趣的对象：

object_methods = [method_name for method_name in dir(object)
                  if callable(getattr(object, method_name))]

我在diveintopython.net 发现了它（现已存档）。希望这应该提供更多细节！

如果您收到AttributeError，则可以改用它：

getattr( 不能容忍 pandas 风格的 python3.6 抽象虚拟子类。这段代码和上面一样，忽略异常。

import pandas as pd
df = pd.DataFrame([[10, 20, 30], [100, 200, 300]],
                  columns=['foo', 'bar', 'baz'])
def get_methods(object, spacing=20):
  methodList = []
  for method_name in dir(object):
    try:
        if callable(getattr(object, method_name)):
            methodList.append(str(method_name))
    except:
        methodList.append(str(method_name))
  processFunc = (lambda s: ' '.join(s.split())) or (lambda s: s)
  for method in methodList:
    try:
        print(str(method.ljust(spacing)) + ' ' +
              processFunc(str(getattr(object, method).__doc__)[0:90]))
    except:
        print(method.ljust(spacing) + ' ' + ' getattr() failed')

get_methods(df['foo'])

【讨论】：

这是一个列表推导，返回一个方法列表，其中 method 是 dir(object) 返回的列表中的一项，并且只有 getattr(object,method) 才会将每个方法添加到列表中返回一个可调用对象。

你是如何使用这个的？要说打印方法列表。

@marsh 打印方法：print [method for method in dir(object) if callable(getattr(object, method))].

当我尝试运行它时，我收到了一个AttributeError: module 'pandas.core.common' has no attribute 'AbstractMethodError'。在***.com/q/54713287/9677043查看详细信息。

不适用于 python 3.6 中的 pandas 数据框对象。

【参考方案2】：

您可以使用内置的dir() 函数来获取模块具有的所有属性的列表。在命令行中尝试一下，看看它是如何工作的。

>>> import moduleName
>>> dir(moduleName)

此外，您可以使用hasattr(module_name, "attr_name") 函数来确定模块是否具有特定属性。

请参阅Guide to Python introspection 了解更多信息。

【讨论】：

hasattr 帮助我的用例查找 python 对象是否具有特定的成员变量或方法。

我不确定为什么这个解决方案没有得到足够的支持。这是简洁而准确的。

由于 dir() 返回一个列表，我们可以使用'attrib_name' in dir(moduleName) 来查找模块是否具有特定属性。

【参考方案3】：

最简单的方法是使用dir(objectname)。它将显示该对象可用的所有方法。很酷的把戏。

【讨论】：

它也显示了对象的属性，所以如果你想专门找方法是不行的。

是的。同意。但是，我不知道任何其他仅获取方法列表的技术。也许最好的办法是获取属性和方法的列表，然后使用 进一步过滤掉它？

@neuronet，我正在尝试运行已接受的答案，但得到了AttributeError: module 'pandas.core.common' has no attribute 'AbstractMethodError'。有任何想法吗？请参阅***.com/q/54713287/9677043 的 deets。 +1 给@Pawan Kumar b/c 答案是有效的，并给@ljs 以保证只包含方法的过滤列表。

【参考方案4】：

我相信你想要这样的东西：

对象的属性列表

内置函数dir()可以完成这项工作。

取自 Python shell 上的 help(dir) 输出：

目录（...）

dir([object]) -> list of strings

如果在没有参数的情况下调用，则返回当前范围内的名称。

否则，返回一个按字母顺序排列的名称列表，其中包括给定对象的（部分）属性以及可从该对象访问的属性。

如果对象提供了一个名为__dir__的方法，它将被使用；否则 使用默认的 dir() 逻辑并返回：

对于模块对象：模块的属性。 对于一个类对象：它的属性，以及它的基类的递归属性。 对于任何其他对象：其属性、其类的属性以及递归其类的基类的属性。

例如：

$ python
Python 2.7.6 (default, Jun 22 2015, 17:58:13)
[GCC 4.8.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.

>>> a = "I am a string"
>>>
>>> type(a)
<class 'str'>
>>>
>>> dir(a)
['__add__', '__class__', '__contains__', '__delattr__', '__doc__',
'__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__',
'__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__',
'__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__',
'__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__',
'__setattr__', '__sizeof__', '__str__', '__subclasshook__',
'_formatter_field_name_split', '_formatter_parser', 'capitalize',
'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find',
'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace',
'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition',
'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip',
'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title',
'translate', 'upper', 'zfill']

【参考方案5】：

检查它是否有特定的方法：

hasattr(object,"method")

【讨论】：

由于 OP 正在寻找一种方法而不仅仅是和属性，我认为您想更进一步：if hasattr(obj,method) and callable(getattr(obj,method)):

【参考方案6】：

除了更直接的答案之外，如果我不提及IPython，我将失职。

点击 Tab 以查看可用的方法，并自动完成。

一旦你找到了方法，就试试吧：

help(object.method)

查看 pydocs、方法签名等

啊……REPL.

【参考方案7】：

获取任何对象的方法列表的最简单方法是使用help() 命令。

help(object)

它将列出与该对象关联的所有可用/重要方法。

例如：

help(str)

【讨论】：

% 在第一个示例中做了什么？它在我的 Python 2.7 中不起作用。

@Scorchio 我使用“%”作为提示符，而不是“>>>”用于 python。你可以在运行命令之前去掉 %。

【参考方案8】：

如果你特别想要方法，你应该使用inspect.ismethod。

对于方法名称：

import inspect
method_names = [attr for attr in dir(self) if inspect.ismethod(getattr(self, attr))]

对于方法本身：

import inspect
methods = [member for member in [getattr(self, attr) for attr in dir(self)] if inspect.ismethod(member)]

有时inspect.isroutine 也很有用（对于内置、C 扩展、没有“绑定”编译器指令的 Cython）。

【讨论】：

你不应该在列表理解中使用inspect.getmembers而不是dir吗？

是的，这似乎更好！

inspect.getmembers(self, predicate=inspect.ismethod) ?

【参考方案9】：

假设我们有一个 Python obj。然后看看它所有的方法，包括__(magic methods)包围的方法：

print(dir(obj))

要排除内置的魔法，可以这样做：

[m for m in dir(obj) if not m.startswith('__')]

【参考方案10】：

打开一个 Bash shell（在 Ubuntu 上是 Ctrl + Alt + T）。在其中启动 Python 3 shell。创建一个对象来观察方法。只需在其后添加一个点，然后按两次 Tab，您会看到如下内容：

user@note:~$ python3
Python 3.4.3 (default, Nov 17 2016, 01:08:31)
[GCC 4.8.4] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import readline
>>> readline.parse_and_bind("tab: complete")
>>> s = "Any object. Now it's a string"
>>> s. # here tab should be pressed twice
s.__add__(           s.__rmod__(          s.istitle(
s.__class__(         s.__rmul__(          s.isupper(
s.__contains__(      s.__setattr__(       s.join(
s.__delattr__(       s.__sizeof__(        s.ljust(
s.__dir__(           s.__str__(           s.lower(
s.__doc__            s.__subclasshook__(  s.lstrip(
s.__eq__(            s.capitalize(        s.maketrans(
s.__format__(        s.casefold(          s.partition(
s.__ge__(            s.center(            s.replace(
s.__getattribute__(  s.count(             s.rfind(
s.__getitem__(       s.encode(            s.rindex(
s.__getnewargs__(    s.endswith(          s.rjust(
s.__gt__(            s.expandtabs(        s.rpartition(
s.__hash__(          s.find(              s.rsplit(
s.__init__(          s.format(            s.rstrip(
s.__iter__(          s.format_map(        s.split(
s.__le__(            s.index(             s.splitlines(
s.__len__(           s.isalnum(           s.startswith(
s.__lt__(            s.isalpha(           s.strip(
s.__mod__(           s.isdecimal(         s.swapcase(
s.__mul__(           s.isdigit(           s.title(
s.__ne__(            s.isidentifier(      s.translate(
s.__new__(           s.islower(           s.upper(
s.__reduce__(        s.isnumeric(         s.zfill(
s.__reduce_ex__(     s.isprintable(
s.__repr__(          s.isspace(

【讨论】：

虽然我们正在讨论这样的解决方法，但我要补充一点，您也可以运行ipython，开始输入对象并按tab，它也可以正常工作。无需读取行设置

@MaxCoplan 我已经在代码中添加了默认情况下不启用制表符补全的解决方法

【参考方案11】：

这里指出的所有方法的问题是您不能确定某个方法不存在。

在 Python 中，您可以通过__getattr__ 和__getattribute__ 拦截点调用，从而可以“在运行时”创建方法

例子：

class MoreMethod(object):
    def some_method(self, x):
        return x
    def __getattr__(self, *args):
        return lambda x: x*2

如果执行的话，可以调用对象字典中不存在的方法...

>>> o = MoreMethod()
>>> o.some_method(5)
5
>>> dir(o)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattr__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'some_method']
>>> o.i_dont_care_of_the_name(5)
10

这就是您在 Python 中使用 Easier to ask for forgiveness than permission 范式的原因。

【参考方案12】：

没有可靠的方法来列出所有对象的方法。 dir(object) 通常很有用，但在某些情况下它可能不会列出所有方法。根据dir() documentation：“使用参数，尝试返回该对象的有效属性列表。”

检查方法是否存在可以由callable(getattr(object, method)) 完成，正如那里已经提到的那样。

【参考方案13】：

import moduleName
for x in dir(moduleName):
    print(x)

这应该工作:)

【参考方案14】：

可以创建一个getAttrs 函数，该函数将返回对象的可调用属性名称

def getAttrs(object):
  return filter(lambda m: callable(getattr(object, m)), dir(object))

print getAttrs('Foo bar'.split(' '))

那会回来的

['__add__', '__class__', '__contains__', '__delattr__', '__delitem__',
 '__delslice__', '__eq__', '__format__', '__ge__', '__getattribute__', 
 '__getitem__', '__getslice__', '__gt__', '__iadd__', '__imul__', '__init__', 
 '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', 
 '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', 
 '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', 
 '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 
 'remove', 'reverse', 'sort']

【参考方案15】：

以列表为对象

obj = []

list(filter(lambda x:callable(getattr(obj,x)),obj.__dir__()))

你得到：

['__add__',
 '__class__',
 '__contains__',
 '__delattr__',
 '__delitem__',
 '__dir__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__gt__',
 '__iadd__',
 '__imul__',
 '__init__',
 '__init_subclass__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__reversed__',
 '__rmul__',
 '__setattr__',
 '__setitem__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'append',
 'clear',
 'copy',
 'count',
 'extend',
 'index',
 'insert',
 'pop',
 'remove',
 'reverse',
 'sort']

【参考方案16】：

...除了简单地检查调用方法时是否发生错误之外，是否至少有一种简单的方法可以检查它是否具有特定的方法

虽然“Easier to ask for forgiveness than permission”当然是 Pythonic 方式，但您可能正在寻找：

d='foo':'bar', 'spam':'eggs'
if 'get' in dir(d):
    d.get('foo')
# OUT: 'bar'

【参考方案17】：

我已经完成了以下函数（get_object_functions），它接收一个对象（object_）作为其参数，返回一个包含所有方法（包括静态和类）的列表（functions）方法）在对象的类中定义：

def get_object_functions(object_):
    functions = [attr_name
                 for attr_name in dir(object_)
                 if str(type(getattr(object_,
                                     attr_name))) in ("<class 'function'>",
                                                      "<class 'method'>")]
    return functions

好吧，它只是检查类属性类型的字符串表示是否等于"<class 'function'>" 或"<class 'method'>"，然后如果是True，则将该属性包含在functions 列表中。

---

演示

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print(f'My name is self.name')

    @staticmethod
    def say_hi():
        print('hi')

    @classmethod
    def reproduce(cls, name):
        return cls(name, 0)


person = Person('Rafael', 27)
print(get_object_functions(person))

输出

['__init__', 'introduce', 'reproduce', 'say_hi']

对于更简洁的代码版本： https://github.com/revliscano/utilities/blob/master/get_object_functions/object_functions_getter.py

【参考方案18】：

为了在整个模块中搜索特定的方法

for method in dir(module) :
  if "keyword_of_methode" in method :
   print(method, end="\n")

【参考方案19】：

例如，如果您正在使用 shell plus，则可以改用它：

>> MyObject??

那样，用 '??'就在您的对象之后，它会向您显示该类具有的所有属性/方法。

【讨论】：

什么是"shell plus"？

【参考方案20】：

您可以使用 Python 中预定义的 dir()。

import module_name
dir(module_name)

您也可以将对象传递给 dir()

dir(object_name)

如果对象是预定义类的对象，例如 int、str 等。它会显示其中的方法（您可能知道这些方法是内置函数）。如果该对象是为用户定义的类创建的，它会显示该类中给出的所有方法。

【参考方案21】：

这是一个不错的衬线（但也会获得属性）：

print(*dir(obj), sep='\n')

【参考方案22】：

大多数时候，我希望看到用户定义的方法，而不希望看到以'__'开头的内置属性，如果您愿意，可以使用以下代码：

object_methods = [method_name for method_name in dir(object) if callable(getattr(object, method_name)) and '__' not in method_name] 

例如，对于这个类：

class Person: 
    def __init__(self, name): 
        self.name = name 
    def print_name(self):
        print(self.name)

上面的代码将打印：['print_name']