您现在的位置是：首页 > Python

当前栏目

Python面向对象编程

Python 对象变量编程

2023-03-02 11:48:34 时间

一、面向对象

面向对象程序设计(Object-oriented programming,OOP)是一种程序设计范式，也是一种程序开发方

法。对象指的是类的实例，类是创建对象的模板，一个类可以创建很多个对象，每个对象都是类类型

的一个变量；创建对象的过程也叫做类的实例化。编程方法主要可以分为两类：面向过程与面向对

象，他们的主要区别在于：

<table> 
 <tbody> 
 <tr> 
 <td style="border-width:1px;">&nbsp; 面向过程编程：以指令为核心，围绕“正在发生什么”进行编写，程序具有一系列线性步骤，主体思想是代码作用于数据。&nbsp; 面相对象编程(OOP)：以数据为核心，围绕“将影响谁”进行编写，围绕数据及为数据严格定义的接口来组织程序， 用数据控制对代码的方向。</td> 
 </tr> 
 </tbody> 
</table>

面向对象编程种主要有以下几个主要概念：

<table> 
 <tbody> 
 <tr> 
 <td style="border-width:1px;">&nbsp; 类：定义了被多个同一类型对象共享的结构和行为(数据和代码)。&nbsp; 对象：类的实例。既包含数据(变量，也称属性)，也包含代码（函数，也称方法）。&nbsp;&nbsp;封装：隐藏实现方案细节；将代码及处理的数据绑定在一起的一种编程机制，用于保证程序和数据不受外部干扰且不会被误用。 &nbsp; 继承：一个对象获得另一个对象属性的过程，用于实现按层分类的概念；一个深度继承的子类继承了类层次中它的每个先祖的所有属性；超类、基类、父类，子类、派生类。 &nbsp; 多态：允许一个接口被多个通用的类动作使用的特性，具体使用哪个动作与应用场合相关；“一个接口上，多种方法”：用于为一组相关的动作设计一个通用的接口，以降低程序复杂性。</td> 
 </tr> 
 </tbody> 
</table>

二、类的创建

*  使用class关键字创建类

超类是一个或多个用于继承的父类的集合类体中可以包含：声明语句、类成员定义、数据属性、方法。

Class ClassName(bases):          #不存在继承关系时，可以不提供bases
      'class documentation string'   #类文档可选
      Data = value                   #定义数据属性
      def method(self , ...)         #定义方法属性
        self.member = value 
      
    class MyClass():                 
        """A simple example class"""
        i = 12345
        def f(self):                 
            return 'hello world'

*  类方法及调用

实例(对象)通常包含属性和方法。  
 数据属性：即变量 可调用的方法：object.method()，即函数

在OOP中，实例就像是带有”数据”的记录，而类是处理这些记录的”程序”。通过实例调用方法相

当于调用所属类的方法来处理当前实例，类似obj.method(arg...)自动转为class.method(instance,

args...)；因此在类中每个方法必须具有 self 参数，它隐含当前实例之意；在方法内对self属性做

赋值运算会产生每个实例的属性；没有实例，方法就不允许调用。

In [1]: class MyClass():
       ...:         """A simple example class"""
       ...:         i = 12345
       ...:         def f(self):
       ...:                 return 'hello world'
       ...:     
    In [2]: x=MyClass()       #实例化一个类
    In [3]: x.f()             #调用类的方法
    Out[3]: 'hello world'
    In [4]: x.i
    Out[4]: 12345
    In [5]: x.i=23456         #修改成员变量
    In [6]: x.i
    Out[6]: 23456

*  构造函数与析构函数

构造函数：创建实例时，python 会自动调用类中的\_\_init\_\_方法，以隐性的为实例提供属性

\_\_init\_\_方法被称为构造器，如果类中没有定义\_\_init\_\_方法，实例创建之初仅是一个简单的名称空间。构造函数不能有返回值。

In [8]:  class Myclass(object):
       ...:    message='Hello,Developer'
       ...:    def show(self):
       ...:       print(self.message)
       ...:      
    In [9]:  class Myclass(object):
       ...:    message='Hello,Developer'
       ...:    def show(self):
       ...:       print(self.message)
       ...:    def __init__(self):                #构造函数
       ...:       print('Constructor is called')
       ...:        
    In [10]: inst=Myclass()       #当Myclass类实例化时，自动执行了构造函数
    Constructor is called
    In [11]: inst.show()
    Hello,Developer

析构函数：\_\_del\_\_方法被称为析构函数，在销毁(释放)对象时将调用它们。析构函数往往用来

