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 a = wrapper(a) #这里必须注意，a必须是那个调用函数名
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'))
