【python】随笔 - 知识点小课堂 -7.字符串

前言

本文是关于字符串的习题整理和讲解

7.1

在Python中，max() 函数用于获取可迭代对象中的最大值。对于列表对象 x=['11','2','3']，max(x) 将会返回列表中的最大元素。

需要注意的是，列表中的元素都是字符串类型，所以 max() 将会根据字符串的字典顺序来确定最大值。在字符串字典顺序中，数字字符会根据它们的字符编码来比较，而不是它们的数值大小。

对于列表 x=['11','2','3']，max(x) 的结果是 '3'，因为字符 ‘3’ 在字典顺序中排在 ‘11’ 和 ‘2’ 之后。

如果想要获取数值意义上的最大值，需要先将字符串转换为整数，然后进行比较。这可以通过列表推导式和 max() 函数结合使用来实现：

x = ['11', '2', '3']
max_value = max(int(item) for item in x)

这将返回数值上的最大值，即 11。

在这个例子中，比较过程如下：

‘2’ < ‘3’，因为字符 ‘2’ 的ASCII值小于字符 ‘3’ 的ASCII值。
‘11’ 和 ‘2’ 比较时，首先比较它们的第一位字符 ‘1’ 和 ‘2’。由于 ‘1’ 的ASCII值小于 ‘2’，所以 ‘11’ < ‘2’。
‘11’ 和 ‘3’ 比较时，首先比较它们的第一位字符 ‘1’ 和 ‘3’。由于 ‘1’ 的ASCII值小于 ‘3’，所以 ‘11’ < ‘3’。

7.2

在Python中，max() 函数可以接受一个可选的 key 参数，该参数指定一个函数，用于从可迭代对象中每个元素提取一个用于比较的值。在提供的例子中，max(x, key=len) 表示使用 len 函数作为 key 参数，即基于每个元素的长度来确定最大值。

列表 x = ['11', '2', '3'] 中的每个元素都是字符串，len 函数将会计算每个字符串的长度。比较过程将会基于字符串的长度来进行：

• ‘11’ 的长度是 2
• ‘2’ 的长度是 1
• ‘3’ 的长度是 1

由于 ‘11’ 的长度最长，所以 max(x, key=len) 的值将会是 ‘11’。即使 ‘2’ 和 ‘3’ 在字典顺序上比 ‘11’ 小，但在这个比较中，我们是基于字符串的长度，而不是它们在字典中的位置。

7.3

在Python中，'{:c}'.format(65) 这个表达式使用了格式化字符串字面量（通常称为f-string）来格式化一个整数。:c 表示格式化为字符，其中65是一个整数，它对应的ASCII字符是大写字母’A’。

因此，'{:c}'.format(65) 将会输出字符 ‘A’。

另一方面，str(65) 是将整数65转换为字符串，结果同样是 ‘65’。

比较这两个表达式：

• '{:c}'.format(65) 的结果为 ‘A’（字符）
• str(65) 的结果为 ‘65’（字符串）

由于 ‘A’ 和 ‘65’ 是不同的，所以表达式 '{:c}'.format(65) == str(65) 的值为 False。

7.4

在 Python 中，字符串的 expandtabs() 方法用来将字符串中的制表符（\t）转换为空格。默认情况下，\t 被转换成空格，直到字符串的长度达到下一个8的倍数。在例子 'abc\tdef' 中：

• 'abc' 占用了3个字符位置。
• \t 将被扩展为5个空格，以使总长度达到8（因为下一个制表位在第8个位置）。

所以 'abc\tdef' 在调用 .expandtabs(8) 后变为 'abc def'，总长度是11个字符。这就是为什么 len('abc\tdef'.expandtabs(8)) 的结果是11。

7.5

在Python中，字符串方法 .ljust(width) 用于在字符串的右侧填充空格，使得字符串的总长度达到指定的宽度。如果字符串的长度已经大于或等于指定的宽度，则返回原字符串不变。

给定的字符串 'Hello world!' 长度为12个字符（包括空格和感叹号）。调用 .ljust(20) 会在这个字符串的右侧填充空格，直到总长度达到20个字符。

因此，原始字符串 'Hello world!' 经过 .ljust(20) 处理后，会变成 'Hello world! '，其中末尾有8个空格。

len() 函数用来计算字符串的长度，包括所有的字符，但不包括字符串结束的空字符。

所以，表达式 len('Hello world!'.ljust(20)) 的值将会是填充后的字符串长度，即 12 + 8 = 20。

7.6

在Python中，字符串通过加号 + 操作符进行连接操作。表达式 'a' + 'b' 将两个字符串 'a' 和 'b' 连接在一起，形成一个新的字符串 'ab'。

