代码收藏家技术教程 2024-03-29

浙大版《Python 程序设计》题目集-第三章全解析 | PTA

第三章使用字符串、列表和元组

一、判断题

1.'age'+23不是正确的表达式。T

2.列表可以用find()函数来搜索数据是否在列表中。F

find()函数是字符串处理函数；Python find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始）和 end（结束）范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。

str.find(str, beg=0, end=len(string))

str—a指定检索的字符串

beg—开始检索，默认为0

end—结束检索，默认为字符串的长度

返回值

如果包含子字符串返回开始的索引值，否则返回-1。

3.将列表中的元素顺序打乱的函数shuffle()不是random模块的函数或方法。F

random.shuffle(列表)：将列表内元素随机排列

4.字符串和列表都是序列类型。T

5.可以通过[]访问字符串的某个字符，也可将它修改成其他字符。F

my_string = "Hello"

# 访问字符串中的某个字符

char = my_string[1] # 这将得到 'e'

# 尝试修改字符串中的字符（这不会起作用，因为字符串是不可变的）

# my_string[0] = 'J' # 这会引发错误

# 创建一个新的字符串来实现修改

new_string = 'J' + my_string[1:] # 这样可以得到 'Jello'

print(new_string) # 输出 'Jello'

6.字符串对象和元组对象是不可变对象，列表对象为可变对象。T

7.列表lst=[12, -5, -22, -10, -26, 35, 0, 49, 3, -21],lst[::]的结果是[12, -5, -22, -10, -26, 35, 0, 49, 3, -21]。T

b[:] ##单独一个冒号,代表从头取到尾,步长默认为1

b[::]##单独两个冒号一样代表从头取到尾,步长默认为1

b[::-1]##注意,两个冒号后面是步长,步长为1,故应从右往左取

8.列表lst=[12, -5, -22, -10, -26, 35, 0, 49, 3, -21],lst[::-1]的结果是[-21, 3, 49, 0, 35, -26, -10, -22, -5, 12]。T

9.列表lst=[12, -5, -22, -10, -26, 35, 0, 49, 3, -21],lst[::2]的结果是[12, -22, -26, 0, 3]。T

10.列表lst=[12, -5, -22, -10, -26, 35, 0, 49, 3, -21],lst[1::2]的结果是[12, -22, -26, 0, 3]。F

11.列表lst=[12, -5, -22, -10, -26, 35, 0, 49, 3, -21],lst[3:8:2]的结果是[-10, 35, 49]。T

12. 列表lst=[12, -5, -22, -10, -26, 35, 0, 49, 3, -21],lst[0:100]的结果是错误。F

13. 列表lst=[12, -5, -22, -10, -26, 35, 0, 49, 3, -21],lst[100:]的结果是[]。T

14. 列表lst=[12, -5, -22, -10, -26, 35, 0, 49, 3, -21],lst[100]的结果是运行错误

a[0] ##单个数,代表位数,第0位就是a里面的第一位，切割一位

15.下面的程序当输入是 c d e a时，输出是 a c d e。F

a = input().split(" ")['', 'c', 'd', 'e', 'a']

for i in a.sort():

print(i,end=" ") 下一个print接着上一个在同一行输出

list.sort( key, reverse )，返回None，默认升序list1.sort(reverse=False)；

降序：list1.sort(reverse=True)，代码错了

sort()是一个列表（或可变序列）的方法，它直接对原始列表进行排序，而不会创建新的对象。它改变原始列表的顺序，并且不返回任何值（返回值为None）。sorted()是一个内置函数，接受可迭代对象作为参数，并返回一个新的已排序的列表，而不改变原始对象。

总的来说，sort()直接作用于列表本身并修改其顺序，而sorted()则返回一个新的已排序列表，不影响原始数据。

16.表达式："34" in "1234"==True 返回值是True。F

对于列表只能使用in检查单个数据是否在列表中，对于字符串，in可以检查某个字符串是否是另一个字符串的一部分，结果是bool值

