小甲鱼——元组字符串错题本

我先成为我自己

墨衍会员 · AI 创作全网分发码龄3年

关注

原创最新推荐文章于 2026-10-11 14:12:23 发布 1.1k 阅读 AI 写同款· GEO 优化 ›

Python 小甲鱼课后习题第27讲：字符串（Ⅰ）-最新版本篇博客包括小甲鱼课后习题为个人整理的易错题，仅供参考奥~ 阅读详情

概念题

1. 请写出仅有一个元素 5 的元组。}]

5, 或者 (5,)=(-bw>,0O'
({@lxUp)'2u#KPM"b9?jd!i
解析：不要写成 (5)，因为这样表示的是整数 5。

2,用一个专业的名词描述以下代码的行为？

script, first, second, third = argv

解包。版权属于
;+j8m!]* cx|W<fh#~Ya)g23
解析：将赋值号右边变量的多个值拆分给（赋值号）左边各个变量的行为，我们称之为解包。8"

3.如何修改一个元组Dt)9ldw!
FVw;bX?C"ydAM_Rvx9e$6[
答：创建一个新的元组，并赋值给同个变量。

4.有一天，居委会的大妈找上门，让你帮她用 Python 创建一个对象，用于登记接种新冠疫苗的情况。登记内容包含（姓名、生日、接种日期），你应该怎么做？Sbh@.
_DX]"z8`[QJ%9uPWF2:0Z3,@hmf

>>> checked = [("口口布", 19910220, 20210601), ("弓长飞", 19630509, 20210623), ("刘Baby", 19990520, 20210520)]

5.请问 "-520".zfill(10) 和 "-520".rjust(10, "0") 的执行结果一样吗？

不一样

>>> "-520".zfill(10)
'-000000520'
>>> "-520".rjust(10, "0")
'000000-520'

6.请问下面代码执行的结果是？

>>> "-520".center(6, "0").zfill(10)

正解：

>>> "-520".center(6, "0").zfill(10)
'00000-5200'

