记一次python考试题

迈不过友情╰ 2023-03-01 13:29 6阅读 0赞

## 记一次python考试题 ##

这个我参加的一次考试题，附上答案解析。供大家学习。

一、单项选择题（每小题1分，共30分）  
1、下列哪个语句在Python中是非法的？ （ B ）  
A、x = y = z =1 B、x = (y = z + 1) C、x, y = y, x D、x += y

2、关于Python内存管理，下列说法错误的是（ B ）。  
A、变量不必事先声明 B、变量无须先创建和赋值而直接使  
C、变量无须指定类型 D、可以使用del释放资源  
解析：不先赋值会报错，is not defined。

3、下面哪个不是Python合法的标识符。（ B ）  
A、int32 B、40XL C、self D、name  
解析：合法的标识符不能以数字开头。

4、下列哪种说法是错误的。（ D ）  
A、除字典类型外，所有标准对象均可以用于布尔测试  
B、空字符串的布尔值是False  
C、空列表对象的布尔值是False  
D、值为0的任何数字对象的布尔值是False  
解析：当一个列表L = \[0\]时，bool(L)为True  
  
5、Python不支持的数据类型有（ A ）。  
A、char B、int C、float D、list  
解析：Python里无char型数据

6、关于字符串下列说法错误的是（ B ）。  
A、字符应该视为长度为1的字符串  
B、字符串以\\0标志字符串的结束  
C、既可以用单引号，也可以用双引号创建字符串  
D、在三引号字符串中可以包含换行回车等特殊字符  
解析：Python因为字符串有长度限制，到了长度就标志字符串的结束。

7、以下不能创建一个字典的语句是（ C ）。  
A、dict1 = \{\} B、dict2 = \{ 3 : 5 \} C、dict3 =\{\[1,2,3\]: “uestc”\} D、dict4 = \{(1,2,3): “uestc”\}  
解析：字典的键必须是不变的，而列表是可变的。

8、下列Python语句正确的是：( D )  
A、min = x if x< y = y B、max = x > y ?x:y C、if (x >y) print(x) D、while True :pass  
解析：A应为：min = x if x< y else x  
B应为为max = x if x>y else y，  
C应为if (x >y): print(x)  
  
9、以下代码运行结果是什么?（ C ）  
counter = 1  
def doLotsOfStuff():  
global counter  
for i in (1, 2, 3):  
counter += 1  
doLotsOfStuff()  
print (counter)

A、1 B、3 C、4 D、7

10、以下代码运行结果是什么?（ C ）  
for i in range(2):  
print (i)  
for i in range(4,6):  
print (i)

A、2, 4, 6 B、0,1, 2, 4, 5, 6 C、0, 1, 4, 5 D、1, 2, 4, 5, 6  
解析：第一个循环输出0,1，第二个循环输出4,5

11、以下代码运行结果是什么?（ B ）  
import math  
print (math.floor(5.5))

A、5 B、5.0 C、5.5 D、6 E、6.0  
解析：math.floor的意思是返回最大整数

12、假设有个文件/usr/lib/python/person.py内容如下，执行以下命令输出结果是什么？（ D） python /usr/lib/python/person.py

class Person:  
def **init**(self):  
pass  
def getAge(self):  
print(**name**)

p = Person()  
p.getAge()

A、Person B、getAge C、usr.lib.python.person D、**main**  
解析：当内部单独执行模块时，**name\_\_的返回值就是\_\_main**，当被外部模调用时，返回的是模块的名字，在此即为person。

13、以下代码运行结果是什么?（ B ）  
names1 = \[‘Amir’, ‘Barry’, ‘Chales’, ‘Dao’\]  
if ‘amir’ in names1:  
print (1)  
else:  
print (2)

A、1 B、2 C、报错 D、结果为空

