11.30

面向对象：

特性方法，又可以理解为只读属性，也就是说这个方法只具有读的属性，不具有写的属性

class Person(object):
	# 数据属性
	country = '中国'
	# 叫构造方法--->初始化类的过程
	# name,age,sex实例属性
	def __init__(self,name,age,sex):
		self.name=name
		self.age=age
		self.sex=sex

	def getName(self):
		'''获取姓名'''
		return self.name

	def getAge(self):
		return self.age

	def getSex(self):
		return self.sex

	def setName(self,name):
		'''设置姓名'''
		self.name=name

	def setAge(self,age):
		self.age=age

	def setSex(self,sex):
		self.sex=sex

	def show(self,asd):
		print('my name is {0},and age is {1},and my sex is {2},and method params is{3}'.
		      format(self.name,self.age,self.sex,asd))
# 特性方法，又可以理解为只读属性，也就是说这个方法只具有读的属性，不具有写的属性
	@property
	def getNameAge(self):
		return 'my name is{0},and my age is {1}'.format(self.name,self.age)

obj=Person(name='gao',age=12,sex='boy')
print('我想调用实例属性：',obj.getName())
print('我想调用数据属性：',obj.country)
print('我想调用普通方法：\n')
obj.show(asd='我是方法的形式参数')
print('我想调用特性方法：',obj.getNameAge)

 

 

面向对象

java和python的继承有什么区别？
java是单继承的，python是多继承的（可以继承多个类）
所有类的基类都是object

基类（父类）：被继承的类
派生类（子类）：继承其他的类

子类继承父类，那么也就是说子类继承了父类所有的属性（数据属性&实例属性）和方法
注意：原则上来说，继承一般不建议超过二代关系

super().__init__(xinge)
Father(xinge).__init__(self)

方法重写：当子类的方法与父类的方法名一致的时候，就说子类重写了父类的方法
目的：父类的方法没有办法满足子类的诉求

class Father(object):
	county='吾问无为谓'
	def __init__(self,caiyi):
		self.caiyi=caiyi
	def show(self):
		print('多才多艺')
class Son(Father):
	def __init__(self,caiyi,hobby):
		self.hobby=hobby
		super().__init__(caiyi)
	def show(self):
		print('才艺：{0}，爱好：{1}'.format(self.caiyi,self.hobby))
obj=Son(caiyi='多才多艺',hobby='学习')
obj.show()
print(obj.county)

 

继承第一原则：
约束条件：从上到下原则是前提条件是子类没有重写父类的方法
继承第二原则：
约束条件：从下到上原则是前提条件是子类重写了父类的方法

class Father(object):
	county='吾问无为谓'
	def __init__(self,caiyi):
		self.caiyi=caiyi
	def show(self):
		print('多才多艺')
class Son(Father):
	def __init__(self,caiyi,hobby):
		self.hobby=hobby
		super().__init__(caiyi)
	def show(self):
		print('才艺：{0}，爱好：{1}'.format(self.caiyi,self.hobby))
	def show(self):
		print('少时诵诗书')
obj=Son(caiyi='多才多艺',hobby='学习')
obj.show()
print(obj.county)

 

从左到右原则：
调用的方法，在第一个继承的类里面寻找这个方法，若果查找到，后面的类不在进行寻找，假设第一个继承的

class F(object):
	cunty='神神叨叨'

	def __init__(self,caiyi):
		self.caiyi=caiyi

	def show(self):
		print('少时诵诗书')

class M(object):
	def show(self):
		print('星象衔新宠')

class Son(F,M):
	def __init__(self,caiyi,hobby):
		self.hoyyb=hobby
		super().__init__(caiyi)

obj=Son(caiyi='温和',hobby='书法')
obj.show()
print(obj.cunty)

 

 继承原理：

1、当实例化子类的对象后，那么子类调用某一个方法，优先考虑子类是否这个方法，如果存在，优先调用子类的方法
2、如果调用的方法子类不存在，那么就按照线性查找的方式来进行寻找，直到找到符合要求的方法为止

class Person(object):
	def show(self):
		print('aaa')

class Mother(Person):
	def show(self):
		print('bbb')

class Father(Person):
	def show(self):
		print('ccc')

class Son(Father,Mother):
	pass
if __name__ == '__main__':
# 查看继承顺序mro()
    print(Son.mro())

 

针对如上的案例代码，调用后，调用的顺序是不同的，具体如下：

python3顺序:D--->B--->C

python2顺序:D--->b--->A

class A:
  def show(self):
    print('A')

class B(A):
  pass

class C(A):
  def show(self):
    print('C')

class D(B,C):
  pass

if __name__ == '__main__':
  obj=D()
  obj.show()

 

 

 

鸭子类型

class Animal(object):
	def talk(self):
		print('动物会叫')

class Cat(Animal):
	def talk(self):
		print('猫也是会叫的')

class People(Animal):
	def talk(self):
		print('人也是动物的一类，也是会叫的')

def func(animal):  # 是Animal类的对象
	animal.talk()

if __name__ == '__main__':
	# 对猫进行一个实例化的过程
	cat = Cat()  # 调用方式不需要修改，就直接能够输出"猫也是会叫的"的信息
	func(animal=Cat())
	func(animal=People())