人生苦短
我用Python

Python017-OOP|面向对象(2)

OOP|面向对象(2)

PyS2POSTS

本篇将介绍Python类的成员、成员修饰符、类的特殊成员。

1. 类的成员

注意:所有成员中,只有普通字段的内容保存在对象中,即:根据此类创建了多少对象,在内存中就有多少普通字段,而其他的成员保,都是保存在类中的,即:无论对象的多少,在内存中只创建一份。

字段

字段包括:普通字段和静态字段,他们在定义和使用中有所区别,而最本质的区别是内存中保存的位置不同。

  • 普通字段属于对象
  • 静态字段属于

静态字段的使用:

class Province:
    # 静态字段
    country = '中国'

    def __init__(self, name):

        # 普通字段
        self.name = name


# 直接访问普通字段
obj = Province('河北省')
print obj.name

# 直接访问静态字段
Province.country

字段的定义和使用

由上述代码可以看出:

  • 普通字段需要通过对象来访问
  • 静态字段通过类访问

在使用上可以看出普通字段和静态字段的归属是不同的。如下图:

由上图可知:

  • 静态字段在内存中只保存一份
  • 普通字段在每个对象中都要保存一份

应用场景:通过类创建对象时,如果每个对象都具有相同的字段,那么使用静态字段

方法

方法包括:普通方法、静态方法和类方法,三种方法在内存都归属类,区别在于调用方式不同。

  • 普通方法
    由对象调用,至少一个self参数,执行普通方法时,自动将该方法的对象赋值给self
  • 类方法
    由类调用,至少一个cls参数,执行类方法时,自动将该方法的类复制给cls
  • 静态方法
    由类调用,武默认参数
class Foo:
    def __init__(self, name):
        self.name = name

    def ord_func(self):
        """
        定义普通方法,至少有一个self参数
        :return:
        """
        print('普通方法')

    @classmethod
    def class_func(cls):
        """
        定义一个类方法,至少有一个cls参数
        :return:
        """
        print("类方法")

    @staticmethod
    def static_func():
        """
        定义一个静态方法,无默认参数
        :return:
        """
        print('静态方法')

#调用普通方法
f = Foo('Siffre')
f.ord_func()

#调用类方法
Foo.class_func()

#调用静态方法
Foo.static_func()

相同点:对于所有的方法而言,均属于类(非对象)的中,所以内存中只保存一份。
不同点:方法调用者不同、调用方法时自动传入的参数不同。

属性

详见这里:http://lanzhishi.org/?p=1591

2.类成员的修饰符

对于每一个类的成员而言都有两种方式:

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

私有成员与公有成员的定义不同:
私有成员命名时,前两个字符是下划线。(特殊成员除外,eg:__init__,__call__,__dict__等)

class Foo:    
    def __init__(self):
        self.name = '公有字段'
        self.__foo = '私有字段'

私有成员与公有成员的访问限制不同:

静态字段

  • 公有静态字段:类可以访问,类内部可以访问,派生类中可以访问
  • 私有静态字段:仅类内部可以访问
class C:
    name = "公有静态字段"
    def func(self):
        print C.name
class D(C):
    def show(self):
        print C.name
C.name         # 类访问

obj = C()
obj.func()     # 类内部可以访问

obj_son = D()
obj_son.show() # 派生类中可以访问

class C:
    __name = "公有静态字段"
    def func(self):
        print C.__name
class D(C):
    def show(self):
        print C.__name
C.__name       # 类访问            ==> 错误

obj = C()
obj.func()     # 类内部可以访问     ==> 正确

obj_son = D()
obj_son.show() # 派生类中可以访问   ==> 错误

普通字段

  • 公有普通字段:对象可以访问,类内部可以访问,派生类中国可以访问
  • 私有普通字段:仅类内部可以访问

如果想要强制访问私有字段,可以通过 【对象._类名私有字段明 】访问(如:obj._Cfoo),不建议强制访问私有成员。

class C:

    def __init__(self):
        self.foo = "公有字段"

    def func(self):
        print self.foo  # 类内部访问

class D(C):

    def show(self):
        print self.foo # 派生类中访问

obj = C()

obj.foo     # 通过对象访问
obj.func()  # 类内部访问

obj_son = D();
obj_son.show()  # 派生类中访问

class C:

    def __init__(self):
        self.__foo = "私有字段"

    def func(self):
        print self.foo  # 类内部访问

class D(C):

    def show(self):
        print self.foo # 派生类中访问

obj = C()

obj.__foo     # 通过对象访问    ==> 错误
obj.func()  # 类内部访问        ==> 正确

obj_son = D();
obj_son.show()  # 派生类中访问  ==> 错误

