面向对象练习题

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')