【废物研究生刷算法】字符串

如果使用python处理字符串，有很多py内置的函数可以使用，主要还是记住这些处理方法。

1. 反转字符串

class Solution:
    def reverseStr(self, s, k):
        s = list(s)  # 将字符串转为列表，因为字符串是不可变的
        for i in range(0, len(s), k * 2):  # 步长为 2k，从 0 开始循环
            s[i: i + k] = s[i: i + k][::-1]  # 反转从 i 到 i+k 的子段
        return ''.join(s)  # 将列表转回字符串

1. 为什么将字符串转为列表？
   Python 的字符串是不可变类型（immutable），无法直接修改其中的字符。而列表是可变的，可以通过切片赋值来修改。因此，第一步 s = list(s) 将字符串转为字符列表，便于后续操作。
2. 为什么用 range(0, len(s), k * 2)？

• range(0, len(s), k * 2) 表示从 0 开始，以 2k 为步长递增，直到到达或超过字符串长度。
• 步长 2k 是因为题目要求每隔 2k 个字符处理一次：
• 前 k 个字符反转，后 k 个字符保持不变，总共处理 2k 个字符。

3. 为什么 s[i: i + k] = s[i: i + k][::-1] 能正确反转？
   s[i: i + k] 是从索引 i 到 i + k 的子列表（不包含 i + k）。
   [::-1] 是 Python 的切片语法，表示反转整个列表。
   赋值操作 s[i: i + k] = ... 将反转后的结果放回原位置。
   关键点：当 i + k 超出字符串长度时，Python 的切片会自动截断到字符串末尾，不会报错。

例如：
如果 s = [‘a’, ‘b’, ‘c’], i = 2, k = 2：
s[2:4] 实际只取到 s[2:] = [‘c’]，反转后还是 [‘c’]，赋值回去不会越界。

2. 替换数字

s = list(input())
i = 0
while i < len(s):
    if '0' <= s[i] <= '9':  # 判断是否为数字
        s[i:i+1] = list('number')  # 替换为 'number' 的字符列表
        i += len('number')  # 跳过 'number' 的长度
    else:
        i += 1
print("".join(s))

• 用 ‘0’ <= s[i] <= ‘9’ 判断字符是否为数字（比 ord 更直观）。
• s[i:i+1] = list(‘number’) 将单个字符替换为 “number” 的字符列表。
• 每次替换后，i 跳过 “number” 的长度（6），避免重复检查。

s = input()
result = ''
for char in s:
    if char.isdigit():  # 判断是否为数字
        result += 'number'
    else:
        result += char
print(result)

• char.isdigit() 是 Python 内置方法，直接判断字符是否为数字。
• 逐字符构建结果字符串，数字替换为 “number”，非数字保持不变。

3. 反转字符串中的单词

class Solution(object):
    def reverseWords(self, s):
        """
        :type s: str
        :rtype: str
        """
        s = s.strip()
        strs = s.split()
        strs.reverse()
        return " ".join(strs)

4. 右旋字符串

n = int(input())
s = input()

print(s[-n:]+s[:-n])

总结

1、字符串处理函数

str.find(str1)
str.count(str1)
str.replace(str1,count)
str.split('分界符')
str.capitalize()
str.strip()
str.join()
str.isdigit()
str.isalpha()
str.reverse()

2、字符串切片

切片操作的基本语法是 sequence[start:stop:step]，其中：
start：切片开始的位置（包含该位置的元素），默认为 None，如果为负数则从序列末尾开始计数。
stop：切片结束的位置（不包含该位置的元素），默认为 None，如果为负数则从序列末尾开始计数。
step：切片的步长，默认为 1，可以为负数，表示从右向左切片。

倒数有关的切片

# 定义一个列表
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 示例 1：获取最后一个元素
last_element = my_list[-1]
print("最后一个元素:", last_element)

# 示例 2：获取倒数三个元素
last_three = my_list[-3:]
print("倒数三个元素:", last_three)

# 示例 3：获取从倒数第五个元素到倒数第二个元素
sub_list = my_list[-5:-1]
print("从倒数第五个元素到倒数第二个元素:", sub_list)

# 示例 4：使用负步长反转列表
reversed_list = my_list[::-1]
print("反转后的列表:", reversed_list)

# 示例 5：每隔一个元素取一个，从倒数第二个元素开始到第一个元素
new_list = my_list[-2::-2]
print("每隔一个元素取一个，从倒数第二个元素开始到第一个元素:", new_list)