python基础学习10(类)

01
<blockquote>

02
   
03
   
04
   
05
类的方法：

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

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

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

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

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

16
 
17
self参数：区别函数与类的方法（必须有一个self），用于指向对象本身

18
 
19
类的装饰器：

20
 
21
@classmethod

22
 
23
@staticmethod

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

26
 
27
静态方法和动态方法在调用的时候是看不到任何区别，调用方法是一样的。一般没什么区别，在大型数据的时候，需要考虑到运行时间，运行资源的时候，需要考虑一下classmethod, staticmethod的选择问题

28
 
29
  
30
  
31
 </blockquote>

01
#!/usr/bin/python

02
class Ren(object):#类名大写，继承超类object，也可以写成Ren()或Ren

03
    name = "人"#类的公有属性，也是静态成员，可以直接用类名访问,但是不能使用类名访问方法，需要使用实例来调用方法

04
    high = "很高"

05
    weight = "很重"

06
    __money = "五毛"#私有属性，只能在类中调用；不过调试的时候也可以通过instance._classname__atrribute

07
    def run(self)：#类方法，必须传入self参数

08
        print self.name#访问公有属性

09
        print "跑步"

10
    def say(self)：

11
        lie = "我爱你"

12
        print self.__money#访问私有属性

13
        pring lie

14
if __name__ == '__main__':#直接调用时触发，如果类被作为模块被其他py引用则__name__为类名

15
    zhangsan = Ren()#实例

16
    zhangsan.say()

17
    print zhangsan.lie

修改类内置属性的办法

01
#!/usr/bin/python

02
#coding:utf8

03
class Ren:

04
name = "人"

05
hight = "高"

06
wight = "重"

07
__money = "我有1块钱"      # 私有属性

08
__age = 30

09
def run(self):          # 类的方法定义，必须有一个行参

10
#有人把self，写成cls 就是class

11
print self.name         # 类中访问自己类的属性。

12
print "跑步"

13
def __lie(self):        # 私有方法只能被类内部方法使用

14
print "我很欣赏你"

15
def say(self):

16
print "说话"

17
self.__lie()        # 这个表示是调用的当前自己类里面的私有方法

18
def get(self,x):        # 一般在调用私有属性的时候，都是新建一个方法

19
# 这里用了(self,x)目的是为了使用get("money")这样的用法

20
# return self.x # 将私有属性封装起来

21
if x == "money":

22
    return self.__money

23
elif x == "age":

24
    return self.__age

25
else:

26
    return "请正确输入"

27
def set(self,x):        # 使用这个方法，我们用来修改内置属性

28
    self.__age = x

29
def moRi(self):

30
    return "世界末日"

31
mr = classmethod(moRi)  # 类的方法，动态的,不实例化类，也能访问这个方法

32
# 从内存角度来说，节省内存，别的方法没有加载

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

34
# 被自己调用，执行

35
    zhangsan = Ren()  # 把Ren类实例化，变成张三

36
    # zhangsan.__age = 20 # 私有属性是不能设置值的，因为根本访问不了

37
    zhangsan.say()  # 这样我们就可以通过self.__lie() 来调用私有方法了

38
zm = zhangsan.get("age")

39
print zm

40
zhangsan.set(20)

41
print zhangsan._Ren__age

类方法：

01
<strong>#!/usr/bin/python

02
#coding:utf8

03
class Ren:

04
    name = "人"

05
    hight = "高"

06
    wight = "重"

07
    __money = "我有1块钱"      # 私有属性

08
    __age = 30

09
    def run(self):          # 类的方法定义，必须有一个行参

10
#有人吧self，写成cls 就是class

11
        print self.name         # 类中访问自己类的属性。

12
        print "跑步"

13
    def __lie(self):        # 私有方法只能被类内部方法使用

14
        print "我很欣赏你"

15
    def say(self):

16
        print "说话"

17
        self.__lie()        # 这个表示是调用的当前自己类里面的私有方法

18
    def get(self,x):        # 一般在调用私有属性的时候，都是新建一个方法

19
# 这里用了(self,x)目的是为了使用get("money") # 这样的用法

20
# return self.x # 将私有属性封装起来

21
    if x == "money":

22
         return self.__money

23
    elif x == "age":

24
         return self.__age

25
    else:

26
         return "请正确输入"

27
    def set(self,x):        # 使用这个方法，我们用来修改内置属性

28
         self.__age = x

29
    def moRi(self):

30
         return "世界末日"

31
mr = classmethod(moRi)  # 类的方法，动态的,不实例化类，也能访问这个方法

32
# 从内存角度来说，节省内存，别的方法没有加载

33
# 把 moRi()这个方法变成了类方法,可供外部直接调用

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

35
# 被自己调用，执行

36
    print Ren.mr()      # 调用的类方法,其他的方法没有加载

