Python练习宝典：Day 5 - 选择题 - 网络编程、进程和线程

Amo Xiang

于 2024-09-27 14:45:30 发布

阅读量653

点赞数 11

分类专栏：流畅的Python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/xw1680/article/details/142591889

版权

流畅的Python 专栏收录该内容

26 篇文章 7 订阅

订阅专栏

一、网络编程

1.相对TCP协议,UDP协议则是面向()的协议:

A.无连接
B.有连接
C.对象
D.编程

2.UDP是面向()的协议。

A.对象
B.消息
C.连接
D.服务器

3.互联网协议包含了上百种协议标准,最重要的两个协议是()协议。

A.TCP和IP
B.IPX/SPX
C.IPX
D.HTML

4.创建TCP服务器时,使用()方法等待客户端的连接?

A.accept()
B.socket()
C.bind()
D.listen()

5.IP地址可以转换为一个()位的整数?

A.16
B.32
C.24
D.64

6.创建TCP服务器时,使用()方法绑定IP和port?

A.bind()
B.socket()
C.list()
D.listen()

7.使用()协议时,不需要建立连接,只需要知道对方的IP地址和端口号,就可以直接发数据包.

A.IP
B.UDP
C.TCP
D.XPX

8.创建一个UDP客户端程序的第一步是什么?

A.创建服务端套接字
B.创建客户端套接字
C.接收数据
D.发送数据

9.低级别的网络服务支持基本的Socket,它提供了标准的 BSD Sockets API,可以访问底层操作系统()接口的全部方法.

A.Socket
B.Socketing
C.SocketServer
D.List

10.我们知道,UDP一般用于多点通信和实时的数据业务,下面哪个不属于UDP业务范围?

A.语音广播
B.TFTP
C.视频
D.重要文件传送

11.一个进程也可能同时与多个计算机建立链接,因此它会申请很多()。

A.端口
B.协议
C.服务器
D.IP地址

12.在UDP通信模型中,通信开始之前,需要建立什么连接?

A.服务器
B.消息
C.端口
D.不需要

13.如果同一台计算机上跑着多个网络程序。一个TCP报文来了之后,到底是交给浏览器还是QQ,就需要()来区分?

A.TCP
B.端口号
C.IP
D.UDP

14.创建TCP连接时,主动发起连接的叫客户端,被动响应连接的叫()。

A.终端
B.服务器
C.开发端
D.显示端

15.如果客户端主动初始化TCP服务器连接,需要什么方法?

A.s.connect()
B.s.sendall()
C.s.close()
D.s.recv()

16.如果要返回套接字选项的值,需要使用什么函数?

A.s.getsockopt(level,optname[.buflen])
B.s.setsockopt(level,optname,value)
C.s.connect()
D.s.sendall()

17.被动接受TCP客户端连接,(阻塞式)等待连接的到来是什么函数?

A.s.getsockname()
B.s.accept()
C.s.setblocking(flag)
D.s.getsockname()

18.如果创建一个与该套接字相关联的文件,需要使用什么函数?

A.s.connect()
B.s.makefile()
C.s.make()
D.s.fileno()

19.为了创建UDP/IP套接字,需要执行什么语句?

A.udpSock = socket(socket.AF_INET, socket.SOCK_DGRAM)
B.udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
C.udpSock = socket.socket(AF_INET, socket.SOCK_DGRAM)
D.udpSock = socketing.socket(socket.AF_INET, socket.SOCK_DGRAM)

20.在Python中使用socket模块的函数socket()就可以完成,语法格式是什么?

A.s= socket.socket(AddressFamily, Type)
B.s= socket(AddressFamily, Type)
C.s= socket.socket(AddressFamily)
D.s= socket.socket(AddressFamily, List)

21.小明写了一段代码创建服务端的socket 对象,接着,调用socket对象的accept方法.该方法等待客户端的连接,并返回connection对象,表示已连接到客户端,他写的对么?

import socket
import sys

serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
host = socket.gethostname()
port = 9999
serversocket.bind((host, port))
serversocket.listen(5)
while True:
    clientsocket, addr = serversocket.accept()
    print("连接地址: %s" % str(addr))
    msg = 'Hello！' + "\r\n"
    clientsocket.send(msg.encode('utf-8'))
    clientsocket.close()