做"清理善后"工作，如数据库链接对象可以在析构函数中释放对数据库资源的占用。

In [17]:  class Myclass1(object):
        ...:    message='Hello,Developer'
        ...:    def show(self):
        ...:       print(self.message)
        ...:    def __init__(self):
        ...:       print('Constructor is called')
        ...:    def __del__(self):
        ...:       print('Destructor is called!')    
        ...:      
    In [18]: inst1=Myclass1()        #实例化类
    Constructor is called
    In [19]: inst1.show()
    Hello,Developer
    In [20]: del inst1               #析构函数
    Destructor is called!

类的特殊属性：可以使用类的\_\_dict\_\_字典属性或内置的 dir()函数来获取类的属性。

In [27]: dir(Myclass1)      #查看类所拥有的属性和方法
    Out[27]: 
    ['__class__',
     '__del__',
     '__delattr__',
     '__dict__',
     '__dir__',
     '__doc__',
     '__eq__',
     '__format__',
     '__ge__',
     '__getattribute__',
     '__gt__',
     '__hash__',
     '__init__',
     '__init_subclass__',
     '__le__',
     '__lt__',
     '__module__',
     '__ne__',
     '__new__',
     '__reduce__',
     '__reduce_ex__',
     '__repr__',
     '__setattr__',
     '__sizeof__',
     '__str__',
     '__subclasshook__',
     '__weakref__',
     'message',
     'show']

*  实例属性(成员变量)

实例仅拥有数据属性(方法是类属性)，通常通过构造器”\_\_init\_\_”为实例提供属性；这些数据属

性独立于其他实例或者类；实例释放时，其属性也将被清除。内建函数 dir()或者实例的特殊属性

\_\_dict\_\_可用于查看实例属性。

In [31]: class Myclass2(object):
        ...:         message='Hello,Developer'            #类成员属性
        ...:         def show(self):
        ...:           print(self.message)                #实例成员变量
        ...:           print('Here is %s in %s' %(self.name,self.color))
        ...:         def __init__(self,name='unset',color='black'):
        ...:           print('Constructor is called with parms:',name,'',color)
        ...:           self.name=name
        ...:           self.color=color
        ...:            
    In [32]: Myclass2.message                #输出类变量
    Out[32]: 'Hello,Developer'
    In [33]: Myclass2.message='Hello Python' #更改类成员变量
    In [34]: Myclass2.message
    Out[34]: 'Hello Python'
    In [35]: init3=Myclass2()                #实例化类Myclass2
    Constructor is called with parms: unset  black
    In [36]: init3.message                   #访问类成员变量
    Out[36]: 'Hello Python'
    In [37]: init3.message='Hello'           #更改类成员变量
    In [39]: Myclass2.message                #可以发现，实例对象无法更改类成员对象
    Out[39]: 'Hello Python'

*  类方法中的可用变量

<table> 
 <tbody> 
 <tr> 
 <td style="border-width:1px;">&nbsp; &nbsp;实例变量：指定变量名称及示例自身进行引用；self.变量名 &nbsp; &nbsp;局部变量：方法内部创建的变量，可以直接使用 &nbsp; &nbsp;类变量(静态变量)：通过指定变量名与类名进行引用；类名.变量名 &nbsp; &nbsp;全局变量：直接使用</td> 
 </tr> 
 </tbody> 
</table>

*  类成员的修饰符

公有成员，在任何地方都能访问  
 私有成员，只有在类的内部才能方法

class C:
      classname = '公有变量'    #类的公有字段，即变量
      __classfoo = "私有变量"   #类的私有字段，使用__开头声明的变量为私有变量
      def __init__(self):
        self.name = '公有变量'    #对象的公有字段，即变量
        self.__foo = "私有变量"   #对象的私有字段，使用__开头声明的变量为私有变量

静态字段(属于类)  
 公有静态变量：类可以访问；类内部可以访问；派生类中可以访问  
 私有静态变量：仅类内部可以访问  
普通字段(属于对象)  
 公有普通变量：对象可以访问；类内部可以访问；派生类中可以访问  
 私有普通变量：仅类内部可以访问