因此，表达式 'a' + 'b' 的值为 'ab'。

7.7

表达式 len('字字字字字'.encode('utf-8')) 的值为 15，是因为在 UTF-8 编码中，中文字符通常会被编码为 3 个字节。在这个字符串 “字字字字字” 中，每个字符都是中文字符，共有 5 个字符。因此，每个字符编码成 3 个字节后，总共会有 15 个字节。这就是为什么 len('字字字字字'.encode('utf-8')) 返回的值是 15。

在Python中，encode(‘utf-8’)是一个字符串方法，用于将字符串转换成UTF-8编码格式的字节序列。UTF-8是一种广泛使用的字符编码方式，它能够表示Unicode标准中的任何字符，并且对ASCII字符集（即英文字符和一些符号）兼容，使用单个字节表示。

7.9

表达式 len(‘::’.join([‘a’,‘b’,‘c’])) 会首先使用两个冒号 :: 作为分隔符将列表 [‘a’, ‘b’, ‘c’] 中的字符串连接起来，形成新的字符串 ‘a:🅱️:c’。接着，len() 函数计算这个字符串的长度，因此，结果是 a:🅱️:c 中所有字符的总数，包括字母和冒号。
‘a:🅱️:c’ 总共有 7 个字符，所以 len(‘a:🅱️:c’) 的结果是 7

7.10

