面向对象

面向过程：

核心是‘过程’二字，将程序流程化
优点：#将程序流程化，进而程序的设计会变得简单化
缺点：#可扩展性差

面向对象：

#核心是‘对象’二字
#对象的终极奥义就是将程序高度‘整合’
#对象是‘容器’，用来盛放数据与功能的
优点：#提升程序的解耦合成度，进而增强程序的可扩展性
缺点：#设计起来较为复杂，容易过度设计

#程序 = 数据 + 功能                         学生的容器  =   学生的数据  +   学生的功能

程序中
         # 一定是先定义类，调用类产生对象(****************)

 

类的命名规范：

# 1. 类名的命名遵循变量的命名规范
# 2. 类名的首字母一般大写
# 3. 如果类名存在多个单词，一般是大驼峰格式

定义类发生的三件事：

"""
        1. 定义类，会立马执行类体代码
        2. 产生类的名称空间，并且把类中的属性和方法名字丢在类的名称空间中，其实就是丢在大字典里
        3. 把类的名称空间绑定给__dict__，类名.__dict__
"""

 

 面向对象的功能模板： 

self.name = name   #self后面的name是对象下面的属性，后面的name是变量名是一个值

 

属性的查找顺序：

类：
Student.xxx #访问xxx属性

Student.xxx = xx
#如果这个属性原来存在的话则修改，不存在则新增，存放在student内存空间

del Student.xxx  #删除

类对应的对象：
stu.age = 20  #没有则新增，有的话修改

stu.age #访问age属性

del stu.age  #删除

Student.xxx = 1
stu1 = student(xxxxxxxxxx)
stu2 = student(xxxxxxxxxx)
stu1.xxx = 333333
print(stu.xxx)  #33333
print(stu2.xxx)  #1

 

 课堂作业:

# 定义一个类出来，产生一堆对象
定义一个计数器，记录一共产生了多少个对象？
class Student():
    school = 'SH'
    count = 0
    def __init__(self, name, age):
        self.name = name
        self.age = age
        # self.count += 1
        Student.count+=1

stu = Student('kevin', 20)
stu1 = Student('kevin1', 21)
stu2 = Student('kevin2', 21)
stu3 = Student('kevin3', 21)
'''类属性一改，对象在调用的时候全改'''
print(Student.count)   #  4

 

 作业：

 定义两个英雄类， 昵称，生命值，攻击力
# 两个英雄对象互相攻击，生命值掉血

class Hero():
	def __init__(self,name,hp,sttack):
		self.name = name
		self.hp = hp
		self.sttack = sttack

	def argue(self,q):
		while q.hp>0 and self.hp>0:
			q.hp -= self.sttack  #q2攻击时减去q1的生命值
			self.hp-=q.sttack    ##q1攻击时减去q2的生命值
			print(f'{q1.name}重击了{self.name}，{self.name}还剩下{self.hp}点血')
			print(f'{self.name}轻击了{q1.name}，{q1.name}还剩下{q1.hp}点血')

q1 = Hero('whx',1000,89)
q2 = Hero('拉伸男爵',200,23)

q2.argue(q1)

 

面向对象小例题：

#学校
class School():
   def __init__(self,school_name):
      self.schoool_name = school_name
      self.class_mate = []

   def classmate(self,class_obj):
      self.class_mate.append(class_obj)  #校区特有的班级

   def school_class(self):
      print(self.schoool_name)
      for class_obj in self.class_mate:  #遍历class——mate这个列表
         class_obj.sourse()

school_obj1 = School('老男孩魔都校区')
school_obj2 = School('老男孩帝都校区')



#班级
class classes():
   def __init__(self,classs):
      self.classs = classs
      self.course = None

   def class_sourse(self,course):
      self.course = course

   def sourse(self):
      self.course.sourse_ing()



class_obj1 = classes('二十三期')
class_obj2 = classes('二十四期')
class_obj3 = classes('二十五期')


school_obj1.classmate(class_obj1)
school_obj1.classmate(class_obj2)
school_obj2.classmate(class_obj3)


#课程
class sourse():
   def __init__(self,sourse,tuition,timed):
      self.sourse = sourse
      self.tuition = tuition
      self.timed = timed

   def sourse_ing(self):
      print('课程:%s 学费:%s 时间:%s'%(self.sourse,self.tuition,self.timed))


sourse1_obj1 = sourse('全栈开发python',28000,'6mon')
sourse2_obj2 = sourse('全栈开发Linex',18000,'5mon')


class_obj1.class_sourse(sourse1_obj1)
class_obj2.class_sourse(sourse2_obj2)
class_obj3.class_sourse(sourse1_obj1)

school_obj2.school_class()
school_obj1.school_class()