python的类

__init__()

类有一个名为__init__()的特殊方法（构造方法），该方法在类实例化时会被自动调用；

当然，__init__()方法也可以有参数，参数通过__init__()传递到类的实例化操作上，例如：

class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 输出结果：3.0 -4.5

self 

self代表类的实例，代表当前对象的地址，self.__class__则指向对应的类

类的方法普通函数只有一个区别——它们必须有一个额外的第一个参数名称，按照惯例是self（当然self不是python关键字，可以是任意名称）。例如：

class Test:
    def prt(self):
        print(self)
        print(self.__class__)
 
t = Test()
t.prt()

#输出为
<__main__.Test instance at 0x100771878>
__main__.Test

super()函数用于调用父类（超类）的一个方法

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

#输出
调用子类方法
调用父类方法

类的属性(变量)和方法

• 属性：类中的变量
• 私有属性：以两个下划线开头的属性，表明该属性为私有，不能在类的外部被使用或直接访问，在类内部的方法中可以被访问
• 类的方法：在类的内部定义的函数，且必须包含参数self（可以为其它）
• 类的私有方法：以两个下划线开头的方法，只能在类的内部调用(self.__private_methods)，不能在类的外部调用
• 类的私有属性实例如下：

• class JustCounter:
      __secretCount = 0  # 私有变量
      publicCount = 0    # 公开变量
   
      def count(self):
          self.__secretCount += 1
          self.publicCount += 1
          print (self.__secretCount)
   
  counter = JustCounter()
  counter.count()
  counter.count()
  print (counter.publicCount)
  print (counter.__secretCount)  # 报错，实例不能访问私有变量
  
  #输出
  1
  2
  2
  Traceback (most recent call last):
    File "test.py", line 16, in <module>
      print (counter.__secretCount)  # 报错，实例不能访问私有变量
  AttributeError: 'JustCounter' object has no attribute '__secretCount'

• 类的私有方法实例如下：

• class Site:
      def __init__(self, name, url):
          self.name = name       # public
          self.__url = url   # private
   
      def who(self):
          print('name  : ', self.name)
          print('url : ', self.__url)
   
      def __foo(self):          # 私有方法
          print('这是私有方法')
   
      def foo(self):            # 公共方法
          print('这是公共方法')
          self.__foo()
   
  x = Site('菜鸟教程', 'www.runoob.com')
  x.who()        # 正常输出
  x.foo()        # 正常输出
  x.__foo()      # 报错

  输出结果： 

•  

类的专有方法 

• __init__：构造函数，在生成对象时调用
• __del__：析构函数，释放对象时使用
• __str__:
• __repr__：打印，转换
• __stitem__：按照索引[]赋值
• __getitem__：按照索引[]获取值
• __len__：获取长度
• __cmp__：比较运算
• __call__：函数调用
• __add__：加运算
• __sub__：减运算
• __mul__：乘运算
• __truediv__：除运算
• __mod__：求余运算
• __pow__：乘方运算

针对__str__专有方法的直观例子：

class people:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def __str__(self):
        return '这个人的名字是%s,已经有%d岁了！'%(self.name,self.age)

a=people('孙悟空',999)
print(a)

#输出
这个人的名字是孙悟空,已经有999岁了！

#如果没有重载__str__运算符则会输出：
如果没有重载函数的话输出的就是一串看不懂的字符串：
<__main__.people object at 0x00000272A730D278>

python同样支持运算符重载，

如对专有方法 __add__重载

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b
 
   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)
 
v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

#输出
Vector(7,8)

类的方法总结

• 普通方法:只能被对象调用, 默认有个self参数。
• 静态方法: 类和对象访问。用 @staticmethod 装饰的不带 self 参数的方法叫做静态方法，类的静态方法可以没有参数，可以直接使用类名调用。
• 类方法: 类和对象访问。默认有个 cls 参数，需要加上 @classmethod 装饰器。
• 私有方法：类和对象都无法访问。两个下划线开头，只能类内部访问。
• 多继承情况下：从左到右查找父类的方法，找到为止，不然就抛出异常

实例：

class Classname:
    @staticmethod
    def fun():
        print('静态方法')

    @classmethod
    def a(cls):
        print('类方法')

    # 普通方法
    def b(self):
        print('普通方法')

    #私有方法
    def __f(self):
        print('私有方法')



Classname.fun()
Classname.a()

C = Classname()
C.fun()
C.a()
C.b()
C.__f()  #出错