Python.考试笔试小题练习

包含有许多小知识点，和易混易错的小题
对于 对于一些 小知识点 有充分解释

# 考试练习题


# 6.
print(str((1,2,3)))
# (1, 2, 3)


# 9.
print(sorted([111,2,33],key=lambda x:len(str(x))))
# [2, 33, 111]


# 11.
print(''.join(list('hello,world!')))
print(list('hello,world!'))
# hello,world!
# ['h', 'e', 'l', 'l', 'o', ',', 'w', 'o', 'r', 'l', 'd', '!']

# 14.
x = 3,3 ,5   # 这是 元组 的创建
print(x)
print(type(x))
# (3, 3, 5)
# <class 'tuple'>

# 19.
x = [1,2,3,2,3]
x.remove(2)
print(x)
# [1, 3, 2, 3]


# 20.
y = x[:]
print(id(x[0]) == id(y[0]))
# True


# 21.
print('ab' in 'abcde')
# True


# 22.
# 复数表达形式
a = 3 + 4j
print(a)
# (3+4j)


b = complex(3,4)
print(b)
# (3+4j)


# 26.
print(int('123',16))
# 意思的是 把123 化为16进制
# 1*16^2+2* 16^1+3* 16^0=256 + 32 + 3 = 291
# 291

print(int('123',8))
# 83
print(int('123'))
# 123
print(int(16))
# 16


# 28.
print(3 and 5)
# 5

# 在Python中，and运算符会按照如下规则进行操作：

# 1. **返回规则**：当使用逻辑与`and`连接两个表达式时，如果第一个表达式为真（即非零或非空），那么它将返回第二个表达式的值

# 2. **真值测试**：在Python中，数字3被认为是“真”，因为它是非零数值。
#                 因此，当and左边的值为3时，根据上面的规则，结果将是右边的值，也就是5

# 3. **短路求值**：逻辑与and运算符采用短路求值的方式，即如果第一个操作数为假，
#                则不再计算第二个操作数，直接返回第一个操作数的值；
#                如果第一个操作数为真，则返回第二个操作数的值
#
# 因此，当执行3 and 5时，由于3是真值，所以Python返回与之配对的另一个值，即5


# 31.
print(0 or 5)
# 5

# 在Python中，逻辑运算符or遵循短路求值的原则
# 如果运算符左边的值为真（True），则返回该值
# 如果为假（False），则返回右边的值
# 由于在Python中，数字0被视为逻辑假（False）
# 因此表达式0 or 5中的0被认定为假值，根据or的规则，会返回右边的值，也就是`5`


# 32.
print(list(str([1,2,3])) == [1,2,3])
print(list(str([1,2,3])))
# False
# ['[', '1', ',', ' ', '2', ',', ' ', '3', ']']


# 33.
x = (3,)
# 这是一个元组
# x = 3,
print(x)
# (3,)


# 34.
print(3 and not 5)
# False


# 35.
print(3 & 6)
# 2

# 在这个表达式中，&`是一个 按位与 运算符
# 它对两个整数进行二进制运算，并返回一个新的整数，其中的位是原始两个整数对应位进行与运算的结果

# 按位与 运算的规则如下：

# - 如果两个相应位都为 1，则该位的结果为 1
# - 如果一个位是 0，另一个位是 1 或 0，那么该位的结果为 0

# 3 和 6 的二进制表示：


# 3 的二进制表示是 011
# 6 的二进制表示是 110


# 现在，对这两个二进制数进行按位与 运算：


#  011  (3 的二进制表示)
#  110  (6 的二进制表示)

#   010  (3 & 6结果的二进制表示)


# 因此，3 & 6 的结果是二进制数 010，即十进制的 2



# 37.
print(3 | 5)
# 7

# 在这个表达式中，| 是一个按位或运算符
# 它也对两个整数进行二进制运算，并返回一个新的整数，其中的位是原始两个整数对应位进行或运算的结果

# 按位或运算的规则如下：

