day25作业

1、类的属性和对象的属性有什么区别?

类的属性可以被类名和所有类声明对象调用到，而对象的属性只能由对象来调用到。

2、面向过程编程与面向对象编程的区别与应用场景?

面向过程的编程主要是依照流程来编程的一种编程思想，使用对扩展性小，像是linux内核，shell脚本

面向对象编程主要依照对象来实现功能的一种编程思想，具有较好扩展性，使用与用户交互的程序。

3、类和对象在内存中是如何保存的。

类在执行时，开辟一个名称空间，执行类中代码将名字保存到名称空间。

对象在声明时，创建一个空对象，对象的名称空间保存内存的独有的属性。

4、什么是绑定到对象的方法，、如何定义，如何调用，给谁用？有什么特性

通过self来将对象和函数绑定，调用是会将对象自动传给对象方法的第一参数

对象定义绑定的方法：

class 类名：
    
    def 方法（self）:
        代码体

调用

对象名.对象方法（参数）

提供给类声明的对象使用

特性：调用要能通过对象调用，或是将对象作为第一参数传入调用（类名。绑定方法（对象，参数）调用）

5、如下示例, 请用面向对象的形式优化以下代码，在没有学习类这个概念时，数据与功能是分离的,如下

def exc1(host,port,db,charset):
       conn=connect(host,port,db,charset)
       conn.execute(sql)
       return xxx
       def exc2(host,port,db,charset,proc_name)
       conn=connect(host,port,db,charset)
       conn.call_proc(sql)
       return xxx
       # 每次调用都需要重复传入一堆参数
       exc1('127.0.0.1',3306,'db1','utf8','select * from tb1;')
       exc2('127.0.0.1',3306,'db1','utf8','存储过程的名字')

答案：

class excl:
    def __init__(self,host,port,db,charset,proc_name):
        self.host = host
        self.prot = port
        self.db = db
        self.charset = charset
        self.proc_name = proc_name

    def exc1(self,sql):
        conn = connect(self.host, self.port, self.db, self.charset)
        conn.execute(sql)
        return xxx

    def exc2(self,sql):
        conn = connect(self.host, self.port, self.db, self.charset)
        conn.call_proc(sql)
        return xxx

6、下面这段代码的输出结果将是什么？请解释。

class Parent(object):
    x = 1

class Child1(Parent):
    pass

class Child2(Parent):
    pass

print(Parent.x, Child1.x, Child2.x)
Child1.x = 2
print(Parent.x, Child1.x, Child2.x)
Parent.x = 3
print(Parent.x, Child1.x, Child2.x)

1 1 1 Child1 和Child2都没有自己的x属性，所以只能调用父类Parent中x属性。

1 2 1child1中新增了一个x属性=2，所以child1的x属性就是等于2

3 2 3child1中已经新增了一个x属性，不需要调用parent中x属性，child3没有x属性，只能调用parent中的属性x。

7、多重继承的执行顺序，请解答以下输出结果是什么？并解释。

class A(object):
   def __init__(self):
       print('A')
       super(A, self).__init__()

class B(object):
   def __init__(self):
       print('B')
       super(B, self).__init__()

class C(A):
   def __init__(self):
       print('C')
       super(C, self).__init__()

class D(A):
   def __init__(self):
       print('D')
       super(D, self).__init__()

class E(B, C):
   def __init__(self):
       print('E')
       super(E, self).__init__()

class F(C, B, D):
   def __init__(self):
       print('F')
       super(F, self).__init__()

class G(D, B):
   def __init__(self):
       print('G')
       super(G, self).__init__()

if __name__ == '__main__':
   g = G()
   f = F()

结果：GDABFCBDA

class A(object):
   def __init__(self):
       print('A')#6打印A
       super(A, self).__init__()# 7 找对象g mro列表中__init__最先的__init__函数（是B类的__init__),已经移动过G class,
       #object 不符合对象广度优先的原则

class B(object):
   def __init__(self):
       print('B')# 8 打印B
       super(B, self).__init__()#最后查找object.__init__(),结束

class C(A):
   def __init__(self):
       print('C')
       super(C, self).__init__()

class D(A):
   def __init__(self):
       print('D')#4 打印 D
       super(D, self).__init__()# 5 找对象g mro列表中__init__最先的__init__函数（是A类的__init__),已经移动过G class

class E(B, C):
   def __init__(self):
       print('E')
       super(E, self).__init__()

class F(C, B, D):
   def __init__(self):
       print('F')
       super(F, self).__init__()

class G(D, B):
   def __init__(self):
       print('G')#2 打印G
       super(G, self).__init__()#3找对象g mro列表中__init__最先的__init__函数（是D类的__init__)

if __name__ == '__main__':
    #[<class '__main__.G'>, <class '__main__.D'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
    g = G()#1.调用G__init__函数
    #F--->C---->B---->D---->A---->object
    print(F.mro())
    f = F()

8、什么是新式类，什么是经典类，二者有什么区别？什么是深度优先，什么是广度优先？

新式类：但凡继承object类的子类，以及该子类的子子类……都称之为新式类。

经典类：没有继承object类的子类，以及该子类的子子类……都称之为经典类。

在菱形继承的情况下，