In [42]: class Myclass2(object):
     ...:         message='Hello,Developer'            #类成员
     ...:         __classname='Python'
     ...:         def show(self):
     ...:           print(self.message)
     ...:           print('Here is %s in %s' %(self.name,self.color))
     ...:         def __init__(self,name='unset',color='black'):
     ...:           print('Constructor is called with parms:',name,'',color)
     ...:           self.name=name
     ...:           self.__color=color
 In [43]: inst4=Myclass2()             #实例化类
 Constructor is called with parms: unset  black
 In [44]: inst4.message                #实例化的对象可以访问类的公有变量
 Out[44]: 'Hello,Developer'
 In [45]: inst4.__classname            #实例化的对象无法访问类的私有变量
 --------------------------------------------------------------------------
 AttributeError                           Traceback (most recent call last)
 <ipython-input-45-379f39c829cf> in <module>()
 ----> 1 inst4.__classname
 In [47]: inst4.name                   #实例对象可以访问对象公有变量
 Out[47]: 'unset'
 In [48]: inst4.__color                #实例对象无法外部访问对象私有变量
 --------------------------------------------------------------------------
 AttributeError                           Traceback (most recent call last)
 <ipython-input-48-5db61d225aac> in <module>()
 ----> 1 inst4.__color
 AttributeError: 'Myclass2' object has no attribute '__color'

o 静态函数和类函数

Python中支持两种基于类名访问成员的函数：静态函数和类函数，它们的不同点是类函数有一个隐

性参数cls可以用来获取信息，而静态函数没有该参数。静态函数使用装饰器@staticmethod定义，类

函数使用装饰器@classmethod定义。

class Myclass(object):
        message='Hello,Developer'
        def show(self):
            print('self.message')
            print('Here is %s in %s !' %(self.name,self.color))
        
        @staticmethod           #定义静态函数，可以访问类成员变量
        def printMessage():
            print('print Message is called ')
            print(Myclass.message)
        
        @classmethod            #定义类函数，第一个参数必须是cls
        def creatobj(cls,name,color):
            print('Object will be created: %s(%s,%s)' %(cls.__name__,name,color))
            return cls(name,color)
        def __init__(self,name='unset',color='black'):
            print('Constructor is called with params:',name,'',color)
            self.anme=name
            self.color=color
        
        def __def__(self):
            print('Destructor is called for %s' %self.name)
            
    Myclass.printMessage()     #直接调用静态函数     
    inst=Myclass.creatobj('Toby', 'Red')  
    print(inst.message)
    
    输出结果：
      print Message is called      #静态函数输出结果
      Hello,Developer
      Object will be created: Myclass(Toby,Red)     #类函数输出结果
      Constructor is called with params: Toby  Red  #构造函数
      Hello,Developer              #print输出

三、继承与多态

类之间的继承是面向对象的设计的重要方法，通过继承可以达到简化代码和优化设计模式的目的。

Python类在定义时可以在小括号中指定基类。所有Pyhon类都是object类型的子类。

class BaseClass(object)           #父类定义
      block_class
    class SubClass(BaseClass)         #子类定义
      block_class

*  新式类与经典类

在Python中存在两种类，经典类与新式类，它们的区别在于：

<table> 
 <tbody> 
 <tr> 
 <td>1）写法不一样<pre style="text-align:left;">class&nbsp;A:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;#经典类
&nbsp;&nbsp;&nbsp;&nbsp;pass
class&nbsp;B(object):&nbsp;&nbsp;&nbsp;#新式类
&nbsp;&nbsp;&nbsp;&nbsp;pass</pre> &nbsp; Python 2.x中默认都是经典类，只有显式继承了object才是新式类&nbsp; Python 3.x中默认都是新式类，不必显式的继承object 2）在多继承中，继承搜索的顺序发生了改变,经典类多继承属性搜索顺序: 先深入继承树左侧，再&nbsp; 返回，开始找右侧;新式类多继承属性搜索顺序: 先水平搜索，然后再向上移动 3）新式类更符合OOP编程思想，统一了python中的类型机制。 &nbsp;&nbsp;新式类对象可以直接通过__class__属性获取自身类型:type&nbsp; 新式类增加了__slots__内置属性, 可以把实例属性的种类锁定到__slots__规定的范围之中&nbsp; 新式类增加了__getattribute__方法</td> 
 </tr> 
 </tbody> 
</table>

class BaseA(object):
        def move(self):
            print('move called in BaseA')
            
    class BaseB(object):
        def move(self):
            print('move called in BaseB')
    class BaseC(BaseA):
        def move(self):
            print('move called in BaseC')
            
    class Sub(BaseC,BaseB):
        def move(self):
            print('move called in Sub')
    inst=Sub()
    inst.move()

在此新式类的多重继承当中，当子类继承了多了父类并且调用共有的方法时，Python解释器会选择最近的一个基类成员方法。上面的例子move()搜索顺序为Sub、BaseC、BaseA、BaseB。

