day6

类
属性
实例变量 每个实例的变量
类变量 所有实例共享的变量,共享内存，13亿人都是实例的花 国际都是中国，只用存一份
私有属性 __var


方法
构造方法 __init__(self)初始化实例，执行的初始化动作
析构方法 实例销毁时释放时自动执行的方法（默认有析构函数，只不过什么都没干），写了的话相当于重构析构方法
私有方法

面向过程的程序设计：核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么......面向过程的设计就好比精心设计好一条流水线，是一种机械式的思维方式。

优点是：复杂度的问题流程化，进而简单化（一个复杂的问题，分成一个个小的步骤去实现，实现小的步骤将会非常简单）

缺点是：一套流水线或者流程就是用来解决一个问题，生产汽水的流水线无法生产汽车，即便是能，也得是大改，改一个组件，牵一发而动全身。

应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Apache HTTP Server等。

面向对象的程序设计：核心是对象二字，（要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象，不存在的也可以创造出来。面向对象的程序设计好比如来设计西游记，如来要解决的问题是把经书传给东土大唐，如来想了想解决这个问题需要四个人：唐僧，沙和尚，猪八戒，孙悟空，每个人都有各自的特征和技能（这就是对象的概念，特征和技能分别对应对象的数据属性和方法属性），然而这并不好玩，于是如来又安排了一群妖魔鬼怪，为了防止师徒四人在取经路上被搞死，又安排了一群神仙保驾护航，这些都是对象。然后取经开始，师徒四人与妖魔鬼怪神仙交互着直到最后取得真经。如来根本不会管师徒四人按照什么流程去取),对象是特征与技能的结合体，基于面向对象设计程序就好比在创造一个世界，你就是这个世界的上帝，存在的皆为对象，不存在的也可以创造出来，与面向过程机械式的思维方式形成鲜明对比，面向对象更加注重对现实世界的模拟，是一种“上帝式”的思维方式。

优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。

缺点：

1. 编程的复杂度远高于面向过程，不了解面向对象而立即上手基于它设计程序，极容易出现过度设计的问题。一些扩展性要求低的场景使用面向对象会徒增编程难度，比如管理linux系统的shell脚本就不适合用面向对象去设计，面向过程反而更加适合。

2. 无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法准确地预测最终结果。于是我们经常看到对战类游戏，新增一个游戏人物，在对战的过程中极容易出现阴霸的技能，一刀砍死3个人，这种情况是无法准确预知的，只有对象之间交互才能准确地知道最终的结果。

应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方

面向对象的程序设计并不是全部。对于一个软件质量来说，面向对象的程序设计只是用来解决扩展性。

选读：程序设计思想发展史

三 类与对象

类即类别、种类，是面向对象设计最重要的概念，对象是特征与技能的结合体，而类则是一系列对象相似的特征与技能的结合体

那么问题来了，先有的一个个具体存在的对象（比如一个具体存在的人），还是先有的人类这个概念，这个问题需要分两种情况去看

在现实世界中：先有对象，再有类

世界上肯定是先出现各种各样的实际存在的物体，然后随着人类文明的发展，人类站在不同的角度总结出了不同的种类，如人类、动物类、植物类等概念

也就说，对象是具体的存在，而类仅仅只是一个概念，并不真实存在

在程序中：务必保证先定义类，后产生对象

这与函数的使用是类似的，先定义函数，后调用函数，类也是一样的，在程序中需要先定义类，后调用类

不一样的是，调用函数会执行函数体代码返回的是函数体执行的结果，而调用类会产生对象，返回的是对象

按照上述步骤，我们来定义一个类（我们站在老男孩学校的角度去看，在座的各位都是学生）

#在程序中，务必保证：先定义（类），后使用（产生对象）
PS:
  1. 在程序中特征用变量标识，技能用函数标识
  2. 因而类中最常见的无非是：变量和函数的定义

#程序中的类
class OldboyStudent:
    school='oldboy'
    def learn(self):
        print('is learning')
        
    def eat(self):
        print('is eating')
    
    def sleep(self):
        print('is sleeping')
  


#注意：
  1.类中可以有任意python代码，这些代码在类定义阶段便会执行
  2.因而会产生新的名称空间，用来存放类的变量名与函数名，可以通过OldboyStudent.__dict__查看
  3.对于经典类来说我们可以通过该字典操作类名称空间的名字（新式类有限制），但python为我们提供专门的.语法
  4.点是访问属性的语法，类中定义的名字，都是类的属性

#程序中类的用法
.:专门用来访问属性，本质操作的就是__dict__
OldboyStudent.school #等于经典类的操作OldboyStudent.__dict__['school']
OldboyStudent.school='Oldboy' #等于经典类的操作OldboyStudent.__dict__['school']='Oldboy'
OldboyStudent.x=1 #等于经典类的操作OldboyStudent.__dict__['x']=1
del OldboyStudent.x #等于经典类的操作OldboyStudent.__dict__.pop('x')


#程序中的对象
#调用类，或称为实例化，得到对象
s1=OldboyStudent()
s2=OldboyStudent()
s3=OldboyStudent()

