Python知识点总结（4） 面向对象

0 类

class Player(object):
	def __init__(self,name,age):
		self.name=name
		self.age=age
	def message(self ):
		print('nmae:%s ,age:%d '(self.name ,self.age))
lbl=Player('lbl',30)
lbl.message()

1封装

class Player(object):
 	name=' '
 	age=0
	def message(self ):
		print('nmae:%s ,age:%d '(self.name ,self.age))
lbl=Player(')
lbl.name='lbl'
messi.age=30
messi.mssage()

此时的name和age是共有变量，可以把属性改为私有变量；
前面加__ 双下划线变为私有;可以使用 set+类名进行访问；

class Player(object):
 	__name=' '
 	__age=0
	def message(self ):
		print('nmae:%s ,age:%d '(self.name ,self.age))
lbl=Player(')
lbl.name='lbl'
messi.age=30
messi.mssage()
lbl.setPlayer('lbl',30)

2 继承

继承：

class  CF(Player):
	goal =0
	def print(self):
		print('name:%s, age:%d , goal :%d  ' % （self.name ,self.age,self.goal）) 
devlant=CF(  )
devlant.name='devlant'
devlan.age=30
devlan.goal=91

多重继承

class A(object):
	def __init_(self): #构造函数 ，对象的创建
		print('init class A')
	class B(A):
	def __init__(self):
		A.__init__(self):
		print('init class B')
	
	class C(A):
		def __init__(self):
			A.__init__(self)
			print('C')

class D(B,C):
	def __Init__(self):
		B.__init(self)
		C.__init(self)
		print('init class D')
	d=D()
	B,C单继承，D多继承
	TCP和UDP的多进程和多线程
class MyTCPSsever(TCPSever, ForkingM):
class MyUDPSever(UDPSever,ThreadingMixin):

super()
实现了多重继承的功能；但是A被多次初始化；很不合理；所有super可以解决

class A(object):
	def __init__(self):
		print('int class A')
	
class B(A):
	def __initII(self):
		super(B,self).__init__()
		print('init class B')

class C(B):
	def __init__(self):
		super(D,self).__init__()
		print('init class D')
	d= D

3 多态

类具有继承关系，子类类型转化为父类类型,可以从person转出为Student和Teachaer

class Person(object):
	def __init__(self, name):
		self.name =name
	def whoI(sefl):
		return 'I am person ,my name is % s'% self.name
class Student (Person)：
	def  __init__(Person):
		super(Shudent.slef).__init__(name)
		self.socer=scoer
	def whoAmI(Self)：
		return 'I am a Student ,my name is %s ,my score is %d '% (self.name,self.score)
		def who_am_i(x)
			print(x.whoAmI())
		p=Person('caomei')
		s=Student('liuliu')
		who_am_i(p)
		who_am_i(s)

面向对象所谓的多态方法；就是调用x；s是student类型，whoAmI（）方法从继承的whoAmi方法，调用到s.whoAmI()的定义；没有定义，继续向父类中找；

Python是动态语言；动态语言和静态语言的差距是；
动态语言，传给who_am_i的参数不一定是person的子类型；任何数据类型的实例都可以，只要有一个whoAmi方法；
这是动态语言和静态语言java最大差距；
动态调用实例方法不检查类型，参数正确就可以；

4运算符重载

python提供很多魔法方法；
运算法重载及时通过重写这些Python方法实现的；
类似于__X__的形式；
Python中常见的运算法重载：

1__init__
2__del__
3__add_
4__sub__
5__or__

5构造函数和析构函数

构造函数和析构函数：

class Human():
	def __init__(slef,n):
		self.name=n
		print(''__init__',self.name)
	def __del__(self):
		print('__del__')

h=Human('messi')
h='a'