面向对象测试题

1.测试题目

1.简述解释型和编译型编程语言

2.位和字节的关系？

3.b、B、KB、MB、GB
1 Byte（B） = 8 bit
1 Kilo Byte（KB） = 1024 B
1 Mega Byte（MB） = 1024 KB
1 Giga Byte （GB）= 1024 MB

4.字符串和列表如何相互转换

5.写代码实现字符串反转，如：v = 'oldboy'

6.python递归的最大层数

7.列举Python2和Python3的区别？

8.用一行代码实现数值交换：
a=1
b=2

9.比较：a = [1,2,3] 和 b = [(1),(2),(3)] 以及 b = [(1,),(2,),(3,)]的区别

10.求结果：
v = [lambda:x for x in range(10)]
print(v)
print(v[0])

11.re的match和search区别

12.如何实现 "1,2,3"变成['1','2','3']

13.msg = '123.33sdf3424.34fdg323.324'，计算字符串中所有数字的和



15.创建一个闭包函数需要满足哪几点？

16.简述面向对象的三大特性并用代码说明

17.列举面向对象所有成员并用代码表示

18.看代码写结果


22.列举你了解的5个模块并描述其内容

23.简述：isinstance、issubclass、callable、type

24.函数和方法如何通过代码区分

26.如何将一个对象变成一个可迭代对象

27.简述反射的作用举例反射相关的所有方法

29.写代码实现一个md5加密的函数

30.接口的作用

31.抽象类加抽象方法和接口的区别

32.python中应该如何约束派生类中指定的方法并编写示例代码

33.如何自定义异常，需要做哪些

34.如何获取异常的堆栈信息

35.模拟cs游戏

1.任务角色分为警察和匪徒两种，定义成两个类
所有的警察角色都是police
每个警察都有自己独有名字，生命值，武器，性别
每个都可以开枪攻击敌人，且攻击目标不能是police
所有的匪徒角色都是terrorist
每个匪徒都有自己独有名字，生命值，武器，性别
每个都可以开枪攻击敌人，且攻击目标不能是terrorist

2.实例化一个警察，一个匪徒，警察攻击匪徒，匪徒掉血

3.提取警察类和匪徒类相似之处定义成一个父类，使用继承的方式减少代码重复

2.题目答案

题目答案内容

  
1.解释型和编译型语言的区别
    编译型：
        先把代码编译成机器码 ——> 计算机寄存器去运行      C语言
        先把代码编译成xx ——> 计算机找到虚拟机执行代码 ——>机器码交给计算机去运行     C语言、Java、C#
    解释型：边解释边执行
2.位和字节的关系

8 bit = 1 Byte


8 bit = 1 Byte

1024 B = 1 Kilo Byte(KB)

1024 KB = 1 Mega Byte(MB)

1024 MB = 1 Giga Byte(GB)



v = 'ha+ha+oq+qo'

l_v = v.split('+')

print(l_v)
i_str = '-'.join(l_v)

print(i_str)



v = 'oldboy'

print(v[::-1])

官方解释递归最大层数是1000层

实际

import sys

print(sys.getrecursionlimit())

def calc(n):

try:

print(n)

return calc(n+1)

except RecursionError as e:

print(e)

print('最大层数：【%s】'%n)

calc(0)
7.python2和python3的区别

1.编码&字符串

编码：

py2：默认编码使用ASCII

py3：默认编码使用utf-8
数据类型不同：type()
    py2：
        unicode       v = u'root'	
				输出信息：u'root'，本质上用unicode存储(4个字节表示1个字符)
        bytes和str是同一种数据类型：str    	v = 'root'
				v = '哈哈'，输出信息：'\xe5\x93\x88\xe5\x93\x88'，本质上用Byte存储(gbk/utf-8)

    py3:
        str       v = 'root'	本质上用unicode存储(4个字节表示1个字符)
        bytes     v = b'root'	本质上用Byte存储(gbk/utf-8)
		
	总结：py2的str类型是用Byte存储的，py3的str类型是用unicode存储的

2.继承
    py2：经典类/新式类
    py3：新式类(object)，新式类继承object

3.范围
    py2：range(在内存中立即创建)/xrange(迭代一个生成一个)
    py3：xrange=range，但没有xrange

4.输入
    py2：v1 = raw_input('请输入用户名：')
    py3：v2 = input('请输入用户名：')

5.打印
    py2：print 'xx'
    py3: print('xx')




a=1

b=2

a,b = b,a

print(a,b)



a = [1,2,3]

b = [(1),(2),(3)]	#列表里面的是整数

print(a,b)
以后写元组，必须在元组末尾加"，"

b = [(1,),(2,),(3,)]	#列表里面的是元组

print(b)



10-1

for i in range(10):

pass
print(i)    #循环完就是9，本质是在Python中函数是一个作用域
10-2

def f1(x):

return x+i
f_lst = []

for i in range(10):     #i=9，函数执行时才生效

f_lst.append(f1)

print(f_lst0)
v = [lambda x:x+i for i in range(10)]

print(v)