37
# 节省内存！</strong>

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

01
#!/usr/bin/python

02
#coding:utf8

03
    class Ren:

04
        name = "人"

05
        hight = "高"

06
        wight = "重"

07
        __money = "我有1块钱"      # 私有属性

08
        __age = 30

09
        def run(self):          # 类的方法定义，必须有一个行参

10
#有人吧self，写成cls 就是class

11
            print self.name         # 类中访问自己类的属性。

12
            print "跑步"

13
        def __lie(self):        # 私有方法只能被类内部方法使用

14
            print "我很欣赏你"

15
        def say(self):

16
            print "说话"

17
            self.__lie()        # 这个表示是调用的当前自己类里面的私有方法

18
        def get(self,x):        # 一般在调用私有属性的时候，都是新建一个方法

19
# 这里用了(self,x)目的是为了使用get("money") # 这样的用法

20
# return self.x # 将私有属性封装起来

21
            if x == "money":

22
                 return self.__money

23
            elif x == "age":

24
                 return self.__age

25
            else:

26
                 return "请正确输入"

27
            def set(self,x):        # 使用这个方法，我们用来修改内置属性

28
            self.__age = x

29
            @staticmethod       #装饰器，表示下面的一个方法是静态方法

30
            def moRi():         # 如果被下面的静态方法引用，则不需要

31
                 return "世界末日"

32
# 由于上面已经装了staticmethod了,就不用下面了

33
# mr = staticmethod(moRi)   # 静态方法，

34
# 从内存角度来说，不节省内存，所有方法都加载

35
# 把 moRi()这个方法变成了静态方法,可供外部直接调用

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

37
# 被自己调用，执行

38
print Ren.moRi()        # 调用的类方法,所有的方法都加载

39
# 消耗内存！！

使用方法装饰器：

01
<b>#!/usr/bin/python

02
#coding:utf8

03
class Ren:

04
name = "人"

05
hight = "一人高"

06
wight = "一人重"

07
__money = "我有10块钱"      # 私有属性

08
__age = 30

09
def run(self):          # 类的方法定义，必须有一个行参

10
#有人吧self，写成cls 就是class

11
print self.name         # 类中访问自己类的属性。

12
print "跑步"

13
def __lie(self):        # 私有方法只能被类内部方法使用

14
print "我很欣赏你"

15
def say(self):

16
print "说话"

17
self.__lie()        # 这个表示是调用的当前自己类里面的私有方法

18
def get(self,x):        # 一般在调用私有属性的时候，都是新建一个方法

19
# 这里用了(self,x)目的是为了使用get("money") # 这样的用法

20
# return self.x # 将私有属性封装起来

21
if x == "money":

22
return self.__money

23
elif x == "age":

24
return self.__age

25
else:

26
return "请正确输入"

27
def set(self,x):        # 使用这个方法，我们用来修改内置属性

28
self.__age = x

29
@classmethod        # 装饰器，在它下面的方法就是classmethod

30
def moRi(self):

31
return "世界末日"

32
# 由于上面有装饰器，所以不用新建方法了

33
# mr = classmethod(moRi)    # 类的方法，动态的,不实例化类，也能访问这个方法

34
# 从内存角度来说，节省内存，别的方法没有加载

35
# 把 moRi()这个方法变成了类方法,可供外部直接调用

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

37
# 被自己调用，执行

38
print Ren.moRi()        # 调用的类方法,其他的方法没有加载</b>

内部类：

方法1：直接使用外部类调用内部类

调用格式：object_name=outclass_name.inclass_name()

方法2：先对外部类进行实例化,然后实例化内部类

调用格式：out_name=outclass_name()

in_name=out_name.inclass_name()

in_name.method()

类常用的内置方法：

内置方法	说明
__init__(self,...)	初始化对象，在创建新对象时调用
__del__(self)	释放对象，在对象被删除之前调用；显示调用格式del 对象名
__new__(cls,args,*kwd)	实例的生成操作
__str__(self)	在使用print语句时被调用
__getitem__(self,key)	获取序列的索引key对应的值，等价于seq[key]
__len__(self)	在调用内联函数len()时被调用
__cmp__(stc,dst)	比较两个对象src和dst
__getattr__(s,name)	获取属性的值
__setattr__(s,name,value)	设置属性的值
__delattr__(s,name)	删除name属性
__getattribute__()	__getattribute__()功能与__getattr__()类似
__gt__(self,other)	判断self对象是否大于other对象
__lt__(slef,other)	判断self对象是否小于other对象
__ge__(slef,other)	判断self对象是否大于或者等于other对象
__le__(slef,other)	判断self对象是否小于或者等于other对象
__eq__(slef,other)	判断self对象是否等于other对象
__call__(self,*args)	把实例对象作为函数调用