#这个是先运算运算优先级 == 高于in '1234' == True ，这个结果为 False，然后再运算 '34' in False，所以结果是False

print( '34' in '1234' == True )

##这个是先运算括号里面的内容，为True，然后再运算 True == True，结果还是 True

print( ( '34' in '1234' ) == True )

17.下面程序输出是yes。F

lst=["1","2","3","4","5"]

s1=""

for c in lst:

s1=s1+c+" "

s2=" ".join(lst)

if s1==s2:

print("yes")

else:

print("no")

s1 = 1 2 3 4 5 (有空格)

s2 = 1 2 3 4 5（无空格）

. join()：将序列（也就是字符串、元组、列表、字典）中的元素以指定的字符连接生成一个新的字符

+可实现：数字相加，字符串拼接，列表合并，元组合并，字典合并

18. "12 "*3==" ".join(["12","12","12"]) 的输出是True。F

19. 语句print("输出结果是{:8s}".format("this"))的输出是：输出结果是 □□□□this。□表示空格。F

同第二章第七题,s表示是字符串，四个□□□□在this右边

20.语句print("输出结果是{:8d}".format(1234))的输出是：输出结果是 1234□□□□。 □表示空格。F

d表示是整数，数字默认右对齐

21.语句print("输出结果是{:08.2f}".format(14.345))的输出是：输出结果是00014.34。F 00014.35

f表示是浮点数0 表示填充空白处的字符是0。8 表示总字符宽度是8，包括小数点和小数部分。 .2f 表示保留两位小数。

22.[1,2,[3]]+[4,5]的结果是[1,2,3,4,5]。F

[1, 2, [3], 4, 5] 序列加法p59 连接2个序列并保持原有顺序不变

23. [4,5]*3的结果是[[4,5],[4,5],[4,5]]。F

[4, 5, 4, 5, 4, 5] 列表乘法的操作为重复列表元素

24.下面程序的输出是字符a。F

c="A"

print(c.lower)# lower()函数写错了

牢记各函数

三、单选题

1. max((3, 5, 1, 7, 4))的结果是D.7

2.以下哪句打印出smith\exam1\test.txt？

B.print("smith\\exam1\\test.txt") 转义字符

3. list("abcd")的结果是? A.['a', 'b', 'c', 'd']

4.如果list1 = [1, 2, 3, 4, 5, 4, 3, 2, 1]，那么以下那个是list1[:-1]？C.[1, 2, 3, 4, 5, 4, 3, 2]

5.要把5加到列表lst的末尾，用的是B.lst.append(5)

四、填空题

1. '23'*3的结果是232323

2. len('3//11//2018'.split('/'))的结果是5

['3', '', '11', '', '2018']

3. lst=[3,4,5,6,5,4,3],执行lst.remove(3)后，lst[0]的值是：

lst.remove(value)删除值为value的第一个元素,只删除首次出现的值

4. list(range(2,12,2))[:-2].pop()的结果是：

lst.pop(index)返回并删除下标为index的元素，默认是最后一个元素

1. list(range(2, 12, 2))创建了一个列表[2, 4, 6, 8, 10]。这是一个从 2 开始、以步长为2递增到12的列表。

2. [:-2] 从这个列表中排除了最后两个元素，因此现在列表变为 [2, 4, 6]。

3. pop() 方法弹出并返回列表的最后一个元素，即 6。

因此，list(range(2, 12, 2))[:-2].pop() 的结果是 6。

5.要想得到[0,100]范围内的随机数，random.randint(0,n)里的n应该是：100

random库书77 random.randint(a,b)返回一个介于[a,b]的随机整数

random.uniform(a,b)返回一个介于[a,b]的浮点数

6. print("{1}+{0}={2}".format(2,3,2+3))的输出是3+2=5

7. a=34

b=23

print("{first}-{second}={0}".format(34-23,first=a,second=b))

上面程序输出是34-23=11

