题目与解答
1-10
#1.面向过程编程与面向对象编程的区别与应用场景?
# 面向过程编程可扩展性较弱，适合写部署脚本，算法编写
# 面向对象编程可扩展性较强，把事物分解为不同对象，适合编写复杂程序开发
#2. 类和对象在内存中是如何保存的。
# 类和对象的属性在内存中是通过dict形式保存的，python创建对象时，会在内存中开辟一块空间
#3. 什么是绑定到对象的方法、绑定到类的方法、解除绑定的函数、如何定义，如何调用，给谁用？有什么特性
# obj.func 绑定到对象的方法，把obj自动传给self
# @classmethod绑定到类的方法,由类来调用把类名自动传给cls
# @staticmethod非绑定方法，不绑定类与对象，类与对象都可以调用。按正常形式传参
# 4.使用实例进行 获取、设置、删除 数据, 分别会触发类的什么私有方法
class A(object):
def __setitem__(self, key, value):
print('setitem')
self.__dict__[key] = value
def __getitem__(self, item):
print('getitem')
return self.__dict__.get(item)
def __delitem__(self, key):
print('delitem')
del self.__dict__[key]
a = A()
print(a.__dict__)
a["key"] = "val"
print(a.__dict__)
del a["key"]
print(a.__dict__)
# --输出结果--
# {}
# setitem
# {'key': 'val'}
# delitem
# {}
#5.python中经典类和新式类的区别
# python2经典类没有继承objcect，查找属性为深度优先
# Python2：经典类
# class A:
#
# 新式类：继承object
# class A(object)查找属性为广度优先
# python3都是新式类，全部继承object
# 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 A:
host = '127.0.0.1'
port = 3306
db = 'db1'
charset = 'utf-8'
def exec1(self,sql):
conn = self.connect()
conn.execute(sql)
@staticmethod
def connect():
print('conn host<%s> port<%s> db<%s> charset<%s>')
def exec2(self,proc_name):
conn = self.connect()
conn.call_proc(proc_name)
# 9、示例1, 现有如下代码， 会输出什么：
class People(object):
__name = "luffy"
__age = 18
p1 = People()
print(p1.__name, p1.__age)
# 会报错，无法通过对象名+属性访问私有属性
# 会抛出错误，因为__name及__age，隐藏了所以不能直接调用，__开头在类执行的时候已经将属性名称更改为'_People__name'，
10、示例2, 现有如下代码， 会输出什么：
class People(object):
def __init__(self):
print("__init__")
def __new__(cls, *args, **kwargs):
print("__new__")
return object.__new__(cls, *args, **kwargs)
# __new__
# __init__
# 先执行__new__方法，再执行__init__，
# __new__创建新的对象，是一个静态方法，第一个参数是cls。
# __init__对象的初始化方法，第一个参数的self，实例本身
# __call__对象的调用方法
11-15
#11 请简单解释Python中 staticmethod（静态方法）和 classmethod（类方法）, 并分别补充代码执行下列方法。
class A(object):
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()
a.foo(1)
A.class_foo(2)
a.static_foo(3)
A.static_foo(4)
# 静态方法是非绑定方法，类与对象都可以调用，按照正常形式传参
# classmethod方法是绑定到类方法，第一参数是cls，一般通过类名+方法访问，类名会自动传值给cls
# --输出结果---
# executing foo(<__main__.A object at 0x00000000126AACC0>, 1)
# executing class_foo(<class '__main__.A'>, 2)
# executing static_foo(3)
# executing static_foo(4)
# 12 请执行以下代码，解释错误原因，并修正错误。
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
# eat通过@property装饰后，通过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指向了新的内存地址
print(Child2.mro())
# 继承顺序[<class '__main__.Child2'>, <class '__main__.Parent'>, <class 'object'>]
# 14多重继承的执行顺序，请解答以下输出结果是什么？并解释。
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
# 新式类按照广度优先搜索
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'>]
# 15、请编写一段符合多态特性的代码
import abc
class Animals(metaclass=abc.ABCMeta):
@abc.abstractmethod
def talk(self):
pass
class Cat(Animals):
def talk(self):
print('miaomiao')
class Dog(Animals):
def talk(self):
print('wangwang')
c = Cat()
c.talk()
d = Dog()
d.talk()
# miaomiao
# wangwang
16-21
# 16 什么是领域建模，以及如何通过其设计面向对象的程序
# 领域建模指的是构建业务模型
# 领域建模的三字经方法：找名词，加属性，连关系
#
# 17 请写一个小游戏，人狗大站，2个角色，人和狗，游戏开始后，生成2个人，3条狗，互相混战，
# 人被狗咬了会掉血，狗被人打了也掉血，狗和人的攻击力，具备的功能都不一样。注意，请按题14领域建模的方式来设计类。
# 名词：人，狗，
# 属性:血，攻击力,武器
class Animals(object):
def __init__(self,name,life,weapon):
self.name = name
self.life = life
self.weapon = weapon
def attack(self,obj):
obj.life -= self.weapon
class People(Animals):
def attack(self,obj):
super().attack(obj)
print('%s attack %s'%(self.name,obj.name))
class Dog(Animals):
def attack(self, obj):
super().attack(obj)
print('%s attack %s' % (self.name, obj.name))
p1 = People('张三',100, 20)
p2 = People('李四',100, 30)
d1 = Dog('刺狼',100, 40)
d2 = Dog('狼1',100, 30)
d3 = Dog('狼2',100, 20)
p1.attack(d1)
print(d1.life)
p2.attack(d2)
print(d2.life)
#
d1.attack(p1)
print(p1.life)
d2.attack(p2)
print(p2.life)
d3.attack(p1)
print(p1.life)
# # 18、编写程序, 在元类中控制把自定义类的数据属性都变成大写.
class Mymeta(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=Mymeta):
country='China'
tag = 'Legend'
def walk(self):
print('%s is walking' %self.name)
print(Chinese.__dict__)
# 19、编写程序, 在元类中控制自定义的类无需init方法.
class Mymetaclass(type):
def __call__(self, *args, **kwargs):
if args:
raise TypeError('must use keyword argument for key function')
obj = object.__new__(self) #创建对象，self为类Foo
for k,v in kwargs.items():
obj.__dict__[k.upper()]=v
return obj
class Chinese(metaclass=Mymetaclass):
country='China'
tag='Legend of the Dragon' #龙的传人
def walk(self):
print('%s is walking' %self.name)
p=Chinese(name='egon',age=18,sex='male')
print(p.__dict__)
# 20、编写程序, 编写一个学生类, 要求有一个计数器的属性, 统计总共实例化了多少个学生.
class Student:
count = 0
def __init__(self,name):
Student.count += 1
self.name = name
s1 = Student('k1')
s2 = Student('k2')
s3 = Student('k3')
print(s3.count)
# 21、编写程序, A 继承了 B, 俩个类都实现了 handle 方法, 在 A 中的 handle 方法中调用 B 的 handle 方法
class B:
def handle(self):
print('handle B')
class A(B):
def handle(self):
super().handle()
print('handle A')
a1 = A()
a1.handle()
22
# 22.编写程序, 如下有三点要求：
#
#
# 自定义用户信息数据结构， 写入文件, 然后读取出内容, 利用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:
user = input('user > ').strip()
passwd = input('password >').strip()
user_info = self.db()
if user in user_info.keys():
password = user_info.get(user).get("password")
time_o = user_info.get(user).get("timeout")
login_t = time.time()
print(user, login_t, time_o)
if login_t - time_o > 10:
if passwd == password:
print('user login success')
user_info.get(user)["status"] = True
user_info.get(user)["timeout"] = time.time()
break
else:
print('user or password is incorrect')
count += 1
else:
print('过于频繁禁止登陆,请间隔至少10s')
continue
else:
print('user login count > 3')
user_info.get(user)["timeout"] = time.time()
self.save_user(user_info)
def exit(self,user):
user_info = self.db()
if user in user_info.keys():
if user_info.get(user)["status"]:
print('用户 %s 正在登陆,准备退出' %user)
time.sleep(2)
user_info.get(user)["status"] = False
self.save_user(user_info)
else:
print('user is not exist')
@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)
u = User()
# u.write() # 写入json
# print(u.db()) # 读 json文件
# u.login()
# u.exit('egon')
23-27
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题, 它们雷同的功能, 是否可以通过继承的方式进行一些优化
代码：
MyPickle.py
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# @Time : 2018/6/3 17:30
# @File : MyPickle.py
# @Software: luffy_test
import pickle
import os
class MyPickle(object):
def __init__(self,file_name):
self.file_name = file_name
def dump(self,obj):
with open(self.file_name,'ab') as f:
pickle.dump(obj,f)
def loaditer(self):
if os.path.isfile(self.file_name):
with open(self.file_name, 'rb') as f:
while True:
try:
obj = pickle.load(f)
yield obj
except:
break
def edit(self,obj): # 编辑，修改
f2 = MyPickle(self.file_name+'.old')
for item in self.loaditer():
if item.name == obj.name:
f2.dump(obj)
else:
f2.dump(item)
os.remove(self.file_name)
os.rename(self.file_name+'.old',self.file_name)
def delobj(self, obj):
f2 = MyPickle(self.file_name + '.old')
for item in self.loaditer():
if item.name != obj.name:
f2.dump(item)
else:
print('del name',obj.name)
os.remove(self.file_name)
os.rename(self.file_name + '.old', self.file_name)
settings.py
#!/usr/bin/env python3 # -*- coding: utf-8 -*- # @Time : 2018/6/21 23:00 # @File : settings.py # @Software: python_utils import os path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),'db')
teacher.py
from config.settings import path
from src.MyPickle import MyPickle
from prettytable import PrettyTable
import os
class Behavior(object):
path = ''
def fetchobj(self, obj):
pick = MyPickle(obj.path)
iter_obj = pick.loaditer()
for item in iter_obj:
if item.name == obj.name:
print('find obj ',item.__dict__)
return obj
else:
print('obj is not exist')
def createobj(self,obj):
pick = MyPickle(obj.path)
if not self.fetchobj(obj):
pick.dump(obj)
print('create object', obj.__dict__)
else:
print('object exists')
def delobj(self,obj):
pick = MyPickle(obj.path)
pick.delobj(obj)
print('del object', obj.__dict__)
def fetchall(self,obj):
pick = MyPickle(obj.path)
iter_obj = pick.loaditer()
obj_list = []
for item in iter_obj:
obj_list.append(item)
return obj_list
def printobj(self,obj):
obj_list = self.fetchall(obj)
tb = PrettyTable()
k = 0
for item in obj_list:
if k == 0:
tb.field_names = item.__dict__.keys() # 字段名
tb.add_row(item.__dict__.values()) # 增加行
tb.align = 'l'
k += 1
# print(item.__dict__)
print(tb)
class Teacher(Behavior):
path = os.path.join(path, "teacher_obj")
def createobj(self):
self.name = input('teacher name >')
self.age = input('teacher age >')
super().createobj(self)
class Classes(Behavior):
path = os.path.join(path, "class_obj")
def createobj(self):
self.name = input('class name >')
super().createobj(self)
class School(Behavior):
path = os.path.join(path, "school_obj")
def createobj(self):
self.name = input('school name >')
self.addr = input('school addr >')
super().createobj(self)
class Subject(Behavior):
path = os.path.join(path, "subject_obj")
def createobj(self):
self.name = input('subject name >')
super().createobj(self)
main.py
def interactive(object):
menu = """
------- {obj}管理 ---------
1. 创建{obj}(功能已实现)
2. 查看{obj}(功能已实现)
3. 删除{obj}(功能已实现)
4. 查看{obj}列表
5. 退出
""" .format(obj=object.__name__) # 获得类名
menu_dic = {
'1': 'createobj',
'2': 'fetchobj',
'3': 'delobj',
'4': 'printobj'
}
exit_flag = False
while not exit_flag:
print(menu)
user_option = input(">>:").strip()
if user_option in menu_dic:
obj = object()
if obj.fetchall(obj):
print('last create obj', obj.fetchall(obj)[-1].__dict__) # 打印上次创建对象
if user_option == '2' or user_option == '3':
obj.name = input('input {obj} name >'.format(obj=object.__name__))
getattr(obj, menu_dic.get(user_option))(obj) # 反射调用对象的方法
elif user_option == '1':
getattr(obj, menu_dic.get(user_option))()
elif user_option == '4':
print('{0:*^30}'.format(object.__name__ + ' List'))
getattr(obj, menu_dic.get(user_option))(obj)
else:
print('EXIT')
exit_flag = True
else:
print("Option does not exist!", "error")
exit_flag = True
manage.py
from bin import main from src.teacher import Teacher from src.teacher import Classes from src.teacher import School from src.teacher import Subject if __name__ == '__main__': main.interactive(School) main.interactive(Teacher) main.interactive(Subject)
---执行结果--
------- School管理 ---------
1. 创建School(功能已实现)
2. 查看School(功能已实现)
3. 删除School(功能已实现)
4. 查看School列表
5. 退出
>>:1
last create obj {'name': 'kk', 'addr': 'bei'}
school name >老男孩
school addr >沙河
obj is not exist
create object {'name': '老男孩', 'addr': '沙河'}
------- School管理 ---------
1. 创建School(功能已实现)
2. 查看School(功能已实现)
3. 删除School(功能已实现)
4. 查看School列表
5. 退出
>>:4
last create obj {'name': '老男孩', 'addr': '沙河'}
*********School List**********
{'name': 'luffy', 'addr': 'shahe'}
{'name': 'kk', 'addr': 'bei'}
{'name': '老男孩', 'addr': '沙河'}
------- School管理 ---------
1. 创建School(功能已实现)
2. 查看School(功能已实现)
3. 删除School(功能已实现)
4. 查看School列表
5. 退出
>>:3
last create obj {'name': '老男孩', 'addr': '沙河'}
input School name >kk
del name kk
del object {'name': 'kk'}
------- School管理 ---------
1. 创建School(功能已实现)
2. 查看School(功能已实现)
3. 删除School(功能已实现)
4. 查看School列表
5. 退出
>>:4
last create obj {'name': '老男孩', 'addr': '沙河'}
*********School List**********
{'name': 'luffy', 'addr': 'shahe'}
{'name': '老男孩', 'addr': '沙河'}
------- School管理 ---------
1. 创建School(功能已实现)
2. 查看School(功能已实现)
3. 删除School(功能已实现)
4. 查看School列表
5. 退出
>>:5
Option does not exist! error
------- Teacher管理 ---------
1. 创建Teacher(功能已实现)
2. 查看Teacher(功能已实现)
3. 删除Teacher(功能已实现)
4. 查看Teacher列表
5. 退出
>>:2
last create obj {'name': 'egon', 'age': '30'}
input Teacher name >alex
find obj {'name': 'alex', 'age': '18'}
------- Teacher管理 ---------
1. 创建Teacher(功能已实现)
2. 查看Teacher(功能已实现)
3. 删除Teacher(功能已实现)
4. 查看Teacher列表
5. 退出
>>:4
last create obj {'name': 'egon', 'age': '30'}
*********Teacher List*********
{'name': 'hyang', 'age': '12', 'classes': 'p9', 'subject': 'python'}
{'name': '4', 'age': 'dd', 'classes': 'ad', 'subject': 'dg'}
{'name': 'jk', 'age': '11', 'classes': 'dd', 'subject': 'pyhton'}
{'name': 'alex', 'age': '18'}
{'name': 'egon', 'age': '30'}
------- Teacher管理 ---------
1. 创建Teacher(功能已实现)
2. 查看Teacher(功能已实现)
3. 删除Teacher(功能已实现)
4. 查看Teacher列表
5. 退出
>>:1
last create obj {'name': 'egon', 'age': '30'}
teacher name >yuan
teacher age >20
obj is not exist
create object {'name': 'yuan', 'age': '20'}
------- Teacher管理 ---------
1. 创建Teacher(功能已实现)
2. 查看Teacher(功能已实现)
3. 删除Teacher(功能已实现)
4. 查看Teacher列表
5. 退出
>>:4
last create obj {'name': 'yuan', 'age': '20'}
*********Teacher List*********
{'name': 'hyang', 'age': '12', 'classes': 'p9', 'subject': 'python'}
{'name': '4', 'age': 'dd', 'classes': 'ad', 'subject': 'dg'}
{'name': 'jk', 'age': '11', 'classes': 'dd', 'subject': 'pyhton'}
{'name': 'alex', 'age': '18'}
{'name': 'egon', 'age': '30'}
{'name': 'yuan', 'age': '20'}
------- Teacher管理 ---------
1. 创建Teacher(功能已实现)
2. 查看Teacher(功能已实现)
3. 删除Teacher(功能已实现)
4. 查看Teacher列表
5. 退出
>>:5
Option does not exist! error
------- Subject管理 ---------
1. 创建Subject(功能已实现)
2. 查看Subject(功能已实现)
3. 删除Subject(功能已实现)
4. 查看Subject列表
5. 退出
>>:1
last create obj {'name': 'python'}
subject name >C++
obj is not exist
create object {'name': 'C++'}
------- Subject管理 ---------
1. 创建Subject(功能已实现)
2. 查看Subject(功能已实现)
3. 删除Subject(功能已实现)
4. 查看Subject列表
5. 退出
>>:2
last create obj {'name': 'C++'}
input Subject name >python
find obj {'name': 'python'}
------- Subject管理 ---------
1. 创建Subject(功能已实现)
2. 查看Subject(功能已实现)
3. 删除Subject(功能已实现)
4. 查看Subject列表
5. 退出
>>:2
last create obj {'name': 'C++'}
input Subject name >java
obj is not exist
------- Subject管理 ---------
1. 创建Subject(功能已实现)
2. 查看Subject(功能已实现)
3. 删除Subject(功能已实现)
4. 查看Subject列表
5. 退出
>>:4
last create obj {'name': 'C++'}
*********Subject List*********
+--------+
| name |
+--------+
| C |
| python |
| C++ |
+--------+
------- Subject管理 ---------
1. 创建Subject(功能已实现)
2. 查看Subject(功能已实现)
3. 删除Subject(功能已实现)
4. 查看Subject列表
5. 退出
>>:5
Option does not exist! error
Process finished with exit code 0