一、面向对象的编程
和面向过程编程比较
过程编程（思想）：
流水线式
优点：逻辑清晰 （逻辑一步步的，系统）
缺点：可扩展性差（上一个函数的输出结果是下一个函数的输入）
面向对象编程（思想）：
pyhton中的一切皆对象
对象的概念（特征和技能结合体）
面向*对象*编程==定义出一个个鲜明的独特对象，然后通过对象之间的交互编程
优点：扩展性非常强
缺点：逻辑关系非常复杂
二、定义类和对象
以选课系统为例
定义学生为对象
#姓名：A
#学号：2222
#学校：oldboy
#技能：选课
#姓名：B
#学号：2323
#学校：oldboy
#技能：选课
定义老师为对象
#姓名：tank
#学校：oldboy
#技能：教书
#姓名：nick
#学校：oldboy
#技能：教书
类：分类/类别
按照学生和老师分类，一个是学生，一个是老师
类的概念：一系列具有共同特征或技能的对象
现实世界中，先有对象，再有类
在python中，先有类，再有对象
#以class类名（必须使用驼峰体）
#多个特征
#多个技能
# 造类
def f1(): #函数定义阶段，只检测语法，不执行代码
class OldBoyStudent :# 类的定义阶段，会运行代码（牢记）
school = 'oldboy'
addr = 'shanghai'
def choose_course(self):
print('is choosing course')
lodboystudent_dict = OldBoyStudent.__dict__
#双下划綫开头的方法会在某种情况下自动触发
print(oldboystudent_dict['school'])
#oldboy
oldboystudent_dict['choode_course'](111)
# is choosing_course
#造对象（实例化对象）
stu1 = OldBoyStudent()
print(1,stu1.school)
# 1，oldboy
1,stu1.choose_course()
# is choosing course
stu2 = OldBoyStudent()
print(2,stu2.school)
#2,oldboy
stu3 = oldboystudent()
print(3,stu3.school)
#3,oldboy
三、定义对象独有的特征
class OldBoyStudent: # 类的定义阶段，会先运行代码
school = 'oldboy'
count =0
def __init__(self,id,name,age=15):
self.id =id
self.name = name
self.age = age
OldBoyStudent.count+=1
def choose_course(self):
print('is choosing course')
@stu1 = OldBoyStudent(222,'瑞星')
print (OldBoyStudent.__dict__)
# {'__module__': '__main__', 'school': 'oldboy', 'count': 1, '__init__': <function OldBoyStudent.__init__ at 0
print(stu1.id,stu1.name,stu1.age)
# 222 ,瑞星， 15
@stu2 =OldBoyStudent(666,'孙悟空'，10)
print(stu2.id,stu2.name,stu2.age)
# 666 孙悟空，10
@stu3 = OldBoyStudent(11232,'sda',121)
print(OldBoyStudent.count)
#3
四、属性查找顺序
class OldBoyStudent:#类的定义阶段会运行代码
school =‘oldboy'
name ='xxx'
def __init__(self,id,name,age=12):#self 是实例化对象，自传值
self.id = id #stu1.id = id
# self.name =name #stu1.name =name
self.age = age # stu1.age =age
def choose_course(self):
print('is choosing course')
print(OldBoyStudent.__dict__)
#{'__module__': '__main__', 'school': 'oldboy', 'name': 'xxx', '__init__': <function OldBoyStudent.__init__ at 0x00000000029551E0>, 'choose_course': <function OldBoyStudent.choose_course at 0x0000000009E021E0>, '__dict__': <attribute '__dict__' of 'OldBoyStudent' objects>, '__weakref__': <attribute '__weakref__' of 'OldBoyStudent' objects>, '__doc__': None}
stu1 = OldBoyStudent(222,'瑞星') #每次实例化对象时候，都会自动调用.__init__方法
print(stu1.name)
# XXX
print(stu1.__dict__)
#{'id': 222, 'age': 15}
stu2 = OldBoyStudent(666,'孙悟空'，10)
print(stu2.__dict__)
# {'id': 666, 'age': 19}
属性的查找顺序:先从对象本身查找，对象没有，会去类中查找，类中没有则报错
五、类与对象的绑定方法
class OldBoyStudent:
school = 'oldboy'
def __init__(self,id,name,age=10): #self是实例化对象，自动传值
self.id =id #stu1.id =id
self.name =name #stu1.name =name
self.age = age #stu1.age =age
def choose_course(self): #约定俗成为self
print(id(self))
print(self.school)
print(self.id)
self.id+=1
print(f'{self.name} is choosing course)
stu1 =OldBoyStudent(222,'瑞星')
stu1.choose_course() # # self = <__main__.OldBoyStudent object at 0x000001C5EC999860>
#35791368
#oldboy
#222
#瑞星 is choosing course
print(stu1.id)
# 223
#针对类而言：choose_course里的self 就是传的参数
#针对对象而言：choose_course 里的self就是对象本身
stu2.OldBoyStudent(666,’孙悟空‘,12)
print（stu2.id)
# 666 鄙视667
六类与数据类型
class Foo:
pass
class OldBoyStudent: # 类的定义阶段,会运行代码(牢记)
# 1 / 0
school = 'oldboy'
def __init__(self, id, name, age=15): # (******) # aaa是实例化的对象,自动传值 # self=stu1 # self=stu2
self.id = id # stu1.id = id
self.name = name # stu1.name = name
self.age = age # stu1.age = age
def choose_course(self,name): # 约定俗成为self
print(f'{self.name} is choosing course')
stu1 = OldBoyStudent(222222, '朱瑞星') # 每次实例化对象的时候都会自动调用__init__方法(排在第一位的）
# OldBoyStudent.choose_course(stu1,'2222')
# stu1.choose_course(3)
朱瑞星 is choosing course
stu2 = OldBoyStudent(666666, '孔悟空')
孔悟空 is choosing course
七：对象的高度整合
class Animal
def __init__(self,attri,height,weight):
self.attri =attri
self.height=height
self.weight =weight
def jiao(self):
print(self.attri,'开始叫了')
def eat(self):
print(self.attri,'开始吃发了')
people =Animal ('人类'，180，150)
dog = Animal('狗'，100,50)
people.eat()
dog.jiao()
#人类 开始吃饭了了
#狗 开始叫了