Python 类

定义

class 类名:
	成员变量
	成员方法

变量=类名()# 创建对象
变量.成员变量# 使用成员变量
变量.成员方法

类与对象

类相当于设计图纸，规定了各种属性与行为。
对象也就是按照类所实现的实例，对象完成具体的工作。

成员方法

语法：参数列表中有一个self关键字，是必须填写的。用于表示类对象自身。
在方法内部，若要访问成员变量与调用成员函数，则需要通过self来访问。
在调用成员方法时，self由python自动传入，不用手动传入。

def 方法名(self,参数1...):
	方法体

构造方法

构造对象时，会自动调用。类会默认存在一个无参的构造函数。
注意：若实现了构造函数，则默认的无参构造函数将不存在。
前后为两个下划线。

def __init__(self,参数):
	方法体

魔术方法

定义：python类内置的方法，如__init__
常用的魔术方法：

① __str__字符串方法：控制类转换为字符串的行为。
在不使用__str__时，print(类对象)输出的是该对象的内存地址。

class Example:
	x=None
	y=None
	def __init(self,x,y):
		self.x=x
		self.y=y
	def __str__(self):# 控制类转换为字符串的行为
		return f"x={self.x}, y={self.y}"
ex=Example(1,2)
print(ex)# 输出 x=1, y=2
print(str(ex))

② lt 小于符号比较方法：控制类之间比较大小的行为，类似C++中重载<与>运算符。
实现了__it__方法，即可同时完成：小于符号与大于符号。

class Example:
	x=None
	y=None
	def __init__(self,x,y):
		self.x=x
		self.y=y
	def __lt__(self,other):# 控制小于符合，other为右边的类对象
		return self.x<other.x# 按照x的大小
ex1=Example(1,2)
ex2=Example(2,3)
print(ex1<ex2)# True
print(ex1>ex2)# False 大于号也可以

③ le 小于等于比较符号方法，可用于<=, >=。类似C++中重载<=与>=

class Example:
	x=None
	y=None
	def __init__(self,x,y):
		self.x=x
		self.y=y
	def __le__(self,other):# 控制小于等于符号，other为右边的类对象
		return self.x <= other.x# 按照x的大小
ex1=Example(1,2)
ex2=Example(2,3)
print(ex1<=ex2)# True
print(ex1>=ex2)# False 大于等于比较符号

④ eq 等于运算符方法，用于 ==，类似C++中重载 ==。
若没有__eq__方法，则==比较的是两个类对象的内存地址是否相同。

class Example:
	x=None
	y=None
	def __init__(self,x,y):
		self.x=x
		self.y=y
	def __eq__(self,other):# 控制等于符号，other为右边的类对象
		return self.x==other.x# 按照x的大小
ex1=Example(2,2)
ex2=Example(2,3)
print(ex1==ex2)# True

私有成员

在成员变量或成员方法前面增加两个下划线即可。私有成员可以被类内的其他成员访问，注意调用时不要漏了下划线。

class Example:
	__x=None # 私有成员变量
	def __setX(self,x):# 私有成员方法
		self.__x=x
	def getX(self,x):
		self.__setX(x)
		return self.__x

ex=Example()
# ex.__x # 报错
# ex.__setX(x) # 报错
ex.getX(x)

继承

class 子类名(父类名1,父类名2...)
	类体

若多个父类中，存在同名的成员，则优先从左到右递减，先继承的保留，后继承的被覆盖。

class Shape:
	x=None
	y=None
	def __init__(self,x,y):
		self.x=x
		self.y=y

class Circle(Shape):
	R=None
	def __init__(self,x,y,R):
		self.x=x
		self.y=y
		self.R=R		

复写父类成员

在子类定义同名的成员变量或成员方法即可

调用父类成员

有两种方法：
① 使用父类名：
父类名.成员变量或成员方法**(self)** # 注意要传入self

② 使用super()调用
super().成员变量或成员方法() # 注意不要传入self

class Shape:
	x=0
	y=0
	def __init__(self,x,y):
		self.x=x
		self.y=y
	def getPlace(self):
         return self.x,self.y
		
class Circle(Shape):
	R=0
	def __init__(self,x,y,R):
		super().__init__(x,y)# 调用父类构造函数
		self.R=R
	def getPlace(self):# 重写父类方法
		print(self.name,Shape.name)# 调用父类的成员变量
		return Shape.getPlace(self)# 调用父类方法

多态

使用不同的对象时，会得到不同的状态。
多态经常在继承中使用，使用父类对象来控制子类对象，在C++中有更加严格的使用。
如：
函数中的形参注解为父类，调用时传入子类对象。根据传入对象的子类不同，执行不同的操作。

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("汪")
        
class Cat(Animal):
    def speak(self):
        print("喵")
        
def F(animal: Animal):  # 多态，animal注解为父类
    animal.speak()  # 根据传入对象所属的子类来执行对应子类中的方法
    
animal1 = Dog()
animal2 = Cat()
F(animal1)# 传入子类对象
F(animal2)

抽象方法：
方法体为空实现(pass)的方法，如Animal中的speak方法。
子类必须重写父类中的抽象方法，不然对于子类来说，抽象方法等于不存在。

抽象类（接口）：
包含抽象方法的类。
用于顶层设计（设计标准），便于子类的实现。
对子类的一种软性约束