Python基础语法之继承、多态、属性与方法

1.继承简介

			。继承是面向对象的三大特性之一
			。通过继承我们可以使一个类获取到其他类中属性和方法
			。在定义类时，可以在类名后面的括号中指定当前类的父类（超类、基类）
			。继承提高了类的复用性，让类与类之间产生了关系，有了这个关系，才有了多态的特性。
			隐患：创建一个新类比较麻烦，需要大量的复制粘贴代码。维护修改起来比较麻烦，因此引入了继承
			class Person():
				name = ''
				age = ''
			calss Doctor(Person):
				pass
			在创建类时，如果省略了父类，则默认父类为object
			object是所有类的父类，所有类都继承自object
			所有对象都是object的实例
			class Presson(object):
				pass
			issubclass() 检查一个类是否是另一个类的子类
			print(issubclass(Person,object))   # True
			print(issubclass(int,object))  # True

2.方法重写

		如果子类中有和父类同名的方法，则通过子类的实例去调用方法时，会调用子类的方法而不是父类的方法，这个特点我们也称之为方法的重写（覆盖）
		当我们用对象去调用一个方法时，
		首先会优先当前对象中寻找是否具有该方法，如果有则直接调用，如果没有，则去当前对象的父类中寻找，如果父类中有则调用父类中的方法，如果父类中没有则去父类的父类寻找，以此类推，如果没有则返回错误
		class A(object):
			def test(self):
				print('a....')
		class B(A):
			def test('B....')
	c = B()
	print(c.test) # B.....

3.super（）

		父类中的所有方法都会被子类继承，包括特殊方法
		有一种动态的方法来获取类的父类
		通过super（）可以直接获取当前类的父类

4.多重继承

		__bases__可以获取当前类所有的父类
		用法：类名.__bases__
		在Python中是支持多重继承的，也就是我们可以为一个类指定多个父类
		如果多个父类中有同名的方法，则会在第一个父类中寻找，然后找第二个父类。。。。。。前边会覆盖后面的

5.多态

		多态是面向对象的三大特性之一
		一个对象可以以不同形态去呈现
	
	class A:
		def __init__(self,name):
		self._name = name
	class B:
		def __init__(self,name):
			self._name = naem
	@property
	def name(self):
		return self._name
	@name.setter
	def name(self,name):
		self._name = name 
	class C:
		pass
	
	a = A('葫芦娃')
	b = B('钢铁侠')
	c = C()
	#对应speak（）这个函数来说，只要对象中函数有name属性，它就可以作为参数传递
	#这个函数并不考虑对象的类型，只要有name属性就可以
	def speak(obj):
		print('你好 s%'%.obj.name)
	speak(a)	#你好 葫芦娃
	speak(b)	#你好 钢铁侠
	speak(c)	# AttributeError: 'C' object has no attribute 'name'

#在speak2（）中做了一个类型检查，也就是说只要符合obj是A类型的对象时，才可以执行，其他类型的对象使用不了该函数，这个函数就违反了多态
def speak2(obj):
	#检查obj是否是A的实例
	if isinstance(obj,A):
		print('你好 %s'%obj.name)
	
	面向对象的三大特征：
	封装：封装是确保对象中的数据安全
	继承：保证的对象的可扩展性
	多态：保证是程序的灵活性

属性和方法

		属性
			类属性，直接在类中定义的属性是类属性
			类属性可以通过类或者类的实例进行访问，但是类属性只能通过类对象修改，无法通过实例对象修改
			实例属性 通过实例对象添加的属性输液实例属性
			实例属性只能通过实例对象来访问和修改，类对象无法访问修改
			class A(object):
				count = 0
				def __init__(self):
					self.name = '葫芦娃'
			a = A()
			#类属性可以通过类或者类的实例进行访问
			print a.count	#0
			print A.count  	#0
			
			a.count = 10
			print('A',A.count)		#0
			print('a',a.count)		#10
			#类属性只能通过类对象修改，无法通过实例对象修改
			A.count = 100
			print('A',A.count)		#100
			print('a',a.count)		#100
			
				print('a',a.name) 		#葫芦娃
				
				print('A',A.name)		#AtrributeError :type object 'A' has not attribute 'name'
			
		方法
			在类中定义，以self为第一个参数的方法都是实例方法
			实施方法在调用时，Python会将调用对象以self传入
			实例方法可以通过类实例和类去调用
			当通过实例调用时，会自动将当前调用对象作为self传入
			当通过类调用时，不会自动传递self，我们必须手动传递self
			类方法在类的内容以@classmethon来修饰的方法属性类方法
			类方法第一个参数是cls也会自动被传递，cls就是当做类对象
			类方法和实例方法的区别，实例方法的第一个参数self
			@staticmethod 修饰的方法是静态方法
			静态方法不需要指定任何默认参数，静态方法可以通过类或者实例调用
			静态方法基本上是一个和当前类无关的方法，他只是一个保存到当前类的函数
			静态方法一般都是一些工具方法，和当前类无关
			class A(object):
				def test(self):
					print('这是test方法。。。。。')
				@classmethod
				def test2(cls):
					print(' 这是test2方法。。。。。'）
				@staticmethod
				def test3():
					print('test3方法是静态方法')
			a = A()
			#当通过实例调用时，会自动将当前调用对象作为self传入
			a.test()		#这是test方法。。。。。
			#当通过类调用时，不会自动传递self，我们必须手动传递self
			A.test()		#TypeError : test() missing 1 required postitiaonal argument::'self'
			#，我们必须手动传递self 需要手工传递参数
			A.test(a)		#这是test方法。。。。。
			a.test() 等价于 A.test(a)
			#类方法和实例方法的区别，实例方法的第一个参数self
			A.test2()		#这是test2方法。。。。。
			A.test2() 等价于 a.test2()
			A.test3()		#test3方法是静态方法
			a.test3()		#test3方法是静态方法