print(v0)      #选择列表中第1个lambda函数，传参执行
v = [lambda:x for x in range(10)]

print(v)

print(v1)



match：从头开始匹配第一个，返回第一个匹配到值的变量，变量需要调用group()才能拿到值

search：匹配第一个匹配到的值，返回匹配值的变量，变量需要调用group()才能拿到值



s = '1,2,3'

lst = s.split(',')

print(lst)



import re

msg = '123.33sdf3424.34fdg323.324'

ret = re.findall('\d+.\d+',msg)

print(ret)

suma = 0
for i in ret:

i = float(i)

suma += i

print(suma)

两层函数、返回内层函数名给外层函数

def outer():

a = 1

def inner():

print(a)

return 'in inner...'

return inner

ret = outer()

print(ret())



封装

class Message(object):

def email(self):pass

def msg(self):pass

def wecha(self):pass
class Dog(object):

def init(self,name):

self.name = name
def bulk(self):
    print(self.name)

继承

class Father1(object):

def f1(self):

print('Class Father1')
class Father2(object):

def f2(self):

print('Class Father2')
class Son(Father1,Father2):

pass
obj = Son()

obj.f1()

obj.f2()
多态

传参的时候不用指定数据类型

列举面向对象所有成员并用代码表示

变量：类变量、实例变量

class Foo(object):

country = '中国'  # 类变量

def init(self,name):

self.name = name    # 实例变量

obj1 = Foo('王小明')

obj2 = Foo('小樱')
Foo.country = '法国'

obj2.name = 'ZZZZZZ'

print(obj1.country,obj1.name)

print(obj2.country,obj2.name)
实例方法

class Foo(object):

def init(self,name):

self.name = name
def func(self):
    print(self.name)

obj = Foo('希雷')

obj.func()
静态方法和类方法

class Foo(object):
@staticmethod
def static():
    print('666')

@classmethod
def show(cls,x):
    print(cls,x)

Foo.static()    # 通过类调用静态方法

obj = Foo()

obj.static()    # 通过对象调用静态方法
Foo.show(233)   # 直接通过类名调用，默认把当前类传到参数中



class StarkConfig(object):
def __init__(self,num):
    self.num = num  #alex  #wupeiqi

def run(self):
    self()

def __call__(self, *args, **kwargs):
    print(self.num)

class RoleConfig(StarkConfig):

def call(self, *args, **kwargs):

print(345)
def __getitem__(self, item):
    print(item)     #1
    return self.num[item]   #l

v1 = RoleConfig('alex')

v2 = StarkConfig('wupeiqi')

print(v1[1])

print(v2[2])	# StarkConfig类没有__getitem__方法，所以报错



class UserInfo(object):

pass
class Department(object):

pass
class StarkConfig(object):
def __init__(self,num):
    self.num = num  #StarkConfig(UserInfo)   #RoleConfig(Department)

def changelist(self,request):
    print(self.num,request)     #<class '__main__.UserInfo'>,999

def run(self):
    self.changelist(999)

class RoleConfig(StarkConfig):
def changelist(self,request):
    print(666,self.num)         #666,<class '__main__.Department'>

class AdminSite(object):
def __init__(self):
    self._registry = {}

def register(self,k,v):     # register(UserInfo,StarkConfig)    # register(Department,RoleConfig)
    self._registry[k] = v(k)    # UserInfo=StarkConfig(UserInfo)    # Department=RoleConfig(Department)

site = AdminSite()
site.register(UserInfo,StarkConfig)

site.register(Department,RoleConfig)
for k,row in site._registry.items():

row.run()   #StarkConfig.run()      RoleConfig.run()



class F3(object):

def f1(self):

ret = super().f1()

print(ret)

return 999
class F2(object):

def f1(self):

print('123')

return 'F2..'
class F1(F3,F2):

pass
obj = F1()

obj.f1()



class Foo(object):

def init(self,a1):  #初始化方法

print(1)

self.a1 = a1
def __new__(cls, *args, **kwargs):  #真正的构造方法
    print('__new__')
    return object.__new__(cls)  #返回当前类的对象

def __iter__(self):     #循环可迭代对象
    return iter([1,2,3,4,5])

obj1 = Foo(99)

print(obj1.a1)
obj2 = Foo(321)

for i in obj2:

print(i)
class Foo1(object):

'''

my doc..

'''

def init(self,a1,a2):

self.a1 = a1

self.a2 = a2
def __call__(self, *args, **kwargs):
    print(args,kwargs)

def __getitem__(self, item):
    print(item)
    return 'getitem'

def __setitem__(self, key, value):
    print(key,value)

def __delitem__(self, key):
    print(key)

def __add__(self, other):
    return self.a1 + other.a2

def __enter__(self):
    print('进入执行对象')
    return '返回值'

def __exit__(self, exc_type, exc_val, exc_tb):
    print('退出执行对象')

def __str__(self):
    return '类：Foo1 内存地址：？？'

obj = Foo1(1,2)

print(obj.a1)
obj(1,2,3,key='1')
ret = obj['gou']

