python试题

Posted 2020-10-07

1.文件操作有哪些模式？请简述各模式的作用
r:读， 默认文件打开就是以r模式，这个文件前提要存在不然报错。
w:写,文件不存在，会自动创建，存在话，就覆盖写。
a:追加，文件末尾追加写入内容。
r+:可读也可写。
w+:可写，，不过写是覆盖的写‘
a+,追加写

2.s = ‘**hello,world!**‘请使用strip方法去掉字符串两端的‘*‘号
s = ‘**hello,world!**‘
s = s.strip(‘*‘)
print(s)

3.用户输入一个任意数字n，求1-n之间所有数字中的奇数

while True:
    num_input = input(‘请输入数字:‘).strip()
    if num_input.isdigit() and int(num_input) != 0:
        num_input = int(num_input)
        for num in range(1, num_input + 1):
            if num % 2 == 1:
                print(num)  # 显示奇数

            else:
                continue
    else:
        print("输入非法,请重新录入")
        continue


4.s = ‘hskakhlkshfkskjakf‘,请去除s字符串中重复的字母
s = ‘hskakhlkshfkskjakf‘
s_new = []
for api in s.strip():
    if api in s_new:
        continue
    else:
        s_new.append(api)
        s = "".join(s_new)
print(s)

5.a=10
  b=20
  def test5(a,b):
     print(a,b)
  c = test5(b,a)
  print(c)
b=20

def test5(a,b):

    print(a,b)
c = test5(b,a)
print(c)
  上述代码中,打印出来的值a,b,c分别是什么？为什么？
报错，c=test5(b,a),调用test5,程序的内容加载到内存,,，从事例看，是位置传值 ，实参b-->a,实参a--->b,c是函数的结果
b是直接找到在函数里找不到，
就找外面找到了b=20,,b赋值给形参a,  ，所以a会有值
同理，,由于实参a没定义,找不到，没法给b值，所以直接报错，并结束下面代码的运行，print(a,b)不会被执行
同理，c是在是全局，有定义，由于函数定义中没有return,所以c是none,
总结：实参a没定义，报错，中止函数体内容被执行，,所以b，c没被输出


6.s = ‘123.33sdhf3424.34fdg323.324‘,计算字符串中所有数字的和
s = ‘123.33sdhf3424.34fdg323.324‘
import re
result  = ""
s = re.findall(‘\d+\.?\d+‘,s)
for i in s:
    result = "+".join(s)
print("表达式:%s 的和是"%result) #123.33+3424.34+323.324
su = 0
for i in result.split("+"):
    i = float(i)
    su += i
print(i) #323.324

  本题结果应为：123.33+3424.34+323.32
7.d={‘k1‘:‘v1‘,‘k2‘:[1,2,3],(‘k‘,‘3‘):{1，2，3}}
  请用程序实现：
  1）输出上述字典中value为列表的key
  2）如果字典中的key是一个元祖，请输出对应的value值。
  3）d[(‘k‘,‘3‘)]对应的value是一个什么数据类型
d={‘k1‘:‘v1‘,‘k2‘:[1,2,3],(‘k‘,‘3‘):{1,2,3}}
for key,value_re in d.items():
    if type(value_re) == list:
        print(key)#k2
    elif type(key) == tuple:
        print(d[key]) #{1, 2, 3}
        ty = {"<class ‘list‘>": "list", "<class ‘dict‘>": "dict", "<class ‘set‘>": "set"}
        for i  in ty.keys():
            if i == str(type(d[key])):
                print(ty[i]) #set

8.如果不使用@wrapper装饰器，请在a()之前加入一句代码，达到相同的效果
def wrapper(func):
    def inner(*arg, **kwargs):
        func(*arg, **kwargs)
    return inner

@wrapper
def a(arg):
    print(arg)

a()

def wrapper(func):
    def inner(*arg, **kwargs):
        func(*arg, **kwargs)
    return inner
# @wrapper
def a(arg):
    print(arg)
a = wrapper(a)  #这里必须注意，a必须是那个调用函数名
a(1)

9.请处理文件7th_questions,输出所有以‘T‘开头的行
with open ("7th_questions",‘r‘,encoding=‘utf-8‘) as f:
    for line in f:
        if line.startswith(‘T‘):
            print(line.strip())
        else:
            continue

10.读代码，请为这段代码画流程图

11 默写字符串对象的内置方法，越多越好
plist = dir(str)
s = ""
p = []
for i in plist:
    if i.startswith("__"):
        p.append(i)
        s = ",".join(p)

    else:
        continue
print(s )
__add__,__class__,__contains__,__delattr__,__dir__,__doc__,__eq__,__format__
,__ge__,__getattribute__,__getitem__,__getnewargs__,__gt__,__hash__,__init__,
__iter__,__le__,__len__,__lt__,__mod__,__mul__,__ne__,__new__,__reduce__,__reduce_ex__,
__repr__,__rmod__,__rmul__,__setattr__,__sizeof__,__str__,__subclasshook__


二 面向对象