*  类与实例的内建函数

<table> 
 <tbody> 
 <tr> 
 <td style="text-align:left;">issubclass() </td> 
 <td style="text-align:left;">布尔函数，判断一个类是否由另一个类派生。issubclass(sub,sup)</td> 
 </tr> 
 <tr> 
 <td style="text-align:left;">isinstance() </td> 
 <td style="text-align:left;">布尔函数，判断一个对象是否是给定类的实例。isinstance(obj1,class_obj2)</td> 
 </tr> 
 <tr> 
 <td style="text-align:left;">hasattr() </td> 
 <td style="text-align:left;">布尔函数，判断一个对象是否拥有指定的属性，hasattr(obj , ‘attr’) 同类的函数还有 getattr()、setattr()、delattr()</td> 
 </tr> 
 <tr> 
 <td style="text-align:left;">super() </td> 
 <td style="text-align:left;">在子类中找出其父类以便于调用其属性；一般情况下仅能采用非绑定方式调用祖先方法；super()可用于传入实例或类型对象，super(type[,obj ])</td> 
 </tr> 
 </tbody> 
</table>

In [1]: class Person():
       ...:     def __init__(self,name):
       ...:         self.name=name
       ...:         
    In [2]: class EmailPerson(Person):
       ...:     def __init__(self,name,email):
       ...:         super.__init__(name)
       ...:         self.email=email

上例中，子类EmailPerson通过super()方法获取了父类Person的定义，子类的\_\_init\_\_()调用了

Person.\_\_init\_\_()方法。它会自动将self参数传递给父类。这样不仅可以继承父类中的定义方法，还

可以创建子类独有的属性。

*  运算符重载

在方法中拦截内置的操作——当类的实例出现在内置函数中，Python 会自动调用自定义的方法，并

且返回自定义方法的操作结果。运算符重载让类拦截常规的 Pyhton 运算：类可以重载所有表达式

运算符；类也可以重载打印、函数调用、属性点运算等内置操作；载使类实例的行为项内置类型，重

载通过提供特殊名称的类方法实现。

*  特殊方法制定类

除了\_\_init\_\_和\_\_del\_\_之外，Python 类支持许多特殊方法,特殊方法都是以双下划线开头和结尾， 有些特殊方法有默认行为，没有默认行为的是为了留到需要的时候再实现.这些特殊的方法是python

中用来扩充类的强大工具， 他们可以实现： 模拟标准类型，重载操作符特殊方法允许类通过重载标

准操作符\+,\*甚至包括下标及映射操作\[\]来模拟标准类型.

