Python编程与正则表达式实战

47、给定一个能正常工作的

uses_only

函数，该函数用于判断一个字符串

word

是否只由另一个字符串

available

中的字符组成。编写一个调用

uses_only

的

uses_all

函数，

uses_all

函数用于判断一个字符串

word

是否包含另一个字符串

required

中的所有字符。

def uses_only(word, available):
    for letter in word:
        if letter not in available:
            return False
    return True

def uses_all(word, required):
    return uses_only(required, word)

48、Python正则表达式中最常用的特殊字符有哪些？

在Python正则表达式中，最常见的特殊字符及其作用如下：

.

：匹配除换行符以外的任意单个字符。例如，

r'a.b'

可以匹配 ‘aab’、’acb’ 等，但不能匹配 ‘ab’。

^

：匹配字符串的开头。例如，

r'^Hello'

可以匹配以 ‘Hello’ 开头的字符串。

$

：匹配字符串的结尾。例如，

r'World$'

可以匹配以 ‘World’ 结尾的字符串。

*

：匹配前面的子表达式零次或多次。例如，

r'ab*'

可以匹配 ‘a’、’ab’、’abb’ 等。

+

：匹配前面的子表达式一次或多次。例如，

r'ab+'

可以匹配 ‘ab’、’abb’ 等，但不能匹配 ‘a’。

?

：匹配前面的子表达式零次或一次。例如，

r'ab?'

可以匹配 ‘a’ 或 ‘ab’。

{m}

：匹配前面的子表达式恰好 m 次。例如，

r'a{3}'

可以匹配 ‘aaa’。

{m,n}

：匹配前面的子表达式至少 m 次，至多 n 次。例如，

r'a{2,4}'

可以匹配 ‘aa’、’aaa’、’aaaa’。

[]

：用于定义字符类，匹配方括号中指定的任意一个字符。例如，

r'[aeiou]'

可以匹配任意一个元音字母。

|

：表示或的关系，匹配两个或多个表达式中的任意一个。例如，

r'cat|dog'

可以匹配 ‘cat’ 或 ‘dog’。

：转义字符，用于将特殊字符转义为普通字符。例如，

r'.'

可以匹配实际的点号。

d

：匹配任意一个数字，等价于

[0-9]

。

D

：匹配任意一个非数字字符，等价于

[^0-9]

。

s

：匹配任意一个空白字符，包括空格、制表符、换行符等。

S

：匹配任意一个非空白字符。

w

：匹配任意一个字母、数字或下划线，等价于

[a-zA-Z0-9_]

。

W

：匹配任意一个非字母、数字或下划线的字符，等价于

[^a-zA-Z0-9_]

。

49、编写一个Python正则表达式，用于匹配带连字符的10位电话号码。

在Python中，可以使用

re

模块来编写正则表达式匹配带连字符的10位电话号码。以下是示例代码：

import re
pattern = r'^d{3}-d{3}-d{4}$'
phone_number = '123-456-7890'
if re.match(pattern, phone_number):
    print('匹配成功')
else:
    print('匹配失败')

在上述代码中，正则表达式

^d{3}-d{3}-d{4}$

的含义如下：

^

：表示字符串的开始。

d{3}

：匹配3个数字。

-

：匹配连字符。

$

：表示字符串的结束。

所以该正则表达式可以精确匹配格式为

XXX-XXX-XXXX

的10位带连字符的电话号码。

50、编写一个Python正则表达式，用于匹配包含数字和街道名称，后面跟着ST或AVE的街道地址。

可以使用如下正则表达式：

r'd+ [A-Za-z]+ (ST|AVE)'

。

解释：

d+

匹配一个或多个数字，代表街道地址中的门牌号；

[A-Za-z]+

匹配一个或多个字母，代表街道名称；

(ST|AVE)

是一个分组，使用

|

表示或的关系，匹配

ST

或者

AVE

。

示例代码如下：

import re

