考试题

Python11 期第二次考试（基础数据类型与函数部分）

考试时长：3 个小时满分：105 分

一，选择题（每题 2 分，共 24 分）

1、python 不支持的数据类型有

A、char

B、int

C、float

D、list

2、

x ="foo"
y = 2
print(x+y)

A.foo B.foofoo C.foo2 D.2 E.TypeError

3、关于字符串下列说法错误的是

A、字符串应该视为长度为 1 的字符串

B、字符串可以转化成数字

C、既可以用单引号，也可以用双引号创建字符串

D、在三引号字符串中可以包含换行回车等特殊字符

4、以下不能创建一个字典的语句是

A、dic1 = {}

B、dic2 = {123:345}

C、dic3 = {[1,2,3]:’uestc’}

D、dic3 = {(1,2,3):’uestc’}

5、

Kvps = {'1':1,'2':2}
theCopy = kvps
kvps['1'] = 5
sum = kvps['1'] + theCopy['1']
print(sum)

A.1 B.2 C.7 D.10

6、已知 x=43，ch=’A’，y = 1，则表达式(x>=y and ch <’b’ and y)的值是

A、0 B、1 C、出错 D、True

7、下列 Python 语句正确的事（多选）

A、min = x if x < y else y

B、max = x > y ? x : y

C、if(x>y) print(x)

D、while True:pass

8、若 k 为整形，下述 while 循环执的次数为：

k=1000
while k>1:
print(k)
k=k/2

A.9 B.10 C.11 D.100

9、以下叙述正确的是：

A、continue 语句的作用是结束整个循环的执行

B、只能在循环体内使用 break 语句

C、在循环体内使用 break 语句或 continue 语句的作用相同

D、从多层循环嵌套中退出时，只能使用 goto 语句

10、下面的语句哪个会无限循环下去：

A、

for a in range(10):
    time.sleep(10)

B、

while 1<10:
     time.sleep(10)

C、

while True:
     break

D、

a = [3,-1,',']
 for i in a[:]:
   if not a: break

11、下列说法正确的是(多选,选错不得分)：

A，

a = [1,2,3]

b = [1,2,3]

a 与 b 指向同一个内存地址。

B，

i1 = 356

I2 = 356

i1 与 i2 是同一个内存地址。

C，

s1 =’laonanhai’

s2 =’laonanhai’

s1 与 s2 是同一个内存地址。

D，tu = (1) tu 是元组类型。

12、下面的代码，哪些是输出 1,2,3 三个数字(多选,选错不得分):

A、

for i in range(3):
    print(i)
    print(i+1)

B、

aList = [0,1,2]
for i in aList:
    print(i+1)

C、

i = 1
while i < 3:
    print(i)
    i+=1

D、

for i in range(3):
    print(i+1)

二，简答题（共 42 分）

1、is 和 == 的区别（2 分）

2、Python 如何实现 tuple 和 list 的转换。（2 分）

3、list 和 tuple 有什么不同（2 分）

4、args 和*kwargs 在什么情况下会使到？请给出使 kwargs 的事例（2 分）

5、Python 中什么数据类型存在小数据池？小数据池有什么作用？（2 分）

6、在 Python3x 版本中，s1 =’老男孩’，如何将 s1 转化成 utf-8 的 bytes 类型？转化成功之后，得到了 s2，如何将 s2 转化成 gbk 的 bytes 类型（请写出具体代码）？（3 分）

7、有如下操作，最后 dic 的结果是什么？为什么？（2 分）

dic = dict.fromkeys(['barry','alex',],[])
dic['barry'].append(666)
    print(dic)

8、请描述 unicode,utf-8,gbk 等编码之间的关系？（2 分）

9、l = [1,1,2,2,3,4,5,5,6,6,7,8]将此列表去重。（2 分）

10、有如下代码，写出最后结果，并解释为什么。（3 分）

l1 = [1,[22,33,44],3,4,]
l2 = l1
l3 = l1.copy()
l1.append(666)
l1[1].append('55')
Print(l1,l2,l3)

11、有如下代码，说出 l1 与 l2 的关系？（2 分）

l1 = [1,2,3,4,5]
l2 = l1[:]

12、’1,2,3’如何变成[‘1’,’2’,’3’]？ [‘1’,’2’,’3’]如何变成[1,2,3]?（写具体代码）（4 分）

13、如何生成[1,4,9,16,25,36,64,81,100]尽量用一行实现。（2 分）

14、map(str,[1,2,3,4,5,6,7,8,9])输出什么？（2 分）