# - 如果两个相应位中有一个为 1，则该位的结果为 1
# - 如果两个位都为 0，那么该位的结果为 0

#  3 和 5 的二进制表示：


# 3 的二进制表示是 011
# 5 的二进制表示是 101


# 现在，对这两个二进制数进行按位或运算：


#  011  (3 的二进制表示)
#  101  (5 的二进制表示)

#   111  (3 | 5 结果的二进制表示)


# 因此，3 | 5 的结果是二进制数 111，即十进制的 7


# 39.
# 在Python中，None 表示空类型或无值（null）类型

# None 是Python的内置常量，它表示没有任何值的特殊类型
# 它是唯一的 NoneType 实例
# 当一个变量被赋值为 None，它表示该变量没有引用任何对象或者其值为空
# 这通常用于初始化变量、返回函数的默认值、指示函数没有明确的返回值，或者作为字典、列表、元组等数据结构中的空元素占位符

# 例如：

# 变量初始化为 None
# my_var = None

# 函数返回 None 表示没有具体返回值
# def my_function():
#     return None

# 在列表中使用 None 作为一个占位符
# my_list = [1, None, 3]

# 检查变量是否为 None
# if my_var is None:
#     print("my_var is empty")


# 使用 is 运算符来检查变量是否为 `None` 是一种推荐的做法
# 因为 is 检查对象的身份（即它们是否是同一个对象），而不是它们的等价性


# 42.
import numpy as np
A = np.array([1,2,3])
print(A*3)
print(np.array([1,2,3])*3)
# [3 6 9]
# [3 6 9]


# 43.
x = [3,5,7]
x[:3] = [2]
print(x)
# [2]

x[:3] = 2,2,2
print(x)
# [2, 2, 2]


# 46.
a = [1,2,3]
b = [1,2,4]
print(id(a[1])==id(b[1]))
# True

# a[1]和b[1]的内存地址是相同的

# 在Python中，变量是对内存中对象的引用，而不是存储对象本身
# 当我们创建列表 a和 b时，它们的第二个元素都是整数2
# 由于整数2 在Python中是不可变对象，所以当多个变量引用相同的整数时，它们实际上指向的是同一个内存地址

# 可以使用id()函数来获取对象的内存地址，如果两个变量引用的是同一个对象，那么它们的id将是相同的
# 因此，在这种情况下，a[1]和b[1]的内存地址是相同的


# 48.
print(sorted([1,2,3] ,reverse=True) == reversed([1,2,3]))
# False

# 在 Python 中，sorted() 函数返回的是一个新的已排序列表，而 reversed() 函数返回的是一个反向迭代器
# 当你尝试直接比较这两个返回值时，你会得到一个错误，因为它们不是同一类型的对象
# 要解决这个问题，你可以将 reversed() 函数返回的迭代器转换成列表，
# 然后再与 sorted() 函数的结果进行比较

# 下面是修改后的代码：

print(sorted([1,2,3] ,reverse=True) == list(reversed([1,2,3])))
# True

# 这段代码会先将 [1, 2, 3] 列表按降序排序，然后将其与 [1, 2, 3] 列表的反向列表进行比较
# 由于这两者都是 [3, 2, 1]，比较结果为 True


print(sorted([1,2,3] ,reverse=True))
# [3, 2, 1]


# 51.
a = [5 for i in range(10) ]
print(a)
# [5, 5, 5, 5, 5, 5, 5, 5, 5, 5]


# 52.
x = [3,5,7]
x[1:] = [2]
print(x)
# [3, 2]


# 53.
a = [1,2,3]
print(a*3)
print([1,2,3]*3)


# 54.
print(list(range(1,10,3)))
# [1, 4, 7]


# 55.
print(abs(3+4j))
# 5.0

# 在Python中，abs()函数用于计算 复数的模 或者 绝对值
# 复数的模是它在复平面上的距离到原点（0,0）的直线距离


