一学就废|Python基础碎片，关于函数的自测题_python单笔语句测试-优快云博客

本文链接：https://blog.youkuaiyun.com/aiyocxuan/article/details/145093133

测试题1

print(type(type(int)))

以输出结果为：

A.<class 'int'>

B.<class 'type'>

C.Error

D.0

题1详细解释

在 Python 中，int 是用来表示整数的数据类型。例如 1、100、-5 等这些整数值在 Python 里都是 int 类型的实例。
type() 函数在 Python 里是一个内置函数，当你把一个对象作为参数传递给 type() 函数时，它会返回该对象所属的类型，比如 type(1) 会返回 <class 'int'>，表示数值 1 属于 int 类型；type('hello') 会返回 <class'str'>，说明字符串 'hello' 是 str 类型的对象。
最内层的 type(int) ：这里把 int 这个类型对象（注意 int 本身也是 Python 中的一个对象，只不过它代表了整数类型）作为参数传递给 type() 函数，此时 type(int) 执行的结果是返回 int 类型所属的类型，在 Python 里所有的类型（像 int、str、list 等）它们本身都是 type 类的实例，所以 type(int) 的返回值是 <class 'type'>
外层的 type(type(int)) ：也就是把 <class 'type'> 这个结果（它也是一个对象，代表 int 类型的类型信息）再次作为参数传递给 type() 函数，而 type 类本身也是一种类型，它的类型就是它自己，所以 type(type(int)) 的返回值依然是 <class 'type'>。
总结一下就是，题目代码通过两次使用 type() 函数来探究 Python 中 int 类型的类型信息，最终发现 int 类型的类型是 type 类，并且 type 类的类型也是它自己。
答案：B

测试题2

li = ['a','b','c','d']
print("".join(li))

以上代码结果为：
A.Error
B.None
C.abcd
D.[‘a’,’b’,’c’,’d’]

题2详细解释

首先创建了一个名为 li 的列表，使用方括号 [] 来定义列表，其中包含了四个字符串元素，分别是 'a'、'b'、'c' 和 'd'。在 Python 中，列表是一种可以容纳多个不同类型元素的有序集合，在这里它存放的都是字符串类型的元素。
join() 是 Python 字符串的一个方法，它的作用是将一个可迭代对象（例如列表、元组等，只要其中的元素是字符串类型就行）中的元素连接成一个新的字符串。
"" 这里表示连接字符串时使用的分隔符为空字符串，也就是在把列表 li 中的元素连接起来时，各个元素之间没有额外的字符间隔。
执行这段代码后，会将列表 li 中的字符串元素按照指定的连接方式（这里是无分隔符连接）拼接成一个新的字符串，最终拼接得到的字符串是 "abcd"。
答案：C

测试题3

print(chr(ord('A'))) 

以上代码执行结果为：
A.A
B.B
C.a
D.Error

题3详细解释

ord() 是 Python 中的一个内置函数，它的作用是接受一个字符（长度为 1 的字符串）作为参数，然后返回这个字符对应的 Unicode 编码值（在 Python 里通常用十进制整数来表示）。例如，对于字符 'A'，它在 Unicode 编码中有对应的编码值，当执行 ord('A') 时，会返回 65。
接着把这个返回的 65 作为参数传递给 chr() 函数，也就是执行 chr(65)，按照 chr() 函数的功能，它会返回对应的字符 'A'。
总结一下就是通过 ord() 函数获取字符 'A' 的 Unicode 编码值，再利用 chr() 函数根据这个编码值还原出字符 'A' 并输出，实现了字符和其 Unicode 编码值之间的转换验证操作。
答案：A

测试题4

y = 8
z = lambda x : x * y
print(z(6))

以上代码结果为：
A.48
B.14
C.64
D.都不是

题4详细解释

