类的属性和方法总结

一、类的属性总结

1.总结一下类的属性

有公有属性，私有属性，对象的公有属性，对象的私有属性，内置属性，函数的局部变量，全局变量。

2.公有属性

class MyClass(object):
    var1 = "类属性，类的公有属性 var1"
    __var2 = "类的私有属性 __var2"

    def func1(self):
        self.var3 = "对象的公有属性 var3"
        self.__var4 = "对象的私有属性 __var4"
        var5 = "函数的局部变量"
mc = MyClass()
print mc.var1

可以访问公有属性。

3.私有属性

class MyClass(object):
    var1 = "类属性，类的公有属性 var1"
    __var2 = "类的私有属性 __var2"

    def func1(self):
        self.var3 = "对象的公有属性 var3"
        self.__var4 = "对象的私有属性 __var4"
        var5 = "函数的局部变量"
mc = MyClass()
print mc.__var2

访问不了，如何访问呢，可以加类名print mc._MyClass.__var2

不过这种方式不推荐使用，仅作测试使用。

4.对象的公有属性

class MyClass(object):
    var1 = "类属性，类的公有属性 var1"
    __var2 = "类的私有属性 __var2"

    def func1(self):
        self.var3 = "对象的公有属性 var3"
        self.__var4 = "对象的私有属性 __var4"
        var5 = "函数的局部变量"
mc = MyClass()
print mc.var3

不能访问，为什么呢？因为没有没有调用方法，所以就没有加载。

加入mc.func1()就可以访问了

5.对象的私有属性

class MyClass(object):
    var1 = "类属性，类的公有属性 var1"
    __var2 = "类的私有属性 __var2"

    def func1(self):
        self.var3 = "对象的公有属性 var3"
        self.__var4 = "对象的私有属性 __var4"
        var5 = "函数的局部变量"
mc = MyClass()
print mc.__var4

也是访问不了的。

6.函数的局部变量

class MyClass(object):
    var1 = "类属性，类的公有属性 var1"
    __var2 = "类的私有属性 __var2"

    def func1(self):
        self.var3 = "对象的公有属性 var3"
        self.__var4 = "对象的私有属性 __var4"
        var5 = "函数的局部变量"
mc = MyClass()
print mc.var5

也是不行的。

7.总结一下就是

1.类的公有属性可以通过对象来访问。

2.类的私有属性也可以通过对象来访问，方式特殊一点。

3.对象的公有属性也可以通过对象来访问。前提是对象要调用方法。

4.对象的私有属性通过对象不可以访问。

5.函数的局部变量在外部通过对象也不能访问。

8.通过类来访问属性。

1.通过类来访问公有属性

class MyClass(object):
    var1 = "类属性，类的公有属性 var1"
    __var2 = "类的私有属性 __var2"

    def func1(self):
        self.var3 = "对象的公有属性 var3"
        self.__var4 = "对象的私有属性 __var4"
        var5 = "函数的局部变量"
print MyClass.var1

可以访问。

2.通过类来访问私有属性

class MyClass(object):
    var1 = "类属性，类的公有属性 var1"
    __var2 = "类的私有属性 __var2"

    def func1(self):
        self.var3 = "对象的公有属性 var3"
        self.__var4 = "对象的私有属性 __var4"
        var5 = "函数的局部变量"
print MyClass.__var2

不可以。

3.通过类来访问对象的公有属性。

class MyClass(object):
    var1 = "类属性，类的公有属性 var1"
    __var2 = "类的私有属性 __var2"

    def func1(self):
        self.var3 = "对象的公有属性 var3"
        self.__var4 = "对象的私有属性 __var4"
        var5 = "函数的局部变量"
mc = MyClass()
mc.func1()
print MyClass.var3

也不行。对象的属性只能通过对象来访问。对象的属性和属性有什么区别，就是定义的位子不同。在方法里的就是对象的属性。

9.在类内调用属性。

1.在类内调用公有属性和私有属性

class MyClass(object):
    var1 = "类属性，类的公有属性 var1"
    __var2 = "类的私有属性 __var2"

    def func1(self):
        self.var3 = "对象的公有属性 var3"
        self.__var4 = "对象的私有属性 __var4"
        var5 = "函数的局部变量"
    def func2(self):
        print self.var1
        print self.__var2
mc = MyClass()
mc.func2()

是可以访问的。

2.在类内调用对象的公有属性和私有属性

class MyClass(object):
    var1 = "类属性，类的公有属性 var1"
    __var2 = "类的私有属性 __var2"

    def func1(self):
        self.var3 = "对象的公有属性 var3"
        self.__var4 = "对象的私有属性 __var4"
        var5 = "函数的局部变量"
    def func2(self):
        print self.var3
        print self.__var4  
