python面向对象之类成员

一、概述

       上篇《python面向对象OOP》介绍了Python面向对象的基础初级入门部分，提到了类的定义，使用，类的三大特性;经典类，新式类在查找时的区别等，有了前面的基础，本文接着描述面向对象中类成员;先整体描述下，类中的成员分以下几部分：

#类成员

  #字段（属性）:
      普通字段  属于对象,保存在对象中,只能通过对象访问
      静态字段  属于类,保存(一份)在类中(所有对象共享的字段属性),执行时可以是类访问也可以是对象访问
  #方法:
      普通方法  保存在类中,又叫实例方法，首先创建对象,对象间接访问普通方法,类也可以访问,需要传对象 self==>对象
      静态方法  通过加@staticmethod装饰器变为静态方法,保存在类中;self可省,此时可以通过类直接调用,类似模块对函数的封装
      类方法    通过加@claSSMethod保存在类中,由类直接调用,cls ==>当前类
  #属性（特性）:  
        按方法定义 ,调用时像字段属性

二、类字段属性

class Foo:
    public = "isclass"    #静态字段
    def __init__(self,arg):
        self.name = "a"   ##普通字段
        self.arg = arg    ##普通字段

    def bar(self):
        print(self.name,self.arg)


        
obj = Foo("hello")
obj.bar()
print(obj.public)
print(Foo.public)

运行结果：

a hello
isclass

isclass

说明：在类中定义的属性（字段）我们叫静态字段，它不属于对象，属于类，好处是不管创建实例化多少对象，它只在内存中保留一份;self.xxx = xxxx这种，由于 self表示对象本身，因此保存在对象中，属于对象，叫普通字段，实例化多少对象，内存中就保留多少份。静态字段和普通字段，实例化的对象都可以调用。静态字段除了对象可以调用，类也可以调用。但类不能调用对象的普通字段，因为它属于对象。

三、类中的方法

类的方法分为普通方法，类方法 ，静态方法 三种下面我们分别来说明：

1、普通方法(实例方法)

class Foo:
    public = "isclass"  # 静态字段

    def __init__(self,name,age):
        self.name = name     ##普通字段
        self.age = age       ##普通字段

    def bar(self,arg):
        print(self.name, self.age,arg)


obj = Foo(san,18)     #实例化出obj对象
obj.bar(666)            #通过obj对象调用bar普通方法
Foo.bar(obj,666)        #通过Foo类传入obj对象调用bar方法

运行结果：

san 18 666
san 18 666

说明：对于普通方法，保存在类中;实例对象可以直接调用(有参数就需要传参)，类可以调用方法再传入对象，和需要的参数，效果一样。因此对于普通方法，实例对象可以调用，类也可以调用，但前提都需要先实例化对象，要么直接调用，要么通过类调用把实例对象传入。

2、静态方法

class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def showinfo(self):
        print(self.name,self.age)

    @staticmethod      #通过@staticmethod 把方法转换成静态方法
    def stac():        #静态方法时self不是必须的,加了self也并非指对象
        print("static")

    @staticmethod
    def stac2(a1,a2):
        print(a1,a2)
        
obj = Foo("san",18)      #实例化出对象obj
obj.showinfo()           #obj对象调用showinfo普通方法
obj.stac()               #obj调用类静态方法stac
obj.stac2(1,2)           #obj调用需要传参数的类静态方法stac2
Foo.stac()               #Foo类直接调用静态方法stac
Foo.stac2(1,2)           #Foo类直接调用需要传参数的类静态方法stac2

运行结果：

说明：静态方法通过在方法上面添加@staticmethod装饰器，保存在类中;静态方法不需要传入self参数，即使传入了self参数也并不像普通方法那样代指对象本身。而只是一个普通的形参数。类静态方法对象可调用，但主要是给类调用。相当于模块对函数的封装。

3、类方法

class Foo:
   def __init__(self,name,age):
        self.name = name
        self.age = age
   def showinfo(self):
        print(self.name,self.age)
   @classmethod
   def classmd(cls,arg):
        print(arg)

obj = Foo(san,18)         
obj.showinfo()              
Foo.classmd()   
obj.classmd()

运行结果：

说明：类方法的定义通过在方法前加@classmethod，保存在类中。默认参数为cls，cls代指类本身;类可调用，对象也可调用。该传参数时就传。

以上为类的三种方法，他们都保存在类中，实例化的对象都可以调用。

类的普通方法即实例方法，这是类中最常见的方法;主要是实例调用，在没有实例的情况下类是无法调用的，调用时需要传入实例和参数（如果有参数）对象.方法([参数])  == 类.方法(实例对象,[参数])

在类中运行而不在实例中运行的方法，我们想让方法不在实例中运行时可用类方法;主要是用于类调用，传入的参数是类，主要用于修改和类有关的数据。在没有实例情况下类可直接调用。实例也可以调用。类方法和类静态方法可以通过在其他模块中在不实例化对象情况下调用。

经常有一些跟类有关系的功能但在运行时又不需要实例和类参与的情况下需要用到静态方法.有点类似于模块对函数的封装。

因此我们#如果对象中需要保存一些值,执行某功能时需要使用对象中的值,用普通方法#不需要任何对象中的值,  用静态方法，需要修改类中的值时用类方法。

四、类中属性

现在 我们都知道 类中的方法是对过 对象.方法([参数]) 调用的，但有时候为了简洁明了，想把这种方式变为 对象.属性形式获取值，这里就引用了类中的属性@property,来看示例：

class Foo(object):
    def __init__(self):
        self.name = "a"            ##普通字段   #obj.name获取

    def bar(self):                 #实例方法 obj.bar()调用
        print("bar")

    @property                      #属性或叫特性  用于执行obj.per获取值
    def per(self):
        return  1

    @per.setter                   #设置值 obj.per = 值
    def per(self,val):
        print(val)

    @per.deleter                   # 删除值
    def per(self):
        print(66666)
        
obj = Foo()      #实例化obj
r = obj.per      #由于per方法加了@property此时通过obj.per获取调用
print(r)
obj.per = 123    #@per.setter即把123传入
del obj.per       #@per.deleter删除功能，这里模拟，可以做任何想做的功能

运行结果：

另一种写法：

class Foo:
    def f1(self):           #等同于@property def f1
        return 123                    

    def f2(self,v):
        print(v)

    def f3(self):
        print("del")
    per = property(fget=f1,fset=f2,fdel=f3)   #第一个参数默认是fget


obj = Foo()       #实例化obj对象
ret = obj.f1    
print(ret())
obj.per = 2    #传输值2
print(obj.per) #调用obj.per == obj.f1()
del obj.per    #删除obj.per ==  obj.f3()

运行结果：

总结：通过@property装饰器可以将一个方法变为类似属性的调用形式。让代码看起来更简洁。

以上为个人总结，如有错误之处欢迎指正交流。类的进阶部分参考Http://www.cnblogs.com/wupeiqi/p/4766801.html