方法、属性的访问于上述方式相似,即:私有成员只能在类内部使用

3.类的特殊成员

Python的类成员中,存在着一些具有特殊含义的成员,详情如下:

3.1 __doc__

表示类的描述信息

class Foo:
    """描述类信息,这是用于。。。"""
    def func(self):
        pass

print(Foo.__doc__)

3.2 __module____class__
  • __module__表示当前操作的对象在哪个模块
  • __class__表示当前操作的对象的类是什么

文件:lib/aa.py

class C:
    def __init__(self):
        self.name = 'Siffre'

文件:index.py

from lib.aa import C

obj = C()
print obj.__module__  # 输出 lib.aa,即:输出模块
print obj.__class__      # 输出 lib.aa.C,即:输出类

3.3 __init__

构造方法,通过类创建对象时,自动触发执行

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

obj = Foo('Siffre') # 自动执行类中的__init__方法

3.4__del__

析构方法,当对象在内存中被释放时,自动 触发执行。

注:次方法一般无须定义,在Python中,无需关心内存的分配和释放,这些均由解释器来执行。所以,析构函数的调用时有解释器在进行垃圾回收时自动触发执行的。

class Foo:
    def __del__(self):
        pass
3.5__call__

对象后面加括号,触发执行。

注:构造方法的执行时由创建对象触发,即:对象 = 类名(),而对于__call__方法的执行是由对象后加括号触发的,即:对象()或类()()

class Foo:
    def __init__(self):
        pass    
    def __call__(self, *args, **kwargs):
        print '__call__'
obj = Foo() # 执行 __init__
obj()       # 执行 __call__
3.6__dict__

类或对象的所有成员

类的普通字段属于对象,类中的静态字段和方法属于类。

class Province:

    country = 'China'

    def __init__(self, name, count):
        self.name = name
        self.count = count

    def func(self, *args, **kwargs):
        print('func')

#获取类的成员:静态字段、方法
print(Province.__dict__)

#获取对象的成员:普通字段
obj1 = Province('Hbei', 1000)
print(obj1.__dict__)

3.7__str__

如果一个类中定义了__str__方法,那么在打印对象时,默认输出该方法的返回值

class Foo:
    def __str__(self):
        return 'Siffre'
obj = Foo()
print(obj) #Siffre
3.7__getitem____setitem____delitem__

用于索引操作,如字典。分别表示:获取、设置、删除

class Foo:

    def __getitem__(self, item):
        print('__getitem__', item)

    def __setitem__(self, key, value):
        print('__setitem__', key, value)

    def __delitem__(self, key):
        print('__delitem__', key)

obj = Foo()
result = obj['k1']
obj['k2'] = 'Siffre'
del obj['k1']

3.8__new____metaclass__

在Python中,一切皆对象。

class Foo:   
    def __init__(self):
        pass    
obj = Foo() #实例化的对象

猜测:obj对象时通过执行Foo类的构造方法创建,那么Foo类对象应该也是通过执行某种类的构造方法创建。

print(type(obj)) # 输出:<class '__main__.Foo'>     表示,obj 对象由Foo类创建
print(type(Foo)) # 输出:<type 'type'>              表示,Foo类对象由 type 类创建

推出:obj对象时Foo类的一个实例,Foo类对象时type类的一个实例,即:Foo对象时通过type类的构造方法创建。

因此,创建类可有两种方式:

  1. 普通方式
class Foo:   
    def __init__(self):
        pass    
  1. 特殊方式(type类的构造函数)
def func(self):
    print 'hello'

Foo = type('Foo',(object,), {'func': func})
#type第一个参数:类名
#type第二个参数:当前类的基类
#type第三个参数:类的成员

===> 类是有type类实例化产生的

那么问题来了,类默认是由type 类实例化产生,type类中如何实现的创建类?类又是如何创建对象?

答:类中有一个属性 __metaclass__,其用来表示该类由 谁 来实例化创建,所以,我们可以为__metaclass__ 设置一个type类的派生类,从而查看 类 创建的过程。

class MyType(type):

    def __init__(self, what, bases=None, dict=None):
        super(MyType, self).__init__(what, bases, dict)

    def __call__(self, *args, **kwargs):
        obj = self.__new__(self, *args, **kwargs)

        self.__init__(obj)

class Foo(object):

    __metaclass__ = MyType

    def __init__(self, name):
        self.name = name

    def __new__(cls, *args, **kwargs):
        return object.__new__(cls, *args, **kwargs)

# 第一阶段:解释器从上到下执行代码创建Foo类
# 第二阶段:通过Foo类创建obj对象
obj = Foo()

流程如下:

 

仅供学习参考:懒执事 » Python017-OOP|面向对象(2)

分享到:更多 ()