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
#金额不能为负