mc = MyClass()
mc.func1()
mc.func2()

也是可以的，但是在调用前必须先调用func1这个方法，才可以被func2调用。

3.在内部类里调用局部变量

class MyClass(object):
    var1 = "类属性，类的公有属性 var1"
    __var2 = "类的私有属性 __var2"

    def func1(self):
        self.var3 = "对象的公有属性 var3"
        self.__var4 = "对象的私有属性 __var4"
        var5 = "函数的局部变量"
    def func2(self):
  print self.var5
mc = MyClass()
mc.func1()
mc.func2()

不能被调用，但是可以在定义函数局部变量的方法里访问。

这是因为，局部变量只能在方法里自己调用，外部调用不了，除非转变成全局变量

var5 = "全局变量var5"
class MyClass(object):
    var1 = "类属性，类的公有属性 var1"
    __var2 = "类的私有属性 __var2"

    def func1(self):
        self.var3 = "对象的公有属性 var3"
        self.__var4 = "对象的私有属性 __var4"
        var5 = "函数的局部变量"
    def func2(self):
  print var5
mc = MyClass()
mc.func1()
mc.func2()

这样就可以访问全局变量。

还有一个内置属性。mc.__dict__，也可以通过类调用，MyClass.__dict__

二、类的方法总结

1.类的方法有：公有方法，私有方法，类方法，静态方法，内置方法。

1.调用公有方法

class MyClass(object):
    name = "Test"
    def func1(self):
        print self.name
        print "我是公有方法"
    def __func1(self):
        print self.name
        print "我是私有方法"
    def classFun(self):
        print self.name
        print "我是类方法"
    def staticFun():
        print MyClass.name
        print "我是静态方法"
mc = MyClass()
mc.func1()

可以调用

2.调用私有方法。

class MyClass(object):
    name = "Test"
    def func1(self):
        print self.name
        print "我是公有方法"
    def __func2(self):
        print self.name
        print "我是私有方法"
    def classFun(self):
        print self.name
        print "我是类方法"
    def staticFun():
        print MyClass.name
        print "我是静态方法"
mc = MyClass()
mc.__func2()

不能调用私有方法，如何才能调用呢，要放在公有方法里调用

class MyClass(object):
    name = "Test"
    def func1(self):
        print self.name
        print "我是公有方法"
   self.__func2()
    def __func2(self):
        print self.name
        print "我是私有方法"
    def classFun(self):
        print self.name
        print "我是类方法"
    def staticFun():
        print MyClass.name
        print "我是静态方法"
mc = MyClass()
mc.func1()

这样就可以调用私有方法了

3.调用类方法。

class MyClass(object):
    name = "Test"
    def func1(self):
        print self.name
        print "我是公有方法"
   self.__func2()
    def __func2(self):
        print self.name
        print "我是私有方法"
    def classFun(self):
        print self.name
        print "我是类方法"
    def staticFun():
        print MyClass.name
        print "我是静态方法"
mc = MyClass()
MyClass.classFun()

不能调用，为什么呢，因为没有加装饰器。

class MyClass(object):
    name = "Test"
    def func1(self):
        print self.name
        print "我是公有方法"
   self.__func2()
    def __func2(self):
        print self.name
        print "我是私有方法"
    @classmethod
    def classFun(self):
        print self.name
        print "我是类方法"
    def staticFun():
        print MyClass.name
        print "我是静态方法"
mc = MyClass()
MyClass.classFun()

这样就可以调用了，类方式就是使用类名来调用。

4.调用静态方法

class MyClass(object):
    name = "Test"
    def func1(self):
        print self.name
        print "我是公有方法"
   self.__func2()
    def __func2(self):
        print self.name
        print "我是私有方法"
    @classmethod
    def classFun(self):
        print self.name
        print "我是类方法"
    @staticmethod
def staticFun():
        print MyClass.name
        print "我是静态方法"
mc = MyClass()
MyClass.staticFun()

这样就可以调用静态方法了。

5.调用内置方法

class MyClass(object):
    name = "Test"
    def __init__(self):
  self.func1()
  self.__func2()
  self.classFun()
  self.staticFun()
    def func1(self):
        print self.name
        print "我是公有方法"
    def __func2(self):
        print self.name
        print "我是私有方法"
    @classmethod
    def classFun(self):
        print self.name
        print "我是类方法"
    @staticmethod
def staticFun():
        print MyClass.name
        print "我是静态方法"
mc = MyClass()

使用内置方法,构造函数都可以调用。而且在实例化的时候会自动加载构造函数

6.总结一下

1.公有方法可以在类的内部和外部来调用。

2.私有方法只能在类的内部来调用。

3.类的方法有2种，一种是类方法，一种是静态方法。都是可以通过类来调用的。