A.没有错误
B.4行socket改成socket.socket
C.9行True:去掉:
D.14行改为clientsocketing.close()

22.明明写一个简单的客户端实例连接到以上创建的服务.端口号为 9999,看看他写的有毛病么?

import socket
import sys

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
host = socket.sethostname()
port = 9999
s.connect((host, port))
msg = s.recv(1024)
s.close()
print(msg.decode('utf-8'))

A.5行sethostname改为gethostname
B.8行s.recv改为s.name
C.9行()加5
D.没有错误

二、进程和线程

1.进程之间有时需要通信,操作系统提供了很多机制来实现进程间的通信.可以使用multiprocessing模块的()实现多进程之间的数据传递.

A.Pipes
B.List
C.Queue
D.Process

2.在多任务系统下,当一个或多个线程等待系统资源,而资源又被线程本身或其他线程占用时,就形成了()。

A.死锁
B.互斥锁
C.资源锁定
D.线程锁定

3.Queue的常用方法中,什么方法如果队列为空,返回True,反之返回False?

A.Queue.full()
B.Queue.empty()
C.Queue.qsize()
D.Queue.put(item,[block[, timeout]])

4.如果队列满了,返回True,反之返回False,这是Queue的什么常用方法?

A.Queue.qsize()
B.Queue.full()
C.Queue.get_nowait()
D.Queue.empty()

5.要如何才能实现进程间的通信呢?Python的()模块包装了底层的机制,提供了Queue(队列),Pipes(管道)等多种方式来交换数据.

A.multiprocessing
B.Process
C.Group
D.List

6.为了防止多个线程同时读写某一块内存区域,我们会使用什么?

A.程序分离
B.内存分离
C.互斥锁
D.单线程

7.初始化Queue()对象时(例如：q=Queue(num)),若括号中没有指定最大可接收的消息数量,或数量为负值,代表什么?

A.可接受的消息数量没有上限
B.可接受的消息数量有上限
C.初始化失败
D.不可以接受消息

8.threading模块提供了一个()类来代表一个线程对象。

A.thred
B.Thread
C.Threading
D.Queue

9.计算机中已运行程序的实体是指什么?

A.进程
B.程序
C.软件
D.数据

10.操作系统能够进行运算调度的最小单位是什么?

A.线程
B.进程
C.程序
D.指令

11.多线程类似于同时执行多个不同程序,下面哪个不是多线程优点?

A.使用线程可以把占据长时间的程序中的任务放到后台去处理。
B.程序的运行速度可能加快
C.用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度。
D.可以结束不必要的程序

12.multiprocessing模块提供了一个()类来代表一个进程对象.

A.Precoss
B.Process
C.List
D.Group

13.在线程间,可以使用()队列实现线程间通信。

A.List
B.Queue
C.Thread
D.Threading

14.如果要处理复杂任务的进程,通常定义一个类,使其继承()类,每次实例化这个类的时候,就等同于实例化一个进程对象。

A.Process
B.Group
C.List
D.Object

15.下面哪个不是进程和线程的区别?

A.进程是系统进行资源分配和调度的一个独立单位，线程是进程的一个实体,是CPU调度和分派的基本单位。
B.进程之间是相互独立的，多进程中，同一个变量，各自有一份拷贝存在于每个进程中，但互不影响；
而同一个进程的多个线程是内存共享的，所有变量都由所有线程共享。
C.由于进程间是独立的，因此一个进程的崩溃不会影响到其他进程；
而线程是包含在进程之内的，线程的崩溃就会引发进程的崩溃，继而导致同一进程内的其他线程也崩溃。
D.进程之间是相互影响的，而线程之间却是相互独立的，不会互相影响。

16.如果要启动线程活动,我们需要使用什么方法?

A.start()
B.run()
C.getName()
D.threading.currentThread()

17.在threading模块中使用Lock类可以方便处理锁定,那么创建锁要用什么语法呢?

A.mutex = thread.Lock()
B.mutex = threading.Lock()
C.mutex.release()
D.mutex.acquire([blocking])

18.下面一段程序运行后,输出结果会是什么?

from threading import Thread, Lock, RLock
import time


class mythread(Thread):
    def __init__(self, number1, number2):
        super(mythread, self).__init__()
        self.number1 = number1
        self.number2 = number2

    def run(self):
        print('开启线程', self.name)
        lock.acquire()
        print('run is:', time.time(), self.number1 + self.number2)
        arithmetic(self.number1, self.number2)
        time.sleep(2)
        lock.release()


