二十一、 Python 面向对象基础（二） -- 类成员、修饰符、特殊成员

 

一、类成员

   类成员可以分为3类：字段，方法和属性。

   字段：静态字段、普通字段

   方法：静态方法、普通方法、类方法

   属性：普通属性

 

  通过类访问：静态字段、 静态方法、类方法、

  通过对象访问：普通字段，类普通方法、类特性

 

 所有的成员中：只有普通字段内容保存在对象中。即：根据此类创建了多少对象，在内存中就有多少普通字段。

                      其他的成员则保存在类中。即：无论对象多少，在内存中仅创建一份。

 

 

二、字段

 字段包括：普通字段和静态字段。他们在定义和使用中有区别。本质区别为在内存中保存的位置不同。

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

   静态字段，将每个对象重复的东西放到类中。

   访问规则：谁的成员谁访问。对象的成员用对象访问。类的成员用类访问，除了类中的方法。

  

class Province:

    #静态字段
    country = '中国'

    def __init__(self,name):

        #普通字段
        self.name = name

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

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

#也可以通过对象访问静态字段，但是不推荐
print(obj.country)

 从上图可以看出

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

 

 

三、方法

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

  普通方法：由对象调用，至少一个self参数；执行普通参数的时候，自动调用该方法的对象，赋值给self

  静态方法：由类调用，无默认参数。

  类方法：由类调用；至少一个cls参数。在执行的时候，自动调用该类赋值个给cls

 

  静态方法：仅仅属于该类，类似函数工具库的作用。可以直接使用，不需要类的实例调用

  类方法：将类作为参数传递，主要用来获取和类相关的一些数值

 

class Foo:

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

    def ord_func(self):

        """
        定义普通方法，至少一个self参数
        :return:
        """
        #print self.name

        print('普通方法')

    @classmethod

    def class_fun(cls):
        """
        定义类方法，至少有一个cls 参数
        :return:
        """
        print('类方法')
        print(dir(cls))

    @staticmethod
    def static_func():
        """静态方法，无默认参数"""
        print('静态方法')


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

#调用类方法
Foo.class_fun()

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


C:\Python35\python.exe D:/python/day8/pr.py
普通方法
类方法
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'class_fun', 'ord_func', 'static_func']
静态方法

  

相同点：对于所有方法而言，均属于类中。所以在内存中也只保存一份。

 不同点：方法调用者不同。调用方法时传递的参数不同

 

四、属性

  Python中的属性就是普通方法的变种。

•  属性的基本使用
•  属性的两种定义方式

 1：属性的基本使用

class Foo:

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

    def ord_func(self):

        """
        定义普通方法，至少一个self参数
        :return:
        """
        #print self.name

        print('普通方法')

    @property
    def start(self):
        temp = '%s '%self.name
        print(temp)


#调用普通方法
f = Foo('yy')

#直接使用特性名称访问
f.start

 

属性的定义和使用的注意点：

定义时，在普通方法的基础上添加 @property 装饰器

定义时，仅仅有self一个参数

调用方法的时候，无需()

 

属性存在的意义: 访问属性时可以制造出和访问字段相同的假象。

             

2、属性的定义

（此部分，需要参考老师博客http://www.cnblogs.com/wupeiqi/p/4766801.html）

装饰器：在方法上应用property装饰器

    @property
    def start(self):
        temp = '%s '%self.name
        print(temp)

 

静态字段：定义只为property对象的静态字段

BAR = property(get_bar)

 

五、成员修饰符

类的所有成员，对于访问分2种：

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

 

1：私有成员和公有成员定义不同

私有成员命名时：前2个字符是下划线（特殊成员除外：__init__, __call__, __dict__等）

 

2： 私有成员和公有成员的访问限制不同

静态字段

• 公有静态字段 ：类可以访问；类内部可以访问；派生类可以访问
• 私有静态字段 ：仅内部可以访问

 

普通字段

• 公有普通字段： 对象可以访问；类内部可以访问；派生类可以访问
• 私有普通字段：仅类内部可以访问
• 如果要强制访问私有字段，可以使用【对象.__类名称__私有字段】 访问