7.请使用一行代码来检测列表中的每个元素是否为回文数，并返回一个结果为回文数构成的列表。)h|->
8yW$,?zDHpc|1+i_S3`s9ket{b&
提供的列表：["123", "33211", "12321", "13531", "112233"]C: mv&)f
IS!_ Q.7UVPe1HWJ<t]8xo>
返回的结果：['12321', '13531']

[each for each in x if each == each[::-1]]

8.请问下面代码打印的结果是什么？

>>> str1 = "xxxxx"
>>> str1.count("xx")

count(sub[, start[, end]]) 方法是返回 sub 在字符串中不重叠的出现次数。什么叫“不重叠”呢？就是一个元素不能被重复匹配。OGt;j`?u|
还不理解的童鞋请看小甲鱼下面的图示就一目了然了。O!?pz+G5
Bcx;^hW_(#}qJ+FKEI*P-e{n98V

9.3. 请问下面代码执行的结果是 A 还是 B 抑或是 C 呢（为了你可以更容易地计数，下面使用 * 表示空格）？d"znA|OUT6
U+d9*RwhOY8'q~@?DK=IF

print(x)
print(x.expandtabs(2))
print(x.expandtabs(5))
print(x.expandtabs(10))

A：来自：

Hello****FishC
Hello**ishC
Hello*****FishC
Hello**********FishC

B：

Hello***FishC
Hello*FishC
Hello*****FishC
Hello*****FishC

C：

Hello*FishC
Hello*****FishC
Hello**********FishC

答：B。版权属于
#*j$xiIX{Qym1ORl+J6cE!-hsq
解析：是不是难以置信？是不是匪夷所思？如果是，那么说明你对制表键（tab）的理解可能不是很充分。bwD'4GPrj
"sX5k{EPy`6l2p(|rDLJ<I:aF
来，咱们一图胜千言~来自
3@aR`l-Ch_F!H5Q(MLV">z[

10.请问下面代码打印的结果是什么？BI8"0d
Qg7DE

>>> "I love FishC.com".translate(str.maketrans("love", "1234", "love"))

NxaF&PsSZ0!B+9(U~4i]n"X%`

答：'I FishC.cm'K<IxS4)%D
.A'uTr~z<c?$jBG|1WVMgm4o
解析：嗯，这道题要考的是，str.maketrans() 方法是先执行替换还是先执行忽略操作。事实证明，如果传入了第 3 个参数，那么它是先忽略掉 'l'、'o'、'v'、'e' 4 个字符，然后再执行替换操作。xam[j

请问下面代码执行的结果是？

>>> x = "我爱Pyhon"
>>> x.startswith(["你", "我", "她"])

isdecimal()、isdigit() 和 isnumeric() 这 3 个方法都是判断数字的，那么请问这其中哪一个方法 “最严格”，哪一个又是 “最宽松” 的呢？yXLv)DpP=#
F+y`bf:r,?6$Y5%9ZOk;nT^d
答：isdecimal() 方法是最严格的，只有真正意义上的数字才能得到 True；isnumeric() 方法是最宽松的，罗马数字、中文数字都不在话下。1Tn{9|H
5z]@U0{.`cIA:M3}d=8T!(oGeHSLR
解析：一般都是用于判断输入是否合法，能否进行下一步的运算，所以 isdecimal() 方法最严谨，使用的频率也相对会更多一些。

请使用一行代码判断 s 字符串中，是否所有字符都是英文字母？-1{~9J,.n`
6xq2A#k'5!(;nvIpw)Q+f?9>_yjB<
答：x.isalpha() and x.isascii()=SDq 3%
M
解析：请看上一题的解析，由于 isalpha() 方法判断的字母是 Unicode 编码中定义的字母，所以像 "FishC小甲鱼" 这样的字符串它也会返回 True，显然不符合题意。8LZ`eKF

因此，我们要进一步判断它是否为 ASCII 编码

请问下面代码打印的内容是什么？

"www.ilovefishc.com".removeprefix("w.")

>>> "www.ilovefishc.com".lstrip("wcom.")
'ilovefishc.com'
>>> "www.ilovefishc.com".rstrip("wcom.")
'www.ilovefish'
>>> "www.ilovefishc.com".strip("wcom.")
'ilovefish'

请问下面的代码打印什么内容

>>> "www.ilovefishc.com".removeprefix("w.")

>>> "www.ilovefishc.com".removeprefix("w.")
'www.ilovefishc.com'

split() 方法常常被应用于对数据的解析处理，那么考考大家，如果要从字符串 "https://ilovefishc.com/html5/index.html" 中提取出 "ilovefishc.com"，使用 split() 方法应该如何实现呢？

>>> "https://ilovefishc.com/html5/index.html".split('//')[1].split('/')[0]
'ilovefishc.com'

>>> "https://ilovefishc.com/html5/index.html".split('//')
['https:', 'ilovefishc.com/html5/index.html']
>>> "https://ilovefishc.com/html5/index.html".split('//')[1]
'ilovefishc.com/html5/index.html'
>>> "https://ilovefishc.com/html5/index.html".split('//')[1].split('/')
['ilovefishc.com', 'html5', 'index.html']
>>> "https://ilovefishc.com/html5/index.html".split('//')[1].split('/')[0]
'ilovefishc.com'

plain = list(input("请输入需要加密的明文（只支持英文字母）："))
key = int(input("请输入移动的位数："))

base_A = ord('A')
base_a = ord('a')

cipher = []
for each in plain:
if each == ' ':
cipher.append(' ')
else:
if each.isupper():
base = base_A
else:
base = base_a
cipher.append(chr((ord(each) - base + key) % 26 + base))

print(''.join(cipher))

>>> s = "I" + " " + "love" + " " + "FishC"
>>> s
'I love FishC'

>>> s = " ".join(["I", "love", "FishC"])
>>> s
'I love FishC'

请问下面代码会返回什么内容

>>> "我叫{name}，我爱{0}。喜爱{0}的人，运气都不会太差^o^".format(name="小甲鱼", "python")

报错

是使用关键字进行索引的话，它必须放在位置索引的后面，否则就会报错

请问下面的代码会打印什么内容

>>> "{{0}}".format(1)

>>> "{{0}}".format(1)
'{0}'

在花括号外边套一层花括号，外层是对内层起到“注释“的作用。U
up
所谓”注释“，就是剥夺了花括号的特殊功能，使它变会一个正经的字符串。

动手题

1.请编写代码，测试一下到底是创建列表的速度快，还是创建元组的速度快？为了得到更精准的数据，请重复测试 100 次，并分别计算出平均时间。

import timeit
    
t_speed = timeit.repeat('t = (1, 2, 3, 4, 5)', repeat=100)
l_speed = timeit.repeat('l = [1, 2, 3, 4, 5]', repeat=100)
    
# 统计生成元组的平均时间
t_sum = 0
for each in t_speed:
    t_sum = t_sum + each
    
t_average = t_sum / len(t_speed)
    
# 统计生成列表的平均时间
l_sum = 0
for each in l_speed:
    l_sum = l_sum + each

l_average = l_sum / len(l_speed)
    
print("创建元组的平均时间是：", t_average)
print("创建列表的平均时间是：", l_average)

2.请按照以下规则整理一个给定的字符串 s。s.yhkq
m>2G=`rz9ZPK#JX}*S-']
一个整理好的字符串中，两个相邻字符 s[j] 和 s[j+1]，其中 0 <= j <= s.length - 2，要满足如下条件：G>j)"I
A#2N(']*=yl<pe5!D[9Gr)Z:~,CP

若 s[j] 是小写字符，则 s[j+1] 不可以是相同的大写字符
若 s[j] 是大写字符，则 s[j+1] 不可以是相同的小写字符
如果 s[j] 和 s[j+1] 满足以上两个条件，则将它们一并删除

举例：

整理前："FishCcCode"来自
整理后："FishCcCode" -> "FishCode")f|_

整理前："AbBaACc"Powered b
整理后："AbBaACc" -> "AaACc" -> "AaA" -> "A"3KqO<jLb
cz
整理前："AABaAbCc"P
整理后："AABaAbCc" -> "AABbCc" -> "AACc" -> "AA"USC`c~IiE

请按要求整理好字符串，并将结果打印到屏幕上

s = input("请输入一个字符串：")
    
res = []
for each in s:
    if res and res[-1].lower() == each.lower() and res[-1] != each:
        res.pop()
    else:
        res.append(each)
    
for each in res:
    print(each, end='')

解析：这里比较难理解的应该是判断部分，它是先判断列表是否为空；如果不为空，则将列表中最后一个元素（即上一轮迭代放进去的字符）拿出来比对，大家都转换成小写，如果一样，那么说明它是同一个字母（此时可能是一个大写一个小写，两个都是大写，或者两个都是小写 3 种可能性）；最后判断如果两者不相同，则说明是同一个字母的大小写。

3.给定的字符串 s 是按照如下规则存放的：它的偶数下标为小写英文字母，奇数下标为正整数。|]
题目要求：编写代码，将奇数下标的数字转换为相对于上一个字母偏移后的字母。:N{ry
q
比如 s = "a1b2c3" 转换后的结果是 "abbdcf"（a1 -> ab，b2 -> bd，c3 -> cf）；s = "x7y8z9" 转换后的结果是 "xeygzi"（遇到最后字母 z ，则从 a 继续计算偏移）

s = input("请按规则输入一个字符串：")
    
length = len(s)
res = []
# 获取字母 a 的编码值
base = ord('a')
    
# 从第一个元素开始，每次迭代跳过一个元素
for i in range(0, length, 2):
    # ord(s[i]) - base 操作得到一个字母的偏移值，比如 b 就是 1
    # 跟 26 求余数的作用是防止溢出，循环计算偏移
    shift = chr((ord(s[i]) - base + int(s[i+1])) % 26 + base)
    print(s[i]+shift, end="")

4.用户输入两个版本号 v1 和 v2，请编写代码比较它们，找出较新的版本。-H=7>j`I%]
S^vKDIFb6E?g|py8+oA<7">

科普：

版本号是由一个或多个修订号组成，各个修订号之间由点号（.）连接，每个修订号由多位数字组成，例如 1.2.33 和 0.0.11 都是有效的版本号。

从左到右的顺序依次比较它们的修订号，点号（.）左侧的值要比右侧的权重大，即 0.1 要比 0.0.99 大。

程序实现如下（请务必确保实现截图效果）：|wF[ik
p'%BC0h(Z^MlaPbm<TJr@?kx-}:*

v1 = input("请输入第一个版本号，v1 = ")
v2 = input("请输入第二个版本号，v2 = ")
    
n, m = len(v1), len(v2)
i, j = 0, 0
    
while i < n or j < m:
    x = 0
    while i < n and v1[i] != '.':
        x = x * 10 + int(v1[i])
        i += 1
    i += 1
    y = 0
    while j < m and v2[j] != '.':
        y = y * 10 + int(v2[j])
        j += 1
    j += 1
    if x > y:
        print("v1")
        break
    elif x < y:
        print("v2")
        break
    
if x == y:
    print("v1 = v2")

5.编写一个加密程序，其实现原理是通过替换指定的字符进行加密，附加要求是实现密文逆向检测。I:|.2L(}bJ
bh]")<P>=eYxZ`*k+H@fo3QJ4{n2z^
程序实现如下（请务必确保实现截图效果）：7]v2j`>[h
admof`sS~5-uXc2B)3zT

plain = input("请输入需要加密的明文：")
x = input("请输入需要替换的字符：")
y = input("请输入将要替换的字符：")
    
# 加密的代码
if len(x) != len(y):
    print("需要替换的字符数量必须跟将要替换的字符数量一致！")
else:
    cipher = plain.translate(str.maketrans(x, y))
    print("加密后的密文是：" + cipher)
    
# 检测冲突的代码
# flag 变量标志是否退出检测（只要找到一个冲突，就可以直接退出）
flag = 0
    
# 如果 x 中存在相同的字符，那么 y 对应下标的字符也应该是相同的
for each in x:
    if x.count(each) > 1 and flag == 0:
        i = x.find(each)
        last = y[i]
        while i != -1:
            if last != y[i]:
                print("由于替换字符出现冲突，该密文无法解密！")
                flag = -1
                break
    
            i = x.find(each, i+1)
    
# 如果 y 中存在相同的字符，那么 x 对应下标的字符也应该是相同的
for each in y:
    if y.count(each) > 1 and flag == 0:
        i = y.find(each)
        last = x[i]
        while i != -1:
            if last != x[i]:
                print("由于替换字符出现冲突，该密文无法解密！")
                flag = -1
                break
    
            i = y.find(each, i+1)

0. 给定一个字符串 text 和字符串列表 words，返回 words 中每个单词在 text 中的位置（要求最终的位置从小到大进行排序）。namyC&?~0
N^PC1I7;@z%v&s`.m"a'~YUDg[d(y
举例：版
PWi6=L8}Nav[%4g?R)!mu
text："I love FishC and FishC love me"([S!1{Mu5n
words："FishC"Powered
输出：[[7, 11], [17, 21]]vpZVO=
W(]ji| pwZ#Ka`t:0I@"+nX?z
text："I love FishC and FishC love me"%!A8<m."
words："FishC love"Powe
输出：[[2, 5], [7, 11], [17, 21], [23, 26]]g?Jtod7
IMP@4:29txf'6v7-neCRl("ZEU
text："FCFCF"Powere
words："FCF FC"Powered
输出：[[0, 1], [0, 2], [2, 3], [2, 4]]Dr ?Cu
&+qz ?5LaGv![0^RO*p;>nk)ViEN
程序实现如下：版权属于

text = input("请输入text的内容：")
words = input("请输入words的内容：")
words = words.split()
    
result = []
for each in words:
    temp = text.find(each)
    while temp != -1:
        result.append([temp,temp+len(each)-1])
        temp = text.find(each, temp+1)
    
print(sorted(result))

1. 编写一个程序，判断输入的字符串是否由多个子字符串重复多次构成。)Nx@K
@'&x3O%Rj$#"EY4JV_5Kczm2rwMA9
举例：
oVI*0xqM='^Qj
输入："FCFC"
输出：TruePo