经典类是深度优先：有左边的分支开始，追溯到最后非object类，在追溯其他分支，最后追溯总结点非object类， 再追溯object。

新式类是广度优先：从左边的分支开始，追溯到最后除了，再追其他分支，当最后追溯到总结点非object 再追溯object。

9、用面向对象的形式编写一个老师类, 老师有特征：编号、姓名、性别、年龄、等级、工资，老师类中有功能
1、生成老师唯一编号的功能，可以用hashlib对当前时间加上老师的所有信息进行校验得到一个hash值来作为老师的编号

2、获取老师所有信息
def tell_info(self):
pass

3、将老师对象序列化保存到文件里，文件名即老师的编号，提示功能如下
def save(self):
with open('老师的编号','wb') as f:
pickle.dump(self,f)

4、从文件夹中取出存储老师对象的文件，然后反序列化出老师对象,提示功能如下
def get_obj_by_id(self,id):
return pickle.load(open(id,'rb'))

import time,hashlib,pickle
class Teacher:
    def __init__(self,name,gender,age,level,salaries):
        self.name = name
        self.gender = gender
        self.age = age
        self.level =level
        self.salaries = salaries
        self.id =self.creat_id()

    def creat_id(self):
        info= "%s%s%s%s%s"%(self.name,self.gender,self.age,self.level,self.salaries)
        m1 = hashlib.md5(info.encode('utf-8'))
        m1.update(str(time.time()).encode('utf-8'))
        return m1.hexdigest()

    def tell_info(self):
        print("id %s|name %s|gender %s|age %s|level %s|salaries %s"
              %(self.id,self.name,self.gender,self.age,self.level,self.salaries))

    def save(self):
        with open('%s'%self.id,'wb') as f:
            pickle.dump(self,f)

    def get_obj_by_id(self,id):
        with open('%s'%id,'rb') as f:
            res =pickle.load(f)
        return res





# tea1 = Teacher('egon','male',18,10,3000)
# tea1.tell_info()
# tea1.save()

10、按照定义老师的方式，再定义一个学生类

class Student:
    def __init__(self, name, gender, age):
        self.name = name
        self.gender = gender
        self.age = age

    def tell_info(self):
        print('name %s|gender %s|age %s|' % (self.name, self.gender, self.age), end=' ')

11、抽象老师类与学生类得到父类，用继承的方式减少代码冗余

import time,hashlib,pickle
class PeopleInfo:
    def __init__(self,name,gender,age):
        self.name = name
        self.gender = gender
        self.age = age

    def tell_info(self):
        print('name %s|gender %s|age %s|'%(self.name,self.gender,self.age),end=' ')

class Teacher(PeopleInfo):
    def __init__(self,name,gender,age,level,salaries):
        super().__init__(name,gender)
        self.level =level
        self.salaries = salaries
        self.id =self.creat_id()

    def creat_id(self):
        info= "%s%s%s%s%s"%(self.name,self.gender,self.age,self.level,self.salaries)
        m1 = hashlib.md5(info.encode('utf-8'))
        m1.update(str(time.time()).encode('utf-8'))
        return m1.hexdigest()

    def tell_info(self):
        print('id %s|'%self.id)
        super().tell_info()
        print("level %s|salaries %s"%(self.salaries))

    def save(self):
        with open('%s'%self.id,'wb') as f:
            pickle.dump(self,f)

    def get_obj_by_id(self,id):
        with open('%s'%id,'rb') as f:
            res =pickle.load(f)
        return res


class Student(PeopleInfo):
    pass

12、基于面向对象设计一个对战游戏并使用继承优化代码，参考博客

http://www.cnblogs.com/linhaifeng/articles/7340497.html#_label1

class Hero:
    def __init__(self,camp,nickname,aggressivity,life_value,money,armor):
        self.camp =camp
        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
        print('%s 攻击%s'%(self.nickname,enemy.nickname))
        enemy.life_value-=damage_value
        print('%s 收到 %s 伤害 剩余血量 %s'%(enemy.nickname,damage_value,enemy.life_value))
        if enemy.life_value <= 0:
            print('%s 已死亡'%enemy.nickname)

class Equipment:
    def __init__(self, name,price, aggrev, life_value):
        self.name = name
        self.price = price
        self.aggrev = aggrev
        self.life_value = life_value

    def update(self, obj):
        obj.money -= self.price  # 减钱
        obj.aggressivity += self.aggrev  # 加攻击
        obj.life_value += self.life_value  # 加生命值

class BlackCleaver(Equipment):
    def fire(self, enemy):  # 这是该装备的主动技能,喷火,烧死对方
        enemy.life_value -= 300  # 假设火烧的攻击力是300
        if enemy.life_value <= 0:
            print('%s 已死亡'%enemy.name)


riven = Hero('Noxus','Riven',54,414,1001,12)
garen =Hero('Demacia','Demacia',56,455,500,19)
BC = BlackCleaver('bbff',400,9,100)
while True:
    if riven.money>BC.price:
        BC.update(riven)
    if garen.money>BC.price:
        BC.update(garen)
    riven.attack(garen)
    garen.attack(riven)
    if riven.life_value <=0 or garen.life_value<=0:
        print('对战结束')
        break