#如此，s1、s2、s3都一样了，而这三者除了相似的属性之外还各种不同的属性，这就用到了__init__
#注意：该方法是在对象产生之后才会执行，只用来为对象进行初始化操作，可以有任意代码，但一定不能有返回值
class OldboyStudent:
    ......
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    ......


s1=OldboyStudent('李坦克','男',18) #先调用类产生空对象s1，然后调用OldboyStudent.__init__(s1,'李坦克','男',18)
s2=OldboyStudent('王大炮','女',38)
s3=OldboyStudent('牛榴弹','男',78)


#程序中对象的用法
#执行__init__,s1.name='牛榴弹'，很明显也会产生对象的名称空间
s2.__dict__
{'name': '王大炮', 'age': '女', 'sex': 38}

s2.name #s2.__dict__['name']
s2.name='王三炮' #s2.__dict__['name']='王三炮'
s2.course='python' #s2.__dict__['course']='python'
del s2.course #s2.__dict__.pop('course')

五 绑定到对象的方法的特殊之处

class OldboyStudent:
    school='oldboy'
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def learn(self):
        print('%s is learning' %self.name) #新增self.name

    def eat(self):
        print('%s is eating' %self.name)

    def sleep(self):
        print('%s is sleeping' %self.name)


s1=OldboyStudent('李坦克','男',18)
s2=OldboyStudent('王大炮','女',38)
s3=OldboyStudent('牛榴弹','男',78)

#类变量的用途？大家公用的属性
#析构函数：在实例释放、销毁的时候执行的，通常用于做一些收尾工作，如关闭一些数据库连接，打开的临时文件
#封装
#继承
#多态
class Role(object):
    n = 123 #类变量
    n_list = []
    name = '我是类name'#实例变量没有的话，会找类变量
    def __init__(self,name,role,weapon,life_value=100,money=10000):#
        #构造函数
        #在实例化时做一些类的初始化的工作
        self.name = name#r1.name=name赋给实例，实例变量，又叫静态属性。动态的传入，吧变量存到self相当于r1，否则函数中的name=name局部变量随函数结束就消失了存不下来
        self.role = role#实例变量，作用域就是实例本身
        self.weapon = weapon
        self.__life_value = life_value
        self.money = money

    def shot(self):#类的方法，动态属性（也算一个属性，执行过程），功能，还是在类中
        print("%s 射击"%(self.name))

    def got_shot(self):
        self.__life_value -= 50
        print("life_value:%s"%(self.__life_value))
    def show_status(self):
        print("name:%s life_value:%s"%(self.name,self.__life_value))

    def buy_gun(self,gun_name):
        print("%s buy a %s"%(self.name,gun_name))

    def who_weapon(self):
        print("%s has weapon %s"%(self.name,self.weapon))

    def __del__(self):#传不了参数，在实例结束的时候自动执行的
        print("%s 彻底死了。。。"%(self.name))


print(Role.n)#类的变量存在类的内存中，不用实例化就能打印

Role('alex','police','ak47').shot()#用完了就会销毁的
Role('alex','police','ak47').shot()#新造的，和上一个不一样，内存中的地址不同
r1 = Role('alex','police','ak47')#Role('r1','alex','police','ak47')吧一个类变成一个具体对象的过程叫实例化 ，又叫初始化一个类,造了一个对象，赋值给一个变量，在内存中生成。开辟一块内存，存入属性
r1.name = 'ronghui'#在外面可以重新赋值给self.name

r1.bullet_prove = True#对于已经实例化的对象，可以加新的属性。相当于self.bullet_prove = bullet_prove

r1.buy_gun('ak47')#内部转成Role.buy_gun(r1) def buy_gun(self)必须有self，谁调用这个类，谁就是self

r1.n_list.append('from r1')
r2 = Role('jack','terrorist','B22') #生成一个角色

r2.shot()#Role.shot
r2.n_list.append('from r2')
print(Role.name,r1.name,r2.name,r1.bullet_prove)
print(r2.weapon)
#del r2.weapon #删除一个属性
r2.who_weapon()

r1.n = '改类变量'#在r1的内存里加了个 n='改类变量' 默认找r1中的n

print(r1.n)#其实是在r1的内存中创建了个新的变量n

print(r2.n)#r2没有n，所以去类变量中找
Role.n = 'ABC'
print(r1.n,r2.n)#r1永远是自己的实例变量，r2没有实例变量n，所以只能去找类变量

print(r1.n_list,r2.n_list,Role.n_list)

r3 = Role('chenronghua','police','M4A1')
r3.got_shot()
r3.show_status()

类中定义的函数（没有被任何装饰器装饰的）是类的函数属性，类可以使用，但必须遵循函数的参数规则，有几个参数需要传几个参数

OldboyStudent.learn(s1) #李坦克 is learning
OldboyStudent.learn(s2) #王大炮 is learning
OldboyStudent.learn(s3) #牛榴弹 is learning

类中定义的函数（没有被任何装饰器装饰的）,其实主要是给对象使用的，而且是绑定到对象的，虽然所有对象指向的都是相同的功能，但是绑定到不同的对象就是不同的绑定方法