14、以下代码运行结果是什么?（ C ）  
kvps = \{ ‘1’ :1, ‘2’ : 2 \}  
theCopy =kvps.copy()  
kvps\[‘1’\] = 5  
sum = kvps\[‘1’\]+ theCopy\[‘1’\]  
print (sum)

A、1 B、2 C、6 D、10  
解析：字典的浅拷贝，只拷贝父对象，即theCopy拷贝了kvps，当kvps改变表面时，theCopy不改变相应值。

15、以下选项中，不是 Python 语言保留字的是（ A ）。  
A、 do B、pass C、except D、 while

16、计算机中信息处理和信息储存用（ A ）。  
A、二进制代码 B、十进制代码 C、十六进制代码 D、ASCII代码

17、Python源程序执行的方式是（ B ）。  
A、编译执行 B、解析执行 C、直接执行 D、边编译边执行

18、Python语言语句块的标记是（ C ）。  
A、分号 B、逗号 C、缩进 D、/

19、以下是字符转换成字节的方法是（ B ）。  
A、decode() B、encode() C、upper() D、rstrip()  
解析：字符转字节(编码)是encode(),字节转字符(解码)是decode()

20、有关异常说法正确的是（ B ）。  
A、程序中抛出异常终止程序  
B、程序中抛出异常不一定终止程序  
C、拼写错误会导致程序终止  
D、缩进错误会导致程序终止

21、“ab”+”c”\*2 结果是（ C ）。  
A、abc2 B、abcabc C、abcc D、ababcc

22、以下会出现错误的是（ B ）。  
A、‘北京’.encode() B、‘北京’.decode()  
C、‘北京’.encode().decode() D、以上都不会错误  
解析：decode()是解码，encode()是编码，如果字符串是unicode编码就直接编码不需要解码。

23、以下语句的打印结果是（ B ）。  
str1 = “Runoob example…wow!!!”  
str2 = “exam”  
print(str1.find(str2, 5))

A、6 B、7 C、8 D、-1

24、下面对count()、index(),、find()方法描述错误的是（ C ）。  
A、count()方法用于统计字符串里某个字符出现的次数  
B、find()方法检测字符串中是否包含子字符串 str 如果包含子字符串返回开始的索引值，否则返回-1  
C、index()方法与find()方法类似，可以检测字符串中是否包含子字符串 str，如果str不在返回-1  
D、以上都错误  
解析：同find()方法类似，index()方法也可以用于检索是否包含指定的字符串，不同之处在于，当指定的字符串不存在时，index()方法会抛出异常。

25、以下不属于Python中的关键字的是（ D ）。  
A、raise B、with C、import D、final

26、调用以下函数返回的值是（ D ）。  
def myfun():  
pass

A、0 B、出错不能运行 C、空字符串 D、None

27、函数如下：  
def showNnumber(numbers):  
for n in numbers:  
print(n)

下面选项中在调用函数时会报错的是（ C ）。  
A、showNumer(\[2,4,5\]) B、showNnumber(‘abcesf’)  
C、showNnumber(3.4) D、showNumber((12,4,5))

28、关于Python类，说法错误的是（ B ）。  
A、类的实例方法必须创建对象后才可以调用  
B、类的实例方法必须创建对象前才可以调用  
C、类的类方法可以用对象和类名来调用  
D、类的静态属性可以用类名和对象来调用

29、下列说法正确的是（ A ）。  
A、直接导入一个包，相当于执行了这个包中的\_\_init\_\_文件  
B、在模块的导入中，需要产生循环引用问题  
C、装饰器函数property是一个帮助你将类中的方法伪装成属性的内置函数，调用方法的时候需要主动加括号  
D、面向对象的三个特性是封装、多态、抽象  
解析：B错在在模块的导入中，不要产生循环引用问题  
C错在装饰器函数property是一个帮助你将类中的方法伪装成属性的内置函数，调用方法的时候不需要主动加括号  
D错在面向对象的三个特性是封装、多态、继承

