1、面向过程的程序设计
优点:复杂的问题流程化，进而简单化
缺点:可扩展性差
2、面向对象程序设计
优点:可扩展性强
缺点:编程的复杂性高
3、类与对象
在现实世界中:肯定是先有对象，后又类
在程序中:务必保证先定义类，后产生对象
对象:特征与技能的结合体
类:一系列对象相似的特征与相似的技能的结合体
定义类:
class luffystudent:
school = "luffycity" # 数据属性
def learn(self): # 函数属性
print("is learning")
def eat(self): # 函数属性
print("is eatting")
def sleep(self): # 函数属性
print("is sleepping")
注意:
1、类中可以有任意python代码，这些代码在类定义阶段便会执行，因而会产生新的名称空间，用来存放类的变量名与函数名，可以通过oldboystudent.__dict__查看
2、类中定义的名字，都是类的属性，点是访问属性的语法。
3、对于经典类来说我们可以通过该字典操作类名称空间的名字，但新式类有限制
类的使用:
luffystudent.school #查
luffystudent.school='luffy' #改
luffystudent.x=1 #增
del luffystudent.x #删
类的调用(实例化，得到程序中的对象)
stu1 = luffystudent()
stu2 = luffystudent()
stu2 = luffystudent()
stu1、stu2、stu3被称为对象
__init__方法:此方法是在产生对象之后才会执行，只用来为对象进行初始化操作，可以有任意的代码，但是不能拥有返回值。
class luffystudent:
school = "luffycity" # 数据属性
def __init__(self, name, age, sex)
self.name = name
self.age = age
self.sex = sex
def learn(self): # 函数属性
print("is learning")
def eat(self): # 函数属性
print("is eatting")
def sleep(self): # 函数属性
print("is sleepping")
stu1 = luffystudent("xu", 18, "man")
stu2 = luffystudent("chong", 20, "man")
stu3 = luffystudent("guang", 21, "man")当对象产生后，stu1就会被赋给self
对象的调用:
对象的名称空间可以用stu1.__dict__查看，查询结果为{'name': 'xu', 'age': 18, 'sex': 'man'}
stu1.name 查，与stu1.__dict__['name']相同
stu1.name = 'dashuaige' 改与stu1.__dict__['name']='dashuaige'相同
stu1.course = 'python' #增，等同于s2.__dict__['course']='python'
del s2.course #删，等同于s2.__dict__.pop('course')
注意:
1、站的角度不同，定义出的类是截然不同的；
2、现实中的类并不完全等于程序中的类，比如现实中的公司类，在程序中有时需要拆分成部门类，业务类等；
3、有时为了编程需求，程序中也可能会定义现实中不存在的类，比如策略类，现实中并不存在，但是在程序中却是一个很常见的类
属性查找:
类有两种属性:1、数据属性 2、函数属性
数据属性是所有对象共享的
print(id(luffystudent.school))
print(id(stu1.school)) #4377347328
print(id(stu2.school)) #4377347328
print(id(stu3.school)) #4377347328
类的函数属性是绑定给对象使用的,称为绑定到对象的方法
在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常
绑定方法:
c
lass luffystudent:
school = "luffycity" # 数据属性
def __init__(self, name, age, sex)
self.name = name
self.age = age
self.sex = sex
def learn(self): # 函数属性
print("%s is learning" %self.name)
def eat(self): # 函数属性
print("%s is eatting" %self.name)
def sleep(self): # 函数属性
print("%s is sleepping" %self.name)
stu1 = luffystudent("xu", 18, "man")
stu2 = luffystudent("chong", 20, "man")
stu3 = luffystudent("guang", 21, "man")对绑定方法进行调用:
luffystudent.learn(stu1) #xu is learning
luffystudent.learn(stu2) #chong is learning
luffystudent.learn(stu3) #guang is learning
类中定义的函数(没有被任何装饰器装饰的)是类的函数属性，类可以使用，但必须遵循函数的参数规则，有几个参数需要传几个参数
stu1.learn() 等同于luffystudent.learn(stu1)
stu2.learn() 等同于luffystudent.learn(stu2)
stu3.learn() 等同于luffystudent.learn(stu3)
1、绑定到对象的方法的特殊之处在于，绑定给谁就由谁来调用，谁来调用，就会将‘谁’本身当做第一个参数传给方法，即自动传值(方法__init__也是一样的道理)
2、绑定到对象的方法的这种自动传值的特征，决定了在类中定义的函数都要默认写一个参数self，self可以是任意名字，但是约定俗成地写出self
最后在python中，一切皆为对象。
练习1：编写一个学生类，产生一堆学生对象。
要求：
有一个计数器(属性)，统计总共实例了多少个对象
class student:
school = "luffycity"
count = 0
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
student.count += 1
def learn(self):
print('%s is learning' %self.name)
stu1 = student('xu', 17, 'man')
stu2 = student('chong', 15, 'man')
stu3 = student('guang', 22, 'man')
print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__)
print(stu1.count)
print(stu2.count)
print(stu3.count)练习2：模仿王者荣耀定义两个英雄类， (10分钟)
要求：
1、英雄需要有昵称、攻击力、生命值等属性；
2、实例化出两个英雄对象；
3、英雄之间可以互殴，被殴打的一方掉血，血量小于0则判定为死亡。
class gailun:
def __init__(self, name, aggresivity, life_value):
self.aggresivity = aggresivity
self.name = name
self.life_value = life_value
def attack(self, obj):
obj.life_value -= self.aggresivity
if obj.life_value <= 0:
print('%s 死亡' %obj.name)
return true
else:
print("%s被攻击, 生命值为:%s" %(obj.name, obj.life_value))
return false
class ruiwen:
def __init__(self, name, aggresivity, life_value):
self.aggresivity = aggresivity
self.name = name
self.life_value = life_value
def attack(self, obj):
if obj == self:
print("不能攻击自身")
obj.life_value -= self.aggresivity
if obj.life_value <= 0:
print('%s 死亡' %obj.name)
return true
else:
print("%s被攻击,生命值为:%s" %(obj.name, obj.life_value))
return false
gailun = gailun("盖伦", 20, 100)
ruiwen = ruiwen("锐雯", 10, 150)
gailun.attack(ruiwen)