输入："FishCFish"来
输出：False

输入："FCCF"
输出：FalseP
输入："FishCFishc"Powere
^HA%&"d8oc49 @q;NMCYEuV`#Ij
程序实现如下：来

s = input("请输入一个由字母构成的字符串：")
    
n = len(s)
for i in range(1, n//2+1):
    # 如果子字符串的长度为i，则n必须可以被i整除才行
    if n % i == 0:
        # 如果子字符串的长度为i，则i到i*2之间是一个重复的子字符串
        if s.startswith(s[i:i*2]) and s.count(s[i:i*2]) == n/i:
            print(True)
            break
# for...else的用法，小甲鱼希望大家还没有忘记哦^o^
else:
    print(False)

0. 编写一个生成凯撒密码的程序来自：https://fishc.com.cn
toYkF7s}{9RiUmQecpGWDa@J_v#(V

科普：

凯撒密码最早由古罗马军事统帅盖乌斯·尤利乌斯·凯撒在军队中用来传递加密信息，故称凯撒密码。

原理：版权
凯撒密码是一种通过位移加密的方法，对 26 个（大小写）字母进行位移加密，比如下方是正向位移 6 位的字母对比表：}ZfMu,g
&CfcOpLN|k<"7JE;j 3:nI_}
明文字母表如下Po
E 3`MSZh:s5n>L4(2],KG_C
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzN05W+x>:cn

密文字母表如下版权属于
GHIJKLMNOPQRSTUVWXYZABCDEFghijklmnopqrstuvwxyzabcdef5Agqd;2Hvy
oZg0FNKO`;{I8.,ltAf+JB5j#"^E_v
所以，如果给定加密的明文是：版权属于
I love FishC?#WpsLfK.0
7
那么程序加密后输出的密文便是：来自
O rubk LoynI&Hb;q%

程序实现如下：Pow

plain = list(input("请输入需要加密的明文（只支持英文字母）："))
key = int(input("请输入移动的位数："))
    
base_A = ord('A')
base_a = ord('a')
    
cipher = []
for each in plain:
    if each == ' ':
        cipher.append(' ')
    else:
        if each.isupper():
            base = base_A
        else:
            base = base_a
        cipher.append(chr((ord(each) - base + key) % 26 + base))
    
print(''.join(cipher))

. 给定一个字符串数组 words，只返回可以使用在美式键盘同一行的字母打印出来的单词，键盘布局如下图所示。nc|F
=

WjD+)_^es%[iY!;8"J0Mw]5,d
美式键盘中：
[|]!l_G8g-#(R*HcSi'Y@C$7.N:j

第一行由字符 "qwertyuiop" 组成
第二行由字符 "asdfghjkl" 组成
第三行由字符 "zxcvbnm" 组成

举例：
~S'!p9|YtG*)Uf^(T 7=Nv`M0+-iH]
输入：words = ["Twitter", "TOTO", "FishC", "Python", "ASL"])n~CxAJuP8
K
输出：['Twitter', 'TOTO', 'ASL']