强调：绑定到对象的方法的特殊之处在于，绑定给谁就由谁来调用，谁来调用，就会将‘谁’本身当做第一个参数传给方法，即自动传值（方法__init__也是一样的道理）

s1.learn() #等同于OldboyStudent.learn(s1)
s2.learn() #等同于OldboyStudent.learn(s2)
s3.learn() #等同于OldboyStudent.learn(s3)

注意：绑定到对象的方法的这种自动传值的特征，决定了在类中定义的函数都要默认写一个参数self，self可以是任意名字，但是约定俗成地写出self。

类即类型

　　提示：python的class术语与c++有一定区别，与 Modula-3更像。

　　python中一切皆为对象，且python3中类与类型是一个概念，类型就是类

#类型dict就是类dict
>>> list
<class 'list'>

#实例化的到3个对象l1,l2,l3
>>> l1=list()
>>> l2=list()
>>> l3=list()

#三个对象都有绑定方法append,是相同的功能,但内存地址不同
>>> l1.append
<built-in method append of list object at 0x10b482b48>
>>> l2.append
<built-in method append of list object at 0x10b482b88>
>>> l3.append
<built-in method append of list object at 0x10b482bc8>

#操作绑定方法l1.append(3),就是在往l1添加3,绝对不会将3添加到l2或l3
>>> l1.append(3)
>>> l1
[3]
>>> l2
[]
>>> l3
[]
#调用类list.append(l3,111)等同于l3.append(111)
>>> list.append(l3,111) #l3.append(111)
>>> l3
[111] 

六 对象之间的交互

class Garen:        #定义英雄盖伦的类，不同的玩家可以用它实例出自己英雄;
    camp='Demacia'  #所有玩家的英雄(盖伦)的阵营都是Demacia;
    def __init__(self,nickname,aggressivity=58,life_value=455): #英雄的初始攻击力58...;
        self.nickname=nickname  #为自己的盖伦起个别名;
        self.aggressivity=aggressivity #英雄都有自己的攻击力;
        self.life_value=life_value #英雄都有自己的生命值;
    def attack(self,enemy):   #普通攻击技能，enemy是敌人;
        enemy.life_value-=self.aggressivity #根据自己的攻击力，攻击敌人就减掉敌人的生命值。

class Riven:
    camp='Noxus'  #所有玩家的英雄(锐雯)的阵营都是Noxus;
    def __init__(self,nickname,aggressivity=54,life_value=414): #英雄的初始攻击力54;
        self.nickname=nickname  #为自己的锐雯起个别名;
        self.aggressivity=aggressivity #英雄都有自己的攻击力;
        self.life_value=life_value #英雄都有自己的生命值;
    def attack(self,enemy):   #普通攻击技能，enemy是敌人;
        enemy.life_value-=self.aggressivity #根据自己的攻击力，攻击敌人就减掉敌人的生命值。

实例出俩英雄

>>> g1=Garen('草丛伦')
>>> r1=Riven('锐雯雯')

>>> g1.life_value
455
>>> r1.attack(g1)
>>> g1.life_value
401 

class Garen:
    camp='Demacia'
    def __init__(self,nickname,
                 aggressivity=58,
                 life_value=455,
                 money=100,
                 armor=10):
        self.nickname=nickname
        self.aggressivity=aggressivity
        self.life_value=life_value
        self.money=money
        self.armor=armor

    def attack(self,enemy):
        damage_value=self.aggressivity-enemy.armor
        enemy.life_value-=damage_value

    def tell(self):
        print('英雄属性 nickname:%s aggressivity:%s life_value:%s money:%s armor:%s'%(self.nickname, self.aggressivity,self.life_value,self.money,self.armor))

class Riven:
    camp='netuox'
    def __init__(self,nickname,
                 aggressivity=60,
                 life_value=300,
                 money=1000,
                 armor=20):
        self.nickname=nickname
        self.aggressivity=aggressivity
        self.life_value=life_value
        self.money=money
        self.armor=armor

    def attack(self,enemy):
        damage_value=self.aggressivity-enemy.armor
        enemy.life_value-=damage_value

    def tell(self):
        print('英雄属性 nickname:%s aggressivity:%s life_value:%s money:%s armor:%s'%(self.nickname, self.aggressivity,self.life_value,self.money,self.armor))

class BlackCleaver:
    def __init__(self,price=500,aggressivity=10000,life_value=10000):
        self.price = price
        self.aggressivity = aggressivity
        self.life_value = life_value

    def update(self,obj):
        obj.money -= self.price
        obj.aggressivity += self.aggressivity
        obj.life_value += self.life_value
        obj.tell()

    def fire(self,obj): #这是该装备的主动技能,喷火,烧死对方
        obj.life_value-=1000 #假设火烧的攻击力是1000

g1 = Garen('草丛伦')
r1 = Riven('瑞文文')
b1 = BlackCleaver()

r1.b1=b1
r1.b1.fire(g1)
print(g1.life_value)

if r1.money > b1.price:
    b1.update(r1)

r1.attack(g1)
print(g1.life_value)