15、下面代码输出结果是什么？两次 list1 的结果相同么？为什么？（4 分）

def extendList(val,list=[]):
    list.append(val)
    return list
list1 = extendList(10)
print('list1=%s'%list1)
list2 = extendList(123,[])
print('list2=%s'%list2)
list3 = extendList('a')
print('list3=%s'%list3)
print('list1=%s'%list1)

16、下面代码的执行结果是什么？为什么？（4 分）

a = 1
     def func1():
        a += 1
        print(a)
     func1()

这段代码呢？

def wrapper():
    a = 1
def inner():
    a += 1
    print(a)
inner()
wrapper()

17、什么是闭包（closure），为什么要用它？（2 分）

三，代码题

1、用 map 来处理字符串列表,把列表中所有人都变成 sb,比方 alex_sb（4 分）

name=['oldboy','alex','wusir']

2，用 filter 函数过滤出单价大于 100 的股票。（4 分）

portfolio = [
    {'name': 'IBM', 'shares': 100, 'price': 91.1},
    {'name': 'AAPL', 'shares': 50, 'price': 543.22},
    {'name': 'FB', 'shares': 200, 'price': 21.09},
    {'name': 'HPQ', 'shares': 35, 'price': 31.75},
    {'name': 'YHOO', 'shares': 45, 'price': 16.35},
    {'name': 'ACME', 'shares': 75, 'price': 115.65}]

3，有文件 t1.txt 里面的内容为：（6 分）

id,name,age,phone,job

1,alex,22,13651054608,IT

2,wusir,23,13304320533,Tearcher

3,taibai,18,1333235322,IT

利用文件操作，将其构造成如下数据类型。

[{'id':'1','name':'alex','age':'22','phone':'13651054608','job':'IT'},
......]

4，写程序完成下列功能：(20 分，有 5 分加分项，共计 25 分)

1)，启动程序，首页面应该显示成如下格式：

欢迎来到博客园首页
1:请登录
2:请注册
3:文章页面
4:日记页面
5:评论页面
6:收藏页面
7:注销
8:退出程序

2)，用户输入选项，3~6 选项必须在用户登录成功之后，才能访问成功。

3)，用户选择登录，用户名密码从 register 文件中读取验证，三次机会，没成功则结束整个程序运行，成功之后，可以选择访问 3~6 项，访问页面之前，必须要在 log 文件中打印日志，日志格式为—>用户:xx 在 xx 年 xx 月 xx 日执行了 %s 函数，访问页面时，页面内容为：欢迎 xx 用户访问评论（文章，日记，收藏）页面

4)，如果用户没有注册，则可以选择注册，注册成功之后，可以自动完成登录（完成自动登录+5 分），然后进入首页选择。

5)，注销用户是指注销用户的登录状态，使其在访问任何页面时，必须重新登录。

6)，退出程序为结束整个程序运行。

答案

一、选择题

1.A

解释：char 类型在 python 中不存在，它是其他编程语言的一种数据类型，比如 C/C++,JAVA

2.E

解释：x 是字符串类型，y 是整形，所以 x+y 执行报错

3.A

解释：字符串的长度，不只是有 1 个字符串，还有多个字符串。

4.C

解释：list 是可变类型，它不可哈希，它不能作为字典的 key

5.D (面试题)

解释：theCopy 做了赋值，当 kvps[‘1’] = 5 改变时，theCopy 也改变了，所以最终结果为 10

6.B (面试题)

先判断 x>=y，结果为 True。判断 ch < ‘b’ 也就是’A’ < ‘b’这里比较是 ascii 码字母对应的顺序。

A 对应的顺序是 65，b 对于的是 97，结果为 True。True and True，结果为 True

最后判断 True and y 也就是 True and 1。根据 x and y 判断规则,如果 x 为 false，则取 x，否则取 y。那么这里取 y，最终结果为 1

7.AD

解释：A 是一个三元运算符，语句正确。B 是 PHP 里面的三元运算，语句错误。C 的 if 判断结尾没有冒号，直接 print 了，语句错误

D 是 whlie 循环，语句正确。

8.B (面试题)

直接上代码，测试一波

k=1000
count = 0
while k>1:
    count += 1
    k = int(k)
    print(k)
    k=k/2
print('循环执的次数为{}'.format(count))

执行输出：

1000

500

250

125

循环执的次数为 10

9.B (面试题)

A.continue 的作用是结束当前循环，继续下一次循环，叙述错误

B.循环体，也即是 for 和 while，这里面可以使用 breck，叙述正确

C.break 是结束循环，continue 的作用是结束当前循环，继续下一次循环，叙述错误