• class Foo:
  
      def __init__(self):
          self.name = '公有字段'
          self.__foo = '私有字段'
  
      def Foo_f1(self):
          print(self.__foo)
  
  class B(Foo):
      def F1(self):
          print(self.name)
          #派生类调用父类私有字段报错
          #print(self.__foo)
  
          #强制访问
          print(self._Foo__foo)
  
  obj1 = Foo()
  obj2 = B()
  #对象调用普通公有字段
  print(obj1.name)
  print(obj2.name)
  #对象调用普通私有字段报错
  # print(obj1.__foo)
  # print(obj2.__foo)
  
  #类内部可以调用私有字段
  obj1.Foo_f1()
  obj2.Foo_f1()
  obj2.F1()
  
  
  #强制访问
  obj1._Foo__foo

   

静态字段

• 普通静态字段
• 私有静态字段
• 如果要强制访问私有字段，可以使用【对象.__类名称__私有字段】 访问

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

    def Foo_f1(self):
        print(Foo.age)
        print(Foo.__sex)

class B(Foo):
    def F1(self):
        print(self.name)
        #派生类调用父类私有字段报错
        # print(self.__foo)

        #强制访问
        print(self._Foo__foo)

        #强制访问
        print(self._Foo__sex)



obj1 = Foo()
obj2 = B()

#公有静态类可以访问
print(Foo.age)

#私有静态，类直接访问报错
# print(Foo.__sex)

#公有静态类内部可以访问
#私有静态类内可以直接访问
obj1.Foo_f1()

#公有静态派生类可以访问
print(obj2.name)

#私有静态派生类访问直接报错
# print(obj2.__sex)


obj2.F1()

 

方法

 普通方法

•  普通公有方法： 在对象、类内部、派生类访问
•  普通私有访问：仅仅在内内部访问
• 如果要强制访问私有字段，可以使用【对象.__类名称__私有字段】 访问

class Foo:

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

    def Foo_f1(self):
        print('普通公有方法')

    def __Foo_f2(self):
        print('普通私有方法')


    def Foo_f3(self):
        self.__Foo_f2()

    @staticmethod
    def static_method():
        print('静态方法')





class B(Foo):
    def F1(self):
        self.Foo_f1()
        
        #强制调用普通私有
        self._Foo__Foo_f2()


obj1 = Foo()
obj2 = B()

#对象调用普通访问
obj1.Foo_f1()

#对象调用普通私有报错
# obj1.__Foo_f2()

#类内部调用普通私有方法
obj1.Foo_f3()

obj2.F1() 

 

 静态方法

•  静态公有方法： 在对象、类内部、派生类访问
•  静态私有访问：仅仅在内内部访问
• 如果要强制访问私有字段，可以使用【对象.__类名称__私有字段】 访问

class Foo:

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

    @staticmethod
    def Foo_f1():
        print('静态公有方法')

    @staticmethod
    def __Foo_f2():
        print('静态私有方法')


    def Foo_f3(self):
        self.__Foo_f2()


class B(Foo):
    def F1(self):
        self.Foo_f1()

        #强制调用普通私有
        self._Foo__Foo_f2()


obj1 = Foo()
obj2 = B()
# 类中直接调用静态公有方法
Foo.Foo_f1()

# 类内部调用静态私有方法访问
obj1.Foo_f3()

#派生类调用静态公有，强制调用静态私有
obj2.F1()

 

 在属性上，与字段和方法类似。

 

  六、类的特殊成员

类中有字段、字段、属性三大类成员

如果成员前有两个下环线，表示该成员是私有成员，私有成员只能用于类内部调用。 

但是也存在一些特殊含义的成员

1：__doc__

   输出类的描述信息

class Foo():
    """  查看类的doc """

    def func(self):
        pass


obj1 = Foo()
print(Foo.__doc__)
print(obj1.__doc__)

 

2：__module__ 和 __class__

   __module__当前操作的对象在哪个模块

   __class__ 当前操作的对象是什么类

class Foo():
    """  查看类的doc """

    def func(self):
        pass


obj1 = Foo()
print(Foo.__module__)
print(obj1.__module__)
print(Foo.__class__)
print(obj1.__class__)


C:\Python35\python.exe D:/python/day8/pr.py
__main__
__main__
<class 'type'>
<class '__main__.Foo'>

 