pattern = r'd+ [A-Za-z]+ (ST|AVE)'
address1 = '123 Main ST'
address2 = '456 Elm AVE'
address3 = '789 Oak RD'

print(re.fullmatch(pattern, address1))  # 匹配成功，输出匹配对象
print(re.fullmatch(pattern, address2))  # 匹配成功，输出匹配对象
print(re.fullmatch(pattern, address3))  # 匹配失败，输出 None

51、向虚拟助手询问 ‘What is a raw string in Python?’

A raw string in Python is a string that is preceded by the letter

r

, which indicates that backslashes that appear in the string should not be considered part of a special sequence.

（Python中的原始字符串是在引号前带有字母

r

的字符串，这表明字符串中出现的反斜杠不应被视为特殊序列的一部分。）

52、假设已知猜了单词 TOTEM，并且得知字母 E 仍然不在正确的位置，但字母 M 在正确的位置。现有一个单词列表，需要找出该列表中符合此条件的单词数量，即剩下可能是目标单词的数量。

需要编写代码来解决该问题。首先要实现 `check_word` 函数，根据已知条件（字母 E 不在正确位置，字母 M 在正确位置）来检查每个单词是否符合要求，然后遍历单词列表，统计符合要求的单词数量。

以下是示例代码：

```python
# 假设这是单词列表
word_list = ['MOWER', 'TRIED', 'SPADE', 'CLERK', 'TOTEM']

def check_word(word):
    # 检查 M 是否在正确位置（第 5 个位置）
    if word[4] != 'M':
        return False

    # 检查 E 是否不在第 4 个位置
    if word[3] == 'E':
        return False

    # 检查单词中是否包含 E
    if 'E' not in word:
        return False

    return True

count = 0
for word in word_list:
    if check_word(word):
        count += 1

print(count)

上述代码中，

check_word

函数用于检查一个单词是否符合条件，然后遍历

word_list

统计符合条件的单词数量。最终输出的

count

即为剩下可能是目标单词的数量。

##53、统计单词“pale”以任何形式出现的次数，包括“pale”、“pales”、“paled”、“paleness”以及相关单词“pallor”。使用一个能匹配所有这些单词且不匹配其他单词的正则表达式。
可以使用正则表达式 `pale(s|d|ness)?|pallor` 来匹配这些单词。在Python中可以使用 `re` 模块来实现统计次数的功能，示例代码如下：

```python
import re

text = "需要统计的文本内容"
pattern = r'pale(s|d|ness)?|pallor'
matches = re.findall(pattern, text)
count = len(matches)
print(count)

将

text

替换为实际需要统计的文本，运行代码即可得到这些单词出现的总次数。

54、如果可以通过重新排列一个单词的字母来拼出另一个单词，那么这两个单词就是变位词。例如，“tops” 是 “stop” 的变位词。一种检查两个单词是否为变位词的方法是对两个单词中的字母进行排序。如果排序后的字母列表相同，则这两个单词是变位词。编写一个名为

is_anagram

的函数，该函数接受两个字符串作为参数，如果它们是变位词，则返回

True

。使用你的函数和给定的单词列表

['stake', 'skate', 'takes', 'break', 'steak']

，找出 “takes” 的所有变位词。

以下是实现

is_anagram

函数并找出 “takes” 所有变位词的 Python 代码：

# 定义 is_anagram 函数
from collections import Counter

def is_anagram(word1, word2):
    return Counter(word1) == Counter(word2)

# 假设的单词列表
word_list = ['stake', 'skate', 'takes', 'break', 'steak']

# 找出 takes 的所有变位词
anagrams_of_takes = [word for word in word_list if is_anagram(word, 'takes') and word != 'takes']

print(anagrams_of_takes)

在上述代码中，首先定义了

is_anagram

函数，使用

Counter

对象来比较两个单词的字母计数是否相同。然后，假设有一个单词列表

word_list