def arithmetic(avg1, avg2):
    lock.acquire()
    print('arithmetic:', time.time(), avg1 + avg2)
    time.sleep(2)
    lock.release()


lock = RLock()  # 创建多重锁

if __name__ == "__main__":
    t1 = mythread(3, 4)
    t2 = mythread(5, 6)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print('程序结束！')

A.
	开启线程 Thread-1
	run is: 1727418887.8825226 7
	arithmetic: 1727418887.8825226开启线程 7
	 Thread-2
	run is: 1727418891.910086 11
	arithmetic: 1727418891.910086 11
	程序结束！
B. 报错
C. 
	run is: 1727418887.8825226 7
	arithmetic: 1727418887.8825226开启线程 7
	 Thread-2
	run is: 1727418891.910086 11
D.
	开启线程 Thread-1
	run is: 1727418887.8825226 7
	arithmetic: 1727418887.8825226开启线程 7
	 Thread-2

19.如果在调用线程过程中,我们想返回当前线程变量,需要使用什么方法?

A.run()
B.setName()
C.threading.current_thread()
D.getName()

20.我们知道,进程有多种状态,下面那个不是进程的状态呢?

A.D
B.F
C.S
D.R

21.小红写了一段创建线程锁的代码,但是不知道有没有错误,快来帮他看看吧!

01 # 省略mythread类相关代码
02 import threading,time
03 threadLock = thread.Lock()  #创建线程锁
04 t1 = mythread(1,'thread1')  #创建线程1
05 t2 = mythread(2,'thread2')
06 t1.start()  #启动线程
07 t2.start()
08 t1.join()  #阻塞主线程，等待线程1完成
09 t2.join()
10 print('退出程序')

A.2行thread.Lock改为threading.Lock
B.5行t1.start改为t1.join
C.没有错误
D.7行t1.join改为t1.start

22.小黑写了一段代码,直接调用启动线程,看看他写的有错误么?

01 import threading  #线程模块
02 import time

03 def sayhi(num):  #定义每个线程要运行的函数
04    print('running on number',num)
05    time.sleep(3)

06 if __name__ == "__main__":
07    t1 = threading.Thread(target=sayhi,args=(33,)) #生成一个线程实例
08    t2 = threading.Thread(target=sayhi,args=(22,)) #生成另一个线程实例
09    t1.start()  #启动线程
10    t2.start()
11    print(t1.getName()) #获取线程名
12    print(t2.getName())
13    t1.join()  #阻塞主线程，等待t1子线程执行完后再执行后面的代码
14    t2.join()  #阻塞主线程，等待t2子线程执行完后再执行后面的代码
15    print('-----end')

A.5行3改为i
B.没有错误
C.6行去掉:
D.9行括号内加num

23.小明写了一段代码做一个Queue通信的示例看看他写的对么?

01 from multiprocessing import Process, Queue
02 import os, time, random

03 def write():
04    print('Process to write: %s' % os.getpid())
05    for value in ['A', 'B', 'C']:
06        print('Put %s to queue...' % value)
07        q.put(value)
08        time.sleep(random.random())

09 def read(q):
10    print('Process to read: %s' % os.getpid())
11    while True:
12        value = q.get(True)
13        print('Get %s from queue.' % value)

14 if __name__=='__main__':
15    q = Queue()
16    pw = Process(target=write, args=(q,))
17    pr = Process(target=read, args=(q,))
18    pw.start()
19    pr.start()
20    pw.join()
21    pr.terminate()

A.3行()内加入q
B.7行put改为set
C.12行get改为set
D.18行pw改为pr

24.关于Queue先进先出队列,刘二豆写了一段代码,看看他写的有错误么?

01 import queue
02 def show(q,i):
03    if q.empty() or q.qsize() >= 1:
04        q.put(q)   #存队列
05    elif q.full():
06        print('queue not size')

07 que = queue.Queue(5)   #允许5个队列的队列对象
08 for i in range(5):
09    show(que,i)
10 print('queue is number:',que.qsize())  #队列元素个数
11 for j in range(5):
12    print(que.get())  #取队列
13 print('......end')


A.2行去掉:
B.4行括号内q改为i
C.9行i改为q
D.没有错误