1.请简述类、对象、实例化、实例这些名词的含义：
类是一组有着相似特征或者技能的对象集合
对象：从类中实例化出来的
实例化：产生一个从类中产生一个对象就叫实例化（p = classname.()
p 就叫一个classname实例/对象
2.面向对象的三大特性是什么？
封装，继承，多态
3.什么是方法？类中可以定义哪几种方法？
定义具有有着相同技能、功能叫方法，可以定义构造方法，普通方法，非绑定方法，调用内置方法
4.什么是属性？类中可以定义哪几种属性？
有着相同特征叫属性，定义：私有属性，装饰属性
5.请简述类方法和静态方法有哪些区别？
类方法：可以绑定到任何从类中实例化出来的对象身上，，并且它的第一个参数是self,实例化出来的对象引用被当作第一
参数传给self
静态方法：不需要给参数，调用方式直接是类名.静态方法名() ,也可以是对象调用 对象名.静态方法名()
6.请简述新式类和经典类的区别？
py2中，没有继承object都是经典类，尝试优先
py3中，所有类都叫新式类，广度优先
7.有一个类定义：
    class Person：
        def __init__(self,name,age):
            self.name = name
            self.age = age

    1）初始化10个不同的对象
    2）求最高age的对象的name
import sys
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
dic1 = {}
l = []
for i in range(1,11):
    t = "p%s"%i
    t = Person("name%s"%i,i)
    dic1[t.name] = i
    l.append(i)
if t.age == max(l):
    print(t.name)


8. 模拟cs游戏
人物角色分为警察和匪徒两种，定义成两个类
class public_people:
    def __init__(self,name,sex,livelife,wuqi):
        self.name = name
        self.wuqi = wuqi
        self.sex = sex
        self.livelife = livelife #生命力
class police(public_people):
    acctrvalue = 800  #攻击力
    def __init__(self,name,sex,livelife,wuqi):
        super().__init__(name,sex,livelife,wuqi)

    def attrk (self,tr_obj):
        tr_obj.livelife -= self.acctrvalue
        return  tr_obj.acctrvalue
class terrorist(public_people):
    acctrvalue = 300
    def __init__(self,name,sex,livelife,wuqi):
        super().__init__(name,sex,livelife,wuqi)
    def attrk(self,pol_obj):
        pol_obj.livelife -= self.acctrvalue
        return  pol_obj.livelife
p1 = police(‘name1‘,‘male‘,1000,‘dao‘)
t1 = terrorist(‘t1‘,‘male‘,1000,‘dao‘)
p1.attrk(t1)
print(t1.livelife,p1.name)  #200 name1
t1.attrk(p1)
print(p1.livelife,t1.name)

所有的警察的角色都是police
每个警察都有自己独有名字，生命值，武器，性别
每个都可以开枪攻击敌人，切攻击目标不能是police

所有的警察的角色都是terrorist
每个匪徒都有自己独有名字，生命值，武器，性别
每个都可以开枪攻击敌人，切攻击目标不能是terrorist


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

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

11

class Base:
    def f1(self):
        self.f2()

    def f2(self):
        print(‘...‘)

class Foo(Base):
    def f2(self):
        print(‘9999‘)

obj = Foo()
obj.f1()

问题1:面向对象中的self指的什么？
问题2:运行结果并简述原因
class Base:
    def f1(self):
        self.f2()

    def f2(self):
        print(‘...‘)

class Foo(Base):
    def f2(self):
        print(‘9999‘)
    pass

obj = Foo()
obj.f1()  #9999
self:是调用对象的引用
输出：9999，是继承首先是从对象本身找，没有定义f1,--->对象的类中找，也没有这个f1，
--->去父类中找到f1,f1中调用的是self.f2,，而名称空间已经有self.f2，所以对象优先运行自己的f2


三 并发编程

1 线程，进程，协程的区别？
线程：最小的执行单位
进程：是资源管理单位

2 GIL是什么，对于python有什么影响？
gil是全局解释器锁，，同一时刻，同一进程，只有一个线程被执行
3 解释LOCK，RLOCL，EVENT，samphore的应用场景

4 基于对列实现一个生产者消费者模型，要求：队列内元素不能超过5个，一旦有五个元素了，生产者不再生产，其他内容   自由扩散

5 基于selectors模块实现并发聊天，退出某一个客户端不能影响其他用户
import selectors
import socket
sock = socket.socket()
sock.bind(("127.0.0.1",8000))
sock.listen(5)
sock.setblocking(False)

sel = selectors.DefaultSelector()  #选择最优级模型

def accept(conn,mask):
    conn,addr = sock.accept()
    print(conn)
    sel.register(conn,selectors.EVENT_READ,read)
sel.register(sock,selectors.EVENT_READ,accept)
def read(conn,mask):
    try:
        data = conn.recv(1024)
        print(data.decode(‘utf-8‘))
        send_data = input(">>>").encode(‘utf-8‘)
        conn.send(send_data)
    except Exception as e:
        sel.unregister(conn)  #吊消连接



while True:
    events = sel.select() #监听数据  [(key,mask),(key,mask)]
    for key,mask in events:
        # print(key.data)  #产生一个函数
        # print(key.fileobj)   #产生一个fd（文件描述符)
        func = key.data
        obj = key.fileobj
        func(obj,mask)
    # break


clinet
import socket
sock = socket.socket()
sock.connect(("127.0.0.1",8000))
while True:
    send_data = input(">>>")
    sock.send(send_data.encode(‘utf-8‘))
    recv_data = sock.recv(1024)
    print(recv_data.decode(‘utf-8‘))