一次上机试题(面向对象)

  1 1.文件操作有哪些模式？请简述各模式的作用
  2 r:读， 默认文件打开就是以r模式，这个文件前提要存在不然报错。
  3 w:写,文件不存在，会自动创建，存在话，就覆盖写。
  4 a:追加，文件末尾追加写入内容。
  5 r+:可读也可写。
  6 w+:可写，，不过写是覆盖的写‘
  7 a+,追加写
  8 
  9 2.s = ‘**hello,world!**‘请使用strip方法去掉字符串两端的‘*‘号
 10 s = ‘**hello,world!**‘
 11 s = s.strip(‘*‘)
 12 print(s)
 13 
 14 3.用户输入一个任意数字n，求1-n之间所有数字中的奇数
 15 
 16 while True:
 17     num_input = input(‘请输入数字:‘).strip()
 18     if num_input.isdigit() and int(num_input) != 0:
 19         num_input = int(num_input)
 20         for num in range(1, num_input + 1):
 21             if num % 2 == 1:
 22                 print(num)  # 显示奇数
 23 
 24             else:
 25                 continue
 26     else:
 27         print("输入非法,请重新录入")
 28         continue
 29 
 30 
 31 4.s = ‘hskakhlkshfkskjakf‘,请去除s字符串中重复的字母
 32 s = ‘hskakhlkshfkskjakf‘
 33 s_new = []
 34 for api in s.strip():
 35     if api in s_new:
 36         continue
 37     else:
 38         s_new.append(api)
 39         s = "".join(s_new)
 40 print(s)
 41 
 42 5.a=10
 43   b=20
 44   def test5(a,b):
 45      print(a,b)
 46   c = test5(b,a)
 47   print(c)
 48 b=20
 49 
 50 def test5(a,b):
 51 
 52     print(a,b)
 53 c = test5(b,a)
 54 print(c)
 55   上述代码中,打印出来的值a,b,c分别是什么？为什么？
 56 报错，c=test5(b,a),调用test5,程序的内容加载到内存,,，从事例看，是位置传值 ，实参b-->a,实参a--->b,c是函数的结果
 57 b是直接找到在函数里找不到，
 58 就找外面找到了b=20,,b赋值给形参a,  ，所以a会有值
 59 同理，,由于实参a没定义,找不到，没法给b值，所以直接报错，并结束下面代码的运行，print(a,b)不会被执行
 60 同理，c是在是全局，有定义，由于函数定义中没有return,所以c是none,
 61 总结：实参a没定义，报错，中止函数体内容被执行，,所以b，c没被输出
 62 
 63 
 64 6.s = ‘123.33sdhf3424.34fdg323.324‘,计算字符串中所有数字的和
 65 s = ‘123.33sdhf3424.34fdg323.324‘
 66 import re
 67 result  = ""
 68 s = re.findall(‘\d+\.?\d+‘,s)
 69 for i in s:
 70     result = "+".join(s)
 71 print("表达式:%s 的和是"%result) #123.33+3424.34+323.324
 72 su = 0
 73 for i in result.split("+"):
 74     i = float(i)
 75     su += i
 76 print(i) #323.324
 77 
 78   本题结果应为：123.33+3424.34+323.32
 79 7.d={‘k1‘:‘v1‘,‘k2‘:[1,2,3],(‘k‘,‘3‘):{1，2，3}}
 80   请用程序实现：
 81   1）输出上述字典中value为列表的key
 82   2）如果字典中的key是一个元祖，请输出对应的value值。
 83   3）d[(‘k‘,‘3‘)]对应的value是一个什么数据类型
 84 d={‘k1‘:‘v1‘,‘k2‘:[1,2,3],(‘k‘,‘3‘):{1,2,3}}
 85 for key,value_re in d.items():
 86     if type(value_re) == list:
 87         print(key)#k2
 88     elif type(key) == tuple:
 89         print(d[key]) #{1, 2, 3}
 90         ty = {"<class ‘list‘>": "list", "<class ‘dict‘>": "dict", "<class ‘set‘>": "set"}
 91         for i  in ty.keys():
 92             if i == str(type(d[key])):
 93                 print(ty[i]) #set
 94 
 95 8.如果不使用@wrapper装饰器，请在a()之前加入一句代码，达到相同的效果
 96 def wrapper(func):
 97     def inner(*arg, **kwargs):
 98         func(*arg, **kwargs)
 99     return inner
