Python：类属性，实例属性，私有属性与静态方法，类方法，实例方法

Python：类属性，实例属性，私有属性与静态方法，类方法，实例方法

属性分为实例属性与类属性

方法分为普通方法，类方法，静态方法

 

一：属性：

　　尽量把需要用户传入的属性作为实例属性，而把同类都一样的属性作为类属性。实例属性在每创造一个实例时都会初始化一遍，不同的实例的实例属性可能不同，不同实例的类属性都相同。从而减少内存。

　　1：实例属性：

　　　　最好在__init__(self,...)中初始化

　　　　内部调用时都需要加上self.

　　　　外部调用时用instancename.propertyname

　　2:类属性：

　　　　在__init__()外初始化

　　　　在内部用classname.类属性名调用

　　　　外部既可以用classname.类属性名又可以用instancename.类属性名来调用

　　3：私有属性：

　　　　1）：单下划线_开头：只是告诉别人这是私有属性，外部依然可以访问更改

　　　　2）：双下划线__开头：外部不可通过instancename.propertyname来访问或者更改

　　　　　　实际将其转化为了_classname__propertyname

二：方法

　　1：普通类方法：

　　　　def fun_name(self,...):

　　　　　　pass

　　　　外部用实例调用

　　2：静态方法：@staticmethod            

　　　　　　不能访问实例属性！！！   参数不能传入self！！！

　　　　　　与类相关但是不依赖类与实例的方法！！

　　3:类方法：@classmethod

　　　　　　不能访问实例属性！！！   参数必须传入cls！！！

　　　　　　必须传入cls参数（即代表了此类对象-----区别------self代表实例对象），并且用此来调用类属性：cls.类属性名

　　*静态方法与类方法都可以通过类或者实例来调用。其两个的特点都是不能够调用实例属性

　　

　　e.g1：

  1. class A:  
  2.     member = "this is a test."  
  3.     def __init__(self):  
  4.         pass  
  5.  
  6.     @classmethod  
  7.     def Print1(cls):  
  8.         print "print 1: ", cls.member  
  9.           
  10.     def Print2(self):  
  11.         print "print 2: ", self.member  
  12.             
  13.          
  14.     @classmethod      
  15.     def Print3(paraTest):  
  16.         print "print 3: ", paraTest.member  
  17.     @staticmethod  
  18.     def print4():  
  19.         print "hello"  

 

总结：类属性与类方法是类固有的方法与属性，不会因为实例不同而改变，写他们的目的是减少多实例时所创造出来的内存空间，加快运行速度。

 

 

 

Python语法笔记4
本文由arthinking发表于2年前 | Python | 评论数 1 |  被围观 1,487 views+
1、定义一个类：1.1、类对象支持两种操作：引用和实例化1.2、Python中属性、方法和函数的区别：1.2.1、私有属性：1.3、类属性、实例属性、类方法和实例方法：1.3.1、类方法1.3.2、实例方法1.3.3、静态方法2、继承
1、定义一个类：
class className:
    block

block里面定义属性和方法，当类定义完之后，就产生了一个类对象。

1.1、类对象支持两种操作：引用和实例化
  • 引用操作：通过类对象调用类中的属性或者方法
  • 实例化：产生出一个类对象的实例

下面定义一个类：

#定义一个类
class user:
    name = 'Jason'
    nickname = 'arthinking'
    def getName(self):
        return self.name

#引用操作：
print user.name  #Jason
#实例化
u = user()  #实例化一个类对象
print u.name  #Jason
1.2、Python中属性、方法和函数的区别：

属性：类中定义的变量，如上面的name；

方法：与某个对象进行绑定的函数，一把在类里面定义的函数与类对象或者实例对象绑定；

函数：在类外定义的函数，没有同对象进行绑定。

1.2.1、私有属性：

想把属性声明为私有的，可以再属性签名加两个下划线"__"，这样就不能直接访问了。

class user2:
    __name = 'Jason'
    def getName(self):
        return self.__name

u2 = user2()
print u2.getName()
#print u2.__name  #AttributeError: user2 instance has no attribute '__name'

1.2.2、方法：

类中定义方法，同样使用def关键字，类中的方法至少有一个参数，一般以'self'的变量作为该参数，而且需要作为第一个参数，这个self就相当于对象自身的引用，和Java中的this类似。

私有方法：

同样的，在方法前面加两个下划线，表示该方法是私有的

类内置方法：

Python中有一些内置的方法，这些方法命名一两个下划线开始和结束：

构造方法：__init__(self, ...)

