一.组合

1.定义：

　　组合就是一个对象拥有一个属性，但该属性的值是来自于另外一个类产生的对象。

2.例子：

 1 # 组合：就是一个对象拥有一个属性，该属性的值是另一个类的对象
 2 # 解决类与类之间的问题
 3 
 4 class People():
 5     school = 'sh'
 6 
 7     def __init__(self, name, age, gender):
 8         self.name = name
 9         self.age = age
10         self.gender = gender
11 
12 
13 class Admin(People):
14     pass
15 
16 
17 class Course():
18     def __init__(self, name, period, price):
19         self.name = name
20         self.period = period
21         self.price = price
22 
23 
24 python = Course('jason', '6个月', '21800元')
25 linux = Course('jack', '5个月', '10000元')
26 
27 
28 class Student(People, Course):
29     def __init__(self, name, age, gender, course=None):
30         if course is None:
31             course = []
32         self.course = course
33         super().__init__(name, age, gender)
34 
35     def choose_course(self, stu_obj, course):
36         stu_obj.course.append(course)
37 
38 
39 class Teacher(People, Course):
40     def __init__(self, name, age, gender, level):
41         self.level = level
42         super().__init__(name, age, gender)
43 
44     def score(self, stu_obj, score):
45         stu_obj.score = score
46 
47 
48 stu = Student('jason', 18, 'male')
49 print(stu.choose_course(stu, python))
50 print(stu.name)
51 stu.course.append(python)
52 for course in stu.course:
53     print(course.period)
54     print(course.price)
55 stu.course.append(linux)
56 for i in stu.course:
57     print(i.price)

二.面向对象的内置函数

 1 # 1. __init__()
 2 # 2. __str__()
 3 # 3. __del__()
 4 # 4. __enter__()
 5 # 5. __exit__()
 6 # 6. __call__()
 7 
 8 # __init__调用类的时候出发
 9 class Student():
10     school = 'sh'
11 
12     # 调用类的时候触发
13     def __init__(self, name, age, gender):
14         self.name = name
15         self.age = age
16         self.gender = gender
17 
18     def tell(self):
19         print('name：%s， age：%s' % (self.name, self.age))
20 
21     # __str__
22     def __str__(self):
23         return 'name:%s' % self.name
24 
25     # 打印对象的时候，自动触发的函数
26     # 返回值只能是字符串
27 
28     # 手动执行del
29     # 程序执行完毕自动触发
30     def __del__(self):
31         print('__del__')
32 
33     def __call__(self, *args, **kwargs):
34         print('__call__')
35 
36 
37 stu = Student('ly', 20, 'male')
38 print(stu.__str__())
39 stu.__call__()

三.反射

 1 # 对象一般情况通过字符串来操作属性
 2 # getattr
 3 class Student():
 4     school = 'sh'
 5 
 6     def __init__(self, name, age, gender):
 7         self.name = name
 8         self.age = age
 9         self.gender = gender
10 
11 
12 # 查看属性，没有的话直接报错，可以给他一个返回值就不会报错
13 stu = Student('jack', 18, 'male')
14 print(getattr(stu, 'name'))
15 print(getattr(stu, 'age'))
16 print(getattr(stu, 'gender'))
17 print(getattr(stu, 'name1', None))
18 
19 # setattr 对集合里面的元素进行修改
20 print(setattr(stu, 'name', 'jason'))
21 print(stu.__dict__)
22 
23 # hasattr 判断有没有该属性
24 print(hasattr(stu, 'name'))
25 
26 # delattr 删除属性
27 print(delattr(stu, 'name'))
28 print(stu.__dict__)

四.异常捕获

1. 什么是异常？

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

异常的种类：

1. 语法错误

例如：print(123

2. 逻辑错误

# 逻辑错误尽量写到完美

例如：a = [1, 2, 3]

　　　a[5]

2. 为什么要用异常

增强代码的健壮性

3. 怎么用异常？

 1 # 异常基本语法格式
 2 try:
 3     被监测的代码
 4 except 异常的类型:
 5     pass
 6 except 异常的类型:
 7     pass
 8 except 异常的类型:
 9     pass
10 else:
11     被监测代码没有错误产生是走此代码块
12     pass
13 finally:
14     不管被监测代码是否报错都会执行的代码块