python面向对象开发 2 类的方法

视频地址：

http://v.youku.com/v_show/id_XNDg3MzQ0NDQ0.html

____________________________________________________________

{类}{的}{方}{法}

方法的定义，和函数定义一样，但是需要self作为地一个参数

类的方法也有分类：公有方法和私有方法

————————私有方法：不能被外部类和方法调用，只能被自己类内部调用
定义方法为在前面加上“__"双下滑线就可以了;

________动态方法： 被classmethod()函数处理过的函数，能被类所调用，也能被对象所调用（是继承的关系）动态的,别的方法没有被加载进去，节省内存,>当需要执行某一个特定的方法的时候，会去动态加载，在执行效率来说，比较慢，但节省资源;

________静态方法：被staticmethod()函数处理过的函数，要被处理的函数需要加self,当运行类的时候，所有的属性和方法都传进去了。所以没有用self。会
占用更多的内存。但是在寻找类方法，类属性的时候，速度快（已经全部加载进去不必单独搜索），但不节省资源。

————————共有方法：在自己类内外都能被调用。
~

类的装饰器

@classmethod

@staticmethod

被修饰的方法原来叫什么名，还是什么名，就在不知不觉中变成了类方法（classmethod,可以被直接调用，动态的，节省资源，但耗费搜索时间)，还会在不知不觉中变成了静态方法(staticmethod, 可以被直接调用，静态的，浪费资源，但速度快，所有方法与属性都已经被加载到内存里面了）

静态方法和动态方法在调用的时候是看不到任何区别，调用方法是一样的。

一般没什么区别，在大型数据的时候，需要考虑到运行时间，运行资源的时候，需要考虑一下classmethod, staticmethod的选择问题

修改类内置属性的办法：

#!/usr/bin/python
#coding:utf8
class Ren:
    name = "人"
    hight = "一人高"
    wight = "一人重"
    __money = "我有10块钱"		# 私有属性
    __age = 30
    
    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类实例化，变成张三
   # zhangsan.__age = 20 # 私有属性是不能设置值的，因为根本访问不了
   zhangsan.say()	# 这样我们就可以通过self.__lie() 来调用私有方法了


   zm = zhangsan.get("age")
   print zm
   zhangsan.set(20)
   print zhangsan._Ren__age

　　类方法！ 直接调用类方法 classmethod() [其他的没有加载，节省资源]

#!/usr/bin/python
#coding:utf8
class Ren:
    name = "人"
    hight = "一人高"
    wight = "一人重"
    __money = "我有10块钱"		# 私有属性
    __age = 30
    
    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)	# 类的方法，动态的,不实例化类，也能访问这个方法
			# 从内存角度来说，节省内存，别的方法没有加载
			# 把 moRi()这个方法变成了类方法,可供外部直接调用


if __name__ == '__main__':      # 这表示如果被别人调用的话，将不执行
				# 被自己调用，执行

   print Ren.mr()		# 调用的类方法,其他的方法没有加载
			# 节省内存！

　　静态方法，staticmethod()   功能上一样，在原理多加载了内存，多加载了

#!/usr/bin/python
#coding:utf8
class Ren:
    name = "人"
    hight = "一人高"
    wight = "一人重"
    __money = "我有10块钱"		# 私有属性
    __age = 30
    
    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
	
    @staticmethod		#装饰器，表示下面的一个方法是静态方法
    def moRi():			# 如果被下面的静态方法引用，则不需要
        return "世界末日"
			
			# 由于上面已经装了staticmethod了,就不用下面了
    # mr = staticmethod(moRi)	# 静态方法，
			# 从内存角度来说，不节省内存，所有方法都加载
			# 把 moRi()这个方法变成了静态方法,可供外部直接调用


if __name__ == '__main__':      # 这表示如果被别人调用的话，将不执行
				# 被自己调用，执行

   print Ren.moRi()		# 调用的类方法,所有的方法都加载
			# 消耗内存！！

　　显示一下纯 方法装饰器的作用。

#!/usr/bin/python
#coding:utf8
class Ren:
    name = "人"
    hight = "一人高"
    wight = "一人重"
    __money = "我有10块钱"		# 私有属性
    __age = 30
    
    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
	
    @classmethod		# 装饰器，在它下面的方法就是classmethod
    def moRi(self):
        return "世界末日"

				# 由于上面有装饰器，所以不用新建方法了
    # mr = classmethod(moRi)	# 类的方法，动态的,不实例化类，也能访问这个方法
			# 从内存角度来说，节省内存，别的方法没有加载
			# 把 moRi()这个方法变成了类方法,可供外部直接调用


if __name__ == '__main__':      # 这表示如果被别人调用的话，将不执行
				# 被自己调用，执行

   print Ren.moRi()		# 调用的类方法,其他的方法没有加载
			# 节省内存！

　　

——————————————————————————————————————

还留下个小问题：

用方法访问内置属性的时候，为什么不能直接用zhangsan.get("__money") 呢？为什么呢？

视频中用的是一个def get(self, x): 里面家了一个关于 x内容的判断。但是为什么当

print get("__money") 的时候，

报错如下，说没有Traceback (most recent call last):
File "cls_LeiDeFangFa.py", line 46, in 
zm = zhangsan.get("age")
File "cls_LeiDeFangFa.py", line 26, in get
return self.x # 将私有属性封装起来
AttributeError: Ren instance has no attribute 'x'

————————————这是什么原因呢？？有知道的吗？请留言一下