D.goto 语句也称为无条件转移语句，它是 C 语言和 GO 语言的语法，叙述错误

10.B

A.是 for 循环，它是一个有限循环

B.1<10 是成立的，它会无限循环下去

C.break 直接结束循环了

D.是 for 循环，它是一个有限循环

11.C

A. a 和 b 是重新赋值了，所以 2 个都是新的内存地址

B. 小数据池的范围是数字： -5~256，i1 和 I2 的数值超出范围了，所以不是同一内存地址

C.字符串不含有特殊字符，且长度不超过 20，存在小数据池。这里的 s1 和和 s2 没有超过 20，所以内存地址是同一个

D.tu = (1)缺失逗号，tu = (1,)才是元组类型。

12.BD (面试题)

A.执行输出：

B.执行输出：

C.执行输出：

D.执行输出：

二、简答题

== 比较的是数值

is 比较的是内存地址

#tuple 转换为 list
a = (1,2,3)
b = list(a)

#list 转换为 tuple
a = [1,2,3]
b = tuple(a)

list 的值可以改变,tuple 的值不能改变

list 有增删改查的方法,tuple 只有查看的方法。

list 用[]符号存放元素,tuple 用()符号存放元素

args 和*kwargs 是动态参数,在参数数量不确定的情况下使用，它可以接收任何变量,它是万能参数

事例：

def fun1(**kwargs):
    print(kwargs)

只有数字和字符串类型，存在小数据池

小数据池的作用，就是节省内存

s1 ='老男孩'
s2 = s1.encode(encoding='utf-8') #转化成 utf-8 的 bytes 类型
s3 = s2.decode(encoding='utf-8').encode('gbk') #解码,再转化成 gbk 的 bytes 类型
print(s3)

最后 dic 的结果是 {‘barry’: [666], ‘alex’: [666]}

fromkeys() 方法是创建一个新的字典，并以可迭代对象中的元素分别作为字典中的键,且所有键对应同一个值,默认为 None

所以新的字典应该是 dic = {‘barry’: [], ‘alex’: []},这里的[]是同一个值[],它对应一个内存地址

执行 dic[‘barry’].append(666)之后，列表的值为[666]，由于 2 个 key 对应同一个内存地址

所以 2 个 key 对应的 value 是一样的，最终结果为{‘barry’: [666], ‘alex’: [666]}

unicode,utf-8,gbk 英文，占用 1 个字符

unicode,gbk 中文,占用 2 个字符。utf-8 中文,占用 3 个字符

unicode 是万国码,保存所有国家的编码,升级之后是 4 个字节表示一个字符,

为了解决资源浪费问题,utf-8 诞生了，是在 unicode 基础上，发展过来的。

gbk

l = [1,1,2,2,3,4,5,5,6,6,7,8]
l2 = list(set(l)) #先转换为集合去重，再转换为列表
print(l2)

10.

最后结果为：

[1, [22, 33, 44, ‘55’], 3, 4, 666] [1, [22, 33, 44, ‘55’], 3, 4, 666] [1, [22, 33, 44, ‘55’], 3, 4]

l2 = l1 用的是同一内存地址,l3 = l1.copy() 用了浅 copy

l1.append(666) 增加了一个元素，由于 l2 和 l1 的值，对应的是同一内存地址，所以值也变动了。l3 不受影响

l1[1].append(‘55’) 给 l1 里面的列表增加了一个元素，同上，l1 和 l2 的值是一样的，l3 依然不变

11.

l1 和 l2 的值是一样的,l2 通过切片的方式，把 l1 的值都复制过来了。但是 l2 是一个新的变量，和 l1 的内存地址是不一样的

12.

a = '1,2,3'
b = a.split(',') #分割，转换成列表
print(b) #['1','2','3']

13.

ret = map(lambda x:x **2,[i for i in range(1,11)])

14.

生成器，迭代器，迭代器的地址,map 对象

15.

2 次 list1 的结果不一样

第一次 list1 执行时候,函数用的是默认值 list=[]，所以值为[10]

由于 list3 执行时，也用了函数的默认值 list,由于默认值对应同一内存地址，所以执行完成之后,list 为[10, ‘a’]

