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

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

一、判断题

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 大于身高的平均值

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

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

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

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

1. # num = list(input())
2. N_num = list(map(int,list(input())))
3. Count = len(N_num)
4. Result = sum(N_num)
5. print(Count,Result)

7-4 字符替换

1. a = input()
2. n =''
3. for i in a:
4. num = ord(i)
5. if 65 <= num <= 90:
6. # 加号有很多功能，可以实现字符串拼接
7. # 注意155的含义
8. n += chr(155-num)
9. else:
10. n += i
11. print(n)

7-5 删除字符

1. a = input()
2. c = input()
3. a = a.strip()
4. c = c.strip()
5. new = ''
6. for i in a:
7. if i != c.upper and i != c.lower():
8. new += i
9. else:
10. new += ''
11. print("result: {}".format(new))

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

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

7-7 逆序的三位数

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

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

1. a = list(input())
2. b = list(input())
3. # a = sorted(a)
4. # b = sorted(b)
5. a.sort()
6. b.sort()
7. if a == b:
8. print('yes')
9. else:
10. print('no')

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

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

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

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

7-11 位1的个数

1. n = bin(int(input()))
2. count = 0
3. for i in n:
4. if i == '1':
5. count += 1
6. print(count)

7-12 整数的二进制相加

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

7-13 汉明距离

1. x, y = map(int, input().split())
2. # 将整数转换为二进制字符串，并去除开头的'0b'
3. binary_x = bin(x)[2:]
4. binary_y = bin(y)[2:]
6. # 计算两个二进制数的长度
7. len_x = len(binary_x)
8. len_y = len(binary_y)
10. # 将两个二进制数左边补0补齐至相同的长度
11. if len_x < len_y:
12. binary_x = '0' * (len_y - len_x) + binary_x
13. else:
14. binary_y = '0' * (len_x - len_y) + binary_y
15. # print(list(bit_x != bit_y for bit_x, bit_y in zip(binary_x, binary_y)))
16. # 统计不同位的个数 又是解包 得到 bool值的迭代器
17. count = sum(bit_x != bit_y for bit_x, bit_y in zip(binary_x, binary_y))
18. print(count)

7-14 判断回文字符串

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

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

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

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

1. a = input()
2. b = input()
3. sum = 0
4. for i in a:
5. if i in b:
6. sum += 1
7. print(sum)

7-17 查验身份证

1. n = int(input())
2. ques = []
3. weights = [7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2]
4. test = [1, 0, 'X', 9, 8, 7, 6, 5, 4, 3, 2]
6. for i in range(n):
7. id = input()
8. # 检查前17位是不是数字！！！id[:-1] 不包括最后一个数
9. if not id[:-1].isdigit():
10. ques.append(id)
11. continue
12. #判断全是数字但是校验码错误的id,对切片理解错了，哭死，加权也是加的前17位
13. id_numbers = list(map(int,id[:-1]))
14. # 元组解包赋值再使用sum函数求值操作
15. weighted_sum = sum(id_num * weighte for id_num, weighte in zip(id_numbers, weights))
16. z = weighted_sum % 11
17. if str(test[z]) != id[-1]:
18. ques.append(id)
20. if ques == []:
21. print('All passed')
22. else:
23. for i in ques:
24. print(i)