30、下列不属于使用正则表达式匹配字符串的是（ D ）。  
A、re.findall(’\\d+’,‘python’)  
B、re.search(’\\d+’,‘python’)  
C、re.match(’\\d+’,‘python’)  
D、re.split(’\\d+’,‘python’)  
解析：re.split(’\\d+’,‘python’)是起到的是分割字符串的作用。

二、填空题（每空1分，共10分）  
1、在函数中，传入数字、字符或者元组等不可变对象属于  值  传递，传入列表、字典等可变对象属于  引用 传递。

2、使用可变长参数函数fun(\*args, \*\*kwargs)，按照fun(2,3,4)调用，则args值为  (2,3,4)  ，kwargs为  空字典  。  
 解析：\*args接收的是位置参数，\*kwargs接收的是关键字参数

3、使字符串开头首字母大写的字符串函数有  title()  和  capitalize()  。

4、文件可以读写的模式有  r+  和  w+  。

5、Python  私有  成员只能内部访问，不能从对象来访问。

6、a = \[1, 2, 3\]; a.append(7); 前者a的地址与后者a的地址  相同  。（填“相同”或“不同”）

三、简答题（共20分）  
1、简述is和==的区别。（1分）  
==比较操作符：用来比较两个对象是否相等，value做为判断因素；  
is同一性运算符：比较判断两个对象是否相同，id做为判断因素。  
==：值相等，值运算  
is：内存地址相等，身份运算，is要求更苛刻，不仅要求值相等,还要求内存地址相同

2、写出位与字节之间的关系。（1分）  
 8位 = 1字节

3、利用集合将列表L =\[1, 2, 5, 1, 5, 7\]去重。（1分）  
 列表转集合，集合转列表  
set = set(L)  
L = list(set)

4、Python中的列表和元组有什么不同？（3分）  
 语法差异：使用方括号\[\]创建列表，而使用括号()创建元组  
是否可变：列表是可变的，而元组是不可变的，这标志着两者之间的关键差异。可以修改列表的值，但是不修改元组的值。由于列表是可变的，我们不能将列表用作字典中的key。 但可以使用元组作为字典key。  
重用与拷贝：元组无法复制。 原因是元组是不可变的。 如果运行tuple(tuple\_name)将返回自己。  
List 和tuple 区别  
不同点：  
1、定义的方式：list\[\] tuple()  
2、是否可变：list可变，tuple() 不可变  
3、list中有 append()，insert() 函数，tuple中没有  
相同点：都是有序的集合（容器）

5、’你好’使用utf-8编码时，占用多少位数和字节数？使用gbk编码时，占的位数和字节数又是多少？（2分）  
’你好’： utf-8： 48位6字节，gbk：32位4字节。

6、数字，字符串，列表，元祖，字典对应的布尔值的False分别是什么？（3分）  
数字：0，字符串：空字符串，列表：空列表，元组：空元组，字典：空字典。

7、什么是lambda函数？它有什么好处?请举一个简单的lambda函数例子。（3分）  
lambda表达式，通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是指匿名函数  
lambda函数：首要用途是指点短小的回调函数  
lambda函数例子（lambda \[arguments\]:expression）：  
a=lambdax,y:x+y  
a(3,11)

8、请说明深拷贝和浅拷贝二者的区别并分别写出实现两种拷贝的方法。（3分）  
浅拷贝：创建一个新的对象，但它包含的是对原始对象中包含项的引用（如果用引用的方式修改其中一个对象，另外一个也会修改改变）。亦可理解为：(浅拷贝后，原始对象中的不可变数据类型的与拷贝对象中的不可变数据类型的地址不同。原始对象中的可变数据类型的与拷贝对象中的可变数据类型的地址相同)  
深拷贝：创建一个新的对象，并且递归的复制它所包含的对象（修改其中一个，另外一个不会改变）.亦可理解为：(深拷贝后，原始对象中的不可变类型与可变类型的地址都与拷贝对象不同)  
浅拷贝实现方法：1,完全切片方法；2，工厂函数，如list()；3，copy模块的copy()函数  
深拷贝实现方法：copy模块的deep.deepcopy()函数

