本文链接：https://blog.csdn.net/u013157570/article/details/127124212

1.执行以下程序，输出结果为:（B）

sizes = ['S','M']
colors = ['white','black']
shirts = [(size,color) for color in colors for size in sizes]
print(shirts)

A.[('S', 'white'), ('S', 'black'), ('M', 'white'), ('M', 'black')]

B.[('S', 'white'), ('M', 'white'), ('S', 'black'), ('M', 'black')]

C.[('S', 'white'), ('M', 'black')]

D.[('white', 'S'), ('black', 'M')]

解析：

列表生成式的执行结果等效于：

sizes = ['S','M']
       colors = ['white','black']
       shirts = []
       for color in colors:
             for size in sizes:
                   shirts.append((size,color))
       print(shirts)

因此输出结果为B选项。

先循环colors层，再循环sizes层，就是列表推导式的最前面color和size是相反的，先循环出来的在元组第二个位置了 ,每个color对应两个size，出来顺序是(white,S)，(white,M)，(black,S)，(black,M)，然后组装时题目中顺序是左右调换。

2.执行下列选项的程序，会抛出异常的是:（B）

s1 = 'aabbcc'
s2 = 'abc'
count = s1.count(s2)
if count > 0 :
      print('s2是s1的子串')
else:
      print('s2不是s1的子串')

s1 = 'aabbcc'
s2 = 'abc'
index = s1.index(s2)
if index > -1:
      print('s2是s1的子串')
else:
      print('s2不是s1的子串')

s1 = 'aabbcc'
s2 = 'abc'
find = s1.find(s2)
if find != -1 :
      print('s2是s1的子串')
else:
      print('s2不是s1的子串')

s1 = 'aabbcc'
s2 = 'abc'
if s2 in s1:
      print('s2是s1的子串')
else:
      print('s2不是s1的子串')

解析：

四个选项都是判断s2是否为s1的子串，但B选项的str.index不同于其他方法，当查找不到子串时会抛出异常。

count()函数没有匹配到对象返回0；

index()函数没有匹配到对象报错value Error；

find()函数没有匹配到对象返回-1；

in 没有匹配到对象返回false。

3.执行下列选项代码，输出[1, {'age': 10}]的是:（D）

a = [1,{'age':10}]
b = a
a[1]['age'] = 12
print(b)

a = [1,{'age':10}]
b = a[:]
a[1]['age'] = 12
print(b)

a = [1,{'age':10}]
b = a.copy()
a[1]['age'] = 12
print(b)

import copy
a = [1,{'age':10}]
b = copy.deepcopy(a)
a[1]['age'] = 12
print(b)

解析：

根据题意选项中A选项是值复制，修改变量a的可变对象和不可变对象都会对变量b产生影响，BC选项是浅复制，修改变量a的可变对象会对b产生影响，D选项是深复制，修改可变和不可变对象对b都无影响。

4.下面代码运行后，a、b、c、d四个变量的值，描述错误的是:（D）

import copy
a = [1, 2, 3, 4, ['a', 'b']]
b = a
c = copy.copy(a)
d = copy.deepcopy(a)
a.append(5)
a[4].append('c')

A.a == [1,2, 3, 4, ['a', 'b', 'c'], 5]

B.b == [1,2, 3, 4, ['a', 'b', 'c'], 5]

C.c == [1,2, 3, 4, ['a', 'b', 'c']]

D.d == [1,2, 3, 4, ['a', 'b', 'c']]

解析：

1) 执行b=a时，仅能产生对列表a的一个新的引用(别名)，此时，a和b都是实际数据[1, 2, 3, 4, ['a', 'b']]的表示，真实数据只存储一份；

2) 执行c = copy.copy(a)时，浅拷贝并生成新的列表对象，但需注意的是：浅拷贝中的可变对象(本题中为子列表['a','b'])会随原列表的变化而变化；

3) 依照第2)条，执行a.append(5)，a[4].append('c')时，对c的影响仅作用于可变对象，即['a','b'] -> ['a','b','c']；

4) 执行d = copy.deepcopy(a)时，深拷贝并生成新的列表对象。深拷贝：拷贝后对象的逻辑状态相同，即仅是各自内存地址中所对应的值相同，而不是指向同一内存地址。故修改a不会影响d。

5.执行以下程序，当用户输入0时，输出结果为:（D）

dividend = 1
divide = int(input())
try:
    result = dividend / divide
    print(1, end=" ")
except ZeroDivisionError:
    print(2, end=" ")
except Exception:
    print(3, end=" ")
else:
    print(4)

A.1 2

B.2 4

C.2 3

D.2

解析：

在try...except...else结构中，当执行try程序块的语句时，若出现异常的语句，则不会继续执行try还未执行的代码，而是直接跳到except程序块，由于0不能作为分母，其抛出的异常对象属于异常类ZeroDivisionError，结果输出2，当异常被处理完时，会直接跳出except程序块，当try程序块没有出现异常时，不会执行except而执行else语句，出现异常时则执行except而不执行else，所以最终输出结果是2。