首先定义了一个变量 y，并将整数值 8 赋给它，此时变量 y 在后续代码的相应作用域内可以被访问和使用。
lambda 是 Python 里用于创建简单的匿名函数的关键字，它的语法格式是 lambda 参数列表 : 表达式。在这个例子中，参数列表只有一个参数 x，表示这个匿名函数接受一个参数 x。
表达式部分是 x * y，意味着这个匿名函数的功能是接收一个参数 x，然后将这个参数 x 与在它作用域内可以访问到的变量 y 相乘，并返回相乘的结果。
需要注意的是，这里的 y 是在 lambda 表达式外部定义的变量，lambda 函数会捕获这个外部变量（形成了一个闭包），在后续调用该匿名函数时会使用当时 y 所具有的值。
按照匿名函数 z 的定义，它会执行 x * y 的运算，此时 x = 6，而 y = 8（之前定义好的值），所以计算的结果就是 6 * 8 = 48
答案：A

测试题5

li = [3, 4, 5, 20, 5, 25, 1, 3]
li.pop(1)
print(li)

以上代码结果为：
A.[3, 4, 5, 20, 5, 25, 1, 3]

B.[1, 3, 3, 4, 5, 5, 20, 25]

C.[3, 5, 20, 5, 25, 1, 3]

D.[1, 3, 4, 5, 20, 5, 25]

题5详细解释

创建了一个名为 li 的列表。在 Python 中，列表是一种有序的可变容器，可以容纳多个不同类型的元素（在这个例子里都是整数元素）。
pop() 是 Python 列表对象的一个内置方法，它主要用于移除列表中的指定元素，并返回被移除的那个元素的值。方法接受一个可选的参数，这个参数表示要移除元素的索引位置（索引从 0 开始计数）。在 li.pop(1) 中，参数值为 1，意味着要移除列表 li 中索引为 1 的元素
此时，列表 li 的内容就变为了 [3, 5, 20, 5, 25, 1, 3]，原来处于第二个位置（索引为 1）的元素 4 已经不存在了。
答案：C

测试题6

def outer():
    x = 10
    def inner():
        nonlocal x
        x += 5
        return x
    return inner

closure = outer()
print(closure())
print(closure())

以上代码结果为：
A.
15
20

B.
15
15

C.
10
15

D.
5
5

题6详细解释

首先定义了一个名为 outer 的函数，在 outer 函数内部，定义了一个局部变量 x 并赋值为 10。然后又在 outer 函数内部嵌套定义了一个名为 inner 的函数，形成了函数嵌套的结构。
在 inner 函数中，使用了nonlocal 关键字声明了变量 x。nonlocal 关键字用于在嵌套函数中指示某个变量不是局部变量（不属于当前 inner 函数的局部作用域），也不是全局变量，而是属于外层函数（这里就是 outer 函数）的局部变量。通过使用 nonlocal，在 inner 函数内部就可以修改外层函数 outer 中定义的变量 x 的值了。
inner 函数内部执行了 x += 5 的操作，也就是将外层函数 outer 中定义的变量 x 的值增加 5，然后通过 return x 返回更新后的值。
outer 函数返回了内部定义的 inner 函数对象本身，这就形成了一个闭包。闭包是一种函数对象，它记住了其外层函数的变量（这里就是记住了 outer 函数中的变量 x），即使外层函数已经执行完毕，闭包函数依然可以访问和修改这些被记住的变量。
执行 closure = outer() 语句，调用了 outer 函数，此时 outer 函数会执行，定义局部变量 x 为 10 以及定义内部的 inner 函数，然后返回 inner 函数对象，这个返回的 inner 函数对象就赋值给了变量 closure，所以 closure 现在就是一个闭包实例。
执行 print(closure()) 时，相当于调用了这个闭包函数 closure（也就是之前 outer 函数返回的 inner 函数）。第一次调用时，由于 x 初始值是 10（由 outer 函数定义时设定的），在 inner 函数中执行 x += 5 后，x 的值变为 15，然后返回这个 15，并通过 print() 函数将 15 输出显示出来。
再次执行 print(closure()) ，因为闭包记住了上次对变量 x 的修改，此时 x 的值是上一次调用结束后的 15，再次执行 x += 5 操作，x 的值就变为 20，接着返回 20，并通过 print() 函数将 20 输出显示出来。
答案：A