9、 请写出四种可迭代的对象。（3分）  
字符串，列表，元祖，字典，集合等

四、编程题（40分） 1、请打印出字典d = \{'a':1,'b':2,'c':3\}的key，value键值对。（2分）

d = {
        'a' : 1, 'b' : 2, 'c' : 3}
    for dict_key, dice_value in d.items():
    print(dict_key, dice_value )

2、请编写代码输出九九乘法表。（3分）

for i in range(1,10):
        for j in range(1,i+1):
            print('%sx%s=%s'%(i,j,i*j),end=' ')  #end避免换行
        print()

3、请编写代码，对列表lst = \[18, 88, 5, 8, 41, 6, 1, 23, 99, 2, 35\]内的元素进行从小到大的冒泡排序。（3分）

lst = [18, 88, 5, 8, 41, 6, 1, 23, 99, 2, 35]
    long=len(lst)
    while True:
        count = 0
        for i in range(long-1)
            if lst[i] > lst[i+1]:   # 比较,
                lst[i], lst[i+1] = lst[i+1], lst[i] # 交换
            count+=1
        if count==0
            break
    print(lst)

4、有文件t1.txt里面的内容为：  
201811001, 张三, 19, 男, 1181, 数学  
201822002, 李四, 20, 女, 1182, 英语  
201845003, 王五, 18, 女, 1185, 农业  
利用文件操作，将其构造成如下数据类型。  
\[\{‘学号’:‘201811001’,‘姓名’:‘张三’,‘年龄’:‘19’,‘性别’:‘男’,‘班级’:‘1181’,‘专业’:‘数学’\}, …\]（6分）

lst = []
    with open("t1.txt", encoding="UTF-8") as data:
        # 读取每一行数据
        for line in data:
            number,name,age,gender,clas,major = line.strip().split(",")  #切割
            dct={
        '学号':number,'姓名':name,'年龄':age,'性别':gender,'班级':clas,'专业':major}
            lst.append(dic)   #放入列表
    print(lst)

5、已知两个字典如下：  
dict1 = \{‘a’:1,’b’:2,’c’:3,’d’:4,’f’:’hello’\}  
dict2= \{‘b’:3,’d’:5,’e’:7,’m’:9,’k’:’world’\}

请写一段代码将上面的两个字典的相加生成一个新的字典，将不同的key对应的值保留，相同的key对应的值相加后保留，如果是字符串就拼接，使得最后结果为：\{‘a’: 1, ‘b’: 5, ‘c’: 3, ‘d’: 9, ‘f’: ‘hello’, ‘e’: 7, ‘m’: 9, ‘k’: ‘world’\}。（6分）

lst=[]
    dict1 = {
        'a':1,'b':2,'c':3,'d':4,'f':'hello'}
    dict2 = {
        'b':3,'d':5,'e':7,'m':9,'k':'world'}
    for dict_key, dict_value in dict1.items():
        if dict_key in dict2:  #判断是否有相同
            dict[dict_key]+=dict_value   #两个value相加
            lst.append(dict_key)    #记录下相同的key
    for i in range(len(lst))
        del dict1[lst[i]]   #删除重复
    dict2.update(dict1)   #合并（更新）字典
    print(dict2)

6、定义一个圆环类，计算圆环的周长和面积。圆环周长 = 外环周长 + 内环周长。（6分）

class Ring:
    
        def __init__(self,r1,r2):
            self.r1 = r1
            self.r2 = r2
    
        def area(self):
            return round(self.r1 ** 2 * pi - self.r2 ** 2 * pi, 2)
    
        def perimeter(self):
            return round(self.r1 * 2 * pi + self.r2 * 2 * pi, 2)

解法二：组合的思想