3、__init__

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

 

class Foo():
    """  查看类的doc """

    def func(self):
        pass
    def __init__(self):
        print('我是构造函数')

obj1 = Foo()  #自动触发__init__

 

4、__del___

  解析防范，在对象被释放的时候，自动触发

  此方法不需要定义。python在进行垃圾回收的时候自动触发执行

 

5、__call__

 对象后面加()，触发执行

• 构造方法的执行是有创建对象触发的。即： 对象= 类名（）
• 对于__call__的方法的执行是有对象后加（）触发执行，即对象（） 或者类（）

 

class Foo():
    def func(self):
        pass
    def __init__(self):
        print('我是构造函数')

    def __call__(self):
        print('我是call函数')

obj1 = Foo()  #自动触发__init__

# 对象后加（）触发执行__call__
obj1()

#类后加（）触发执行__call__
Foo()()

C:\Python35\python.exe D:/python/day8/pr.py
我是构造函数
我是call函数
我是构造函数
我是call函数

 

6、__dict__

 显示对象或者类中所有成员

普通字段属于对象，静态字段和方法属于类。

class Foo():
    name = 'Foo'

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

obj1 = Foo(18)

#获取类所有的成员  ：静态成员和方法
print(Foo.__dict__)

#{'__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__init__': <function Foo.__init__ at 0x009D4F60>, '__dict__': <attribute '__dict__' of 'Foo' objects>, 'name': 'Foo', '__module__': '__main__', '__doc__': None}

#获取对象的成员
print(obj1.__dict__)
#{'age': 18}

 

7、__str__

  打印对象，默认返回对象的地址

  如果类中定义了__str__, 在打印对象的时候， 返回该方法返回值

  

class Foo():
    name = 'Foo'

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

    def __str__(self):
        return '我是一个字符串'

obj1 = Foo(18)
print(obj1)
# 未定义__str__ <__main__.Foo object at 0x005995D0>

#添加 __str__ 后返回 我是一个字符串

 

8、 __gettiem__  __setitem__  __delitem__

  用于索引上进行操作，如字段。以上分别为获取、设置、删除数据

 

class Foo:

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

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

   def __setitem__(self,item,value):
       print(item,value)

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

obj1 = Foo('kk')

#对象后【】 调用 __getitem__
result = obj1['k1']

#自动执行__setitem__
obj1['k2'] = 123

#自动执行__delitem__
del obj1['k2']

 

9、__getslice__ __setslice__ __delslice__

   上面3个方法用于切片操作（python2.7）

   在3.5中，3个功能被 __getitem__  __setitem__ __delitem__ 替换

   

class Foo:

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

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

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

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

obj1 = Foo('kk')

#调用 __getitem__  <class 'slice'> slice(1, 3, None) __getitem__
result = obj1[1:3]

#自动执行__setitem__
obj1[1,2] = [11,22]

#自动执行__delitem__
del obj1[1,2]


C:\Python35\python.exe D:/python/day8/pr.py
<class 'slice'> slice(1, 3, None) __getitem__
(1, 2) [11, 22] __setitem__
(1, 2) __delitem__

 

 10、__iter__

  用于迭代器，列表、字段、元组都可以进行迭代，是因为内部定义了__inter__

 如果for对象，直接执行 对象内部的__iter__

 

  有2中方式： 在__iter__应用yield

                   在__iter__iter 返回迭代器

class Foo(object):

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

    #第一种方式
    def __iter__(self):
        yield 1
        yield 2
        yield 3

    #第二种方式
    def __iter__(self):
        return iter(self.sq)

obj1 = Foo([11,22,33,44])

for i in obj1:
    print(i)

 

11： __new__ 和 __metaclass__

   __new__ 创建类实例

   __metaclass__ 指定类由哪个类创建

   类本身也是对象。类是type 类的实例

   

#普通方式
class Foo(object):

    def func1(self):
        print('Foo')


obj1 = Foo()
obj1.func1()

#特殊方式，type创建
def func(self):
    print('bar')

Bar = type('Bar',(object,),{'func':func})

#type 第一个参数，类名称
#type 第二个参数，当前类的基类
#type 第三个参数，类的成员

obj2 = Bar()
obj2.func()