python基础学习-10(类)

 
 
 

 
 
 
  
  
  
  

   
   
   
   
  
  
  
类的方法：

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

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

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

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

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

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

类的装饰器：

@classmethod

@staticmethod

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

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

 
 
 
  
  
  
  

#!/usr/bin/python
class Ren(object):#类名大写，继承超类object，也可以写成Ren()或Ren
    name = "人"#类的公有属性，也是静态成员，可以直接用类名访问,但是不能使用类名访问方法，需要使用实例来调用方法
    high = "很高"
    weight = "很重"
    __money = "五毛"#私有属性，只能在类中调用；不过调试的时候也可以通过instance._classname__atrribute
    def run(self)：#类方法，必须传入self参数
        print self.name#访问公有属性
        print "跑步"
    def say(self)：
        lie = "我爱你"
        print self.__money#访问私有属性
        pring lie
if __name__ == '__main__':#直接调用时触发，如果类被作为模块被其他py引用则__name__为类名
    zhangsan = Ren()#实例
    zhangsan.say()
    print zhangsan.lie

修改类内置属性的办法

#!/usr/bin/python
#coding:utf8
class Ren:
name = "人"
hight = "高"
wight = "重"
__money = "我有1块钱"      # 私有属性
__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

类方法：

#!/usr/bin/python
#coding:utf8
class Ren:
    name = "人"
    hight = "高"
    wight = "重"
    __money = "我有1块钱"      # 私有属性
    __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 = "我有1块钱"      # 私有属性
        __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()        # 调用的类方法,其他的方法没有加载

内部类：

方法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)	把实例对象作为函数调用

类的继承：

格式：class Myclass(ParentClass)

注意：如果父类定义了__init__方法，子类必须显示调用父类的__init__方法(BaseClass.__init__(self,[args...]));如果子类需要扩展父类的行为，可以添加__init__方法的参数。

python支持多重继承,即一个子类可以继承多个父类

格式：Class_name(parent_class1,parent_class2...)

注意：当父类出现多个自定义的__init__方法时，多重继承只执行第一个父类的__init__方法，其他的不执行。

在python中继承中的一些特点：

1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。

2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数

3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

如果在继承元组中列了一个以上的类，那么它就被称作“多重继承” 。

实例：定义一个模块，模块里定义了一个基类：

子类：

输出：

假如在子类中不用__init__()初始化函数，那么子类会继承基类的属性，如：

输出：