words = ["Twitter", "TOTO", "FishC", "Python", "ASL"]

res = []
for i in words:
    # 由于单词存在大小写，所以这里统一先转换为小写字母
    j = i.lower()
    # 灵活运用 strip() 方法，判断 j 是否所有字符都在键盘的同一行内
    if j.strip("qwertyuiop") == '' or j.strip("asdfghjkl") == '' or j.strip("zxcvbnm") == '':
        res.append(i)

print(res)

0. 请编写一个程序，统计字符串中的单词个数（“单词”以空格进行分隔）c)IU[b4
jvQhg+u2p{eE*f. H[5wDo
举例
g;hj%+c &rLyi`dGU}{,56"XP<
输入：（空字符串）
输出：0版
k?9:fZNH&E0rMuOb{Kp3S]Y6B$@X.
输入：Python
输出：1Po
3l{5)U?S%B(1fnAD!xsc
输入：I love FishC
输出：3

s = input("请输入测试字符串：")
print(len(s.split()))

1. 请编写一个程序，将用户输入的字符串重新格式化，使得字母和数字相互分隔（即一个字母一个数字相互间隔）]|>*nokX2y
zch!0}~lD4t9_TL<^,gk[E|-.S
举例：
Ru[mi}~_J%nh,z)q+c4GV*
输入：FishC1314
输出：F1i3s1h4C
+',hDcplo.U>ya?i E%SB6g
输入：FishC520P
输出：字符串中数字和字母的数量不满足重新格式化的条件T2fqeE9I{s
=(I`eloUa'K%#Ag5X"VdB74r~[
输入：Python6543210
输出：6P5y4t3h2o1n0

s = input("请输入测试字符串：")
    
str09 = []
strAZ = []
    
# 将数字和字母进行归类存放
for each in s:
    if each.isdecimal():
        str09.append(each)
    else:
        strAZ.append(each)
    
len09 = len(str09)
lenAZ = len(strAZ)
    
# 如果两个容器的元素个数相差 1 个以上，则不满足重新格式化的条件
if abs(len09 - lenAZ) > 1:
    print("字符串中数字和字母的数量不满足重新格式化的条件。")
else:
    if len09 > lenAZ:
        shorter = strAZ
        longer = str09
    else:
        shorter = str09
        longer = strAZ
    
    result = []
    for i in range(len(shorter)):
        result.append(longer[i])
        result.append(shorter[i])
    
    # 由于 longer 是有可能等于 shorter 的，就不必执行下面这一步
    if len(longer) > len(shorter):
        result.append(longer[-1])
    
    print("".join(result))

0. 相信大家对于压缩和解压缩的操作并不陌生，但对其内部的实现原理，你又知道多少呢？l4sjf{)Wo_
:n%rFO2=a9&{b!#>MK*i6
接下来请大家跟着题目的提示，一起来实现字符串的压缩和解压缩吧。Xemg9.-|
rq-kvI<2*VS 1c_5Bu:Ulw(mJ
利用字符重复出现的次数，编写一个程序，实现基本的字符串压缩功能。比如，字符串 FFiiiisshCCCCCC 压缩后变成 F2i4s2h1C6（15字符 -> 10字符，66% 压缩率）。kW@!R^(hyb
MB:;t5'CkSnFU.Ef"(wR{!8=oVvD
这种朴素的压缩算法并不总是理想的，比如 FFishCC 压缩后反而变长了 F2i1s1h1C2，这可就不是我们想要的了，所以对于重复次数小于 3 的字符，我们的程序应该选择不对其进行压缩。 2S4!?
7] plb.S9{125ex?}8(@ZNJ6g#<wu
好了，大家开始写代码吧~版权
程序实现如图所示：Power