面向对象-内置函数，反射

回顾

继承

面向对象三大特征之一
三大特性：
	封装
	继承
	多态
# 继承：解决类与类之间代码冗余问题
'''
继承的查找顺序：
	单继承：对象自身名称空间>>产生对象的类>>父类
	多继承：
		1.经典类：不继承object类的类，以及子子孙孙类都是经典类
			按照深度优先
		2.新式类：继承object类的类，以及子子孙孙类都是新式类
			按照广度优先
在Python2中区分经典类，新式类
在Python3中都是新式类
'''

suer和mro列表

'''
父类
class People():
	school = 'SH'
	def __init__(self, name, age, gender)
		self.name = name
		self.age = age
		self.gender = gender

子类
class Student(People):
	def __init__(self, name, age, gender, course=None):
		if course = []
		self.course = course
		# People.__init__(self, name, age, gender)  # 类调用方法，有几个参数就要传几个参数
		# super(Student,self) # 返回一个特殊的对象，只要是对象就会将自己以目标传入进去
		super().__init__(name, age, gender)  # py3括号内可以不添加值

哪个类调用mro就以哪个类为起始
'''

多态与多态性

多态：面向对象的三大特征之一
什么是多态?
	一种事物的多种形态

'''
多态中的类目的：让父类限制子类的行为，不是继承父类属性和方法的
import abc  # 
# 此类已经变为抽象类
# 抽象类只能被继承，不能被实例化
class Animal(meteclass=abc.ABCMeta):
	@abc.abstractmmethod  # 抽象方法
	def speak(self):
		pass

class People(Animal):
	def speak(self):  # 子类中必须要有，没有参数也可以，但功能要有
		pass
'''
上述在Python中不推荐使用
python推荐鸭子类型
'''
class People():
	def speak(self):
		pass
		
class Pig():
	def speak(self):
		pass
		
class Dig():
	def speak(self):
		pass

obj1 = People()
obj2 = Pig()
obj3 = Dog()

def animal(animal):
	return animal.speak

animal(obj1)
animal(obj2)
animal(obj3)

# 父类限制子类另一种模式：
class Animal():
	def speak(self):
		raise E  
'''

组合

解决类与类之间的代码冗余问题
	1.继承：什么是什么的关系，is-a的关系
	2.组合:一个对象，拥有一个属性，属性的值是另一个对象。
    
继承是一个双刃剑，并不是继承的越多越好

'''
class Foo:
	def __init__(self, m):
		self.m = m
class Bar():
	def __init__(self, n):
		self.n = n

obj1 = Foo(10)
obj1 = Bar(20)

obj.x = obj1  # 这就是组合
'''
学生选课系统
'''
class People():
	def __init__(self, name, age, gender):
		self.name = name
		self.age = age
		self.gender = gender

class Course():
	def __init__(self, name, period, price):
		self.name = name
		self.period = period
		self.price = price


class Student():
	def __init__(self, name, age, gender, course=None)：
		if course is None:
			course = []
		self.courses = course
		super().__init__(name, age, gender)
	
	def choose_course(self, stu_obj, course):
		stu_obj.courses.append(course)


'''

面向对象的内置函数

1.__init__()
2.__str__()
3.__del__()
4.__enter__()
5.__exit__()
6.__call__()

'''
class Student():
	school = 'SH'
	
	# 调用类的时候直接出发
	def __init__(self, name, age):
		self.name = name
		self.age = age
		
	def tell(self):
		print('name: %s, age: %s' % (self.name, self.age))
		
	# 打印对象的时候，自动触发的函数
	# 返回值只能是字符串
	def __str__(self):  # 
		return 'name: %s' % self.name
	
	# 1.手动执行del
	# 2.程序执行完毕触发
	def __del__(self):
		pass
		# 可以做一些收回系统资源的操作(如打开文件，结束程序文件还在打开中，可以写关闭文件的程序)
	
    # 对象加括号就会触发
	def __call__(self, *args, **kwargs):
		pass
		# 当对象后面加上括号之后，会出发__call__。可以在内部写程序
'''

反射

对象通过字符串来操作属性

1.getattr  # 重要
	print(getattr(stu, 'name', None))  # 相当于print(stu.name) 目标存在就会触发，不存在就会返回None。None的位置可以写入任何值，
	stu.func()  # 方法
	getattr(stu, 'func')()  方法加上括号就会执行

2.setattr  # 添加
	setattr(stu, 'x', 123) # 在这个属性中添加x：123
	stu.__dict__  # 可以查看对象

3.hasattr  # 查看属性存不存在，会返回None或者Fal
	print(hasattr(stu, 'name'))

4.delattr  # 删除目标属性
	delattr(stu, 'name')  # 目标不存在就会报错
	delattr(stu, 'x')  # 

异常

1.什么是异常？
	异常就是错误发生的信号，如果不对信号做处理，那么异常之后的代码都不会执行

	异常的种类：
		1.语法错误
			不允许出现，如果发现立刻更改
		2.逻辑错误
			代码逻辑尽量写到完美
2.为什么要用异常
	增强代码的健壮性
3.怎么用异常
	'''
	try:
		被监测代码
	except 异常的类型：
			pass
	except 异常的类型：
			pass
	except 异常的类型：
			pass
	except Excepption as e:  # 最后万能异常收尾
			pass
	else:
		被监测代码没有出错才会触发
		pass
	finally:
		被监测代码出不出错都会触发
	'''