100 
101 @wrapper
102 def a(arg):
103     print(arg)
104 
105 a()
106 
107 def wrapper(func):
108     def inner(*arg, **kwargs):
109         func(*arg, **kwargs)
110     return inner
111 # @wrapper
112 def a(arg):
113     print(arg)
114 
115 a(1)
116 
117 9.请处理文件7th_questions,输出所有以‘T‘开头的行
118 with open ("7th_questions",‘r‘,encoding=‘utf-8‘) as f:
119     for line in f:
120         if line.startswith(‘T‘):
121             print(line.strip())
122         else:
123             continue
124 
125 10.读代码，请为这段代码画流程图
126 
127 11 默写字符串对象的内置方法，越多越好
128 plist = dir(str)
129 s = ""
130 p = []
131 for i in plist:
132     if i.startswith("__"):
133         p.append(i)
134         s = ",".join(p)
135 
136     else:
137         continue
138 print(s )
139 __add__,__class__,__contains__,__delattr__,__dir__,__doc__,__eq__,__format__
140 ,__ge__,__getattribute__,__getitem__,__getnewargs__,__gt__,__hash__,__init__,
141 __iter__,__le__,__len__,__lt__,__mod__,__mul__,__ne__,__new__,__reduce__,__reduce_ex__,
142 __repr__,__rmod__,__rmul__,__setattr__,__sizeof__,__str__,__subclasshook__
143 
144 
145 二 面向对象
146 
147 1.请简述类、对象、实例化、实例这些名词的含义：
148 类是一组有着相似特征或者技能的对象集合
149 对象：从类中实例化出来的
150 实例化：产生一个从类中产生一个对象就叫实例化（p = classname.()
151 p 就叫一个classname实例/对象
152 2.面向对象的三大特性是什么？
153 封装，继承，多态
154 3.什么是方法？类中可以定义哪几种方法？
155 定义具有有着相同技能、功能叫方法，可以定义构造方法，普通方法，非绑定方法，调用内置方法
156 4.什么是属性？类中可以定义哪几种属性？
157 有着相同特征叫属性，定义：私有属性，装饰属性
158 5.请简述类方法和静态方法有哪些区别？
159 类方法：可以绑定到任何从类中实例化出来的对象身上，，并且它的第一个参数是self,实例化出来的对象引用被当作第一
160 参数传给self
161 静态方法：不需要给参数，调用方式直接是类名.静态方法名() ,也可以是对象调用 对象名.静态方法名()
162 6.请简述新式类和经典类的区别？
163 py2中，没有继承object都是经典类，尝试优先
164 py3中，所有类都叫新式类，广度优先
165 7.有一个类定义：
166     class Person：
167         def __init__(self,name,age):
168             self.name = name
169             self.age = age
170 
171     1）初始化10个不同的对象
172     2）求最高age的对象的name
173 import sys
174 class Person:
175     def __init__(self,name,age):
176         self.name = name
177         self.age = age
178 dic1 = {}
179 l = []
180 for i in range(1,11):
181     t = "p%s"%i
182     t = Person("name%s"%i,i)
183     dic1[t.name] = i
184     l.append(i)
185 if t.age == max(l):
186     print(t.name)
187 
188 
189 8. 模拟cs游戏
190 人物角色分为警察和匪徒两种，定义成两个类
191 class public_people:
192     def __init__(self,name,sex,livelife,wuqi):
193         self.name = name
194         self.wuqi = wuqi
195         self.sex = sex
196         self.livelife = livelife #生命力
197 class police(public_people):
198     acctrvalue = 800  #攻击力
199     def __init__(self,name,sex,livelife,wuqi):
200         super().__init__(name,sex,livelife,wuqi)
201 
202     def attrk (self,tr_obj):
203         tr_obj.livelife -= self.acctrvalue
204         return  tr_obj.acctrvalue
205 class terrorist(public_people):
206     acctrvalue = 300
207     def __init__(self,name,sex,livelife,wuqi):
208         super().__init__(name,sex,livelife,wuqi)
209     def attrk(self,pol_obj):
210         pol_obj.livelife -= self.acctrvalue
211         return  pol_obj.livelife
212 p1 = police(‘name1‘,‘male‘,1000,‘dao‘)
213 t1 = terrorist(‘t1‘,‘male‘,1000,‘dao‘)
214 p1.attrk(t1)
215 print(t1.livelife,p1.name)  #200 name1
216 t1.attrk(p1)
217 print(p1.livelife,t1.name)
218 
219 所有的警察的角色都是police
220 每个警察都有自己独有名字，生命值，武器，性别
221 每个都可以开枪攻击敌人，切攻击目标不能是police
222 
223 所有的警察的角色都是terrorist
224 每个匪徒都有自己独有名字，生命值，武器，性别
225 每个都可以开枪攻击敌人，切攻击目标不能是terrorist
226 
227 
228 9. 实例化一个警察，一个匪徒，警察攻击匪徒，匪徒掉血
229 
230 10. 提取警察类和匪徒类相似之处定义成一个父类，使用继承的方式减少代码重复
231 
232 11
233 
234 class Base:
235     def f1(self):
236         self.f2()
237 
238     def f2(self):
239         print(‘...‘)
240 
241 class Foo(Base):
242     def f2(self):
243         print(‘9999‘)
244 
245 obj = Foo()
246 obj.f1()
247 
248 问题1:面向对象中的self指的什么？
249 问题2:运行结果并简述原因
250 class Base:
251     def f1(self):
252         self.f2()
253 
254     def f2(self):
255         print(‘...‘)
256 
257 class Foo(Base):
258     def f2(self):
259         print(‘9999‘)
260     pass
261 
262 obj = Foo()
263 obj.f1()  #9999
264 self:是调用对象的引用
265 输出：9999，是继承首先是从对象本身找，没有定义f1,--->对象的类中找，也没有这个f1，
266 --->去父类中找到f1,f1中调用的是self.f2,，而名称空间已经有self.f2，所以对象优先运行自己的f2
267 
268 
269 三 并发编程
270 
271 1 线程，进程，协程的区别？
272 线程：最小的执行单位
273 进程：是资源管理单位
274 
275 2 GIL是什么，对于python有什么影响？
276 gil是全局解释器锁，，同一时刻，同一进程，只有一个线程被执行
277 3 解释LOCK，RLOCL，EVENT，samphore的应用场景
278 
279 4 基于对列实现一个生产者消费者模型，要求：队列内元素不能超过5个，一旦有五个元素了，生产者不再生产，其他内容   自由扩散
280 
281 5 基于selectors模块实现并发聊天，退出某一个客户端不能影响其他用户
282 import selectors
283 import socket
284 sock = socket.socket()
285 sock.bind(("127.0.0.1",8000))
286 sock.listen(5)
287 sock.setblocking(False)
288 
289 sel = selectors.DefaultSelector()  #选择最优级模型
290 
291 def accept(conn,mask):
292     conn,addr = sock.accept()
293     print(conn)
294     sel.register(conn,selectors.EVENT_READ,read)
295 sel.register(sock,selectors.EVENT_READ,accept)
296 def read(conn,mask):
297     try:
298         data = conn.recv(1024)
299         print(data.decode(‘utf-8‘))
300         send_data = input(">>>").encode(‘utf-8‘)
301         conn.send(send_data)
302     except Exception as e:
303         sel.unregister(conn)  #吊消连接
304 
305 
306 
307 while True:
308     events = sel.select() #监听数据  [(key,mask),(key,mask)]
309     for key,mask in events:
310         # print(key.data)  #产生一个函数
311         # print(key.fileobj)   #产生一个fd（文件描述符)
312         func = key.data
313         obj = key.fileobj
314         func(obj,mask)
315     # break
316 
317 
318 clinet
319 import socket
320 sock = socket.socket()
321 sock.connect(("127.0.0.1",8000))
322 while True:
323     send_data = input(">>>")
324     sock.send(send_data.encode(‘utf-8‘))
325     recv_data = sock.recv(1024)
326     print(recv_data.decode(‘utf-8‘))