print(ret)
obj['xkey'] = 1
del obj['uuu']
obj1 = Foo1(2,8)

obj2 = Foo1(100,200)

print(obj1+obj2)

print(obj1,obj2)
obj3 = Foo1(2,1)

with obj as ret:

print('执行内部代码。。')

print(ret)
obj = Foo1(1,2)

print(obj,type(obj))
print(Foo1.doc)
obj1 = Foo1('哈哈',99)

print(obj1.dict)



time模块：主要用于生成时间戳和换算时间

os模块：用于调用操作系统

random模块：用于生成随机数

re模块：用于配合正则表达式操作

sys模块：用于调用python解释器
23

class Father(object):

pass
class Son(Father):

pass
class GrandSon(Son):

pass
print(issubclass(Son,Father))     #判断一个参数(类)是否是第二个参数(类)的子孙类

print(issubclass(GrandSon,Son))
print(type('str'))  #判断对象是由哪个类创建的
class Foo(object):

pass

obj = Foo()

print(isinstance(obj,Foo))      #判断一个参数（对象）是否是第二个参数（类/父类）的实例
class Foo(object):

pass

print(callable(Foo))    #查看对象能否被调用
24

函数

def func():

pass
func()  # 函数可以直接调用
方法

class Foo():

def init(self,name):

self.name = name
def oob1(self):
    print('obj1')

obj = Foo('byh')    # 方法要先实例化类调用类中的方法

obj.oob1()
25

class StarkConfig(object):

list_display = []
def get_list_display(self):
    self.list_display.insert(0,33)
    return self.list_display

class RoleConfig(StarkConfig):

list_display = [11,22]	#先找自身变量，然后insert 33
s1 = StarkConfig()

s2 = RoleConfig()
result1 = s1.get_list_display()

print(result1)
result2 = s2.get_list_display()

print(result2)
结果
[33]

[33,11,22]
26.类里写iter方法，并返回一个迭代器

class Foo(object):
def __iter__(self):
    return iter([1,2,3,4,5])

obj1 = Foo()

for i in obj1.iter():

print(i)
27

什么是反射？

通过字符串形式，到指定对象中获取与字符串同名的成员进行操作
class Foo(object):

def init(self,name):

self.name = name
def f1(self):
    print('gagag')

obj = Foo('hui')

setattr(obj,'f2','zeeeeeeeee')
g1 = getattr(obj,'f2')

print(g1)
g2 = delattr(obj,'f2')
g3 = hasattr(obj,'f1')

g4 = hasattr(obj,'f2')

print(g3,g4)
28

class Foo(object):
def __init__(self):
    self.name = '无佩奇'
    self.age = 100

obj = Foo()

setattr(Foo, 'email', 'wupeiqi@xx.com')
v1 = getattr(obj, 'email')

v2 = getattr(Foo, 'email')
print(v1,v2)
29

import hashlib
def gmd5(x):

obj = hashlib.md5(b'woshiyan')	#加盐

obj.update(x.encode('utf-8'))

return obj.hexdigest()
ret = gmd5('我不认识你，你走开')

print(ret)
30

接口的作用：接口是一种数据类型，用于约束派生类中必须有指定的方法
31

抽象类+抽象方法和接口一样用于约束派生类

区别：抽象类可以写公共方法
32

class BaseMessage(object):

def send(self):

raise NotImplementedError('必须要有send方法')
class email(BaseMessage):

def f1(self):

print(1)
obj1 = email()

obj1.send()
33

自定义异常继承Exception类，raise抛出异常，except捕捉异常
35

class Base1(object):

def init(self,name,gender,life_value,weapon):

self.name = name

self.gender = gender

self.life_value = life_value

self.weapon = weapon
class Police(Base1):
def i_name(self):
    tpl = '我是警察，我叫：%s'%self.name
    print(tpl)

def attack(self,kill):
    '''
    攻击自己人生命值 -0，攻击敌人生命值 -100
    :param kill: 匪徒对象
    :return:
    '''
    if isinstance(kill,Police):
        print('自己人，反正你也打不死我')
        return
    print('警察%s 要打匪徒 %s' %(self.name,kill.name))
    self.life_value -= 0
    kill.life_value -= 100

class Terrorist(Base1):
def i_name(self):
    tpl = '我是匪徒，我叫：%s'%self.name
    print(tpl)

def attack(self,kill):
    '''
    攻击自己人生命值 -0，攻击敌人生命值 -100
    :param kill: 匪徒对象
    :return:
    '''
    if isinstance(kill,Terrorist):
        print('自己人，反正你也打不死我')
        return
    print('匪徒%s 要打警察 %s' %(self.name,kill.name))
    self.life_value -= 0
    kill.life_value -= 100

j1 = Police('王霸','男',300,'王八锤')

j2 = Police('天天','女',300,'忍者卷轴')
t1 = Terrorist('暴龙','男',300,'爆菊花的龙骨')

t2 = Terrorist('鲁鲁托','男',300,'一双会飞的鸡翅')
j1.i_name()

j1.attack(t1)

j1.attack(j2)
t1.attack(j1)