4.20作业

1、类的属性和对象的属性有什么区别?
类的属性：
数据属性：共享给所有对象使用的
函数属性：绑定给对象使用的
对象属性：对象的属性都是自己所独有的

2、面向过程编程与面向对象编程的区别与应用场景?
面向过程：核心是‘过程’二字，机械式的思想，将复杂的问题流程化进而简单化，，，适用于扩展性要求低的场景
面向对象：核心是‘对象’二字，‘上帝式’的思维方式，创造对象，通过对象之间的交互来完成编程，可扩展性极高，但是编程难度很大。。。。适用于需要经常修改功能的场景
3、类和对象在内存中是如何保存的。
定义类时，产生类的名称空间，类体内产生的名字都存在类的名称空间中
调用类时，产生一个空对象，再调用__init__函数，self参数接收对象本身，调用类时括号内的参数作为对象的独有属性，存放的对象的名称空间中

4、什么是绑定到对象的方法，、如何定义，如何调用，给谁用？有什么特性
类内部定义的函数，在对象调用时就是绑定给对象使用的
不同的对象调用类内部函数时，对应的是不同的绑定方法，可以从内存地址体现出来
对象名 . 函数名() 就可以调用
特性：谁调用，谁就作为第一个参数自动传入

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 Sql:
    def __init__(self,host,port,db,charset,proc_name):
        self.host = host
        self.port = port
        self.db = db
        self.charset = charset
        self.proc_name = proc_name

    def exc1(self):
        conn = connect(self.host,self.port,self.db,self.charset)
        conn.execute(sql)
        return xxx
    def exc2(self):
        conn = connect(self.host, self.port, self.db, self.charset, self.proc_name)
        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)
1 1 1 
对象自己没有，找子类，子类没有，找父类

Child1.x = 2
print(Parent.x, Child1.x, Child2.x)
1 2 1
对象自己有，以自己的为准

Parent.x = 3
print(Parent.x, Child1.x, Child2.x)
3 3 3
对象自己没有，找子类，子类没有，找父类

 

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

 class A(object):
    def __init__(self):
        print(')
        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__()                                       

g = G()
           [<class '__main__.G'>, <class '__main__.D'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
           非菱形结构，按照分支依次查找
           结果  G D A B


 f = F()
            [<class '__main__.F'>, <class '__main__.C'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.A'>, <class 'object'>]    
            新式类菱形结构
                按照广度优先
            结果：F C B D A

 

8、什么是新式类，什么是经典类，二者有什么区别？什么是深度优先，什么是广度优先？
　　　新式类：继承object的类，以及该类的子类，都是新式类

　　　　　　在python3中，如果一个类没有指定继承的父类，默认就继承object，

　　　　　　　　所以python3中所有的类都是新式类

　　　 经典类：（只有在python2才区分经典类和新式类）

　　　　　　没有继承object的类，以及该类的子类，都是经典类

深度优先：继承关系是菱形结构时，经典类查找属性使用深度优先原则，即第一个分支直接查找到最后一个，在开始下一个分支的查找
广度优先：继承关系是菱形结构时，新式类查找属性使用广度优先的原则，即每个分支在查到了最后一个之前，开始下一个分支的查找，由最后一个分支完成最后一个父类的查找

 

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

 

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

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

import hashlib
import pickle
import time


class Teacher_Student:
    def __init__(self,name,age,sex,):
        self.name = name
        self.age = age
        self.sex = sex

    def create_id(self):
        create_id_msg = ('%s%s%s' %(self.name,self.age,self.sex))
        create_id_msg =  create_id_msg.encode('utf-8')
        create_time = str(time.time()).encode('utf-8')
        teacher_id = hashlib.md5()
        teacher_id.update(create_time)
        teacher_id.update(create_id_msg)
        return teacher_id.hexdigest()

    def tell_info(self):
        print("""
          ===========个人信息=============
          姓名：%s
          年龄：%s
          性别：%s
          """ % (self.name, self.age, self.sex))

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

    def get_obj_by_id(self, id):
        return pickle.load(open(id, 'rb'))

class Teacher(Teacher_Student):
    def __init__(self,name,age,sex,level,saraly):
        #Teacher_Student.__init__(self,name,age,sex)
        super().__init__(name,age,sex)
        self.level = level
        self.salary = saraly

    def create_id(self):
        super().create_id()
        create_id_msg = ('%s%s' %(self.level,self.salary))
        create_id_msg =  create_id_msg.encode('utf-8')
        create_time = str(time.time()).encode('utf-8')
        teacher_id = hashlib.md5()
        teacher_id.update(create_time)
        teacher_id.update(create_id_msg)
        return teacher_id.hexdigest()

    def tell_info(self):
        super().tell_info()
        print("""
        等级：%s
        薪资：%s
        """ %(self.level,self.salary))

# teac1 = Teacher('egon',18,'male',9,3.1)
# res = teac1.create_id()
# print(res)
# teac1.tell_info()
# teac1.save('e373a59d36d84dad27d29db560faa16d')
# teac1.get_obj_by_id('e373a59d36d84dad27d29db560faa16d')

class Student(Teacher_Student):
    pass
 #可以参照老师类定制学生自己的属性