# 57.
# 列表对象的sort()方法用于对列表元素进行原地排序，该函数的返回值是None

# sort()方法是Python中列表对象的一个内置方法，它用于将列表中的元素按照一定的顺序进行排序
# 这个方法没有返回值，因为它是直接在原列表上进行操作的，即所谓的“原地排序”
# 这意味着排序后的结果会直接反映在原列表上，而不会创建一个新的已排序列表
# 如果需要得到一个排序后的副本而保留原列表不变，可以使用sorted()函数，这会返回一个新的排序后的列表，而原列表保持不变

# 此外，sort()方法还可以接受一个可选的参数key，这个参数可以是一个函数，用于指定排序时使用的比较规则
# 例如，sort(key=len)会按照字符串的长度进行排序，sort(key=lambda i: i[1])会按照字符串的第二个字符进行排序
# 如果不提供key参数，则默认按照元素的自然顺序排序，对于数字就是从小到大，对于字符串就是按照字典顺序



# 58.
print(list('hello,world!'))
# ['h', 'e', 'l', 'l', 'o', ',', 'w', 'o', 'r', 'l', 'd', '!']

print('#'.join(list('hello,world!')))
# h#e#l#l#o#,#w#o#r#l#d#!


# 59.
print(set([1,1,2,3]))
# {1, 2, 3}


# 61.
print(list(range(6))[::2])
# [0, 2, 4]


# 63.
print({1, 2, 3, 4} - {3, 4, 5, 6})
# {1, 2}


# 65.  # 68.
print(str([1,2,3]))
# [1, 2, 3]


# 在Python中，str()函数用于将其他数据类型转换为字符串
# 当你使用str([1,2,3])时，你是将一个 列表对象 转换为字符串形式

# str([1,2,3])的输出不会是'1,2,3'，而是会包含列表的完整结构信息，包括列表的方括号和元素之间的逗号
# str([1,2,3])的输出将是：

# '[1, 2, 3]'

# 这是因为str()函数的目标是提供一个对象的字符串表示，以便可以打印或显示，而不是仅仅转换其元素为字符串并连接它们
# 如果你想要得到一个简单的由逗号分隔的字符串，你应该使用join()方法
# 如下所示：


# ','.join(map(str, [1,2,3]))

# '1,2,3'

# map(str, [1,2,3])首先将列表中的 每个元素 转换为字符串，然后','.join()将这些字符串用逗号连接起来


# 69.

# 在Python中，in关键字用于测试一个对象是否是一个可迭代对象（如列表、元组、字典、集合等）的元素

# 当你使用in关键字时，你实际上是在检查左侧的对象是否存在于右侧的可迭代对象中
# 如果存在，表达式的结果为True，否则为False

# 例如：


# 检查元素是否在列表中
# my_list = [1, 2, 3]
# print(1 in my_list)  # True

# 检查键是否在字典中
# my_dict = {'a': 1, 'b': 2}
# print('a' in my_dict)  # True

# 检查元素是否在字符串中（字符串也是可迭代的）
# my_string = "hello"
# print('e' in my_string)  #  True

# 在这些例子中，in关键字用来测试左侧的值是否存在于右侧的可迭代对象中


# 70.
x = 3 == 3, 5
print(x)
# (True, 5)

# 这里涉及到了几个运算符和概念：

# 1. 等于运算符 == : 它用于比较两个值是否相等，如果相等，则返回 True，否则返回 False
#                   在这个例子中，3 == 3 的结果是 True

# 2. 逗号运算符 , : 它用于创建一个元组，将多个表达式连接起来
#                  在这个例子中，3 == 3 和 5 被逗号分隔，形成了一个元组 (True, 5)

# 3. 赋值运算符 = : 它将右侧的值赋给左侧的变量
#                  在这个例子中，True, 5 这个元组被赋值给变量 x

# 所以，执行完 x = 3 == 3, 5 后，变量 x 的值就是 (True, 5)

