python面向对象开发3 (内部类-构造-析构）魔术方法)
视频地址
http://v.youku.com/v_show/id_XNDg3NjMzNDgw.html
复习一下，类属性的用法。有的类属性是在调用类方法后才建立的，类方法可以创建新的类属性。
每次学习，代码必须纯手打。还好有vim，写起来比较方便。嗯。不错。
如果不运行类方法，那么有的类属性，是没有的。
这样的程序结构如下。
#!/usr/bin/python
#coding:utf8
var4 = "全局变量"
class Milo():
var1 = "类属性，公有属性var1"
__var2 = "类的私有属性 __var2"
def fun(self): # 或者里面写成 def fun(self,x,y,z): 里面传入3个值。
self.var2 = "对象的公有属性var2"
self.__var3 = "对象的私有属性__var3"
var4 = "函数 fun 的局部变量var4"
print var4
print self.__var3
def other(self):
print var4
print self.__var3 # 这表示在运行类方法fun()之后，实例有了个
# self.__var3的变量。所以比较好
zou = Milo()
zou.fun()
# print zou.var4 # 如果不执行类方法fun()的话，那么将没有zou.var4
zou.other() # 单独运行输出self.__var3也不行，应该先运行类方法fun()之后
魔术方法---
{内}{部}{类}--的构造
所谓内部类，就是在类内部定义的类，主要目的是为了更好的抽象现实世界。
内部类的距离：
汽车是个类，汽车的地盘，轮胎也可以抽象为类，将其定义到汽车类中，则形成了内部类，更好的描述汽车类，因为底盘，轮胎是汽车的一部分
一般不赞同使用内部类，会是程序结构复杂，但是理解内部类有助于理解模块的调用。
很多模块会使用内部类
魔术方法，魔术方法,不必实例化,当实例化类的时候，自动操作，
类似是这样的，
class Milo():
name = "csvt"
def __str__(self): # 魔术方法 __XXOO__
print "我是Milo实例化对象"
zou = Milo()
---------------运行的时候--------------
~ python cls_MoShuFangFa.py
我是Milo实例化对象
——————————————————————————————————————
说明在创建实例化对象的时候，就能自己执行一次！很magic!故称作为魔术方法。
------------------魔术函数主要应用---------------
构造函数：
用于初始化类的内部状态，Python提供的够在函数是__init__(); 在实例化时候，自动执行的，__init__() 方法是可选的，如果不提供，python会给出一
个默认的__init__方法;
一般对数据的获取需要自定义的get 和 set 方法
析构函数：
用于释放对象占用的资源，python提供的析构函数是__del__();
__del__()也是可选的，如果不提供，则python会在后台提供默认析构函数
如果要显示的调用析构函数，可以使用del关键字，方式如下：
del 对象名
更多关于魔术方法的介绍：http://pycoders-weekly-chinese.readthedocs.org/en/latest/issue6/a-guide-to-pythons-magic-methods.html#python （一定要看）
~
请看下面的代码案例：
#!/usr/bin/python
#coding:utf8
class Milo():
class Test(): # 内部类和底下这些结构是平行的
var1 = "我是内部类"
# 定义后并不冲突，Milo类还是有这些属性和方法
name = "csvt"
def __str__(self): # 魔术方法,不必实例化,当实例化类的时候，自动操作
return "我是Milo实例化的对象"
def fun1(self):
print self.name
print "我是公有方法"
self.__fun2()
def __fun2(self): # 这是一个内置方法
print self.name
print "我是私有方法"
# @classmethod
def classFun(self):
print self.name
print "我是类方法"
classNewFun = classmethod(classFun)
# @staticmethod
def staticFun(self):
print Milo.name
print "我是静态方法"
staticNewFun = staticmethod(staticFun)
zou = Milo() # 先创建一个实例
print zou #输出的结果是“我是Milo实例化的对象"
内部类构造函数：
自己写一个get 或者 set 方法，
用来自定义一些值。
1。常用 自己写一个 set 方法，来设置类中属性的值
class Moto():
a = "This is a"
b = "This is b"
def set(self,x) # 设置了一个简单的设置类内部变量的方法
self.a = x
if __name__ == "__main__":
obj = Moto()
out = obj.set("How are you?") # 自己定义的类中 get()方法，
print out # 这样的话就直接输出“How are you?"这句话了。
#这是一个简单的设置一个值的方法
2. 常用get方法 来获取 类中属性的值，或者需要的数据
class Moto():
a = "This is a"
b = "This is b"
def get(self,x)
if x == "a":
return self.a
else:
return self.b
obj = Moto()
out = obj.get("a") # 自己定义的类中 get()方法，
print out # 这样的话就直接输出“This is a"这句话了。
构造函数：
#!/usr/bin/python
#coding:utf8
name = "global"
class Ren:
name = "人"
hight = "一人高"
wight = "一人重"
__money = "我有10块钱" # 私有属性
__age = 30
def __init__(self,n = "婴儿"): # 实例化的时候，就会被执行
print "初始化"
self.name = n
def run(self): # 类的方法定义，必须有一个行参
#有人吧self，写成cls 就是class
print self.name # 类中访问自己类的属性。
print "跑步"
def __lie(self): # 私有方法只能被类内部方法使用
print "我很欣赏你"
def say(self):
print "说话"
self.__lie() # 这个表示是调用的当前自己类里面的私有方法
def get(self,x): # 一般在调用私有属性的时候，都是新建一个方法
# 这里用了(self,x)目的是为了使用get("money")
# 这样的用法
# return self.x # 将私有属性封装起来
if x == "money":
return self.__money
elif x == "age":
return self.__age
else:
return "请正确输入"
def set(self,x): # 使用这个方法，我们用来修改内置属性
self.__age = x
def moRi(self):
return "世界末日"
mr = classmethod(moRi) # 类的方法，动态的,不实例化类，也能访问这个方法
# 从内存角度来说，节省内存，别的方法没有加载
if __name__ == '__main__': # 这表示如果被别人调用的话，将不执行
# 被自己调用，执行
zhangsan = Ren("张三") # 把Ren类实例化，变成张三
print zhangsan.name
lisi = Ren("李四")
print lisi.name
wangwu = Ren()
print wangwu.name
wangwu.__init__("王五") # 魔术函数也可以这样用
print wangwu.name
显示的结果为：
alex@universe ~/python/OOP $ python cls_LeiDeGouZao.py
初始化
张三
初始化
李四
初始化
婴儿
初始化
王五
注意：王五上面有两个初始化，原因是源代码又执行了一次魔术函数 wangwu.__init__("王五")
~
释放对象
现在我们需要结束程序了，这样我们需要释放一些内存，对象完成之后能自动释放，（比如我们已经建立了一个mysql的对象）
在类中使用
def __del__(self):
self.p.close()
print "释放资源完成"
##############通过上面的手段我们可以释放盛放对象的内存！
样例如下：
1 #!/usr/bin/python 2 #coding:utf8 3 name = "global" 4 5 class Ren: 6 name = "人" 7 hight = "一人高" 8 wight = "一人重" 9 __money = "我有10块钱" # 私有属性 10 __age = 30 11 12 13 def __init__(self,n = "婴儿"): # 实例化的时候，就会被执行 14 print "初始化中，请稍后……" 15 self.name = n 16 self.p = file('/etc/passwd','r') # 这是一个读操作，初始化完成后，需要关闭 17 18 def run(self): # 类的方法定义，必须有一个行参 19 #有人吧self，写成cls 就是class 20 print self.name # 类中访问自己类的属性。 21 print "跑步" 22 23 def __lie(self): # 私有方法只能被类内部方法使用 24 print "我很欣赏你" 25 26 def say(self): 27 print "说话" 28 self.__lie() # 这个表示是调用的当前自己类里面的私有方法 29 30 31 def get(self,x): # 一般在调用私有属性的时候，都是新建一个方法 32 # 这里用了(self,x)目的是为了使用get("money") 33 # 这样的用法 34 # return self.x # 将私有属性封装起来 35 if x == "money": 36 return self.__money 37 elif x == "age": 38 return self.__age 39 else: 40 return "请正确输入" 41 42 def set(self,x): # 使用这个方法，我们用来修改内置属性 43 self.__age = x 44 45 def moRi(self): 46 return "世界末日" 47 48 mr = classmethod(moRi) # 类的方法，动态的,不实例化类，也能访问这个方法 49 # 从内存角度来说，节省内存，别的方法没有加载 50 51 def __del__(self): # 释放函数，析构函数，当函数调用完成后自动释放 52 self.p.close() # p这个对象的从内存中释放 53 print "释放资源完成" 54 55 56 if __name__ == '__main__': # 这表示如果被别人调用的话，将不执行 57 # 被自己调用，执行 58 59 zhangsan = Ren("张三") # 把Ren类实例化，变成张三 60 print zhangsan.name
显示结果如下：
alex@universe ~/python/OOP $ python cls_Lei_XiGouHanShu.py
初始化中，请稍后……
张三
释放资源完成
alex@universe ~/python/OOP $
如果我们怕忘记
def __del__(self):
self.p.close() # 析构函数忘记加入类里面了
我们可以使用python自带的一个gc模块，垃圾内存回收机制
[python 里面有一个自动的垃圾回收装置。]
python采用垃圾回收机制来清理不再使用的对象;python提供gc模块释放不再使用的对象
python采用“引用计数”的算法方式来处理回收，即：当某个对象在其作用域的不再被其他对象引>用的时候，python就会自动清除对象;
python的函数collect()可以一次收集所有待处理的对象(gc.collect())
用法如下：
1 #!/usr/bin/python 2 #coding:utf8 3 name = "global" 4 import gc # 引入gc模块，用来释放内存垃圾 5 class Ren: 6 name = "人" 7 hight = "一人高" 8 wight = "一人重" 9 __money = "我有10块钱" # 私有属性 10 __age = 30 11 12 13 def __init__(self,n = "婴儿"): # 实例化的时候，就会被执行 14 print "初始化中，请稍后……" 15 self.name = n 16 self.p = file('/etc/passwd','r') # 这是一个读操作，初始化完成后，需要关闭 17 18 def run(self): # 类的方法定义，必须有一个行参 19 #有人吧self，写成cls 就是class 20 print self.name # 类中访问自己类的属性。 21 print "跑步" 22 23 def __lie(self): # 私有方法只能被类内部方法使用 24 print "我很欣赏你" 25 26 def say(self): 27 print "说话" 28 self.__lie() # 这个表示是调用的当前自己类里面的私有方法 29 30 31 def get(self,x): # 一般在调用私有属性的时候，都是新建一个方法 32 # 这里用了(self,x)目的是为了使用get("money") 33 # 这样的用法 34 # return self.x # 将私有属性封装起来 35 if x == "money": 36 return self.__money 37 elif x == "age": 38 return self.__age 39 else: 40 return "请正确输入" 41 42 def set(self,x): # 使用这个方法，我们用来修改内置属性 43 self.__age = x 44 45 def moRi(self): 46 return "世界末日" 47 48 mr = classmethod(moRi) # 类的方法，动态的,不实例化类，也能访问这个方法 49 # 从内存角度来说，节省内存，别的方法没有加载 50 51 # def __del__(self): # 释放函数，析构函数，当函数调用完成后自动释放 52 # self.p.close() # p这个对象的从内存中释放 53 # print "释放资源完成" 54 55 56 if __name__ == '__main__': # 这表示如果被别人调用的话，将不执行 57 # 被自己调用，执行 58 59 zhangsan = Ren("张三") # 把Ren类实例化，变成张三 60 zhangsan.run() 61 zhangsan.run() 62 zhangsan.run() 63 zhangsan.run() 64 zhangsan.run() 65 zhangsan.run() 66 zhangsan.run() 67 print gc.collect() 68 lisi = Ren("李四") # 把Ren类实例化，变成李四 69 lisi.run() 70 lisi.run() 71 lisi.run() 72 lisi.run() 73 lisi.run() 74 lisi.run() 75 print gc.collect() # 显示一下到底还剩下多少内存垃圾，释放完成了后，应该是0.这个做测试比较推荐
输出的结果是：
alex@universe ~/python/OOP $ python cls_Lei_gc_ShiFang.py 初始化中，请稍后…… 张三 跑步 张三 跑步 张三 跑步 张三 跑步 张三 跑步 张三 跑步 张三 跑步 0 初始化中，请稍后…… 李四 跑步 李四 跑步 李四 跑步 李四 跑步 李四 跑步 李四 跑步 0
上面的显示为0,说明所有的内存都已经被释放完毕了。
import gc
gc.collect()
比较好用。
下一讲，是常用内置方法
已经讲了，__init__ , __str__, __del__, 还要讲一些
