面向对象之：类的成员

 

1.细分类的组成成员

class A:
​
    name = '张三'  # 静态变量(静态字段)
    __iphone = '455668235'  # 私有静态变量(私有静态字段)
​
​
    def __init__(self,name,age): #特殊方法
​
        self.name = name  #对象属性(普通字段)
        self.__age = age  # 私有对象属性(私有普通字段)
​
    def func1(self):  # 普通方法
        pass
​
    def __func(self): #私有方法
        print(666)
​
​
    @classmethod  # 类方法
    def class_func(cls):
        """ 定义类方法，至少有一个cls参数 """
        print('类方法')
​
    @staticmethod  #静态方法
    def static_func():
        """ 定义静态方法 ，无默认参数"""
        print('静态方法')
​
    @property  # 属性
    def prop(self):
        pass

2.类的私有成员

每一个类的成员而言都有两种形式：

• 公有成员，在任何地方都能访问

• 私有成员，只有在类的内部才能方法

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

静态字段(静态属性)

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

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.__name  # 不可在外部访问
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()  # 派生类中访问

• 私有普通字段：仅类内部可以访问；

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):
        pass
    
    def add(self):
        print('in C')
​
class D(C):
​
    def show(self):
        print('in D')
        
    def func(self):
        self.show()
obj = D()
obj.show()  # 通过对象访问   
obj.func()  # 类内部访问    
obj.add()  # 派生类中访问  

• 私有方法:仅类内部可以访问；

class C:
​
    def __init__(self):
        pass
​
    def __add(self):
        print('in C')
​
class D(C):
​
    def __show(self):
        print('in D')
​
    def func(self):
        self.__show()
obj = D()
obj.__show()  # 通过不能对象访问
obj.func()  # 类内部可以访问
obj.__add()  # 派生类中不能访问

总结：对于这些私有成员来说,他们只能在类的内部使用,不能再类的外部以及派生类中使用.

3.类的其他成员

实例方法

第一个参数必须是实例对象，该参数名一般约定为“self”，通过它来传递实例的属性和方法（也可以传类的属性和方法），只能由实例对象调用。

类方法

使用装饰器@classmethod。第一个参数必须是当前类对象，该参数名一般约定为“cls”，通过它来传递类的属性和方法（不能传实例的属性和方法）；实例对象和类对象都可以调用。

class Student:
    
    __num = 0
    def __init__(self,name,age):
        self.name = name
        self.age= age
        Student.addNum() 
        
    @classmethod
    def addNum(cls):
        cls.__num += 1
​
    @classmethod
    def getNum(cls):
        return cls.__num
​
​
​
a = Student('张三', 18)
b = Student('李四', 36)
c = Student('王五', 73)
print(Student.getNum())

静态方法

使用装饰器@staticmethod。参数随意，没有“self”和“cls”参数，但是方法体中不能使用类或实例的任何属性和方法；实例对象和类对象都可以调用。

import time
​
class TimeTest(object):
    def __init__(self, hour, minute, second):
        self.hour = hour
        self.minute = minute
        self.second = second
​
    @staticmethod
    def showTime():
        return time.strftime("%H:%M:%S", time.localtime())
​
​
print(TimeTest.showTime())
t = TimeTest(2, 10, 10)
nowTime = t.showTime()
print(nowTime)

属性

property属性

例题

例一：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）
​
成人的BMI数值：
过轻：低于18.5
正常：18.5-23.9
过重：24-27
肥胖：28-32
非常肥胖, 高于32
　　体质指数（BMI）=体重（kg）÷身高^2（m）
　　EX：70kg÷（1.75×1.75）=22.86

代码

 通过装饰器形式构建的属性组合

class Bmi:
​
     def __init__(self, name, weight, height):
         self.name = name
         self.weight = weight
         self.height = height
​
     @property
     def bmi(self):
         return self.weight/self.height**2
​
     @bmi.setter
     def bmi(self, aaa):
         print('------>',aaa)
​
     @bmi.deleter
     def bmi(self):
         print('删除时执行我！')
 # wk = Bmi('王无',80,1.83)
 # lj = Bmi('王六',60,1.75)
 # # print(wk.bmi())
 # print(lj.bmi)
 # 稍微有一点点不合理，bmi应该是最为属性的但是我们把它整成方法了。
 # 属性：将一个方法伪装成了一个属性，虽然在代码上没什么提
 obj = Bmi('李四',60,175)
 obj.bmi  # 执行bmi方法的指令。
 obj.bmi = 666  # 执行被bmi.setter装饰的方法的指令。
 del obj.bmi

由于新式类中具有三种访问方式，我们可以根据他们几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除

class Foo:
    @property
    def AAA(self):
        print('get的时候运行我啊')
​
    @AAA.setter
    def AAA(self,value):
        print('set的时候运行我啊')
​
    @AAA.deleter
    def AAA(self):
        print('delete的时候运行我啊')
​
#只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter
f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA
​

或者：

class Foo:
    def get_AAA(self):
        print('get的时候运行我啊')
​
    def set_AAA(self,value):
        print('set的时候运行我啊')
​
    def delete_AAA(self):
        print('delete的时候运行我啊')
    AAA=property(get_AAA,set_AAA,delete_AAA) #内置property三个参数与get,set,delete一一对应
​
f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA

isinstance 与 issubclass

• isinstance(a,b)：判断a是否是b类实例化对象（或者b类的派生类）

class A：
    pass
​
class B(A):
    pass
​
obj = B()
​

isinstance(a,b)：判断对象与类之间的关系，判断a是否是b类（或者b类的派生类）实例化对象

issubclass(a,b)：判断类与类之间的关系，判断a类是否是b类的派生类（子孙类）