8. print("{:>08s}".format(bin(31)[2:]))的输出是00011111

print(bin(31))
print(bin(31)[2:])

0b11111

11111

9. print("programming".find("r",2))的输出是4

在字符串中找到子串所在位置，不存在返回-1，str.find(str,beg=0,end=len(string))

10. print("programming".find("x"))的输出是-1

11. print("a123".isdigit())的输出是False

isdigit() 判断单个字符是否为数字；判断字符串中是否仅含有数字

12. print("aABC".isalpha())的输出是 True

isalpha() 可以判断「字符串」是否只包含「字母」；字符串的所有字符都是字母返

True否则返回False

13. print("□□□xyz□□".strip(),"□□□xyz□□".rstrip(),
"□□□xyz□□".lstrip())的输出是xyz□□□□xyz□xyz□□

内置函数strip，rstrip，lstrip的使用

‘xyz xyz xyz ’

14. a=[1,2,3,4]

b=a

print(id(a)==id(b))

c=a.copy()

print(id(a)==id(c))

d=a[:]

print(id(a)==id(d))

上面程序的输出依次分别是True False False

• b = a：这里将列表 b 指向了和列表 a 相同的内存地址，因此 id(a)==id(b) 会返回 True，因为它们指向同一个对象。

• c = a.copy()：使用 copy() 方法创建了列表 c 的副本，它包含了和列表 a 相同的元素，但在内存中却是不同的对象。因此 id(a)==id(c) 会返回 False，因为它们指向不同的对象。

• d = a[:]：通过切片操作创建了列表 d 的副本，和 a 的元素相同但在内存中是不同的对象。所以 id(a)==id(d) 会返回 False，因为它们指向不同的对象。

15.列表加元组可以表示二维表。

下面程序用三种不同方式打印表格内容，请填空完成与第一种方式输出一样的后面两种方式，不要加无用空格。

students=[(3180102988,"褚好"),

(3170102465,"王凯亮"),

(3160104下面程序输出值是1。6,"李永"),

(3171104169,"陈鑫"),

(318400429,"徐杭诚")]

for row in students: #按行存取

print(row[0],row[1])

print()

在这个代码片段中，通过 for row in students: 这行代码，每次循环迭代都会将 students 列表中的一个元组赋值给变量 row。这里的 row 实际上代表了列表中的每个元组。然后，通过 row[0] 和 row[1]，可以分别访问每个元组中的学号和姓名。

for id,name in students: #按行拆包存取

print( id,name )

print()

直接将元组或列表中的项分别直接赋值给不同的变量

for index in range(len(students)): #按索引存取

print( students[index][0],students[index][1] )

print()

16. print(sum((1,3,5,7,9))/len((1,3,5,7,9)))的输出是5.0

17.下面程序的输出是2

t=1

t,a=2,t+1 #就是解包赋值操作

print(a)

五、编程题

7-1 大于身高的平均值

a_height = list(map(int,input().split()))
avg = sum(a_height) / len(a_height)
for i in a_height:
    if i > avg:
        print("{} ".format(i),end='')

7-2 输出字母在字符串中位置索引

strip_l = list(input())
a,b = input().split()  #本质上也是拆包
c = len(strip_l)
# 序列倒序
for i in strip_l[::-1]:
    c = c - 1
    if c < 0:
        break
    # i == 's' or i == 'p' 错一半
    if i == a or i == b:
        print("{0} {1}".format(c,i))

7-3 求整数的位数及各位数字之和

# num = list(input())
N_num = list(map(int,list(input())))
Count = len(N_num)
Result = sum(N_num)
print(Count,Result)

7-4 字符替换

a = input()
n =''
for i in a:
    num = ord(i)
    if 65 <= num <= 90:
        # 加号有很多功能，可以实现字符串拼接
        # 注意155的含义
        n += chr(155-num)
    else:
        n += i
print(n)

7-5 删除字符

