基础

像init函数，开头和末尾各有两个下划线，这是一种约定，表示Python的默认函数，旨在避免Python默认方法与普通方法发生名称冲突。
类名应该采用驼峰命名法，即将类名中的每个单词的首字母都大写，而不使用下划线，实例名和模块名都采用小写格式，并在单词之间加上下划线。
在import时，先导入系统的库，然后空一行，再导入自己写的模块，这样更清晰。

  1. # object表示从object类继承，相当于Java中extends后的类名
  2. # object是否可省略与python版本有关，Python2.7需要，Python3可以不要
  3. # 为了兼容，建议还是不要省了
  4. class Student(object):
  5.     age = 50;    # 类变量，类似于Java中的static变量
  7.     def __init__(self, name, score):  # self 是一个指向实例的引用，类似于Java中的this
  8.                                       # __init__ 是构造函数，每次初始化实例时，都会执行
  9.         self.__name = name  # python中对成员变量的引用需要使用self明确指出
  10.         self.score = score  # 因为这是跟实例有关的，所以需要self.
  12.     def print_score(self):
  13.         print('%s: %s' % (self.__name, self.score)) 
  15. # 可以创建多个实例 st1 = Student("zhangsan", 20) st2 = Student("lisi", 22)
  16. >>> bart = Student('Bart Simpson', 59) # 创建一个实例
  17. >>> bart.print_score()
  18. Bart Simpson: 59
  19. >>> bart.score = 60 # 可以通过实例名.成员变量来直接修改实例的成员变量值
  20.                     # 但__name变量就不行，因为在变量前加上__，表示这是私有变量，只能在类内部访问
  21.                     # 此时如果依然用bart.__name="james"，并没有改变原来的成员变量，
  22.                     # 只是生成了一个新变量，因为__name被改名成了_Student__name，
  23.                     # 所以，实际上依然是可以在外部访问的，但是建议不要这么做。
  24.                     # 还有__name__这样的，不是私有变量，而是特殊变量
  25.                     # 还有_name，表示我不希望被外部引用，但是实际上就是普通成员变量

继承

普通继承

  1. class Car(object):
  2.     def __init__(self, make, model, year):
  3.         self.make = make 
  4.         self.model = model 
  5.         self.year = year 
  6.         self.odometer_reading = 0
  8.     def get_descriptive_name(self):
  9.         long_name = str(self.year) + ' ' + self.make + ' ' + self.model
  10.         return long_name.title() # title()是首字母大写
  12.     def fill_gas_tank(self):
  13.         print("now fill car gas tank")
  15. class ElectricCar(Car):
  16.     def __init__(self, make, model, year, battery_size):
  17.         # Python2.7里super()的参数不能省
  18.         super(ElectricCar, self).__init__(make, model, year) 
  19.         self.battery_size = battery_size 
  21.     def desc_battery(self):
  22.         print("this car bettery size is :", self.battery_size)
  24.     def fill_gas_tank(self): # 重写父类方法
  25.         print("electric car doesn't need a gas tank!")
  27. my_car = Car('benz', 'outback', 2013)
  28. print(my_car.get_descriptive_name())
  29. my_tesla = ElectricCar('tesla', 'model_s', 2016, 70)
  30. print(my_tesla.get_descriptive_name())
  31. my_tesla.fill_gas_tank()
  33. # 2013 Benz Outback
  34. # 2016 Tesla Model_S
  35. # electric car doesn't need a gas tank!

继承时的参数传递

当没有明确写出构造函数init时，系统会默认传参给父类。

  1. import collections
  3. class Student1(collections.namedtuple('Person1', ["name", "age"])):
  4.     def print(self):
  5.         print("this is print function")
  7. s1 = Student1("wangwu", 30)
  8. print("s1 =", s1)
  9. ----------------------------------------------------------------------------
  11. class Person2():
  12.     def __init__(self, name, age):
  13.         print("this is Person2 init func")
  14.         print("name =", name)
  15.         print("age = ", age)
  17. class Student2(Person2):
  18.     pass
  20. s2 = Student2("sunliu", 40)
  21. print("s2 =", s2)
  23. ----------------------------------------------------------------------------
  24. class Person3():
  25.     pass
  26. class Student3(Person3, collections.namedtuple('Person1', ["name", "age"])):
  27.     def print(self):
  28.         print("this is print function")
  29.         print("name =", self.name)
  31. s3 = Student3("zhaoqi", 70)
  32. print("s3 =", s3)
  33. s3.print()
  34. ----------------------------------------------------------------------------
  35. # res 
  36. s1 = Student1(name='wangwu', age=30)
  37. this is Person2 init func
  38. name = sunliu
  39. age =  40
  40. s2 = <__main__.Student2 object at 0x7ffdacaf0668>
  41. s3 = Student3(name='zhaoqi', age=70)
  42. this is print function
  43. name =  zhaoqi

