python-面向对象(四)——类成员的访问方式汇总

类成员的访问方式

#!/usr/bin/env python
# _*_coding:utf-8 _*_

class pepole(object):

'''This is  __doc__ information!!!'''

    country = "CHINA"   #静态字段 存在类里
    __city = "BeiJing"   #私有静态字段

    def siyou(self):     #私有字段在内部设置方法可以访问
        return pepole.__city

    def __init__(self,name,age,weight):
        self.name = name
        self.age = age    #普通字段，动态字段，对象字段  存在对象里
        self.weight = weight
        self.__name2 = "FUCK"   #私有普通字段，通过内部间接访问，也可通过特殊方法访问

    def __call__(self, *args, **kwargs):
        print 'This is __call__!!!'

    def func(self):         #括号里至少一个参数，可以多个
        print self.__name2  #内部简介访问私有字段
        return  "123"

    def __infunc(self):   #私有方法，通过内部简介访问
        print "This is __infunc!"

    def run_infunc(self):  #通过内部间接的访问私有方法

        self.__infunc()

    @classmethod     #类方法
    def class_func(cls):     #括号里只能有一个参数 cls
        return  "class_method"

    @staticmethod   #静态方法括号里不需要参数（），可以有个多参数
    def sts():
        print "This is staticmethod"

    @staticmethod      #静态的私有方法，属于类，内部间接访问
    def __static_func():    #静态方法括号里不需要参数（），可以有个多参数
        print "This is __static_func"

    def run_static(self):  #简介访问静态私有方法
        pepole.__static_func()

    @property     #属性把一个方法伪造成一个字段、一个属性，像字段那样的属性而不是一个功能
    def att(self):    #只能有一个self参数
        return  "property"

    def __str__(self):
        return "This is __str__"

#class Son(pepole):  #继承people的派生类，不能拿到父类中的私有方法或字段
#    def show(self):
        #print pepole.__city
#        pass

obj = pepole("chenchao",18,70)

print obj.__doc__#查看类里的注释信息

obj()   #执行__call__ 方法  在对象的后面加（）

printobj.country    #执行静态字段

print obj.name    #执行字段self.name = "chenchao"

print obj.siyou()  #内部访问间接的调用私有字段  __city = "Beijing"

print obj.func()   #执行普通方法    def func(self):

print pepole.class_func()   #类方法 调用类方法   @classmethod

pepole.sts()     #调用静态方法    @staticmethod

print obj.att      #执行属性的方法，不带括号 @property

obj.run_infunc()   #执行私有方法 (间接访问) def __func_method()

obj.run_static()   #执行静态的私有方法（间接访问）

print pepole.__dict__ #获取类的成员，即：静态字段，方法

print obj.__dict__  #获取obj对象的成员  普通字段，私有普通字段

print obj   #类中定义了__str__方法，打印对象默认输出方法的返回值
print str(obj)   #自动去类中找__str__方法并得到返回值

from test import pepole

obj2 = pepole("zhangsan",22,66)

print  obj2.__module__   #表示当前操作的对象在那个模块
print obj2.__class__     #表示当前操作的对象的类是什么

print obj._pepole__name2  #特殊方法访问对象中的私有普通字段
print pepole._pepole__city #特殊方法访问类中的私有静态字段
obj._pepole__infunc()  #特殊方法访问类中的私有方法
#obj2 = Son()
#obj2.show()   #如果是继承的关系，那么派生类不能访问父类中的私有方法或私有字段
　　

　　

isinstance()  issubclass()

#!/usr/bin/env python
# _*_coding:utf-8 _*_

a = 10

class A():
    print  "This is class A"

class B(A):
    print "This is class B"

w = B()

print isinstance(w,B)       #True    判断对象w 是否是类B的对象
print isinstance(w,A)       #True    类的基类也可行
print isinstance(a,int)     #True

print issubclass(B,A)       #True    判断B是A的派生类或 A是B的基类
print isinstance(B,int)     #False

isinstance(obj=对象, cls=类)           

检查obj是否是类 cls 的对象       is instance ：实例

 

 

issubclass(sub=子类, super=父类)

检查sub类是否是 super 类的派生类   is subclass：子类