zoukankan      html  css  js  c++  java
  • 面向对象练习题

    1、面向对象三大特性,各有什么用处,说说你的理解。
    封装(Encapsulation):在类中对数据的赋值、内部调用对外部用户是透明的,这使类变成了一个胶囊或容器,里面包含着类的数据和方法
    
    继承(Inheritance):一个类可以派生出子类,在这个父类里定义的属性、方法自动被子类继承
    
    多态(Polymorphism):多态是面向对象的重要特性,简单点说:一种接口,多种实现,指一个基类中派生出不同的子类,且每个子类在继承了同样的方法
    名的同时又对父类的方法做了不同的实现,这就是同一种事物表现出的多种形态
    

      

    2、类的属性和对象的属性有什么区别?
    类有两种属性:数据属性和函数属性
    类的数据属性:是所有对象共享的
    类的函数属性:是绑定给对象用的,称为绑定到对象的方法
    对象的属性是类的实例化
    

      

    3、面向过程编程与面向对象编程的区别与应用场景?
    
    
    面向过程:
    概念:核心是“过程”二字,“过程”指的是解决问题的步骤,即先干什么再干什么,基于面向过程设计程序就好比在设计一条流水线,是一种机械化的思维方式
    优点是:
    复杂的问题流程化,进而简单化
    
    缺点是:
    扩展性比较差
    
    面向对象:
    概念:核心是“对象”二字,
    
    优点是:
    可扩展性好
    
    缺点是:
    编程的复杂度比较高
    
    应用场景:
    需求经常变化的软件中
    
    面向过程:个人视角
    面向对象:上帝视角
    
    
    
    4、类和对象在内存中是如何保存的。
    类的对象的属性:以字典形式保存的
    
    5、什么是绑定到对象的方法、绑定到类的方法、解除绑定的函数、如何定义,如何调用,给谁用?有什么特性
    ①、绑定到对象的方法:没有被任何装饰器装饰的方法
    为对象量身定制
    对象.boud_method(),自动将对象当作第一个参数传入
    (属于类的函数,类可以调用,但是必须按照函数的规则来,没有自动传值那么一说)
    由对象来调用,
    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 __getitem__(self, item):
            return self.__dict__.get(item)
    
        def __delitem__(self, key):
            del self.__dict__[key]
    
        def __setitem__(self, key, value):
            self.__dict__[key] = value
    
    
    a = A()
    
    a["key"] = "val"
    print(a.__dict__)
    # a = a["key"]
    # print(a)
    del a["key"]
    print(a.__dict__)
    

      

    7、python中经典类和新式类的区别

    1.只有在Python2中才分新式类和经典类,Python3中统一都是新式类
    2.在Python2中,没有显式的继承object类的类,以及该类的子类,都是经典类
    3.在Python2中,显式的声明继承object的类,以及该类的子类,都是新式类
    4.在Python3中,无论是否继承object,都默认继承object,即Python3中所有类都是新式类
    
    当类是经典类时,按照:深度优先的方式查找
    当类是新式类时,按照:广度优先的方式查找
    

      

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

    def exc1(host, port, db, charset, sql):
        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 MySQLHandler:
        def __init__(self, host, port, db, charset='utf-8'):
            self.host = host
            self.port = port
            self.db = db
            self.charset = charset
            self.conn = connect(self.host, self.port, self.db, self.charset)
        def exc1(self, sql):
            return self.conn.execute(sql)
    
        def exc2(self, sql):
            return self.conn.call_proc(sql)
    
    obj = MySQLHandler('127.0.0.1', 3306, 'db1')
    obj.exc1('select * from tb1;')
    obj.exc2('存储过程的名字')
    

      

    9、请简单解释Python中staticmethod(静态方法)和 classmethod(类方法), 并分别补充代码执行下列方法。

    staticmethod(静态方法):不与类和对象绑定,类和对象都可以调用,但是没有自动传值那么一说
    classmethod(类方法):绑定到类的方法,是给类使用,类在使用时会将类本身当做参数传给类方法的第一个参数
    

      

    10、下面这段代码的输出结果将是什么?请解释

    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指向了新的内存地址
    

      

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

    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()
    
    输出:
    G
    D
    A
    B
    F
    C
    B
    D
    A
    

      

    12、请编写一段符合多态特性的代码

      

    import abc
    class Animal(metaclass=abc.ABCMeta):
        @abc.abstractmethod
        def talk(self):
            pass
    
    class People(Animal):
        def talk(self):
            print('say hello')
    

      

    13、请写一个小游戏,人狗大站,2 个角色,人和狗,游戏开始后,生成2个人,3条狗,互相混战,人被狗咬了会掉血,狗被人打了也掉血,狗和人的攻击力,具备的功能都不一样。

    
    
    class Animal:
        def __init__(self, name, life_value, gjl):
            self.name = name
            self.life_value = life_value
            self.gjl = gjl
    
    
    
    class People(Animal):
        def attack(self, enemy):
            if not isinstance(enemy, People):
                enemy.life_value -= self.gjl
                if enemy.life_value <= 0:
                    print("已经死亡")
                else:
                    print("剩下的生命值为:", enemy.life_value)
                print('人进行攻击')
            else:
                print('同类')
    
    
    
    class Dog(Animal):
        def attack(self, enemy):
            if not isinstance(enemy, Dog):
                enemy.life_value -= self.gjl
                print(self.gjl)
                if enemy.life_value <= 0:
                    print("已经死亡")
                else:
                    print("剩下的生命值为:", enemy.life_value)
                print('狗咬人')
            else:
                print('同类')
    
    
    p1 = People('tom', 100, 30)
    p2 = People('jack', 100, 50)
    
    d1 = Dog('dog1', 100, 20)
    d2 = Dog('dog2', 100, 30)
    
    d1.attack(d2)
    p1.attack(d2)
    p2.attack(d2)
    p1.attack(d2)
    
    
    

      

    14、编写程序, 在元类中控制把自定义类的数据属性都变成大写.

     
    class Mymetaclass(type):
        def __new__(cls, name, bases, attrs):
            update_attrs = {}
            for k, v in attrs.items():
                if not callable(v) and not k.startswith('__'):
                    update_attrs[k.upper()] = v
                else:
                    update_attrs[k] = v
            return type.__new__(cls, name, bases, update_attrs)
    
    class Chinese(metaclass=Mymetaclass):
        country = 'China'
        tag = 'Legend of the Dragon'    # 龙的传人
        def walk(self):
            print('%s is walking' % self.name)
    
    print(Chinese.__dict__)
    
    
    

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

    class Student:
        count = 0
        def __init__(self, name, country, age):
            self.name = name
            self.country = country
            self.age = age
            Student.count += 1
    
    s1 = Student('mike', 'china', 18)
    s2 = Student('mike1', 'china', 18)
    print(Student.count)
    

      

    16、编写程序, 如下有三点要求:



    自定义用户信息数据结构, 写入文件, 然后读取出内容, 利用json模块进行数据的序列化和反序列化
    e.g
    {
    "egon": {"password": "123", 'status': False, 'timeout': 0},
    "alex": {"password": "456", 'status': False, 'timeout': 0},
    }
    定义用户类,定义方法db,例如 执行obj.db可以拿到用户数据结构
    在该类中实现登录、退出方法, 登录成功将状态(status) 修改为True, 退出将状态修改为False(退出要判断是否处于登录状态).密码输入错误三次将设置锁定时间(下次登录如果和当前时间比较大于10秒即不允许登录)
    import json
    import time
    import os
    
    user_dict = {
        "egon": {"password": "123", 'status': False, 'timeout': 0},
        "alex": {"password": "456", 'status': False, 'timeout': 0},
    }
    
    
    class User():
        def __init__(self):
            if not os.path.isfile('user.json'):
                self.write()
    
        def db(self):
            with open('user.json', 'r', encoding='utf-8') as f:
                return json.load(f)
    
        def login(self):
            count = 0
            while count < 3:
                username = input("请输入用户名:").strip()
                password = input("请输入密码:").strip()
                user_info = self.db()
                if username in user_info.keys():
                    passwd = user_info.get(username).get("password")
                    time_o = user_info.get(username).get("timeout")
                    login_t = time.time()
                    print(username, login_t, time_o)
                    if login_t - time_o > 10:
                        if passwd == password:
                            print("欢迎登录,%s" % username)
                            user_info.get(username)["status"] = True
                            user_info.get(username)["timeout"] = time.time()
                            break
                        else:
                            print("用户名或密码错误!")
                            count += 1
                    else:
                        print("登录过于频繁,请间隔10秒再登录")
                else:
                    print("用户名不存在!")
    
            else:
                print("错误次数大于三次")
                user_info.get(username)["timeout"] = time.time()
            self.save_user(user_info)
    
        def exit(self, username):
            user_info = self.db()
            if username in user_info.keys():
                if user_info.get(username)["status"]:
                    print("用户%s 已经登录,准备退出" % username)
                    time.sleep(3)
                    user_info.get(username)["status"] = False
                    self.save_user(user_info)
            else:
                print("用户名不存在!")
    
        @staticmethod
        def save_user(obj):
            with open('user.json', 'r+', encoding='utf-8') as f:
                json.dump(obj, f, ensure_ascii=False, indent=2)
    
        @staticmethod
        def write():
            with open("user.json", "w", encoding="utf-8") as f:
                json.dump(user_dict, f, ensure_ascii=False, indent=2)
    
    
    login = User()
    # login.write()
    # print(login.db())
    # login.login()
    login.exit('egon')
    

      

      

    
    
     
  • 相关阅读:
    POJ 3253 Fence Repair
    POJ 2431 Expedition
    NYOJ 269 VF
    NYOJ 456 邮票分你一半
    划分数问题 DP
    HDU 1253 胜利大逃亡
    NYOJ 294 Bot Trust
    NYOJ 36 最长公共子序列
    HDU 1555 How many days?
    01背包 (大数据)
  • 原文地址:https://www.cnblogs.com/mike-liu/p/9254343.html
Copyright © 2011-2022 走看看