那么最终 list1 输出 list 时，结果为[10, ‘a

16.

执行报错,因为内层函数只能引用全局变量，不能修改全局变量

第二个也是报错，内层函数可以引用父级函数变量，它不能修改

17.

内部函数包含对外部作用域而非全剧作用域变量的引用，该内部函数称为闭包函数

闭包的好处：

当函数开始执行时，如果遇到了闭包，他有一个机制，他会永远开辟一个内存空间，将必包中的变量等值放入其中，不会随着函数的执行完毕而消失。

三、代码题

res = map(lambda x:x+'_sb',name)
for i in res:
    print(i)

ret = filter(lambda x:x['price'] > 100,portfolio)
for i in ret:
    print(i)

#空列表,存放结果
li_1 = []
with open('t1.txt', encoding='utf-8') as f1:
    # 读取第一行,去除空格,使用逗号切割成列表
    title_name = f1.readline().strip().split(',')
    for i in f1:
        dic = {}
        # 去除空格,以逗号切割成列表
        i = i.strip().split(',')
        for j in range(len(i)):
            # 添加字典, list_name[j]表示 key, i[j]表示 value,比如'id': '1'
            dic[title_name[j]] = i[j]
        # 添加到列表中
        li_1.append(dic)
print(li_1)

老师的代码：

import time
status_dic = {
    'username': None,
    'status': False,
}
flag1 = True
def login(*args,**kwargs):
    i = 0
    while i < 3:
        if args:
            status_dic['username'] = args[0]
            status_dic['status'] = True
            return True
        else:
            username = input('请输入用户名：').strip()
            password = input('请输入密码：').strip()
            with open('register',encoding='utf-8') as f1:
                for line in f1:
                    line_list = line.strip().split()
                    if username == line_list[0] and password == line_list[1]:
                        print('登录成功')
                        status_dic['username'] = username
                        status_dic['status'] = True
                        return True
                else:
                    print('输入不正确，请重新输入,还剩%s 机会' % (2-i))
                    if i == 2: return Quit()
                i += 1
def register(*args, **kwargs):
    flag = True
    while flag:
        username = input('请输入要注册的用户名:')
        f1 = open('register',encoding='utf-8')
        for i in f1:
            if username in i:
                print('用户名重复,请重新输入')
                f1.close()
                break
        else:
            f1.close()
            password = input('请输入要注册的密码:').strip()
            f2 = open('register', encoding='utf-8', mode='a')
            f2.write('\n{}\t{}'.format(username, password))
            f2.close()
            print('恭喜你,注册成功,已经自动为您登录，现在跳转到首页...')
            return login(username,password)
def wrapper(func):
    '''
    :param func:此函数是的登录认证的装饰器， 直接利用 login（）函数进行登陆认证。
    :return: 执行被装饰的函数。
    '''
    def inner(*args,**kwargs):
        if status_dic['status']:
            ret = func(*args,**kwargs)
            return ret
        else:
            print('请先进行登录')
            if login():
                ret = func(*args, **kwargs)
                return ret
    return inner
def log_record(func):
    def inner(*args,**kwargs):
        struct_time = time.localtime()
        time_now = time.strftime("%Y-%m-%d %H:%M:%S", struct_time)
        with open('log_func','a',encoding='utf-8') as f1:
            f1.write('用户:%s 在%s 执行了 %s 函数\n'%(status_dic['username'],time_now,func.__name__))
        ret = func(*args,**kwargs)
        return ret
    return inner
@log_record  # article = wrapper(article)  article --> inner
@wrapper  # article = wrapper(article)  里面的  func = article article --.inner()(wrapper)
def article():
    print('欢迎%s 访问文章页面' % status_dic['username'])
@wrapper
@log_record
def diary():
    print('欢迎%s 访问日记页面' % status_dic['username'])
@wrapper
@log_record
def comment():
    print('欢迎%s 访问评论页面' % status_dic['username'])
@wrapper
@log_record
def enshrine():
    print('欢迎%s 访问收藏页面' % status_dic['username']) 
def login_out():
    status_dic['username'] = None
    status_dic['status'] = False
    print('注销成功')
def Quit():
    global flag1
    flag1 = False
    return flag1
choice_dict = {
    1: login,
    2: register,
    3: article,
    4: diary,
    5: comment,
    6: enshrine,
    7: login_out,
    8: Quit,
}
while flag1:
    print('欢迎来到博客园首页\n1:请登录\n2:请注册\n3:文章页面\n4:日记页面\n5:评论页面\n6:收藏页面\n7:注销\n8:退出程序')
    choice = input('请输入您选择的序号:').strip()
    if choice.isdigit():
        choice = int(choice)
        if 0 < choice <= len(choice_dict):
                choice_dict[choice]()
        else:
            print('您输入的超出范围，请重新输入')
    else:
        print('您输入的选项有非法字符，请重新输入。')

python全栈开发

Day16 函数第一次考试

考试题