# 这里需要注意的是，赋值运算符 = 的优先级低于逗号运算符 ,
# 所以 3 == 3, 5 会首先被求值，形成一个元组，然后这个元组才会被赋值给 x



# 71.
print([3] in [1,2,3,4])
# False

print(3 in [1,2,3,4])
# True


# 73.
print(3 < 5 > 2)
# True

# 在 Python 中，比较运算符是从左到右进行评估的，并且 < 和 > 运算符具有相同的优先级
# 所以这个表达式实际上是 (3 < 5) and (5 > 2)


# 75.
x = {'a':'b' ,'c':'d'}
print('a' in x)
# True

# 表达式 'a' in x 用于检查字典 x 是否包含键 'a'
# 这个表达式会返回一个布尔值，如果 'a' 作为键存在于字典 x 中，则返回 True；否则返回 False

# 76.
x = [90,87,26]
print(','.join(str(x)))
# [,9,0,,, ,8,7,,, ,2,6,]
print(str(x))
# [90, 87, 26]

# 77.
s1 = "企鹅"
s2 = "超级游泳健将"
print("{0:^4}:{1:!<9}".format(s1,s2))
#  企鹅 :超级游泳健将!!!
print("{1:^4}:{0:!<9}".format(s1,s2))
# 超级游泳健将:企鹅!!!!!!!

# 78.
r = eval(input("请输入半径:"))  #  r = input("请输入半径:")
ar = 3.1415 * r * r           #  注意区别
print("{:.0f}".format(ar))

# 请输入半径:3
# 28

# 79.
s = "11+5in"
print((s[1]))  # 1
print((s[-2]))  # i

print(eval(s[1:-2])) #-2的位置不取，取前面的一位
# 1位置对应的是第二个1，-2前面的一个位置是倒数第三位即为5
# 故结果为 1 + 5 = 6

# 80.
print('y'<'x')  # False

print(False == False)  # True

print('y'<'x' == False)  # False
# 上面的表达式相当于下面的表达式
print(('y'<'x') and ('x' == False))  # False

# 验证一下是不是相等
print(('y'<'x' == False) == (('y'<'x') and ('x' == False)))  # True

# 81.
print("{:.2f}".format(20-2**3+10/3**2*5))
# 17.56

print(10/3**2*5)
# 5.555555555555555
print((10/9)*5)
# 5.555555555555555

# 82.
# print(float(complex(10+5j).image))
# image 是 Python 中复数对象的一个属性，用于获取复数的虚部

# 在这段代码中，complex(10+5j) 创建了一个复数对象 10+5j，其中实部为 10，虚部为5
# 通过调用该对象的 image 属性，可以获取到 虚部 的值，即 5 然后
# 使用 float() 函数
# 将虚部的值转换为浮点数类型，最终输出结果为 5.0

# 83.
# 使用键盘输入一三位数的正整数，输出其中的最大的一位数字是多少
# 例如，输入386，输出8;输入290，输出9.
x = eval(input())
m = max(str(x)[0],str(x)[1],str(x)[2])
print(m)
# 290
# 9

# 84.
dat=['1','2','3','0','0','0']
for item in dat:
    if item == '0':
        dat.remove(item)
print(dat)
# ['1', '2', '3', '0']


# 下面解释原因

# 在Python中，当你在遍历一个列表（或任何可迭代对象）的同时修改该列表，会导致意外的行为
# 这是因为修改列表的同时，迭代器内部的状态不会自动更新以反映这些改变，这通常会导致“循环期间修改”的问题
# 在上面的例子中，当你尝试在迭代 dat 列表的同时删除其中的元素时，就会遇到这个问题
# 当你删除一个元素时，列表中的其他元素会向前移动填补空缺，但是迭代器仍然保持在原来的位置，因此它不会移动到下一个元素

# ['1','2','3','0','0','0']
# 索引下标
#   0 , 1 , 2 , 3 , 4 , 5    在中间删除元素的时候，对应的元素位置变了，但是迭代器仍然是按照最初顺序进行