在这个表达式中，{:#<9d} 是一个格式化字符串，表示用#填充，左对齐，总宽度为9的形式化输出，后面的d表示整数的格式。

现在，我们要格式化的整数是666。在这个表达式中，#将用来填充空白，<表示左对齐，9表示总宽度为9。

因此，666会被放在左边，右边用#填充，总共会占据9个字符的位置。

所以，表达式'{:#<9d}'.format(666)的值为:

666######

7.11

单选题:表达式’{},{}'.format(3，5)的值为

在Python中，表达式 '{},{}'.format(3, 5) 使用了 str.format() 方法来格式化字符串。这个方法按照花括号 {} 中面的数字来引用 format() 方法中的参数，按照顺序从左到右。

在这个例子中，有两个花括号 {}，它们分别对应 format() 方法中的两个参数：3 和 5。由于没有指定任何特殊的格式化指令，参数将按照默认的字符串表示方式被插入到花括号的位置。

因此，表达式 '{},{}'.format(3, 5) 的值将把数字 3 和 5 按照它们在 format() 方法中的顺序，插入到逗号分隔的占位符中，最终得到的字符串是：

'3,5'

7.12

单选题:表达式’{1},{0}'.format(3，5)的值为
在Python的字符串格式化中，'{1},{0}'.format(3, 5) 这个表达式使用了 str.format() 方法，其中花括号 {} 内的数字表示 format() 方法中对应位置参数的索引。

在这个例子中：

• {1} 表示 format() 方法中的第二个参数，这里是数字 5。
• {0} 表示 format() 方法中的第一个参数，这里是数字 3。

因此，按照索引顺序将参数格式化到字符串中，表达式 '{1},{0}'.format(3, 5) 的值将为 '5,3'。

所以，正确答案是：

'5,3'

7.13

单选题:表达式’Beautiful is better than ugly.'.index(‘beautiful’)的值为
在Python中，字符串的 .index() 方法用于找出某一个子字符串在字符串中首次出现的索引位置。如果子字符串不在原字符串中，该方法会抛出一个 ValueError 异常。

表达式 'Beautiful is better than ugly.'.index('beautiful') 中，我们试图找出 'beautiful' 这个子字符串在字符串 'Beautiful is better than ugly.' 中的索引位置。

需要注意的是，字符串在Python中是大小写敏感的，所以 'beautiful' 和 'Beautiful' 会被视为不同的字符串。由于原字符串中的 'Beautiful' 是以大写字母开头的，而我们搜索的子字符串是以小写字母 'b' 开头的，所以 .index() 方法将无法找到匹配项，并抛出一个 ValueError。

如果意图是忽略大小写，可以使用 .lower() 或 .upper() 方法将整个字符串转换为全小写或全大写后再进行搜索。但按照原始的表达式，它会抛出一个错误，因为 'beautiful' 并不存在于原始字符串中。

如果想要找出大小写不敏感的索引，可以使用正则表达式的 re.IGNORECASE 标志，如下所示：

import re

index = re.search('beautiful', 'Beautiful is better than ugly.', re.IGNORECASE).start()

但这已经超出了原始表达式的要求，并且 .index() 方法不支持忽略大小写。

因此，根据原始表达式 'Beautiful is better than ugly.'.index('beautiful')，程序会抛出一个 ValueError，因为没有匹配项。正确答案并不是一个有效的索引值，而是一个错误。

7.14

单选题:表达式 len(‘a,b’.split(‘,’))的值为
在Python中，字符串 'a,,b' 使用 split(',') 方法进行分割时，会根据逗号,来切分字符串。默认情况下，split() 方法会将字符串分割成多个子字符串，并且会保留分割符后面的空字符串（empty strings），如果分割符之间存在空格。

字符串 'a,,b' 包含两个逗号，因此它会被分割成三个部分：

1. 'a' —— 第一个元素，位于第一个逗号前。
2. '' —— 第二个元素，两个逗号之间没有字符，因此是一个空字符串。
3. 'b' —— 第三个元素，位于第二个逗号之后。

由于 split() 方法会保留空字符串，所以表达式 len('a,,b'.split(',')) 的值是这三个部分的长度之和，即：

len(['a', '', 'b']) = 3

因此，正确答案是：

3

7.15

单选题:表达式 len(‘a\t\t\tb’.split())的值为
在Python中，str.split()方法用于将字符串分割成多个子字符串，并将它们作为列表返回。如果没有指定分隔符，则按照任何空白字符（包括空格、制表符\t、换行符\n等）作为默认分隔符。

表达式'a\t\t\tb'.split()中，字符串'a\t\t\tb'包含一个字符a，后面跟着多个制表符\t，然后是字符b。由于split()方法默认使用空白字符作为分隔符，这里的多个连续制表符被视为一个分隔点。

因此，字符串会被分割成两个子字符串：

1. 'a' —— 第一个元素，位于制表符之前。
2. 'b' —— 第二个元素，位于制表符之后。

由于只有一个分隔符（多个制表符合并为一个分隔点），所以表达式len('a\t\t\tb'.split())的结果将是这两个子字符串的长度之和，即：

len(['a', 'b']) = 2

所以，正确答案是：

2

7.16

单选题:表达式’1234’.upper()的值为
在Python中，字符串的 .upper() 方法用于将字符串中的所有小写字母转换为对应的大写字母。如果字符串中已经包含大写字母或非字母字符，这些字符将保持不变。

表达式 '1234'.upper() 中，字符串 '1234' 只包含数字，没有小写字母。因此，.upper() 方法不会对数字产生任何影响。

所以，表达式 '1234'.upper() 的值仍然是 '1234'。

正确答案是：

'1234'

7.17

单选题:表达式’ababababa’.rindex(‘aba’)的值为

在Python中，字符串的 .rindex() 方法用于从字符串的末尾开始向前查找子字符串，并返回子字符串在父字符串中最后一次出现的索引位置。

所以返回6

7.18

单选题:表达式’ababababa’.count(‘aba’)的值为

在Python中，字符串的 .count() 方法用于计算某个子字符串在字符串中出现的次数。默认情况下，这个计数是区分大小写的，并且不会重叠计数。也就是说，如果一个子字符串的一部分与前一个子字符串的结束部分重叠，它不会被计算为新的出现。

计算非重叠所以是2

7.19

单选题:表达式’{:->5.4s}'.format(‘abcdefg’)[0]的值为

在给定的表达式 '{:->5.4s}'.format('abcdefg')[0] 中：

1. {:->5.4s} 进行了字符串格式化，根据格式指示符：

   • .4s 截取给定字符串 'abcdefg' 的前 4 个字符，得到 'abcd'。（这里类比.4f）
   • >5 指示结果字符串长度为 5，右对齐。因为 'abcd' 的长度是 4，所以在左侧会填充一个 -，得到 '-abcd'。

2. 表达式的 [0] 部分尝试访问结果字符串的第一个字符。在 '-abcd' 中，第一个字符是 -。

所以，表达式 '{:->5.4s}'.format('abcdefg')[0] 的值为 -。

7.20

单选题:已知table=.maketrans(‘abc’，‘ABC’)，那么表达式dong fuguo’.translate(table)的值为

在表达式 dong fuguo'.translate(table) 中，首先创建了一个翻译表 table，这个表将小写的 ‘a’, ‘b’, ‘c’ 分别映射转换为大写的 ‘A’, ‘B’, ‘C’。

使用此翻译表对字符串 'dong fuguo' 进行转换时，该字符串中只有 ‘c’ 需要被替换，但 ‘c’ 并不存在于字符串 'dong fuguo' 中。因此，转换后的字符串不会改变，仍然是 'dong fuguo'。

所以，表达式 'dong fuguo'.translate(table) 的结果是 'dong fuguo'。

7.21 / 7.22

END