a = input()
c = input()
a = a.strip()
c = c.strip()
new = ''
for i in a:
    if i != c.upper and i != c.lower():
        new += i
    else:
        new += ''
print("result: {}".format(new))

7-6 输出10个不重复的英文字母

a = input()
a = a.replace(' ','')#把字符中的空格换成空
n = ''
for i in a:
    if i.isalpha(): #判断是否为字母
        if i.lower() not in n.lower(): #换成小写判断无重复
            n += i
if len(n) < 10:
    print("not found")
else:
    print(n[:10])

7-7 逆序的三位数

a = input()
b = a[::-1]
b = int(b) #007转换为整型7
print(b)

7-8 判断两个字符串是否为变位词

a = list(input())
b = list(input())
# a = sorted(a)
# b = sorted(b)
a.sort()
b.sort()
if a == b:
    print('yes')
else:
    print('no')

7-9 输入字符串，排序后输出最大字符及该字符在原字符串中的索引

a = list(input())
b = sorted(a)
m = 0
for i in range(0,len(a)):
    if a[i] == b[-1]:
        m = i
print("{}   {}".format(b[-1],m))

7-10 计算有n个字符串中最长的字符串长度

n = int(input())
sum = []
for i in range(0,n):
    s = input()
    s = s.strip()
    length = len(s)
    sum.append(length) #没有返回值
sum.sort()
print("length={}".format(sum[-1]))

7-11 位1的个数

n = bin(int(input()))
count = 0
for i in n:
    if i == '1':
        count += 1
print(count)

7-12 整数的二进制相加

x = int(input())
y = int(input())
#利用格式化输出
print("{:0>8b}".format(x))
print("{:0>8b}".format(y))
print('--------')
print("{:0>8b}".format(x+y))

7-13 汉明距离

x, y = map(int, input().split())
# 将整数转换为二进制字符串，并去除开头的'0b'
binary_x = bin(x)[2:]
binary_y = bin(y)[2:]

# 计算两个二进制数的长度
len_x = len(binary_x)
len_y = len(binary_y)

# 将两个二进制数左边补0补齐至相同的长度
if len_x < len_y:
    binary_x = '0' * (len_y - len_x) + binary_x
else:
    binary_y = '0' * (len_x - len_y) + binary_y
# print(list(bit_x != bit_y for bit_x, bit_y in zip(binary_x, binary_y)))
# 统计不同位的个数 又是解包 得到 bool值的迭代器
count = sum(bit_x != bit_y for bit_x, bit_y in zip(binary_x, binary_y))
print(count)

7-14 判断回文字符串

s = input()
s1 = ''.join([i for i in s if i.isalnum()])
s1 = s1.lower()
if s1 == s1[::-1]:
    print('yes')
else:
    print('no')

7-15 输入一行字符串，并将它转换成10进制数输出

s = input()
s1 = ''.join([i for i in s if '1'<=i<='9' or 'a'<=i.lower()<='f'])
print(s1)
print("{}".format(int(s1,16)))

7-16 统计满足特定条件的字符数

a = input()
b = input()
sum = 0
for i in a:
    if i in b:
        sum += 1
print(sum)

7-17 查验身份证

n = int(input())
ques = []
weights = [7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2]
test = [1, 0, 'X', 9, 8, 7, 6, 5, 4, 3, 2]

for i in range(n):
    id = input()
    # 检查前17位是不是数字！！！id[:-1] 不包括最后一个数
    if not id[:-1].isdigit():
        ques.append(id)
        continue
    #判断全是数字但是校验码错误的id,对切片理解错了，哭死，加权也是加的前17位
    id_numbers = list(map(int,id[:-1]))
    # 元组解包赋值再使用sum函数求值操作
    weighted_sum = sum(id_num * weighte for id_num, weighte in zip(id_numbers, weights))
    z = weighted_sum % 11
    if str(test[z]) != id[-1]:
        ques.append(id)

if ques == []:
    print('All passed')
else:
    for i in ques:
        print(i)