# 当遇到第一个'0'，删除后，列表变为
# ['1','2','3','0','0']   删除第一个索引下标为3的'0'后，后面的'0'往前移动了索引下标变化了
# 索引下标                 但是迭代器是没有变化的，它将继续往后迭代下标为4的'0'，而现在索引下标为3的'0'则未被删除
#   0 , 1 , 2 , 3 , 4     也就是最终导致有一个'0'未删除

# 之后列表变化为
# ['1','2','3','0']   此时迭代器继续迭代，按照原来迭代到索引下标为5的'0'
# 索引下标             但是由于现在的列表没有下标5了，进而也就删除不了，最终留下了一个'0'
#   0 , 1 , 2 , 3


# 若想要完全删除'0',则应该用下面的方法

# 可以使用 列表生成式 或者filter()函数来创建一个新的列表，只包含不等于'0'的元素

# 使用列表推导式：
dat = ['1', '2', '3', '0', '0', '0']
new_dat = [item for item in dat if item != '0']
print(new_dat)
# ['1', '2', '3']


# 使用filter()函数：

dat = ['1', '2', '3', '0', '0', '0']
new_dat = list(filter(lambda x: x != '0', dat))
print(new_dat)
# ['1', '2', '3']

# 85.
# 以下关于异常处理的描述，正确的是:

# A Python 中允许利用 raise 语由程序主动引发异常

# B try 语句中有 except 子句就不能有 finally 子句

# C Python 中，可以用异常处理捕获程序中的所有错误

# D 引发一个不存在索引的列表元素会引发 NameError 错误


# 解释

# A 正确 Python 中确实允许使用 raise 语句来主动引发异常

# B 错误 try 语句中可以同时包含 except 和 finally 子句,finally 子句无论是否有异常发生都会执行
 
# C 错误 虽然 Python 提供了丰富的异常处理机制，但并不能捕获程序中的所有错误，特别是某些无法恢复的错误，如内存不足等

# D 错误 尝试访问一个不存在的列表索引会引发 IndexError，而不是 NameError ,NameError 是指尝试使用未声明或不在当前作用域中的变量

# 86.
# 设 x = 10;y = 20，下列语句能正确运行结束的是:
# A while True: pass
# B min = x if x < y else y
# C max = x >y ? x : y
# D if(x>y) print(x)

# 解释

# A. while True: pass 是一个无限循环，它会一直执行 pass 语句（一个什么也不做的命令），直到被强制中止或出现异常，这个语句是正确的，但它不会在没有任何条件或中断的情况下结束
 
# B. min = x if x < y else y 是一个条件表达式（也称为三元运算符），它会根据 x < y 的布尔值来决定将 x 还是 y 的值赋给 min 这个语句是正确的
 
# C. max = x >y ? x : y 是一个不正确的使用了三元运算符的语句  在 Python 中，三元运算符的语法是 <expression1> if <condition> else <expression2>，而不是 <condition> ? <expression1> : <expression2> 这个语句的正确形式应该是 max = x if x > y else y
 
# D. if(x>y) print(x) 是一个带有打印操作的条件语句。如果 x 大于 y，它会打印 x 的值 这个语句是正确的，但是不能出来结果
 
# 因此，只有语句 B 能正确运行结束

# 87.
# 以下关于程序控制结构描述错误的是
# A Python 里，能用分支结构写出循环的算法
# B 二分支结构组合形成多分支结构
# C 程序由三种基本结构组成
# D 分支结构包括单分支结构和二分支结构

# 解释

# 描述错误的是A选项

# 程序控制结构通常分为三种基本类型：顺序结构、选择结构和循环结。

# 1. **顺序结构**：程序按照代码的书写顺序依次执行各条语句。这是最简单的程序结构，也是所有程序的基础部分
# 2. **选择结构**：程序根据条件判断的结果选择性地执行不同的代码块。它包括单分支结构（如if语句）、两路分支结构（如if-else语句）和多路分支结构（如switch语句或if-elif-else链）
# 3. **循环结构**：程序根据循环条件反复执行某段代码，直到循环条件不再满足为止 常见的循环结构有for循环和while循环

