day25-面向对象结构与成员

1、面向对象结构分析

如下面的图所示:面向对象整体大致分两块区域：

每个大区域又可以分为多个小部分：

class A:
    name = 'Tom'  # 静态变量(静态字段)
    __iphone = '138xxxxxxxx'  # 私有静态变量(私有静态字段)
 
    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、面向对象的私有与公有

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

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

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

2.1、静态字段(静态变量)

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

1）公有静态字段

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() # 派生类中可以访问

2）私有静态字段

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

2.2、普通字段(对象属性)

公有普通字段：对象可以访问；类内部可以访问；派生类中可以访问
私有普通字段：仅类内部可以访问

1）公有普通字段

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()  # 派生类中访问

2）私有普通字段

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()  # 派生类中访问  ==> 错误

2.3、方法

公有方法:对象可以访问；类内部可以访问；派生类中可以访问
私有方法:仅类内部可以访问

1）公有方法

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()  # 派生类中访问 

2）私有方法

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()  # 派生类中不能访问

2.4、总结

对于这些私有成员来说,他们只能在类的内部使用,不能在类的外部以及派生类中使用.
ps：非要访问私有成员的话，可以通过 对象._类__属性名obj._Classname__privateAttributeOrMethod 来访问：
,但是绝对不允许!!!
为什么可以通过._类__私有成员名访问呢?因为类在创建时,如果遇到了私有成员(包括私有静态字段,私有普通字段,私有方法)，它会将其保存在内存时自动在前面加上_类名，可以在__dict__中看到。

3、面向对象的成员

3.1、字段

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

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

class Province:
    # 静态字段
    country ＝ '中国'
 
    def __init__(self, name):
        # 普通字段
        self.name = name
 
# 直接访问普通字段
obj = Province('河北省')
print obj.name
 
# 直接访问静态字段
Province.country

上述代码可以看出：

普通字段需要通过对象来访问，静态字段通过类访问
在使用上可以看出普通字段和静态字段的归属是不同的

其在内存的存储方式类似如下图：

由上图可以看出：
静态字段在内存中只保存一份
普通字段在每个对象中都要保存一份

应用场景：

通过类创建对象时，如果每个对象都具有相同的字段，那么就使用静态字段

3.2、方法

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

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

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

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

实例方法就是第一个参数是self，类方法就是第一个参数是cls，而静态方法不需要额外的参数
类方法和静态方法都可以访问类的静态变量(类变量)，但不能访问实例变量，例如不能访问self.name,而普通方法则可以

1）普通方法
简而言之，实例方法就是类的实例能够使用的方法。这里不做过多解释。

2）类方法
使用装饰器@classmethod。
原则上，类方法是将类本身作为对象进行操作的方法。假设有个方法，且这个方法在逻辑上采用类本身作为对象来调用更合理，那么这个方法就可以定义为类方法。另外，如果需要继承，也可以定义为类方法。

class Student:
    tag = 1
 
    @classmethod
    def info(cls):
        return cls.tag
 
print(Student.info())
结果：1

如下场景：
假设我有一个学生类和一个班级类，想要实现的功能为：
执行班级人数增加的操作、获得班级的总人数；
学生类继承自班级类，每实例化一个学生，班级人数都能增加；
最后，我想定义一些学生，获得班级中的总人数。

思考：这个问题用类方法做比较合适，为什么？因为我实例化的是学生，但是如果我从学生这一个实例中获得班级总人数，在逻辑上显然是不合理的。同时，如果想要获得班级总人数，如果生成一个班级的实例也是没有必要的。

class ClassTest:
    __num = 0
 
    @classmethod
    def addNum(cls):
        cls.__num += 1
 
    @classmethod
    def getNum(cls):
        return cls.__num
 
    # 这里我用到魔术函数__new__，主要是为了在创建实例的时候调用人数累加的函数。
    def __new__(cls, *args, **kwargs):
        ClassTest.addNum()  #括号里不用写cls
        return object.__new__(cls)
 
class Student(ClassTest):
    def __init__(self,name):
        self.name = name
 
s1 = Student('小王')
s2 = Student('小张')
print(ClassTest.getNum())
结果：2

