面向对象-总结练习题

我会带着你远行 2021-09-30 01:32 355阅读 0赞

1.面向对象三大特性，各有什么用处，说说你的理解。
        继承：解决代码重用问题
        多态：多态性，可以在不考虑对象类型的情况下而直接使用对象
        封装：明确的区分内外，控制外部对隐藏属性的操作行为，隔离复杂度
    2.类的属性和对象的属性有什么区别?
        类的属性：数据属性和函数属性，数据属性是所有对象共有的，函数属性是绑定给对象使用的
        对象的属性：对象是类的实例化
    3.面向过程编程与面向对象编程的区别与应用场景?
        面向过程：复杂的问题流程化，简单化      应用场景：不在需要扩展了，监控脚本，自动部署脚本，软件解压安装
        面向对象：特征与技能的结合体 一切皆对象  应用场景：用户需求经常变化，互联网应用，游戏，企业内部应用
    4.类和对象在内存中是如何保存的。
        类和对象的属性：以字典的形式保存的。
    5.什么是绑定到对象的方法、绑定到类的方法、解除绑定的函数、如何定义，如何调用，给谁用？有什么特性
        绑定到对象的方法：就应该由对象来调用，def tell_info(self):...  obj.tell_info()
        绑定到类的方法：就应该由类来调用，@classmethod def from_conf(cls):... class.from_conf()
        非绑定方法：不与类或对象绑定，谁都可以调用，@staticmethod def create_id():... obj.create_if()/class.create_id()
    6.使用实例进行 获取、设置、删除 数据, 分别会触发类的什么私有方法

class A(object):
        def __setitem__(self, key, value):
            self.__dict__[key] = value
    
        def __getitem__(self, item):
            # return self.__dict__[item]
            return self.__dict__.get(item)
    
        def __delitem__(self, key):
            del self.__dict__[key]
    
    a = A()
    a["key"] = "val"
    print(a.__dict__)
    # a = a["key"]
    # print(a)
    del a["key"]
    print(a.__dict__)

7.python中经典类和新式类的区别
        经典类:py2 没有继承object的类,以及它的子类都称之为经典类 -->深度优先     
     新式类:py3 继承object的类,以及它的子类都称之为新式类 -->广度优先

8.如下示例, 请用面向对象的形式优化以下代码

# 1、在没有学习类这个概念时，数据与功能是分离的
    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 exec:
        def __init__(self,proc_name):
            self.host='127.0.0.1'
            self.port=3306
            self.db='db1'
            self.charset='utf-8'
            self.proc_name=proc_name
    
    ex=exec('存储名称')
    ex2=exec('存储名称2')
    print(ex.__dict__)
    print(ex2.__dict__)

9.示例1, 现有如下代码， 会输出什么：