# 在编程中，选择结构和循环结构虽然在某些情况下可以相互替代，但它们在逻辑上是有本质区别的
# 选择结构是根据条件来决定执行路径，而循环结构则是重复执行某个任务直至满足退出条件
# 因此，虽然可以在分支结构中编写出类似循环行为的算法，但这并不意味着分支结构本身就能够完全取代循环结构

# 综上所述
# A选项描述错误，因为分支结构本身并不能直接实现循环的行为；
# B选项正确，多路分支结构通常是由多个二分支结构组合而成；
# C选项正确，程序确实由三种基本结构组成；
# D选项正确，分支结构包括了单分支结构和二分支结构

# 88.

# 以下选项中，不是Python 语言基本控制结构的是
# A顺序结构
# B 程序异常
# C 跳转结构
# D 循环结构

# C

# Python中的基本控制结构主要分为以下几种：
# 
# 1. **顺序结构**：代码按照书写的顺序从上到下依次执行。这是最简单的程序结构，任何程序都会涉及到顺序结构的使用
# 2. **分支结构**：根据条件判断的结果，程序决定执行哪一个代码分支。在Python中，分支结构是通过if、elif和else关键字实现的，并可以组合成多种复杂的逻辑判断形式
# 3. **循环结构**：包括for循环和while循环，允许代码块在满足一定条件时重复执行。循环结构使得程序能够处理批量数据或者反复执行某项任务直到满足退出条件
 
# 而选项中提到的“程序异常”并不是一种控制结构，它通常指的是程序在运行过程中发生的错误或异常情况，
# 需要通过try-except等语句来处理。至于“跳转结构”，虽然在Python中有诸如break和continue这样的跳转语句
# 它们可以在循环或迭代中改变程序的执行流程，但它们并不构成一个独立的控制结构类别。跳转语句通常被视为循环结构中的特例，用于提前结束循环或跳过当前迭代

# 综上所述，Python语言的基本控制结构主要包括顺序结构、分支结构和循环结构，这三种结构是构建任何程序逻辑的基础

# 89.

L1 =['abc',['123','456']]
L2 = ['1','2','3']
print(L1 > L2)
# True

# Python在比较列表时，是按照元素的顺序进行比较的
# 当你使用大于（`>`）操作符比较`L1`和`L2`时，Python首先比较`L1`和`L2`的第一个元素
 
# 对于第一个元素，L1中的第一个元素是字符串'abc'，而L2中的第一个元素是字符串'1'
# 因为字符串是按照字典顺序比较的，'abc'大于'1'，所以整个列表比较的结果就是True
 
# 因此，尽管`L1`和`L2`的第二个元素也是列表，但这个比较并不影响整个列表的比较结果，
# 因为第一个元素已经确定了整个列表的比较结果

# 90.

L2 = [1, 2, 3, 4]
L3 = L2.reverse()
print(L3)
# None

# L2.reverse 方法会对列表 L2 进行原地反转，但它本身没有返回值
# 因此，当你执行 L2.reverse() 时，L2 的内容会被反转，但该方法不会返回反转后的列表

# 在 Python 中，如果一个函数或方法没有明确返回值（即没有使用 return 语句），那么它的返回值默认为 None
# 这就是为什么 L3 = L2.reverse() 的结果是 None 的原因

# 如果你想得到反转后的列表并赋值给 L3，你应该先对 L2 进行反转操作，然后再将反转后的 L2 赋值给 L3
# 下面是正确的做法：

L2 = [1, 2, 3, 4]
L2.reverse()
L3 = L2
print(L3)
# [4, 3, 2, 1]

# 91.

x = ['90','87','90']
n = 90
m = '90'
print(x.count(n))
# 0
print(x.count(m))
# 2