python表达式323的值为_python试题

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 = {"": "list", "": "dict", "": "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‘))