面向对象

类与对象

私有属性

如果一个类属性名是以“—”开头，则该类属性为私有属性。

构造方法

构造方法名为—init—，在创建一个类对象时会自动执行。

析构方法

构造方法名为—del—，在销毁一个类对象时会自动执行。

继承与多态

如何继承父类

class son(father1,father2,....):
	....
	....
	....

方法重写

方法重写是指子类可以对从父类中继承过来的方法进行重新定义，从而使得子类对象可以表现出与父类对象不同的行为。
方法重写是多态的基础。

# 父类Person
class Person:
	def __init__(self,name):
		self.name=name
	def PrintInfo(self):
		print("name:%s"%self.name)
# 子类Student继承父类person
class Student(Person):
	# 构造函数
	def	__init__(self,name,sno):
		self.name=name
		self.sno=sno
	# 重写PrintInfo方法
	def PrintInfo(self):
		print("sno=%s,name=%s" %(self.sno,self.name))

def PrintPersonInfo(a):
	print("最后结果是：",end='#')
	a.PrintInfo();

if __name__=='__main__':
	p=Person("xiaoming");
	stu=Student("xiaohong",1)
	p.PrintInfo()
	stu.PrintInfo()
	# 多态，根据传入的参数去动态选择方法
	PrintPersonInfo(p)
	PrintPersonInfo(stu)

super方法

super方法用于获取父类的代理对象，以执行已在子类中被重写的父类方法。

高级应用

内置函数isinstance、issubclass、type

isinstance函数用于判断一个对象所属的类是否是指定类或指定类的子类、isinstance(Son,Father)
issubclass函数用于判断一个类是否是另一个类的子类、issubclass(Son,Father)
type函数用于获取一个对象所属的类。tupe(Son)==(Father)

类方法

类方法是指使用@classmethed修饰的方法，其第一个参数是类本身。类方法的特点是既可以通过类名直接调用，也可以通过类的实列对象调用。

class c :
	def __init__(self,real=0,image=0):
		self.real=real
		self.image=image
	@classmethod
	def add(c,c1,c2):
		print(c)
		c3=c()
		c3.real=c1.real+c2.real
		c3.image=c1.image+c2.image
		return c3
if __name__=="__main__":
	c1=c(1.1,2.2)
	c2=c(2.2,3.3)
	c3=c.add(c1,c2)
	print(c3.real, c3.image)
	c3=c1.add(c1, c2)
	print(c3.real, c3.image)
	c3=c2.add(c1,c2)
	print(c3.real,c3.image)

静态方法

静态方法是指使用@staticmethod修饰的方法。与类方法相同，静态方法既可以直接通过类名调用，也可以通过类的实例对象调用。与类方法不同的是，静态方法中没有类方法中的第一个类参数。

class c :
	def __init__(self,real=0,image=0):
		self.real=real
		self.image=image
	@staticmethod
	def add(c1,c2):#与类方法区别在此
		print(c)
		c3=c()
		c3.real=c1.real+c2.real
		c3.image=c1.image+c2.image
		return c3
if __name__=="__main__":
	c1=c(1.1,2.2)
	c2=c(2.2,3.3)
	c3=c.add(c1,c2)
	print(c3.real, c3.image)
	c3=c1.add(c1, c2)
	print(c3.real, c3.image)
	c3=c2.add(c1,c2)
	print(c3.real,c3.image)

动态扩展类与实例

Python作为一种动态语言，除了可以在定义类时定义属性和方法外，还可以动态地为已经创建的对象绑定新的属性和方法。

from types import MethodType
class Student:
	pass
def SetName(self,name):
	self.name=name
def SetSno(self,sno):
	self.sno=sno
if __name__=="__main__":
	stu1=Student()
	stu2=Student()
	# 为stu1绑定SetName方法，绑定之后该方法只能被stu1使用
	stu1.SetName=MethodType(SetName,stu1)
	# 为Student类绑定SetSno方法，绑定之后该该方法只能被该类使用
	Student.SetSno=SetSno
	
	#注意，Student是一个空类，没有任何属性，我们可以动态的为他添加属性
	stu1.SetName("xiaoming")
	stu1.SetSno("110")
	stu2.SetSno("1101")

_ slots _

在定义类时，python提供了_ slots _变量以限制可动态扩展的属性。

class Student:
	__slots__ = ("name")只可以动态扩展该属性
if __name__=="__main__":
	stu=Student()
	stu.name="xiaoming"
	print(stu.name)
	# stu.sno="110"，去掉注释会报错

@property

类中的属性可以直接访问和赋值，这为类的使用者提供了方便，但也带来了问题，类的使用者可能会给一个属性附上超出有效范围的值。为了解决这个问题，python提供了@property装饰器，可以将类中属性的访问和赋值操作自动转为方法调用，这样可以在方法中对属性值的取值范围做一些条件限定。

import datetime
class Student:
	#定义一个用于获得属性score的方法即（getter）
	@property
	def score(self):
		return self._score # 在getter/setter方法中使用self访问属性时，需要在属性前加上“_”
		
	# 定义一个设置属性score的方法即（setter）
	@score.setter
	def score(self,score):
		if score<0 or score>100:
			print("the score must between 0-100")
		else:
			self._score=score # 在getter/setter方法中使用self访问属性时，需要在属性前加上“_”
			
	#定义一个用于获得属性age的方法即（getter）
	@property
	def age(self):
		return datetime.datetime.now().year-self.birthyear
		
if __name__=="__main__":
	stu=Student()
	stu.score=80
	stu.birthyear=2000
	# stu.age=19，由于age属性只有getter方法，没有setter方法，age会被设置为只读属性，不允许进行赋值。
	print("年龄：%d,成绩：%d"%(stu.age,stu.score))
	stu.score=105
	print("年龄：%d,成绩：%d"%(stu.age,stu.score))

鸭子类型

在python中编写一个函数，传递实参前其参数的类型并不确定，在函数中使用形参进行操作时，只要传入的对象能够支持该操作程序，就能正常执行。

class Person:
	def CaptureImage(self):
		print("Person中的CaptureImage被调用")
class Camera:
	def CaptureImage(self):
		print("Camera中的CaptureImage被调用")
def CaptureImageTest(arg):
	arg.CaptureImage()
if __name__=="__main__":
	p=Person()
	c=Camera()
	# 传入类型不同，但由于P和C都有CaptureImage()方法，故不会报错
	CaptureImageTest(p)
	CaptureImageTest(c)

由此可见，Python中的多态其实是借助于鸭子类型实现的，与Java中的多态不是同一含义。