，通过列表推导式找出该列表中所有与 “takes” 是变位词且不等于 “takes” 本身的单词，并将结果存储在

anagrams_of_takes

列表中，最后打印出这些变位词。

55、Python提供了一个内置函数

reversed

，它接受一个元素序列（如列表或字符串）作为参数，并返回一个包含逆序元素的反转对象。回文是指一个单词正读和反读都相同，例如“noon”和“rotator”。编写一个名为

is_palindrome

的函数，该函数接受一个字符串参数，如果它是回文则返回

True

，否则返回

False

。

def reverse_word(word):
    return ''.join(reversed(word))

def is_palindrome(word):
    return reverse_word(word) == word

56、编写一个名为reverse_sentence的函数，该函数接受一个由空格分隔的任意数量单词组成的字符串作为参数。它应该返回一个新的字符串，其中包含按相反顺序排列的相同单词。例如，如果参数是“Reverse this sentence”，结果应该是“Sentence this reverse”。提示：你可以使用capitalize方法将第一个单词大写，并将其他单词转换为小写。

def reverse_sentence(sentence):
    words = sentence.split()
    reversed_words = words[::-1]
    capitalized_first = reversed_words[0].capitalize()
    lowercased_rest = [word.lower() for word in reversed_words[1:]]
    result = [capitalized_first] + lowercased_rest
    return ' '.join(result)

57、编写一个名为total_length的函数，该函数接受一个字符串列表，并返回这些字符串的总长度。

def total_length(word_list):
    return sum(len(word) for word in word_list)

58、如何从字符串列表创建Python集合，并检查某个字符串是否是该集合的元素？

在Python中，可以使用

set()

函数将字符串列表转换为集合，然后使用

in

运算符检查某个字符串是否是该集合的元素。示例代码如下：

word_list = ['apple', 'banana', 'cherry']
word_set = set(word_list)
check_string = 'banana'
if check_string in word_set:
    print(f'{check_string} 是集合的元素')
else:
    print(f'{check_string} 不是集合的元素')

在上述代码中，首先定义了一个字符串列表

word_list

，然后使用

set()

函数将其转换为集合

word_set

。接着定义了要检查的字符串

check_string

，并使用

in

运算符检查它是否是集合的元素，最后根据检查结果输出相应信息。

59、编写一个名为has_duplicates的函数，该函数接受一个序列（如列表或字符串）作为参数，如果序列中有任何元素出现不止一次，则返回True。

以下是使用集合来实现

has_duplicates

函数的Python代码：

def has_duplicates(t):
    s = set(t)
    return len(s) < len(t)

你可以使用以下方式调用这个函数进行测试：

print(has_duplicates('unpredictably')) # 测试字符串
print(has_duplicates([1, 2, 3, 4, 5])) # 测试列表

60、编写一个名为find_repeats的函数，该函数接受一个字典作为参数，该字典将每个键映射到一个计数器，就像value_counts函数的结果一样。它应该遍历字典并返回一个键的列表，这些键对应的计数值大于1。

def find_repeats(counter):
    return [key for key, value in counter.items() if value > 1]

61、假设你对两个不同的单词运行value_counts函数，并将结果保存到两个字典中。每个字典将一组字母映射到它们出现的次数。编写一个名为add_counters的函数，该函数接受两个这样的字典，并返回一个新的字典，其中包含所有字母以及它们在任意一个单词中出现的总次数。

def add_counters(dict1, dict2):
    result = dict1.copy()
    for key, value in dict2.items():
        if key in result:
            result[key] += value
        else:
            result[key] = value
    return result

62、编写一个名为is_interlocking的函数，该函数接受一个单词作为参数，如果这个单词可以拆分成两个交错的单词，则返回True，否则返回False。

def is_interlocking(word):
    first = word[0::2]
    second = word[1::2]
    # 这里假设单词可以拆分成任意两个单词，只要拆分逻辑正确就认为是交错单词
    # 简单判断拆分后的两个子串非空，更严谨的判断需要有单词列表来验证是否为有效单词
    if len(first) > 0 and len(second) > 0:
        return True
    return False

