一、字符串是什么？
字符串（String） 是python中最常用的数据类型，用来表示文本、字符、符号 等内容，本质是不可变的有序字符序列。
- 不可变：字符串创建后，不能直接修改里面的单个字符
- 有序：每个字符都有固定位置，支持索引、切片
- 定义：用单引号
' '/ 双引号" "/ 三引号''' '''包裹内容
二、字符串定义与引号用法
Python中单引号、双引号功能完全一样，区别仅在于处理字符串内部引号：
-
普通字符串
str1 = 'Hello, World!' # 单引号
str2 = "Hello, World!" # 双引号 -
字符串内部包含引号（不用转义）
-
字符串里有单引号 → 外层用双引号
-
字符串里有双引号 → 外层用单引号
str3 = "it's a nice day!" # 内部单引号，无需转义
str4 = 'She said, "Hello!"' # 内部双引号，无需转义
-
必须使用转义字符
\str3 = 'It's a nice day!' # 单引号内包单引号，必须加
str4 = "She said, "Hello!"" # 双引号内包双引号，必须加 \
三、字符串基础操作
1. 索引取值（按位置取字符）
字符串每个字符都有下标，从0开始，支持正负索引：
s = "Hello, World!"
print(s[0]) # 第一个字符 → H
print(s[-1]) # 最后一个字符 → !2. 切片（截取一段字符串）
语法：字符串[起始:结束:步长] 规则：包含起始，不包含结束
s = "Hello, World!"
print(s[0:5]) # 0~4 → Hello
print(s[7:12]) # 7~11 → World
print(s[::]) # 取全部
print(s[::-1]) # 字符串反转3. 字符串拼接（+）
s1 = "hello"
s2 = "CSDN"
s3 = s1 + " " + s2 # hello CSDN4. 字符串重复（*）
print("hello" * 3) # hellohellohello5. 成员判断（in /not in）
判断字符串是否包含某个子串，返回True/False
s = "Hello, World!"
print("World" in s) # True
print("Python" in s) # False
print("Python" not in s) # True6. 遍历字符串
字符串是可迭代对象，可用 for 循环逐个取出字符
s = "hello"
for i in s:
print(i) # 依次输出 h e l l o7. 获取字符串长度（len ()）
s = "hello, world!"
print(len(s)) # 输出字符总个数四、字符串格式化（推荐 f-string）
1. f-string（最简单、最推荐）
name = "GFD"
age = 18
print(f"my name is {name}, I am {age} years old.")2. format () 方法
print("My name is {} and I am {} years old.".format(name, age))五、字符串大小写转换
s = "nihao wo shi csdn user"
print(s.title()) # 每个单词首字母大写 → Nihao Wo Shi Csdn User
print(s.upper()) # 全部大写 → NIHAO WO SHI CSDN USER
print(s.lower()) # 全部小写 → nihao wo shi csdn user六、字符串查找与替换
1. 查找（in 关键字）
s = "Hello, World!"
print("World" in s) # True2. 替换（replace）
-
语法：
replace(旧内容, 新内容, 替换次数) -
字符串区分大小写
-
不会修改原字符串，返回新字符串
s = "Hello, World!"
print(s.replace("World", "GFD")) # Hello, GFD!只替换第1个匹配项
s10 = "hello world, hello python"
print(s10.replace("l", "L", 1)) # heLlo world, hello python
七、去除空格（strip 系列）
s = " h ello worl d "
print(s.strip()) # 去除 两端 空格
print(s.lstrip()) # 去除 左侧 空格
print(s.rstrip()) # 去除 右侧 空格
# 去除所有空格（用 replace）
print(s.replace(" ", "")) # helloworld八、字符串分割与合并（高频重点）
1. 分割（split）→ 字符串 转 列表
按指定符号把字符串切成一段段，返回列表
s = "hello,world,python"
lst = s.split(",") # 按逗号分割
print(lst) # ['hello', 'world', 'python']2. 合并（join）→ 列表 / 元组 转 字符串
用指定符号把可迭代对象拼接成字符串
lst = ["hello","world","python"]
print(",".join(lst)) # hello,world,python
print(" ".join(lst)) # hello world python⚠️ 注意：join() 括号里必须是列表、元组等可迭代对象。
九、字符串重要注意事项
-
字符串是不可变类型 不能直接修改某个位置的字符，只能通过切片 / 拼接生成新字符串。
-
字符串严格区分大小写
Hello和hello是两个完全不同的字符串。 -
空格也是一个有效字符 会影响长度、判断、匹配等。
-
特殊字符需要转义 如换行
\n、制表符\t、引号\'\"等。#python 字符串常用方法
#单引号 双引号 三引号 用法
#python字符串单引号和双引号都可以用来定义字符串,具体使用哪种，需要根据字符串内容来决定，如果字符串中包含单引号，则使用双引号定义字符串，反之亦然。
#三引号""" ''' 用于定义多行字符串，可以包含换行符和引号，不需要转义。
str1 = 'Hello, World!' # 使用单引号定义字符串
print(str1)#输出 Hello, World!str2 = "Hello, World!" # 使用双引号定义字符串
print(str2)#输出 Hello, World!str3 = 'It's a nice day!' # 使用单引号定义字符串，包含单引号需要转义
print(str3)#输出 It's a nice day!str3_3 = "it's a nice day!" # 使用双引号定义字符串，包含单引号不需要转义
print(str3_3)#输出 it's a nice day!str4 = "he is a 'good' boy?"# 使用双引号定义字符串，包含单引号不需要转义
print(str4)str4 = "She said, "Hello!"" # 使用双引号定义字符串，包含双引号需要转义
print(str4)#输出 She said, "Hello!"
s_333 = """"
11111111,
22222222,
33333333,"""
print(f"s_333:{s_333}")#输出 s_333:11111111,#字符串的切片
str1 = "Hello, World!"
print(str1[0:5]) # 输出 "Hello"
print(str1[7:12]) # 输出 "World"#字符串拼接
s1 = "hello"
s2 = "CSND740"
s3 =s1 +" " +s2
print(s3) # 输出 "hello CSND740"#字符串格式化
name = "GFD"
age = 18
print("My name is {} and I am {} years old.".format(name,age)) #输出 "My name is GFD and I am 18 years old."
print(f"my name is {name} and I am {age} years old.") #输出 "my name is GFD and I am 18 years old."
#两者的区别是，format方法在字符串中使用花括号{}作为占位符，并通过format方法传入对应的值进行替换，而f-string则直接在字符串前加上f，并在字符串中使用花括号{}来引用变量或表达式，Python会自动将其替换为对应的值。f-string更简洁易读，且支持更复杂的表达式。
#推荐使用f-string进行字符串格式化，因为它更简洁易读，并且支持更复杂的表达式。#字符串的取值
s_value = "Hello, World!"
s_value1 = s_value[0] # 获取字符串的第一个字符
s_value2 = s_value[-1] # 获取字符串的最后一个字符
print(s_value1) # 输出 "H"
print(s_value2) # 输出 "!"#字符串的重复
s_res = "hello" * 3 # 将字符串重复3次
print(f"s_res:{s_res}")#输出 "s_res:hellohellohello"#字符串的大小写转换
#所有首字母大写
s_cap = "nihao wo shi scdn user GFD,id is CSND740"
print(f"首字母大写的s_cap:{s_cap.title()}")#输出 "每一个单词首字母大写的s_cap:Nihao Wo Shi Scdn User Gfd,Id Is Csnd740"
#所有字母大写
print(f"s_cap:{s_cap.upper()}")#输出 "s_cap:NIHAO WO SHI SCDN USER GFD,ID IS CSND740"
#所有字母小写
print(f"所有字母小写:{s_cap.lower()}")#输出 "所有字母小写:nihao wo shi scdn user gfd,id is csnd740"#字符串的查找和替换
s_find = "Hello, World!"
print(f"字符串s_find中是否包含'World':{'World' in s_find}")#输出 "字符串s_find中是否包含'World':True"
print(f"字符串s_find中是否包含'Python':{'Python' in s_find}")#输出 "字符串s_find中是否包含'Python':False"
s_replace = s_find.replace("World","GFD")#将字符串中的"World"替换为"GFD"
print(f"替换后的字符串s_replace:{s_replace}")#输出 "替换后的字符串s_replace:Hello, GFD!" 因为字符串是区分大小写的，所以"World"被替换了。
s_replace2 = s_find.replace("world","GFD")#将字符串中的"world"替换为"GFD"
print(f"替换后的字符串s_replace2:{s_replace2}")#输出 "替换后的字符串s_replace2:Hello, World!" 因为字符串是区分大小写的，所以"world"没有被替换。#去除字符串中的空格
s_st= " h ello worl d "
print(f"去除字符串s_strip两端空格后的结果:{s_st.strip()}")#输出 "去除字符串s_strip两端空格后的结果:h ello worl d" strip()方法只能去除字符串两端的空格，不能去除字符串中间的空格。
#去除左侧空格
print(f"去除字符串s_strip左侧空格后的结果:{s_st.lstrip()}")#输出 "去除字符串s_strip左侧空格后的结果:h ello worl d "
#去除右侧空格
print(f"去除字符串s_strip右侧空格后的结果:{s_st.rstrip()}")#输出 "去除字符串s_strip右侧空格后的结果: h ello worl d"
#去除所有空格
print(f"去除字符串s_strip所有空格后的结果:{s_st.replace(' ','')}")#输出 "去除字符串s_strip所有空格后的结果:helloworld"
#replace()方法可以用来替换字符串中的指定字符或子字符串，可以用来去除字符串中的所有空格。
#把空格字符替换为字符
print(f"把字符串s_strip中的空格字符替换为后的结果:{s_st.replace(' ' ,'')}")#输出 "把字符串s_strip中的空格字符替换为后的结果:helloworld***"
#replace只能替换字符串中的指定字符或子字符串，不能替换字符串中的所有空格，如果要替换字符串中的所有空格，可以使用正则表达式或者其他方法。
#替换子字符串
print(f"把字符串s_strip中的'ello'替换为'hi'后的结果:{s_st.replace('ello','hi')}")#输出 "把字符串s_strip中的'ello'替换为'hi'后的结果: h hi worl d "
#replace('要替换的子字符串','替换后的子字符串')
#replace('要替换的字符'，'替换后的字符')#默认为替换全部的匹配项，如果要替换指定数量的匹配项，可以使用第三个参数来指定替换的次数。
#replace('要替换的子字符串','替换后的子字符串',替换的次数)
s_10 = "hello world, hello python"
print(f"s_10:{s_10}")#输出 "s_10:hello world, hello python"
#只把第一个l替换为L
print(f"只替换第一个l后的结果:{s_10.replace('l','L',1)}")#输出 "只替换第一个l后的结果:heLlo world, hello python"#分割
s_split = "hello,world, python"
print(f"s_split:{s_split}")#输出 "s_split:hello,world,python"
s_new= s_split.split(",")
print(f"使用逗号分割字符串s_split后的结果:{s_new}")#输出 "使用逗号分割字符串s_split后的结果:['hello', 'world', 'python']"
print(f"分割后的类型:{type(s_new)}")#输出 "分割后的类型:<class 'list'>"
print(f"s_split:{s_split}")#输出 "s_split:hello,world,python" split()方法不会修改原字符串，而是返回一个新的列表。
s_new2= s_split.split(" ")#使用空格分割字符串s_split
print(f"使用空格分割字符串s_split后的结果:{s_new2}")#输出 "使用空格分割字符串s_split后的结果:['hello,world,', 'python']"#合并
s_join = ["hello","world","python"]
print(f"s_join:{s_join}")#输出 "s_join:['hello', 'world', 'python']"
s_new_join = ",".join(s_join)#使用逗号连接列表s_join中的字符串
print(f"使用逗号连接列表s_join中的字符串后的结果:{s_new_join}")#输出 "使用逗号连接列表s_join中的字符串后的结果:hello,world,python"
s_new_join2 = " ".join(s_join)#使用空格连接列表s_join中的字符串
print(f"使用空格连接列表s_join中的字符串后的结果:{s_new_join2}")#输出 "使用空格连接列表s_join中的字符串后的结果:hello world python"
s_new_join3= "&".join(s_join)#使用&连接列表s_join中的字符串
print(f"使用&连接列表s_join中的字符串后的结果:{s_new_join3}")#输出 "使用&连接列表s_join中的字符串后的结果:hello&world&python"#" ".join()括号中的内容必须是一个可迭代对象，通常是一个列表或者元组，不能是一个字符串，因为字符串也是一个可迭代对象，会被当做一个个字符来处理。
list = ["hello","world","python"]
print(f"使用空格连接列表list中的字符串后的结果:{' '.join(list)}")#输出 "使用空格连接列表list中的字符串后的结果:hello world python"
str = "hello"
print(f"使用空格连接字符串str中的字符后的结果:{' '.join(str)}")#输出 "使用空格连接字符串str中的字符后的结果:h e l l o" 因为字符串也是一个可迭代对象，所以会被当做一个个字符来处理。
tuple = ("hello","world","python")
print(f"使用空格连接元组tuple中的字符串后的结果:{' '.join(tuple)}")#输出 "使用空格连接元组tuple中的字符串后的结果:hello world python"#遍历字符串，因为是可迭代对象，所以可以使用for循环来遍历字符串中的每个字符。
s_traverse = "hello"
for i in s_traverse:
print(i) #输出 "h e l l o" 每个字符占一行in not in 用于判断字符串中是否包含某个子字符串，返回值是一个布尔值，True表示包含，False表示不包含。
s_in = "hello, world!"
print(f"字符串s_in中是否包含'world':{'world' in s_in}")#输出 "字符串s_in中是否包含'world':True"
print(f"字符串s_in中是否包含'python':{'python' in s_in}") #输出 "字符串s_in中是否包含'python':False"
print(f"字符串s_in中是否不包含'world':{'world' not in s_in}")#输出 "字符串s_in中是否不包含'world':False"
print(f"字符串s_in中是否不包含'python':{'python' not in s_in}")#输出 "字符串s_in中是否不包含'python':True"#字符串长度
s_len = "hello, world!"
print(f"s_len:{len(s_len)}")#注意事项
#1.字符串是不可变类型，不能修改字符串中的字符，但是可以通过切片和拼接来创建一个新的字符串。
#2.字符串是区分大小写的，"Hello"和"hello"是两个不同的字符串。
#3.字符串中的空格也是一个字符，不能忽略。
#4.字符串中的特殊字符需要使用转义字符来表示，例如换行符\n，制表符\t等。