好的，以下是20道关注Python的练习题及答案解析：
1. 编写一个函数，接受一个字符串作为参数，并返回该字符串的反转字符串。
```python
def reverse_string(s):
return s[::-1]
print(reverse_string("hello world")) # 输出 "dlrow olleh"
```
解析：该函数使用 Python 的切片语法来反转字符串。`s[::-1]` 表示从字符串末尾开始，每隔一个字符取一个字符，即返回反转后的字符串。
2. 编写一个函数，接受一个列表作为参数，并返回该列表中的所有偶数。
```python
def even_numbers(lst):
return [num for num in lst if num % 2 == 0]
print(even_numbers([1, 2, 3, 4, 5, 6])) # 输出 [2, 4, 6]
```
解析：该函数使用列表推导式来筛选出列表中的所有偶数。`[num for num in lst if num % 2 == 0]` 表示遍历列表 lst，如果当前元素是偶数，则将其加入新列表中。
3. 编写一个函数，接受一个字符串作为参数，并返回该字符串中的所有数字字符。
```python
def digit_characters(s):
return [char for char in s if char.isdigit()]
print(digit_characters("hello 123 world")) # 输出 ["1", "2", "3"]
```
解析：该函数使用列表推导式来筛选出字符串中的所有数字字符。`[char for char in s if char.isdigit()]` 表示遍历字符串 s，如果当前字符是数字字符，则将其加入新列表中。
4. 编写一个函数，接受一个整数作为参数，并返回该整数是否为素数。
```python
def is_prime(n):
if n < 2:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return False
return True
print(is_prime(7)) # 输出 True
print(is_prime(12)) # 输出 False
```
解析：该函数使用试除法判断一个整数是否为素数。如果该整数小于 2，则返回 False；否则遍历 2 到该整数平方根之间的所有整数，如果该整数能被其中任意一个整数整除，则返回 False，否则返回 True。
5. 编写一个函数，接受一个字符串作为参数，并返回该字符串的所有子串。
```python
def substrings(s):
return [s[i:j] for i in range(len(s)) for j in range(i+1, len(s)+1)]
print(substrings("abc")) # 输出 ["a", "ab", "abc", "b", "bc", "c"]
```
解析：该函数使用两重循环来生成所有可能的子串。外层循环遍历字符串 s 的每个字符作为子串的起始位置，内层循环从起始位置开始遍历到字符串末尾，生成所有以该字符为起始位置的子串。
6. 编写一个函数，接受一个列表作为参数，并返回该列表的所有子列表。
```python
def sublists(lst):
return [lst[i:j] for i in range(len(lst)) for j in range(i+1, len(lst)+1)]
print(sublists([1, 2, 3])) # 输出 [[1], [1, 2], [1, 2, 3], [2], [2, 3], [3]]
```
解析：该函数使用两重循环来生成所有可能的子列表。外层循环遍历列表 lst 的每个元素作为子列表的起始位置，内层循环从起始位置开始遍历到列表末尾，生成所有以该元素为起始位置的子列表。
7. 编写一个函数，接受一个字符串作为参数，并返回该字符串中出现次数最多的字符。
```python
def most_frequent_character(s):
return max(s, key=s.count)
print(most_frequent_character("hello world")) # 输出 "l"
```
解析：该函数使用 max 函数和字符串的 count 方法来找到出现次数最多的字符。max 函数的 key 参数指定排序规则，这里使用字符串的 count 方法作为排序依据，返回出现次数最多的字符。
8. 编写一个函数，接受一个列表作为参数，并返回该列表中出现次数最多的元素。
```python
from collections import Counter
def most_frequent_element(lst):
counter = Counter(lst)
return max(counter, key=counter.get)
print(most_frequent_element([1, 2, 3, 2, 1, 3, 3])) # 输出 3
```
解析：该函数使用 collections 模块的 Counter 类来统计列表中每个元素出现的次数，然后使用 max 函数和 Counter 的 get 方法来找到出现次数最多的元素。
9. 编写一个函数，接受一个字符串作为参数，并返回该字符串中最长的回文子串。
```python
def longest_palindromic_substring(s):
n = len(s)
if n < 2:
return s
start, max_len = 0, 1
for i in range(n-1):
if s[i:i+2] == s[i:i+2][::-1]:
left, right = i, i+1
while left > 0 and right < n-1 and s[left-1] == s[right+1]:
left -= 1
right += 1
if right - left + 1 > max_len:
start = left
max_len = right - left + 1
if i < n-2 and s[i:i+3] == s[i:i+3][::-1]:
left, right = i, i+2
while left > 0 and right < n-1 and s[left-1] == s[right+1]:
left -= 1
right += 1
if right - left + 1 > max_len:
start = left
max_len = right - left + 1
return s[start:start+max_len]
print(longest_palindromic_substring("babad")) # 输出 "bab"
```
解析：该函数使用中心扩展法来找到最长的回文子串。首先遍历字符串 s 的每个字符和每两个相邻字符之间，以它们为中心向两边扩展，同时记录下最长的回文子串的起始位置和长度，最后返回该子串。
10. 编写一个函数，接受一个整数作为参数，并返回该整数的二进制表示。
```python
def decimal_to_binary(n):
return bin(n)[2:]
print(decimal_to_binary(10)) # 输出 "1010"
```
解析：该函数使用 Python 的内置函数 bin 将一个整数转换为二进制字符串，然后去掉字符串开头的 "0b"。
11. 编写一个函数，接受一个二进制字符串作为参数，并返回该字符串所表示的十进制整数。
```python
def binary_to_decimal(s):
return int(s, 2)
print(binary_to_decimal("1010")) # 输出 10
```
解析：该函数使用 Python 的内置函数 int 将一个二进制字符串转换为十进制整数，其中第二个参数指定了字符串的进制。
12. 编写一个函数，接受一个整数作为参数，并返回该整数的阶乘。
```python
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)
print(factorial(5)) # 输出 120
```
解析：该函数使用递归实现了计算阶乘的功能。如果输入为 0，则返回 1；否则返回 n 乘以 n-1 的阶乘。
13. 编写一个函数，接受一个列表作为参数，并返回该列表中的所有奇数。
```python
def odd_numbers(lst):
return [num for num in lst if num % 2 == 1]
print(odd_numbers([1, 2, 3, 4, 5, 6])) # 输出 [1, 3, 5]
```
解析：该函数使用列表推导式来筛选出列表中的所有奇数。`[num for num in lst if num % 2 == 1]` 表示遍历列表 lst，如果当前元素是奇数，则将其加入新列表中。
14. 编写一个函数，接受一个字符串作为参数，并返回该字符串中第一个不重复的字符。
```python
def first_unique_character(s):
counter = {}
for char in s:
counter[char] = counter.get(char, 0) + 1
for char in s:
if counter[char] == 1:
return char
return None
print(first_unique_character("leetcode")) # 输出 "l"
```
解析：该函数使用字典来统计字符串中每个字符出现的次数，然后再次遍历字符串，找到第一个出现次数为 1 的字符。
15. 编写一个函数，接受一个列表作为参数，并返回该列表中的所有质数。
```python
def prime_numbers(lst):
def is_prime(n):
if n < 2:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return False
return True
return [num for num in lst if is_prime(num)]
print(prime_numbers([1, 2, 3, 4, 5, 6])) # 输出 [2, 3, 5]
```
解析：该函数使用内部函数 is_prime 判断一个整数是否为素数，然后使用列表推导式遍历列表 lst，筛选出其中的质数。
16. 编写一个函数，接受一个字符串作为参数，并返回该字符串中的所有字母字符。
```python
def letter_characters(s):
return [char for char in s if char.isalpha()]
print(letter_characters("hello 123 world")) # 输出 ["h", "e", "l", "l", "o", "w", "o", "r", "l", "d"]
```
解析：该函数使用列表推导式来筛选出字符串中的所有字母字符。`[char for char in s if char.isalpha()]` 表示遍历字符串 s，如果当前字符是字母字符，则将其加入新列表中。
17. 编写一个函数，接受一个列表作为参数，并返回该列表中的所有子集。
```python
def subsets(lst):
if not lst:
return [[]]
else:
rest = subsets(lst[1:])
return rest + [[lst[0]] + x for x in rest]
print(subsets([1, 2, 3])) # 输出 [[], [3], [2], [2, 3], [1], [1, 3], [1, 2], [1, 2, 3]]
```
解析：该函数使用递归实现了生成所有子集的功能。如果列表为空，则返回空列表的子集；否则递归求解剩余部分的子集，并将当前元素加入到其中所有子集的末尾。
18. 编写一个函数，接受一个字符串和一个整数 k 作为参数，并返回该字符串中所有长度为 k 的子串。
```python
def k_substrings(s, k):
return [s[i:i+k] for i in range(len(s)-k+1)]
print(k_substrings("hello world", 3)) # 输出 ["hel", "ell", "llo", "lo ", "o w", " wo", "wor", "orl", "rld"]
```
解析：该函数使用列表推导式来生成所有长度为 k 的子串。外层循环遍历字符串 s 的每个长度为 k 的子串的起始位置，内层循环从起始位置开始遍历到字符串末尾，生成所有长度为 k 的子串。
19. 编写一个函数，接受一个列表作为参数，并返回该列表中的所有元素之和。
```python
def sum_elements(lst):
return sum(lst)
print(sum_elements([1, 2, 3, 4, 5])) # 输出 15
```
解析：该函数使用 Python 的内置函数 sum 来计算列表中所有元素的和。
20. 编写一个函数，接受一个字符串作为参数，并返回该字符串中出现次数最多的单词及其出现次数。
```python
from collections import Counter
def most_frequent_word(s):
words = s.split()
counter = Counter(words)
word, count = counter.most_common(1)[0]
return word, count
print(most_frequent_word("hello world hello")) # 输出 ("hello", 2)
```
解析：该函数使用字符串的 split 方法将字符串拆分为单词列表，然后使用 collections 模块的 Counter 类来统计每个单词出现的次数，最后使用 Counter 的 most_common 方法找到出现次数最多的单词及其出现次数。
829
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