该方法在生成对象时进行一些初始化操作，无需显示调用，该方法支持重载。

析构方法：__del__(self)在释放对象时调用，在里面进行一些释放资源的操作，不需要显示调用。支持重载。

__cmp__()

__len__()

1.3、类属性、实例属性、类方法和实例方法：

类属性：和Java中的静态成员变量类似，对于共有的类属性，在类外可以通过类对象和实例对象方法。

实例属性：实例属性是不需要在类中显示定义的：

class user3:
    __name= 'Jason'
    def getName(self):
        return self.__name
p3 = user3()
p3.age = 20
print p3.age  #20
#print user3.age  #AttributeError: class user3 has no attribute 'age'

上面创建了一个user3对象，并实例化，添加了一个age属性，而user3并不能持有该属性。

另外，也可以在实例化对象的时候给age赋值：

class user3:
    __name='Jason'
    def __init__(self, nickname):
        self.nickname = nickname

u3 = user3(123)

print u3.nickname  #123
#print user3.nickname  #AttributeError: class user3 has no attribute 'nickname'

修改类属性：

必须通过类对象去引用然后进行修改。如果通过实例对象去引用，会产生一个同名的实例属性，该属性会把类属性给屏蔽掉，除非删除了该属性。

class user:
    username = 'Jason'

print user.username  #Jason
u = user()
print u.username  #Jason
u.username = 'Mike'
print u.username  #Mike
del u.username  #删除实例属性，访问到的则是类属性
print u.username  #Jason
1.3.1、类方法

类方法是类对象所拥有的方法，需要用修饰器"@classmethod"来表示其为类方法，第一个参数必须是类对象，类方法能够通过实例对象和类对象去访问：

class user:
    username = 'Jason'

    @classmethod
    def getUsername(cls):
        return cls.username

u = user()
print u.getUsername()  #可以通过实例对象引用
print user.getUsername()  #可以通过类对象引用

类方法可以对类属性进行修改

class user:
    username = "Jason"
    @classmethod
    def getUsername(cls):
        return cls.username

    @classmethod
    def setUsername(cls, username):
        cls.username = username

u = user()
print u.getUsername()  #Jason
print user.getUsername()  #Jason
u.setUsername("Mike")  #通过类方法直接修改了类属性
print user.getUsername()  #Mike
1.3.2、实例方法

在类中最常定义的成员方法，至少有一个参数，并且必须以实例对象作为其第一个参数。实例方法只能通过类实例去调用：

class user:
    username = 'Jason'

    def getUsername(self):
        return self.username

u = user()
print u.getUsername()  #Jason
# print user.getUsername()  #TypeError: unbound method getUsername() must be called with user instance as first argument (got nothing instead)
1.3.3、静态方法

通过修饰器"@staticmethod"进行修饰，静态方法无需多定义参数

class user:
    username = 'Jason'

    @staticmethod
    def getUsername():
        return user.username

print user.getUsername()
2、继承

Python支持多继承，如下：

class animal:
    name = 'object'

class dog(animal):
    nickname = 'Baby'

print dog.name #object

如果有多个父类，使用逗号隔开

class animal:
    def __init__(self, name):
        self.name = name

    def getName(self):
        return self.name

class role:
    def __init__(self, name):
        self.rolename = name

    def getName(self):
        return self.rolename

class cat(animal, role):
    def __init__(self, name, nickname, rolename):
        animal.__init__(self, name)  #子类通过父类调用父类的共有方法或属性
        role.__init__(self, rolename)
        self.nickname = nickname

    def getNickname(self):
        return self.nickname

c = cat('Jason', 'Tomcat', 'admin')
print c.name  #Jason
print c.nickname  #Tomcat
print c.rolename  #admin

在Python中，如果父类和子类都重新定义了构造方法，在进行子类实例化的时候，子类的构造方法不会自动调用父类的构造方法，需要在子类中显示调用

子类不继承父类的私有属性和方法，所以在子类中无法通过父类名来访问父类的私有属性和方法。

多重继承的情况下，子类没有定义构造函数时，会自动调用第一个父类的构造方法，包括多个父类有同名的方法时，优先选择第一个父类的。

除了文章中有特别说明，均为IT宅原创文章，转载请以链接形式注明出处。
本文链接：http://www.itzhai.com/python-yu-fa-bi-ji-4.html
关键字: Python, 笔记
arthinkingJava技术交流群：280755654，入门群：428693174more

 

posted on 2016-06-23 14:19  小西红柿  阅读(1883)  评论(0)  编辑  收藏  举报

导航