小结   类方法和类属性既可以通过类名调用，也可以通过实例调用；实例方法只能通过实例调用，实例属性可继承和覆盖（重名时）类属性，通过实例来调用。

1.实例属性每个实例各自拥有，相互独立；而类属性有且只有1份，创建的实例都会继承自唯一的类属性。意思就是绑定在一个实例上的属性不会影响到其它的实例。如果在类上绑定一个属性，那么所有的实例都可以访问类属性，且访问的类属性是同一个，一旦类属性改变就会影响到所有的实例。

2.类属性直接绑定在类上的，可以不实例化直接通过类名调用类属性

3.当实例属性和类属性重名时，实例属性优先级高，它将屏蔽掉对类属性的访问。

4.实例方法：在类中定义的函数，第一个参数是self，指向调用该方法的实例本身。调用实例方法必须在实例上调用

5.通过标记一个@classmethod，将方法绑定到类上，而非类的实例上。类方法的第一个参数传入的是类本身cls，上面的cls.count相当于Person.count。因为在类上调用，而非实例上调用，因此类方法无法获得任何实例变量，只能获得类的引用。

类方法是通过类来直接调用的，或者通过实例直接来调用。

定义类

  1. class Person():
  2. pass

创建实例,一个类可一创建多个实例，每个实例可以有不同的属性

  1. xiaoming = Person()
  2. xiaohong = Person()

实例属性

  1. xiaoming = Person()
  2. xiaoming.name = xiaoming
  3. xiaoming.age = 24
  4. xiaoming.sex = man
  5.  
  6. xiaohong = Person()
  7. xiaohong.name = xiaohong
  8. xiaohong.age = 22
  9. xiaohong.sex = woman

初始化实例属性

当创建实例时，__init__()方法会被自动调用

  1. class Person(object):
  2. def __init__(self, name, age, sex):
  3. self.name = name
  4. self.age = age
  5. self.sex = sex

属性的访问限制

python中定义的普通变量，可以被外部访问。但是有时候，定义的变量不希望被外部访问。

python对属性权限的控制是通过属性名来实现的。如果一个属性由双下划线(__)开头，该属性就无法被外部访问。如果外部需要访问这种变量，可以通过实例方法来访问，在下文将会介绍如何访问。
class Person(object):

  1. def __init__(self, name):
  2. self.name = name
  3. self._title = 'Mr'
  4. self.__job = 'Student'
  5.  
  6. p = Person('Bob')
  7. print p.name # => Bob
  8. print p._title # => Mr
  9. print p.__job
  10. # => Error
  11. Traceback (most recent call last):
  12. File "<stdin>", line 1, in <module>
  13. AttributeError: 'Person' object has no attribute '__job'

属性以"__xxx__"的形式定义的，是可以被外部访问的。它在python中称之为特殊属性。一般都是python内置的属性或者方法，一般我们定义属性和方法时不建议使用这种形式。

类属性

直接在类中创建的属性就叫类属性。

实例属性每个实例各自拥有，相互独立；而类属性有且只有1份，创建的实例都会继承自唯一的类属性。意思就是绑定在一个实例上的属性不会影响到其它的实例。如果在类上绑定一个属性，那么所有的实例都可以访问类属性，且访问的类属性是同一个，一旦类属性改变就会影响到所有的实例。

  1. class Person(object):
  2. address = 'Earth' # 类属性address
  3. def __init__(self, name):
  4. self.name = name
  5.  
  6. print Person.address # => Earth 类属性直接绑定在类上的，可以不实例化直接通过类名调用类属性
  7.  
  8. p1 = Person('Bob')
  9. p2 = Person('Alice')
  10. print p1.address # => Earth # 通过实例来调用类属性
  11. print p2.address # => Earth

例：请给 Person 类添加一个类属性 count，每创建一个实例，count 属性就加 1，这样就可以统计出一共创建了多少个 Person 的实例

  1. class Person(object):
  2. count=0
  3. count += 1
  4. def __init__(self, name):
  5. self.name = name
  6.  
  7. p1 = Person('Bob')
  8. print Person.count # 1
  9.  
  10. p2 = Person('Alice')
  11. print Person.count # 1
  12.  
  13. p3 = Person('Tim')
  14. print Person.count # 1

上述代码没有达到想要的效果。

  1. class Person(object):
  2. count=0
  3. def __init__(self, name):
  4. self.name = name
  5. Person.count += 1
  6.  
  7. p1 = Person('Bob')
  8. print Person.count # 1
  9.  
  10. p2 = Person('Alice')
  11. print Person.count # 2
  12.  
  13. p3 = Person('Tim')
  14. print Person.count # 3

__init__理解成是一个构造函数，构造函数外围的count=0理解成是一个默认参数，而在实例化对象的实现最先调用的是构造函数，然后在第一次调用构造函数里面的count因为没有值就是使用默认参数，因此第一次调用的count是0的默认值，然后第二次调用的时候是有参调用以此用的是有参的count。

count=0，是对最初的第一次赋值，只作用一次，往后每个对象都会使用改变后的count。

实例属性和类属性重名

当实例属性和类属性重名时，实例属性优先级高，它将屏蔽掉对类属性的访问。

python 类将函数当属性调用 python类属性的调用方法_python 类将函数当属性调用


 


  1. class Person(object):
  2. address = 'zhejiang'
  3. def __init__(self, name):
  4. self.name = name
  5.  
  6. p1 = Person('Bob')
  7. p2 = Person('Alice')
  8.  
  9. print 'Person.address = ' + Person.address # zhejiang
  10.  
  11. p1.address = 'shanxi'
  12. print 'p1.address = ' + p1.address # shanxi
  13.  
  14. print 'Person.address = ' + Person.address # zhejiang
  15. print 'p2.address = ' + p2.address # zhejiang

可见，千万不要在实例上修改类属性，它实际上并没有修改类属性，而是给实例绑定了一个实例属性。

定义实例方法

使用场景：一个实例的私有属性通过“__属性名”来定义，无法被外部所访问。但是可以从类的内部进行间接访问，即通过实例方法来访问。

实例方法：在类中定义的函数，第一个参数是self，指向调用该方法的实例本身。

  1. class Person(object):
  2. def __init__(self, name):
  3. self.__name = name
  4.  
  5. def get_name(self):
  6. return self.__name

get_name就是一个实例方法。调用实例方法必须在实例上调用

  1. p1 = Person('xiaoming')
  2. p1.get_name() # xiaoming

在实例方法内部，可以访问所有实例属性，如果外部需要访问私有属性，可以通过方法调用获得。

类方法

在class中定义的全部是实例方法，实例方法第一个参数self是实例本身。

  1. class Person(object):
  2. count = 0
  3. @classmethod
  4. def how_many(cls):
  5. return cls.count
  6. def __init__(self, name):
  7. self.name = name
  8. Person.count = Person.count + 1
  9.  
  10. print Person.how_many()
  11. p1 = Person('Bob')
  12. print Person.how_many()

通过标记一个@classmethod，该方法将绑定到Person类上，而非类的实例。类方法的第一个参数传入的是类本身，上面的cls.count相当于Person.count。因为在类上调用，而非实例上调用，因此类方法无法获得任何实例变量，只能获得类的引用。

类方法是通过类来直接调用的，或者通过实例直接来调用。

  1. class ClassA(object):
  2.  
  3. @classmethod
  4. def func_a(cls):
  5. print(type(cls), cls)
  6.  
  7.  
  8. if __name__ == '__main__':
  9.  
  10. ClassA.func_a()
  11.  
  12. ca = ClassA()
  13. ca.func_a()