3）静态方法
使用装饰器@staticmethod。
静态方法是类中的函数，不需要实例。静态方法主要是用来存放逻辑性的代码，逻辑上属于类，但是和类本身没有关系，也就是说在静态方法中，不会涉及到类中的属性和方法的操作。可以理解为，静态方法是个独立的、单纯的函数，它仅仅托管于某个类的名称空间中，便于使用和维护。

譬如，我想定义一个关于时间操作的类，其中有一个获取当前时间的函数。

import time
 
class TimeTest:
    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)

如上，使用了静态方法（函数），然而方法体中并没使用（也不能使用）类或实例的属性（或方法）。若要获得当前时间的字符串时，并不一定需要实例化对象，此时对于静态方法而言，所在类更像是一种名称空间。

其实，我们也可以在类外面写一个同样的函数来做这些事，但是这样做就打乱了逻辑关系，也会导致以后代码维护困难。

3.3、属性
在Python中，property可以将方法变成一个属性来使用，借助property可以实行Python风格的getter/setter，即可以通过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

#不使用property
class BMI:
    def __init__(self, name, weight, high):
        self.name = name
        self.high = high
        self.weight = weight
 
    def bmi_show(self):
        rst = self.weight/self.high ** 2
        print('%s的BMI值为%s' %(self.name, rst))
 
p1 = BMI('Tom', 65, 1.7)
p1.bmi_show() #需要通过调用方法()的方式显示结果
 
#使用property
class BMI:
    def __init__(self, name, weight, high):
        self.name = name
        self.high = high
        self.weight = weight
    @property
    def bmi_show(self):
        rst = self.weight/self.high ** 2
        print('%s的BMI值为%s' %(self.name, rst))
 
p1 = BMI('Tom', 65, 1.7)
p1.bmi_show #将方法伪装成一个属性，通过调用属性的方式显示结果

为什么要用property

将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则

@property可以将python定义的函数“当做”属性访问，从而提供更加友好访问方式。
1》只有@property表示只读。
2》同时有@property和@x.setter表示可读可写。
3》同时有@property和@x.setter和@x.deleter表示可读可写可删除。

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

class A:
    @property
    def func(self):
        print('get的时候运行我')
 
    @func.setter
    def func(self,value):
        print('set的时候运行我')
 
    @func.deleter
    def func(self):
        print('del的时候运行我')
 
#只有在方法func定义property后才能定义func.setter，func.deleter
obj1 = A()
obj1.func
#get的时候运行我
obj1.func = 'a'
#set的时候运行我
del obj1.func
#del的时候运行我
 
或者：
class Foo:
    def get_func(self):
        print('get的时候运行我啊')
 
    def set_func(self,value):
        print('set的时候运行我啊')
 
    def delete_func(self):
        print('delete的时候运行我啊')
    func=property(get_func,set_func,delete_func) #内置property三个参数与get,set,delete一一对应
 
obj = Foo()
obj.func
#get的时候运行我啊
obj.func = 'a'
#set的时候运行我啊
del obj.func
# delete的时候运行我啊

例子：显示苹果的价格

class Apple:
    def __init__(self, ori_price, discount):
        self.ori_price = ori_price
        self.discount = discount
    @property
    def price(self):
        ret = self.ori_price * self.discount
        print('苹果的折扣价是%s'%ret)
    @price.setter
    def price(self, new_price):
        self.ori_price = new_price
apple1 = Apple(8, 0.8) #定义苹果的价格是8元/kg，折扣是0.8
apple1.price
 
apple1.price = 7 #重新定义苹果的价格是7元/kg，这时苹果的价格是7*0.8
apple1.price

银行账号的例子，我们要确保没人能设置金额为负，并且有个只读属性cny返回换算人名币后的金额。

class Account:
    def __init__(self, rate):
        self._amount = 0
        self.rate = rate
 
    @property
    def amount(self):
      """账号余额（美元）"""
        return self._amount
 
    @property
    def cny(self):
     """账号余额（人名币）"""
        return self._amount * self.rate
    @amount.setter
    def amount(self, value):
        if value < 0:
            print('金额不能为负')
        else:
            self._amount = value
 
obj1 = Account(6.6)
obj1.amount = 100
print(obj1.cny)
#660.0
obj1.amount = -100
#金额不能为负