63、元组通常是可哈希的，可作为字典的键，因为它们是不可变的。但如果一个元组包含可变值，如列表或字典，那么这个元组就不再是可哈希的。例如，有一个包含两个整数列表的元组：list0 = [1, 2, 3]; list1 = [4, 5]; t = (list0, list1); t; ([1, 2, 3], [4, 5])。编写一行代码，将值6追加到t中的第二个列表的末尾。如果显示t，结果应该是([1, 2, 3], [4, 5, 6])。尝试创建一个字典，将t映射到一个字符串，并确认会得到一个TypeError。

首先，将值

6

追加到

t

中的第二个列表末尾的代码是：

t[1].append(6)

然后，尝试创建一个将

t

映射到字符串的字典，代码如下：

list0 = [1, 2, 3]
list1 = [4, 5]
t = (list0, list1)
t[1].append(6)

# 尝试创建字典并将t作为键映射到字符串
try:
    d = {t: 'example'}
except TypeError as e:
    print(f'出现TypeError: {e}')

运行上述代码，会得到一个

TypeError

，因为

t

包含可变的列表，不可哈希，不能作为字典的键。

64、编写一个名为

shift_word

的函数，该函数接受一个字符串和一个整数作为参数，并返回一个新字符串，该字符串包含原字符串中的字母按给定的位数进行移位后的结果。这里的字母移位遵循凯撒密码规则，即字母表中的每个字母按固定的位数进行移位，如果需要则循环回到字母表的开头。为了测试你的函数，请确认“cheer”移位7位后是“jolly”，“melon”移位16位后是“cubed”。

letters = 'abcdefghijklmnopqrstuvwxyz'
numbers = range(len(letters))
letter_map = dict(zip(letters, numbers))

def shift_word(word, shift):
    result = []
    for letter in word:
        if letter in letter_map:
            new_index = (letter_map[letter] + shift) % len(letters)
            new_letter = letters[new_index]
            result.append(new_letter)
        else:
            result.append(letter)
    return ''.join(result)

# 测试函数
print(shift_word('cheer', 7))  # 输出: jolly
print(shift_word('melon', 16))  # 输出: cubed

65、编写一个名为most_frequent_letters的函数，该函数接受一个字符串，并按字母出现频率的降序打印这些字母。

import collections

def most_frequent_letters(s):
    counter = collections.Counter(s)
    items = counter.items()
    sorted_items = sorted(items, key=lambda x: x[1], reverse=True)
    for letter, freq in sorted_items:
        print(letter, end=' ')

66、编写一个程序，该程序接收一个单词列表，并打印出所有变位词组。

以下是实现该功能的Python代码：

from collections import defaultdict

def find_anagram_sets(word_list):
    anagram_dict = defaultdict(list)
    for word in word_list:
        sorted_word = ''.join(sorted(word))
        anagram_dict[sorted_word].append(word)
    for anagram_list in anagram_dict.values():
        if len(anagram_list) > 1:
            print(anagram_list)

word_list = ['deltas', 'desalt', 'lasted', 'salted', 'slated', 'retainers', 'ternaries', 'generating', 'greatening', 'resmelts', 'smelters', 'termless']
find_anagram_sets(word_list)

这段代码首先创建了一个

defaultdict

，用于存储排序后的字符串及其对应的变位词列表。然后遍历单词列表，对每个单词进行排序并将其作为键，将原单词添加到对应的值列表中。最后，打印出所有长度大于1的变位词组。

67、编写一个名为 word_distance 的函数，该函数接受两个长度相同的单词，并返回这两个单词中不同字符位置的数量。

def word_distance(word1, word2):
    distance = 0
    for i in range(len(word1)):
        if word1[i] != word2[i]:
            distance += 1
    return distance