多继承

python中的多继承，在初始化时是按照MRO（Method Resolution Order）表来进行顺序的解析。

  1. class Base(object):
  2.     def __init__(self):
  3.         print("enter Base")
  4.         print("leave Base")
  6. class A(Base):
  7.     def __init__(self):
  8.         print("enter A")
  9.         super(A, self).__init__()
  10.         print("leave A")
  12. class B(Base):
  13.     def __init__(self):
  14.         print("enter B")
  15.         super(B, self).__init__()
  16.         print("leave B")
  18. class C(A, B):
  19.     def __init__(self):
  20.         print("enter C")
  21.         super(C, self).__init__()
  22.         print("leave C")
  24. c = C()
  25. print(C.mro())
  26. ---------------------------------------
  27. # res 
  28. enter C
  29. enter A
  30. enter B
  31. enter Base
  32. leave Base
  33. leave B
  34. leave A
  35. leave C
  36. [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.Base'>, <class 'object'>]
  37. 从结果可以看出按照MRO表，就是先进入A，然后A再super(A, self)，
  38. 注意，此时的self其实是C对象，所以，按照C对象的顺序表，就进入了B，
  39. B再super(B, self)，此时self还是C对象，于是按照顺序表进入了Base,因此会有以下结果。

装饰器

@classmethod

classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

  1. class A(object):
  2.     b = 2
  4.     def __init__(self, a=1):
  5.         print("this is init method,a=", a)
  6.         self.a = a
  8.     def func1(self):
  9.         print("fun1")
  11.     @classmethod
  12.     def func3(cls):
  13.         print("func3")
  15.     @classmethod
  16.     def func2(cls):
  17.         print("func2")
  18.         cls().func1() # func1是属于实例的方法，因此就需要先实例化，再调用
  19.         cls.func3() # func3是属于类的方法，可以直接用类调用
  20.         cls(5) # 实例化一个对象
  21.         print("a=", cls(6).a)
  22.         print("b=", cls.b)
  24. A.func2()
  26. -- output
  27. func2
  28. this is init method,a= 1
  29. func1
  30. func3
  31. this is init method,a= 5
  32. this is init method,a= 6
  33. a= 6
  34. b= 2

@staticmethod

staticmethod不需要任何参数，与classmethod不同，classmethod的主要使用场景是当你想用类来调用方法，而不是对象来调用方法时，而staticmethod一般是用于多个类之间共享该方法，就可以定义为staticmethod，不过在python中，这种场景很少。

@property

@property，把一个getter方法变成属性，同时会创建另外一个装饰器，如下代码就是@width.setter和@height.setter。
从resolution可能看的更清晰一点，创建一个resolution方法，在通过装饰器以后，就默认Screen类有了一个属性，叫做resolution，所以下面可以通过s.resolution调用。并且此时resolution是一个只读属性，不能被修改，从而达到访问控制的目的。

  1. class Screen(object):
  2.     @property
  3.     def width(self):
  4.         return self._width
  5.     @width.setter
  6.     def width(self, width):
  7.         self._width = width
  9.     @property
  10.     def height(self):
  11.         return self._height
  12.     @height.setter
  13.     def height(self, height):
  14.         self._height = height   
  16.     @property
  17.     def resolution(self):
  18.         return self._width * self._height
  20. # 测试:
  21. s = Screen()
  22. s.width = 1024
  23. s.height = 768
  24. print('resolution =', s.resolution)
  25. if s.resolution == 786432:
  26.     print('测试通过!')
  27. else:
  28.     print('测试失败!')
  30. s1 = Screen(100, 700)
  31. print('resolution =', s1.resolution)
  33. # res
  34. resolution = 786432
  35. 测试通过!
  36. Traceback (most recent call last):
  37.   File "/Users/liufei/Downloads/test.py", line 30, in <module>
  38.     s1 = Screen(100, 700)
  39. TypeError: object() takes no parameters

一些奇技淫巧

collections.namedtuple

第一次看到这个类是从tensorflow的源码中，tf.featurecolumn.numericcolumn中的_NumericColumn类继承自collections.namedtuple，这样_NumericColumn可以在没有__init方法的情况下，直接使用self.key等属性：

  1. class _NumericColumn(_DenseColumn,
  2.                      collections.namedtuple('_NumericColumn', [
  3.                          'key', 'shape', 'default_value', 'dtype',
  4.                          'normalizer_fn'
  5.                      ])):
  6.   """see `numeric_column`."""
  8.   @property
  9.   def name(self):
  10.     return self.key

collections.namedtuple是一个工厂方法，它可以动态的创建一个继承tuple的子类。跟tuple相比，返回的子类可以使用名称来访问元素。最大的好处应该是可以提高代码的可读性，最常见的是作为父类给子类提供属性，可以减少很多代码，并且子类的返回结果也更清晰易懂，可以参考上面#继承时的参数传递部分，可以看到，如果是从namedtuple继承，子类返回结果直接可以看到类名，属性值等，而从普通类继承的，则只返回子类的地址。

  1. import collections
  3. Student = collections.namedtuple('Teacher', ['name', 'age'])
  4. s = Student('zhangsan', 25)
  5. print(s)
  6. print("name =", s.name)
  8. t = Teacher("lisi", 26)
  10. # res 
  11. Teacher(name='zhangsan', age=25)
  12. name = zhangsan
  13. Traceback (most recent call last):
  14.   File "/Users/liufei/Downloads/test.py", line 13, in <module>
  15.     t = Teacher("lisi", 26)
  16. NameError: name 'Teacher' is not defined

理解dict

dict用来存储类和对象的属性和方法，以及其他的一些信息。
类的dict存储自己类层面的信息，如类的变量，函数等，不存储函数内的信息，同时不包括父类的信息，对象的dict只存储自己独有的信息。

  1. # -*- coding: utf-8 -*-
  4. class A(object):
  5.     """
  6.     This is doc.
  7.     """
  8.     a = 0
  9.     b = 1
  10.     def __init__(self):
  11.         self.a = 2
  13.     def test(self):
  14.         print 'A func.'
  16.     @staticmethod
  17.     def static_test(self):
  18.         print 'A static func.'
  20.     @classmethod
  21.     def class_test(self):
  22.         print 'A calss func.'
  24. obj = A()
  25. print("A.__dict__:", A.__dict__)
  26. print("\n")
  27. print("obj.__dict__:", obj.__dict__)
  29. class B(A):
  30.     def __init__(self, c=3):
  31.         super(A, self).__init__()
  32.         self.c = c
  34.     def test(self):
  35.         print 'B func.'
  37. print("B.__dict__:", B.__dict__)
  38. print("ojb_B.__dict:", B().__dict__)
  39. --output
  40. ('A.__dict__:', dict_proxy({'a': 0, '__module__': '__main__', 'b': 1, 
  41.                             'class_test': <classmethod object at 0x10ade7210>, 
  42.                             '__dict__': <attribute '__dict__' of 'A' objects>, 
  43.                             '__init__': <function __init__ at 0x10ad70050>, 
  44.                             'test': <function test at 0x10ad702a8>, 
  45.                             '__weakref__': <attribute '__weakref__' of 'A' objects>, 
  46.                             '__doc__': '\n    This is doc.\n    ', 
  47.                             'static_test': <staticmethod object at 0x10ade71d8>}))
  49. ('obj.__dict__:', {'a': 2})
  51. ('B.__dict__:', dict_proxy({'test': <function test at 0x10ae670c8>, 
  52.                             '__module__': '__main__', 
  53.                             '__doc__': None, 
  54.                             '__init__': <function __init__ at 0x10ae67050>}))
  55. ('ojb_B.__dict:', {'c': 3})