class People(object):
        __name = "luffy"
        __age = 18
    
    
    p1 = People()
    # print(p1.__name, p1.__age)
    '''
    AttributeError: 'People' object has no attribute '__name'
    '''
    #__name被转化为了_People__name
    '''

10.示例2, 现有如下代码， 会输出什么：

class People(object):
    
       def __init__(self,name):
           print("__init__")
    
       def __new__(cls, *args, **kwargs):
           print("__new__")
           print(args,kwargs)
           return object.__new__(cls)
    
    # People('alice')
    '''
    __new__
    __init__
    
    __new__是在__init__之前被调用的特殊方法
    __new__是用来创建对象并返回的方法
    而__init__只是用来将传入的参数初始化给对象
    你很少用到__new__,除非你希望能够控制对象的创建
    
    '''

11.请简单解释Python中 staticmethod（静态方法）和 classmethod（类方法）, 并分别补充代码执行下列方法。  
　　　　静态方法：非绑定方法，类和对象都可调用  
　　　　类方法：绑定给类的方法，类调用

class A(object):
        def __init__(self,name):
            self.name=name
    
        def foo(self, x):
            print("executing foo(%s, %s)" % (self,x))
    
        @classmethod
        def class_foo(cls, x):
            print("executing class_foo(%s, %s)" % (cls,x))
    
        @staticmethod
        def static_foo(x):
            print("executing static_foo(%s)" % (x))
    
    # a = A('alice')
    # a.foo('alice')
    # A.class_foo('alice')
    # a.static_foo('alice')
    # A.static_foo('alice')
    '''
    executing foo(<__main__.A object at 0x000002A5FED12AC8>, alice)
    executing class_foo(<class '__main__.A'>, alice)
    executing static_foo(alice)
    executing static_foo(alice)
    '''

12.请执行以下代码，解释错误原因，并修正错误。
        　错误原因：@property 可将函数属性转化为数据属性

class Dog(object):
       def __init__(self,name):
           self.name = name
    
       @property
       def eat(self):
           print(" %s is eating" %self.name)
    
    d = Dog("ChenRonghua")
    # d.eat() 错误的
    # d.eat 正确的

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

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 继承自父类的类属性x，所以都一样，指向同一块内存地址
    # 1 2 1 更改Child1，Child1的x指向了新的内存地址
    # 3 2 3 更改Parent，Parent的x指向了新的内存地址

14.多重继承的执行顺序，请解答以下输出结果是什么？并解释。  
super()表示的是 子类的mro()列表中的下一个  
print(G.mro())  
\[<class '\_\_main\_\_.G'>, <class '\_\_main\_\_.D'>, <class '\_\_main\_\_.A'>, <class '\_\_main\_\_.B'>, <class 'object'>\]  
print(F.mro())  
\[<class '\_\_main\_\_.F'>, <class '\_\_main\_\_.C'>, <class '\_\_main\_\_.B'>, <class '\_\_main\_\_.D'>, <class '\_\_main\_\_.A'>, <class 'object'>\]

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()
       # print(G.mro())
       # print(F.mro())
    
    # G
    # D
    # A
    # B
    #
    # F
    # C
    # B
    # D
    # A
    # [<class '__main__.G'>, <class '__main__.D'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
    # [<class '__main__.F'>, <class '__main__.C'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.A'>, <class 'object'>]

15.请编写一段符合多态特性的代码.

class Animal:
        def __init__(self, name):
            self.name = name
    
    
    class People(Animal):
        def talk(self):
            print('%s is talking' % self.name)
    
    
    class Dog(Animal):
        def talk(self):
            print('%s is talking' % self.name)
    
    
    def func(animal):
        animal.talk()
    
    # p=People('alice')
    # d=Dog('wang')
    # func(p)
    # func(d)
    '''
    alice is talking
    wang is talking
    '''

16.很多同学都是学会了面向对象的语法，却依然写不出面向对象的程序，原因是什么呢？原因就是因为你还没掌握一门面向对象设计利器，  
即领域建模，请解释下什么是领域建模，以及如何通过其设计面向对象的程序？  
http://www.cnblogs.com/alex3714/articles/5188179.html 此blog最后面有详解

领域模型,顾名思义,就是需求所涉及的领域的一个建模,更通俗的讲法是业务模型。
        定义：
            需求到面向对象的桥梁
        作用：
            1.发掘重要的业务领域概念
            2.建立业务领域概念之间的关系 
        方法：
            从用例中找名词
        领域建模的三字经方法:找名词、加属性、连关系。
            参考：http://www.cnblogs.com/linhaifeng/articles/6182264.html#_label15 
                 http://www.cnblogs.com/linhaifeng/articles/7341318.html

17.请写一个小游戏，人狗大站，2个角色，人和狗，游戏开始后，生成2个人，3条狗，互相混战，人被狗咬了会掉血，狗被人打了也掉血，  
狗和人的攻击力，具备的功能都不一样。注意，请按题14领域建模的方式来设计类。

class Animal:
        def __init__(self, name,life_value,aggressivity):
            self.name = name
            self.life_value = life_value
            self.aggressivity = aggressivity
    
        def attack(self,enemy):
            enemy.life_value -= self.aggressivity
    
    
    class People(Animal):
        camp='home'
        def attack(self,enemy):
            super().attack(enemy)
            print('from people')
    
    class Dog(Animal):
        camp='wo'
        def attack(self,enemy):
            super().attack(enemy)
            print('from dog')
    
    p1=People('alice',80,30)
    p1=People('alex',80,30)
    d1=Dog('w1',90,50)
    d2=Dog('w2',90,50)
    d3=Dog('w3',90,50)
    
    # print(p1.life_value)
    # d1.attack(p1)
    # print(p1.life_value)
    
    # print(d1.life_value)
    # p1.attack(d1)
    # print(d1.life_value)

18.编写程序, 在元类中控制把自定义类的数据属性都变成大写.  
19.编写程序, 在元类中控制自定义的类无需init方法.

class Mymeta(type):
        def __new__(cls,class_name,class_bases,class_dic):
            update_dic = {}
            for i in class_dic:
                if not callable(class_dic[i]) and not i.startswith('__'):
                    update_dic[i.upper()]=class_dic[i]
                else:
                    update_dic[i]=class_dic[i]
            return type.__new__(cls,class_name,class_bases,update_dic)
    
        def __call__(self, *args, **kwargs):
            obj=object.__new__(self)
            if args:
                raise TypeError('must be keyword argument')
            for i in kwargs:
                obj.__dict__[i]=kwargs[i]
            return obj
    
    class Chinese(metaclass=Mymeta):
        country='china'
        tag='legend of the dragon'
    
        def talk(self):
            print('%s is talking'%self.name)
    
    # print(Chinese.__dict__)
    # ch=Chinese(name='alice',age=18)
    # ch.talk()
    # print(ch.__dict__)

20.编写程序, 编写一个学生类, 要求有一个计数器的属性, 统计总共实例化了多少个学生.

class Student:
        __count = 0
        def __init__(self, name, age):
            self.name = name
            self.age = age
            Student.__count += 1
    
        @property
        def talk(self):
            print('%s is talking' % self.name)
    
        @staticmethod
        def tell_count():
            print('总共实例化了 %s 人' % Student.__count)
    
    # s1 = Student('alice', 18)
    # s2 = Student('alex', 20)
    # s3 = Student('egon', 28)
    # Student.tell_count()
    # s1.tell_count()
    # s1.talk
    # s2.talk

21.编写程序, A 继承了 B, 俩个类都实现了 handle 方法, 在 A 中的 handle 方法中调用 B 的 handle 方法

class B:
        def handle(self):
            print('from B handle')
    
    class A(B):
        def handle(self):
            super().handle()
            # print('from A handle')
    # a=A()
    # a.handle()

22.编写程序, 如下有三点要求：  
1.自定义用户信息数据结构， 写入文件, 然后读取出内容, 利用json模块进行数据的序列化和反序列化  
e.g  
\{  
"egon":\{"password":"123",'status':False,'timeout':0\},  
"alex":\{"password":"456",'status':False,'timeout':0\},  
\}  
2.定义用户类，定义方法db，例如 执行obj.db可以拿到用户数据结构  
3.在该类中实现登录、退出方法, 登录成功将状态(status)修改为True, 退出将状态修改为False(退出要判断是否处于登录状态).  
密码输入错误三次将设置锁定时间(下次登录如果和当前时间比较大于10秒即不允许登录)

import json
    import time
    class User:
        def __init__(self, name, password):
            self.name = name
            self.password = password
            self.status = False
            self.timeout = 0
    
        @property
        def db(self):
            with open(self.name+'.txt', 'r', encoding='utf-8') as f:
                data = json.load(f)
            return data
    
        def save(self):
            obj={}
            obj[self.name]={
        'password':self.password,'status':self.status,'timeout':self.timeout}
            with open(self.name+'.txt', 'w', encoding='utf-8') as f:
                json.dump(obj,f)
    
        def login(self):
            with open(self.name+'.txt', 'r+', encoding='utf-8') as f:
                data = json.load(f)
                count = 0
                while count < 3:
                    password = input('password>>:').strip()
                    if password != data[self.name]['password']:
                        count += 1
                        continue
                    else:
                        if data[self.name]['timeout'] != 0:
                            if time.time() - data[self.name]['timeout'] > 10:
                                print('不允许登录了！超时')
                                break
                            else:
                                data[self.name]['status'] = True
                                f.seek(0)
                                f.truncate()
                                json.dump(data, f)
                                print('----welcome----')
                                break
                        else:
                            data[self.name]['status'] = True
                            f.seek(0)
                            f.truncate()
                            json.dump(data, f)
                            print('----welcome----')
                            break
    
                else:
                    data[self.name]['timeout']=time.time()
                    f.seek(0)
                    f.truncate()
                    json.dump(data,f)
    
    
        def quit(self):
            with open(self.name+'.txt', 'r+', encoding='utf-8') as f:
                data = json.load(f)
                if data[self.name]['status'] == True:
                    data[self.name]['status'] = False
                    f.seek(0)
                    f.truncate()
                    json.dump(data, f)
                else:
                    print('您是退出状态！')
    
    
    # alex=User('alex','123')
    # egon=User('egon','456')
    # # alex.save()
    # # egon.save()
    # # print(alex.db)
    # # print(egon.db)
    # # alex.login()
    # alex.quit()
    # # egon.quit()
    # print(alex.db)
    # print(egon.db)
    
    # alex.login()
    # egon.login()

23.用面向对象的形式编写一个老师角色, 并实现以下功能, 获取老师列表, 创建老师、删除老师、  
创建成功之后通过 pickle 序列化保存到文件里，并在下一次重启程序时能读取到创建的老师, 例如程序目录结构如下.  
'''  
'''  
.  
|-- bin/  
| |-- main.py 程序运行主体程序(可进行菜单选择等)  
|-- config/  
| |-- settings.py 程序配置(例如: 配置存储创建老师的路径相关等)  
|-- db 数据存储(持久化, 使得每次再重启程序时, 相关数据对应保留)  
| |-- teachers/ 存储所有老师的文件  
| |-- ... ...  
|-- src/ 程序主体模块存放  
| |-- \_\_init\_\_.py  
| |-- teacher.py 例如: 实现老师相关功能的文件  
| |-- group.py 例如: 实现班级相关的功能的文件  
|-- manage.py 程序启动文件  
|-- README.md 程序说明文件  
'''  
'''  
24.根据23 题, 再编写一个班级类, 实现以下功能, 创建班级, 删除班级, 获取班级列表、创建成功之后通过 pickle 序列化保存到文件里，  
并在下一次重启程序时能读取到创建的班级.  
25.根据 23题, 编写课程类, 实现以下功能, 创建课程(创建要求如上), 删除课程, 获取课程列表  
26.根据23 题, 编写学校类, 实现以下功能, 创建学校, 删除学校, 获取学校列表  
27.通过23题, 它们雷同的功能, 是否可以通过继承的方式进行一些优化  
  
伪代码  
class Behavior(object):  
  
def fetch(self, keyword):  
通过 keyword 参数 查询出对应的数据列表  
  
class School(Behavior):  
  
pass  
  
class Teacher(Behavior):  
  
pass  
  
s = School()  
t = Teacher()  
  
s.fetch("school")  
t.fetch("teacher")  
'''

转载于:https://www.cnblogs.com/liangying666/p/9260615.html