<table> 
 <tbody> 
 <tr> 
 <td align="center" style="text-align:left;">方法</td> 
 <td align="center" style="text-align:left;">重载</td> 
 <td align="center" style="text-align:left;">调用</td> 
 </tr> 
 <tr> 
 <td style="text-align:left;">&nbsp;__init__</td> 
 <td style="text-align:left;">构造函数</td> 
 <td style="text-align:left;">对象建立：x=class(args)</td> 
 </tr> 
 <tr> 
 <td style="text-align:left;">__del__</td> 
 <td style="text-align:left;">析构函数</td> 
 <td style="text-align:left;">x对象对象</td> 
 </tr> 
 <tr> 
 <td style="text-align:left;">__add__</td> 
 <td style="text-align:left;">运算符+</td> 
 <td style="text-align:left;">如果没有_iadd_,x+y，x+=y</td> 
 </tr> 
 <tr> 
 <td style="text-align:left;">__or__</td> 
 <td style="text-align:left;">运算符：(位OR)</td> 
 <td style="text-align:left;">如果没有_ior_,x|y，x|=y</td> 
 </tr> 
 <tr> 
 <td style="text-align:left;">__repr__，__str__</td> 
 <td style="text-align:left;">打印，转换</td> 
 <td style="text-align:left;">print(x),repr(x),str(x)</td> 
 </tr> 
 <tr> 
 <td style="text-align:left;">__call__</td> 
 <td style="text-align:left;">函数调用</td> 
 <td style="text-align:left;">x(*args,**kargs)</td> 
 </tr> 
 <tr> 
 <td style="text-align:left;">__getattr__</td> 
 <td style="text-align:left;">点运算符</td> 
 <td style="text-align:left;">x.undefined</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="text-align:left;">__setattr__</td> 
 <td colspan="1" style="text-align:left;">属性赋值语句</td> 
 <td colspan="1" style="text-align:left;">x.any=value</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="text-align:left;">__delattr__</td> 
 <td colspan="1" style="text-align:left;">属性删除</td> 
 <td colspan="1" style="text-align:left;">del x.any</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="text-align:left;">__getattribute__ </td> 
 <td colspan="1" style="text-align:left;">属性获取</td> 
 <td colspan="1" style="text-align:left;">x.any</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="text-align:left;">__getitem__ </td> 
 <td colspan="1" style="text-align:left;">索引运算</td> 
 <td colspan="1" style="text-align:left;">x[key],x[i:j]，没有__iter__时的for循环</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="text-align:left;">__setitem__ </td> 
 <td colspan="1" style="text-align:left;">索引赋值运算</td> 
 <td colspan="1" style="text-align:left;">x[key]=value,x[i:j]=sequence</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="text-align:left;">__delitem__ </td> 
 <td colspan="1" style="text-align:left;">索引和切片删除</td> 
 <td colspan="1" style="text-align:left;">del x[key],del[i:j]</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="text-align:left;">__len__ </td> 
 <td colspan="1" style="text-align:left;">长度</td> 
 <td colspan="1" style="text-align:left;">len(x)，如果没有__bool__真值测试</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="text-align:left;">__bool__ </td> 
 <td colspan="1" style="text-align:left;">布尔测试</td> 
 <td colspan="1" style="text-align:left;">bool(x)，真测试</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="text-align:left;">__lt,__gt__ </td> 
 <td colspan="1" style="text-align:left;">特定的比较</td> 
 <td colspan="1" style="text-align:left;">x&lt;y,x&gt;y,x&lt;=y,x&gt;=y,x==y,x!=y</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="text-align:left;">__le__,__ge__ </td> 
 </tr> 
 <tr> 
 <td colspan="1" style="text-align:left;">__eq__,__ne__ </td> 
 </tr> 
 <tr> 
 <td colspan="1" style="text-align:left;">__radd__</td> 
 <td colspan="1" style="text-align:left;">右侧加法</td> 
 <td colspan="1" style="text-align:left;">other+x</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="text-align:left;">__iadd__ </td> 
 <td colspan="1" style="text-align:left;">实地(增强的)加法</td> 
 <td colspan="1" style="text-align:left;">x+=y</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="text-align:left;">__iter__,__next__ </td> 
 <td colspan="1" style="text-align:left;">迭代环境</td> 
 <td colspan="1">I=iter(x),next(I)</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="text-align:left;">__contains__ </td> 
 <td colspan="1" style="text-align:left;">成员关系测试</td> 
 <td colspan="1" style="text-align:left;">item in x</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="text-align:left;">__index__ </td> 
 <td colspan="1" style="text-align:left;">整数值</td> 
 <td colspan="1" style="text-align:left;">hex(x),bin(x),oct(x),o[x]</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="text-align:left;">__enter__,__exit__ </td> 
 <td colspan="1" style="text-align:left;">上下文管理器</td> 
 <td colspan="1" style="text-align:left;">with obj as var:</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="text-align:left;">__get__,__set__ </td> 
 <td colspan="1" style="text-align:left;">描述运算符</td> 
 <td colspan="1" style="text-align:left;">x.attr,x.attr=value,del x.attr</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="text-align:left;">__delete__ </td> 
 <td colspan="1" style="text-align:left;">删除</td> 
 <td colspan="1" style="text-align:left;">在__del__之后删除对象</td> 
 </tr> 
 <tr> 
 <td colspan="1" style="text-align:left;">__new__ </td> 
 <td colspan="1" style="text-align:left;">创建</td> 
 <td colspan="1" style="text-align:left;">在__init__之前创建对象</td> 
 </tr> 
 </tbody> 
</table>

转载于:https://blog.51cto.com/yinsuifeng/1912543

猜你喜欢

最长无重复子串
写技术博客的一些心得分享
Java 多线程（七）：线程池
Java 多线程（五）：锁（三）
Java 多线程（四）：锁（二）
Java 多线程（三）：锁（一）
Java 多线程（二）：并发编程的三大特性
线性时间非比较类排序
Java 多线程（一）：基础
合并k个已排序的链表
HDFS 高可用分布式环境搭建
合并两个有序数组
连续子数组的最大和
HDFS 分布式环境搭建
容器盛水问题
大数加法
HDFS 伪分布式环境搭建
设计LRU缓存结构
两数之和
使用单调栈来解决的一些问题

zl程序教程

当前栏目

Python面向对象编程

相关文章