class Ring:
    
        def __init__(self,r1,r2):
            self.r1 = Circle(r1)
            self.r2 = Circle(r2)
    
        def area(self):
            return self.r1.area() - self.r2.area()
    
        def perimeter(self):
            return self.r1.perimeter() + self.r2.perimeter()

7、请编写代码生成随机的6位验证码，该验证码由数字和字母组成，数字为0-9，字母区分大小写，例：1a98FU。小写字母ASCװ码为97 - 122，大写字母ASCװ码为65 - 90。（6分）  
chr(97) - chr(122)：小写字母a-z  
chr(65) - chr(90)：大写字母A-Z  
import random

解法一：基础版

code = ''
    for i in range(6):
        rand_num = str(random.randint(0,9))
        rand_alph = chr(random.randint(97,122))
        rand_alph_upper = chr(random.randint(65,90))
        atom_code = random.choice([rand_num,rand_alph,rand_alph_upper])
        code += atom_code
    print(code)

解法二：函数版

def rand_code(n=6):
        code = ''
        for i in range(n):
            rand_num = str(random.randint(0,9))
            rand_alph = chr(random.randint(97,122))
            rand_alph_upper = chr(random.randint(65,90))
            atom_code = random.choice([rand_num,rand_alph,rand_alph_upper])
            code += atom_code
        return code
    
    ret = rand_code()
    print(ret)

8、请写一个装饰器，可以打印输出方法执行时长的信息。（8分）

import time 
    def run_time(func): 
        def inner(*args, **kwargs): 
           start_time = time.time()    
            ret = func() 
            end_time = time.time() 
            return end_time - start_time 
        return inner 
    @run_time
    def hello_world():
        time.sleep(0.1)
        print('hello world')
    ret = hello_world()
    print(ret)

9、请用正则表达式匹配字符串，并返回匹配结果，要求匹配的字数一定是6位数字，如果不是返回false ,如果是则返回true,例如：输入”123456” 程序返回true,输入”123abc”或”123”则返回false。(3分)

import re
        result1=re.findall(r'^\d{6}$','12343aadwad213g213v')   
        result2=re.findall(r'^\d{6}$','12343aadwad213g213v')
    print(bool(result1))  #匹配失败
    print(bool(result1))  #撇皮成功

10、请用python代码统计一个文件夹中所有文件的总大小，比如一个dir1文件夹下有两个文件夹dir2,dir3，dir2,dir3文件夹下分别有1个文件（word1和word2），统计两个word的大小为多少字节。(6分)

解法一：递归

import os
    ret=r'C:\Users\86139\Desktop\python code\dir1'   #添加路径，同时取消转义字符
    sum = 0
    def function(dirpath):
        lst = os.listdir(dirpath)  # 查看指定目录下的文件以及子目录
        for el in lst:  
            new_dirpath = dirpath+'\\'+el   #双\\等于\  
            print(new_dirpath)
            if os.path.isfile(new_dirpath):  #判断该路径是否为文件
                getsize = os.path.getsize(new_dirpath)   #是则计算大小
                global sum
                sum += getsize
            else:     #否则递归
                function(new_dirpath)
        return sum
    
    num = function(ret)
    print(sum)

解法二：循环

import os
    path=r'C:\Users\86139\Desktop\python code\dir1'   #添加路径，同时取消转义字符
    sum = 0
    llst=[]   #用于存放目录路径的列表
    llst2=[]    #用于存放文件路径的列表
    llst.append(path)
    while llst:
        lst=os.listdir(''.join(llst[0]))
        for el in lst:  
            new_path =''.join(llst[0])+'\\'+el  
            if os.path.isfile(new_path):
                llst2.append(new_path)   #存放文件路径
            else:
                llst.append(new_path)    #存放目录路径
        llst.remove(''.join(llst[0]))
    for i in range(len(llst2)):
        getsize = os.path.getsize(''.join(llst2[i]))   #是则计算大小
        sum+=getsize
    print(sum)

end!