四、字符串（1）

操作

1. 创建字符串

string1 = "Hello, World!"
string2 = '你好，世界！'

2. 字符串拼接

str1 = "Hello"
str2 = "World"
result = str1 + ", " + str2 + "!"
print(result)  # 输出: Hello, World!

3. 重复字符串

repeat_str = "Ha" * 3
print(repeat_str)  # 输出: HaHaHa

4. 获取字符串长度

length = len(result)
print(length)  # 输出: 13

5. 字符串切片

substring = result[0:5]  # 从索引0开始到索引5结束，不包括索引5
print(substring)  # 输出: Hello

6. 字符串查找

index = result.find("World")
print(index)  # 输出: 7

7. 字符串替换

new_result = result.replace("World", "Python")
print(new_result)  # 输出: Hello, Python!

8. 大小写转换

upper_str = result.upper()
lower_str = result.lower()
print(upper_str)  # 输出: HELLO, WORLD!
print(lower_str)  # 输出: hello, world!

9. 去除空格

whitespace_str = "  Hello, World!  "
stripped_str = whitespace_str.strip()
print(stripped_str)  # 输出: Hello, World!

10. 字符串分割和连接

split_str = result.split(", ")
print(split_str)  # 输出: ['Hello', 'World!']

joined_str = ", ".join(split_str)
print(joined_str)  # 输出: Hello, World!

11. 检查字符串开头和结尾

starts_with = result.startswith("Hello")
ends_with = result.endswith("!")
print(starts_with)  # 输出: True
print(ends_with)  # 输出: True

12. 格式化字符串

name = "Alice"
age = 30
formatted_str = f"My name is {name} and I am {age} years old."
print(formatted_str)  # 输出: My name is Alice and I am 30 years old.

题目

字符串类似数组，属于字符数组
344.反转字符串
不用额外空间 空间复杂度O(1)

1. 双指针
   可以直接交换 a,b = b, a

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        # 双指针
        n = len(s)
        i, j = 0, n - 1
        temp = 0
        while i < j:
            temp = s[i]
            s[i] = s[j]
            s[j] = temp

            i += 1
            j -= 1
        

3. reversed（）
   reversed() 是一个内置函数，它返回一个反向迭代器。它不会改变原序列，而是生成一个新的反向迭代器

s[:] = reversed(s)

4. reverse()
   reverse() 是列表对象的一个方法，它会原地反转列表，改变原列表的顺序，但不会返回新的列表

s.reverse()

5. 切片

s[:] = s[::-1]

6. 列表推导式

s[:] = [s[i] for i in range(len(s)-1, -1, -1)]

541. 反转字符串II
如果不是字符列表而是string，整体反转字符串。可以用：

• reversed_string = original_string[::-1] 切片操作
• ‘’.join(reversed(substring_to_reverse)) reversed函数（注意返回的是一个迭代器）
  惊！字符串在Python中是不可变的，所以单独某个部分拎出来赋值不ok，应该使用切片和连接操作，而不是直接赋值
  注意切片是：； 方法中不会改变原来的变量，得把要改变的返回；切片也是左闭右开

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        n = len(s)
        l_2k = n//(2*k)
        l_k = n//k

        for i in range(l_2k):
           
            s = self.reverStr(i*2*k, i*2*k + k,s)
            print(s)


        if l_k > 2*l_2k:
            # 前k个
            
            s = self.reverStr(l_2k*2*k, l_2k*2*k+k, s)

        elif l_k == 2*l_2k and n%k != 0:
            # 剩余全反转
            
            s = self.reverStr(l_2k*2*k, n, s)

        return s
    
    def reverStr(self, startindex, endindex, s):
        substr = s[startindex: endindex]
        substr = ''.join(reversed(substr))
        # print(substr)
        s = s[:startindex]+substr+s[endindex:]
        return s

优化！步长其实可以是2k去循环，不用先算出来
string超出下标边界也没有关系，列表就不行

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        l, r = 0, 0
        n = len(s)
        while l < n:
            r = l + k
            # print(r)  # 超出边界也没有关系
            # print(s[r:n])
            s = s[0:l]+ s[l:r][::-1]+ s[r:n]
            l += 2*k
        return s

卡码网：54.替换数字
python中str和int都是不可变的类型，修改值之后其实得到的是新地址的新对象，而不是原来的对象，不像字典 列表 集合。
元组虽然不可以通过下标修改，但是元素可以是可变变量，比如元素是列表
所以，为了防止字符串下标越界，用一个列表保存，最后’'.join()一下

s = input()
ans = []

for i in range(len(s)):
    if s[i].isdigit(): 
        ans.append('number')
    else:
        ans.append(s[i])
        
print(''.join(ans))

判断数字

if s[i]>= '1' and s[i]<='9':

用enumerate+字符串连接（反正是新开一个），直接得到对应位置s

s = input()
ans = ""  #string

for i, s in enumerate(s):
    if s.isnumeric():
        ans += 'number'
    else:
        ans += s
print(ans)