Python3学习（九）:面向对象

面向对象编程(Obeject oriented programming)

Python从设计之初就已经是一门面向对象的语言

• 类(class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 类变量： 类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 实例变量： 在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
• 对象： 通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

---

类定义

class MyClassName:
	<statement>
	...
	i = 123
	<statement>

类对象
类对象支持两种操作：属性引用和实例化。

• 属性引用: obj.xxx
• 实例化: 创建了一个新的类实例并将该对象赋给局部变量 x，x 为空对象。

x = MyClass()
print(x.i())

init方法
如果类定义了 __init__() 方法，类的实例化操作会自动调用 init() 方法。
语法：

def __init__(self):
    self.data = []

示例：

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。
• 在类的内部,类方法必须包含参数 self, 且为第一个参数

---

继承

class DerivedClassName(BaseClassName):  #BaseClassName即为“基类”，也即“父类”
    <statement-1>
    ...
    <statement-N>

实例：

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
s = student('ken',10,60,3)
s.speak()

#输出
ken 说: 我 10 岁了，我在读 3 年级

---

多继承

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
	...
    <statement-N>

如果父类包含同名方法且未指定使用哪一个，优先级从左往右，先继承谁就用谁的。

• super()可以防止父函数被多次初始化。
  在子类中初始化父对象时，利用super函数 就能够在多重继承的时候只初始化父函数一次。

• super()获取的是继承顺序中的下一个类。以下面的继承方式为例：

使用super() 调用父类的父类方法：

class A:
     def add(self, x):
         y = x+1
         print(y)
class B(A):
    def add(self, x):
        super().add(x)   #使用A父类的add方法
b = B()
b.add(2)
  
#输出  3

---

钻石继承

class Base:
    def __init__(self):
        print('Base.__init__')
 
 
class A(Base):
    def __init__(self):
        super().__init__()
        print('A.__init__')
 
 
class B(Base):
    def __init__(self):
        super().__init__()
        print('B.__init__')
 
 
class C(A, B):
    def __init__(self):
        super().__init__()
        print('C.__init__')
 
 
C()

#输出
Base.__init__
B.__init__
A.__init__
C.__init__ 

---

方法重写
可以在子类重写父类的方法，实例如下：

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

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

---

类属性与方法

• 类的私有属性
  __private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
• 类的私有方法
  __private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量
 
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print (self.__secretCount)
    
    def __count(self):
    	print("私有方法")
 
counter = JustCounter()
counter.count()  #1
counter.count()  #2 
counter.__count()  #报错，外部不能调用私有方法
print (counter.publicCount)  #2
print (counter.__secretCount)  # 报错，实例不能访问私有变量

---

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

运算符重载：__str__

class Vector:
#python 3.7简化构造函数写法    
    a:int
    b:int

#    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)

如果没有重载函数的话输出的就是一串看不懂的字符串：
<main.Vector object at 0x00000272A730D278>

注：定义类时，若需要输入参数，则一般必须使用 __init__()方法；若不需要输入参数，是否使用 __init__() 方法都可以。

---

Python3 中类的静态方法、普通方法、类方法

• 静态方法: 用 @staticmethod 装饰的不带 self 参数的方法叫做静态方法，类的静态方法可以没有参数，可以直接使用类名调用。

• 普通方法: 默认有个self参数，且只能被对象调用。

• 类方法: 默认有个 cls 参数，可以被类和对象调用，需要加上 @classmethod 装饰器。

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

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

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

C = Classname()
C.fun()
C.a()
C.b()