Python——字符串及常见操作总结

Python 中的字符串是不可变的（immutable）序列类型，用于存储文本数据。字符串可以包含字母、数字、空格以及任何有效的字符集符号。在 Python 中，字符串可以是单引号（'）或双引号（"）括起来的任意文本。三引号（''' 或 """）可以用来定义多行字符串。

字符串的创建

# 使用单引号  
s1 = 'Hello, World!'  
  
# 使用双引号  
s2 = "Hello, Python!"  
  
# 使用三引号定义多行字符串  
s3 = """这是一个  
多行字符串  
示例"""

大小写转换

在Python中，字符串是不可变的，但你可以通过字符串的方法来创建新的字符串，这些新字符串是基于原始字符串但经过某些修改（如大小写调整）的。以下是字符串调整大小写的几种常见操作总结：

1. str.upper()

将字符串中的所有小写字母转换为大写字母。

s = "Hello, World!"  
upper_s = s.upper()  
print(upper_s)  # 输出: HELLO, WORLD!

2. str.lower()

将字符串中的所有大写字母转换为小写字母。

s = "Hello, WORLD!"  
lower_s = s.lower()  
print(lower_s)  # 输出: hello, world!

3. str.capitalize()

将字符串的第一个字符转换为大写，其余字符转换为小写。

s = "hello, world!"  
capitalized_s = s.capitalize()  
print(capitalized_s)  # 输出: Hello, world!

注意：这个方法只影响第一个字符和其余字符的大小写，不会改变字符串中其他单词的大小写。

4. str.title()

将字符串中每个单词的首字母转换为大写，其余字母转换为小写。

s = "hello, world!"  
title_s = s.title()  
print(title_s)  # 输出: Hello, World!

注意：这个方法会基于空格、连字符（-）或下划线（_）来识别单词的边界。

5. str.swapcase()

将字符串中的小写字母转换为大写字母，大写字母转换为小写字母。

s = "Hello, World!"  
swapcase_s = s.swapcase()  
print(swapcase_s)  # 输出: hELLO, wORLD!

6. str.casefold()

将字符串中的所有字符转换为小写，但比lower()方法更激进，用于进行不区分大小写的比较。它旨在移除所有字符的大小写差异，包括那些不被lower()方法视为不同的情况。除了可以处理英文字母外还能处理其他语言的大小写。

# 示例可能不明显，因为大多数字符集下，casefold()和lower()在英文上效果相同  
s = "Straße"  
lower_s = s.lower()  
casefold_s = s.casefold()  
# 在某些情况下，casefold()会进一步转换字符，但在这个例子中，它们可能看起来相同  
print(lower_s)  # 输出可能依赖于环境  
print(casefold_s)  # 输出可能依赖于环境

注意：casefold()方法主要用于需要严格不区分大小写的比较场景，比如字符串排序或搜索时。

这些方法是Python中处理字符串大小写转换的常用工具，它们允许你以灵活的方式调整字符串的外观，以满足不同的编程需求。

字符串对齐

在Python中，字符串的对齐操作可以通过多种方法实现，主要包括使用字符串的内置方法，如ljust(), rjust(), 和 center()，以及使用format()方法或f-string（Python 3.6+）进行更复杂的格式化。

1. 使用ljust(), rjust(), 和 center()

• ljust(width[, fillchar])：返回一个原字符串左对齐,并使用fillchar（默认空格）填充至指定宽度的新字符串。
• rjust(width[, fillchar])：返回一个原字符串右对齐,并使用fillchar（默认空格）填充至指定宽度的新字符串。
• center(width[, fillchar])：返回一个原字符串居中,并使用fillchar（默认空格）填充至指定宽度的新字符串。

s = "hello"  
print(s.ljust(10, '*'))  # hello*****  
print(s.rjust(10, '*'))  # *****hello  
print(s.center(10, '*')) # **hello***

2. 使用format()方法

format()方法提供了更灵活的方式来格式化字符串，包括对齐、填充和宽度等。

• {:<width}：左对齐
• {:>width}：右对齐
• {:^width}：居中对齐
• {:<width}.format(s)、{:>width}.format(s)、{:^width}.format(s)：其中的width指定了宽度，如果字符串长度小于width，则按照指定的对齐方式填充空格（默认是空格，可以指定填充字符）。

s = "hello"  
print("{:<10}".format(s))  # hello  
print("{:>10}".format(s))  #      hello  
print("{:^10}".format(s))  #   hello  
print("{:*^10}".format(s)) # ***hello*** （使用*作为填充字符）

3. 使用f-string（Python 3.6+）

f-string是Python 3.6引入的一种格式化字符串字面量的新方法，它提供了一种更简洁易读的方式来嵌入表达式到字符串常量中。对于对齐操作，可以直接在表达式中调用上述方法或使用format()方法的特性。

s = "hello"  
print(f"{s:<10}")  # hello  
print(f"{s:>10}")  #      hello  
print(f"{s:^10}")  #   hello  
print(f"{s:*^10}") # ***hello***

f-string在性能上通常比旧的字符串格式化方法（如%操作符或str.format()方法）更快，并且代码更简洁易读。

字符串查找

1. 使用in关键字

in关键字可以用来检查一个字符串是否作为子串出现在另一个字符串中。如果子串存在，返回True；否则返回False。

s = "hello world"  
result = "world" in s  
print(result)  # 输出: True

2. 使用find()方法

find()方法用于查找子串在字符串中首次出现的位置，如果未找到子串，则返回-1。注意，查找的起始位置（默认为0）和结束位置（默认为字符串长度）也可以作为可选参数传入。

s = "hello world"  
index = s.find("world")  
print(index)  # 输出: 6  
  
index = s.find("python")  
print(index)  # 输出: -1

3. 使用index()方法

index()方法与find()方法类似，也是用来查找子串在字符串中首次出现的位置。不过，如果未找到子串，index()会抛出一个ValueError异常，而不是返回-1。

s = "hello world"  
index = s.index("world")  
print(index)  # 输出: 6  
  
# 下面的代码会抛出ValueError异常  
# index = s.index("python")

4. 使用rfind()和rindex()方法

这两个方法分别与find()和index()类似，但是它们是从字符串的末尾开始向前查找子串的首次出现位置。

5. 使用count()方法

count()方法用于统计子串在字符串中出现的次数。

s = "hello hello world"  
count = s.count("hello")  
print(count)  # 输出: 2

字符串替换

在Python中，字符串替换是一个常见的操作，可以通过多种方法实现。字符串是不可变的（immutable），这意味着你不能直接修改字符串本身，但你可以创建一个新的字符串作为替换后的结果。以下是一些常用的字符串替换方法：

1. 使用replace()方法

replace()方法是最直接且常用的字符串替换方法。它接受三个参数：要替换的子串（必需）、用于替换的新子串（必需）、以及可选的最大替换次数（默认为替换所有匹配项）。

s = "hello world"  
new_s = s.replace("world", "Python")  
print(new_s)  # 输出: hello Python  
  
# 替换所有出现的"o"为"O"（默认行为）  
s = "hello world"  
new_s = s.replace("o", "O")  
print(new_s)  # 输出: hellO wOrld  
  
# 只替换前两次出现的"o"  
s = "hello world"  
new_s = s.replace("o", "O", 2)  
print(new_s)  # 输出: hellO wOrld

2.使用expandtabs() 方法

expandtabs() 方法用于将字符串中的制表符（\t）转换为相应数量的空格。默认情况下，它假设一个制表符等于8个空格，但你可以通过指定tabsize参数来改变这个默认值。

s = "Hello\tworld"  
print(s.expandtabs())  # 默认，制表符被转换成8个空格  
print(s.expandtabs(4))  # 指定tabsize为4，制表符被转换成4个空格

输出将显示不同的空格数，这取决于你是否指定了tabsize参数以及你指定的值。

3.使用translate() 方法

translate() 方法用于替换字符串中的某些字符。不过，它不是简单地根据子串进行替换，而是通过一个翻译表（通常通过str.maketrans()方法创建）来指定哪些字符应该被替换，以及它们应该被替换成什么。

翻译表是一个从旧字符到新字符的映射，未指定的字符则保持不变。这意味着translate()方法可以非常高效地处理大量替换操作，尤其是当只涉及少量字符时。

# 创建一个翻译表，将'a'替换为'x'，'b'替换为'y'  
table = str.maketrans('ab', 'xy')  
  
s = "apple banana"  
print(s.translate(table))  # 输出: xpple ynana

注意，translate()方法也支持删除字符，只需在str.maketrans()的第三个参数中指定要删除的字符即可。

# 创建一个翻译表，删除所有的'a'和'b'  
table = str.maketrans('', '', 'ab')  
  
s = "apple banana"  
print(s.translate(table))  # 输出: pple nana

字符串判断

在Python中，字符串判断是编程中常见的任务之一，它涉及到检查字符串是否满足某些条件。Python提供了多种内置函数和操作符来帮助我们进行字符串判断。以下是一些常用的字符串判断方法：

1. 字符串类型判断

• 虽然Python是动态类型语言，但在某些情况下，你可能需要确认一个变量是否为字符串类型。可以使用isinstance()函数。

s = "hello"  
if isinstance(s, str):  
    print("这是一个字符串")  
else:  
    print("这不是一个字符串")

2. 字符串前缀和后缀判断

• 使用startswith()和endswith()方法可以判断字符串是否以指定的前缀或后缀开始或结束。

s = "hello.txt"  
if s.startswith("hello"):  
    print("字符串以'hello'开始")  
if s.endswith(".txt"):  
    print("字符串以'.txt'结束")

3. 字符串是否全为数字、字母等

• 使用str.isalnum(), str.isalpha(), str.isdigit(), str.islower(), str.isupper(), str.isspace()等方法可以判断字符串是否满足特定的条件（如是否全为字母数字、是否全为字母、是否全为数字、是否全为小写、是否全为大写、是否全为空白字符等）。

s = "hello123"  
if s.isalnum():  
    print("字符串包含字母和数字")  
  
s = "hello"  
if s.isalpha():  
    print("字符串全为字母")  
  
s = "123"  
if s.isdigit():  
    print("字符串全为数字")  
  
s = "hello"  
if s.islower():  
    print("字符串全为小写")  
  
s = "HELLO"  
if s.isupper():  
    print("字符串全为大写")  
  
s = "   "  
if s.isspace():  
    print("字符串全为空白字符")

字符串的拆分和拼接

在Python中，字符串的拆分和拼接是常见的操作，它们分别通过不同的方法或操作符来实现。

字符串的拆分

字符串的拆分通常指的是将一个字符串按照指定的分隔符或模式分割成多个子字符串。Python中，可以使用split()方法来实现这一功能。

使用split()方法

split()方法会根据指定的分隔符（默认为空格）将字符串分割成一个列表，列表中的每个元素都是原字符串的一个子串。

s = "apple banana cherry"  
# 使用默认分隔符（空格）拆分  
parts = s.split()  
print(parts)  # 输出: ['apple', 'banana', 'cherry']  
  
# 使用指定分隔符拆分  
s = "apple,banana,cherry"  
parts = s.split(',')  
print(parts)  # 输出: ['apple', 'banana', 'cherry']  
  
# 分隔符可以指定多次出现，并且结果中包括空字符串  
s = "apple,,banana,cherry"  
parts = s.split(',')  
print(parts)  # 输出: ['apple', '', 'banana', 'cherry']

字符串的拼接

字符串的拼接指的是将多个字符串连接成一个字符串。Python提供了多种方式进行字符串的拼接。

使用+操作符

最直观的方式是使用+操作符将多个字符串拼接起来。

s1 = "Hello, "  
s2 = "world!"  
s3 = s1 + s2  
print(s3)  # 输出: Hello, world!

使用join()方法

如果你有一个字符串列表，想要将它们用某个分隔符连接起来，可以使用join()方法。注意，join()是字符串类型的方法，它需要一个可迭代对象（如列表、元组等）作为参数，其中的每个元素都应该是字符串。

parts = ["Hello", "world", "!"]  
s = " ".join(parts)  
print(s)  # 输出: Hello world !  
  
# 使用不同的分隔符  
s = "-".join(parts)  
print(s)  # 输出: Hello-world-!

在大数量字符串拼接的过程中，join 的方法比 + 方法速度要快得多。

格式化字符串

在Python中，格式化字符串是一个常见且重要的操作，它允许你将多个变量和值插入到字符串中。Python提供了几种不同的方法来格式化字符串，包括旧式的%操作符、str.format()方法以及从Python 3.6开始引入的f-string（格式化字符串字面量）。下面将分别介绍这些方法。

1. % 操作符

这是Python中最早的字符串格式化方法，类似于C语言中的printf函数。

name = "Alice"  
age = 30  
print("Hello, %s. You are %d years old." % (name, age))

在上面的例子中，%s用于格式化字符串，%d用于格式化整数。%后面的元组(name, age)中的值会按照顺序替换掉字符串中的%s和%d。

2. str.format() 方法

str.format()方法提供了一种更灵活的方式来格式化字符串。你可以通过位置参数、关键字参数或两者混合使用来格式化字符串。

name = "Bob"  
age = 25  
print("Hello, {}. You are {} years old.".format(name, age))  
# 或者使用关键字参数  
print("Hello, {name}. You are {age} years old.".format(name=name, age=age))

3. f-string（格式化字符串字面量）

从Python 3.6开始，f-string提供了一种非常简洁和易于阅读的方式来嵌入表达式到字符串字面量中。在字符串前加f或F，并在大括号{}中写入表达式，这些表达式的值会被计算并格式化为字符串的一部分。

name = "Charlie"  
age = 28  
print(f"Hello, {name}. You are {age} years old.")

总结

• %操作符是Python中最古老的字符串格式化方法，但现在已较少使用。
• str.format()方法提供了一种灵活且强大的方式来格式化字符串。
• f-string（格式化字符串字面量）是Python 3.6及更高版本中推荐的字符串格式化方法，因为它既简洁又高效。

在实际开发中，建议尽可能使用f-string来格式化字符串。

f-strings（格式化字符串字面量）和.format()方法

ython中的f-strings（格式化字符串字面量）和.format()方法都是用于字符串格式化的强大工具，但它们各自有一些特点和用法上的差异。

f-strings（Python 3.6+）

f-strings提供了一种非常简洁和直观的方式来嵌入表达式到字符串常量中。它们以字母f或F为前缀，并在花括号{}中允许你插入表达式。这些表达式在运行时会被求值，并转换成字符串，然后插入到字符串的相应位置。

优点：

• 简洁明了，易于阅读。
• 性能较好，因为f-strings是在编译时处理的，相比.format()方法，它们在执行时通常更快。
• 支持表达式求值，不仅限于变量。

name = "Alice"  
age = 30  
print(f"Hello, {name}. You are {age} years old.")  
# 输出: Hello, Alice. You are 30 years old.

.format() 方法

.format()方法是Python 2.6中引入的，用于字符串的格式化。它允许你在字符串中插入占位符（由花括号{}表示），然后通过.format()方法将这些占位符替换为相应的值或表达式的结果。

优点：

• 功能强大，支持多种格式化选项（如对齐、填充、十进制、十六进制等）。
• 灵活性高，可以通过位置参数、关键字参数或两者的混合使用来格式化字符串。
• 兼容性好，适用于所有Python版本（尽管f-strings在Python 3.6及更高版本中才可用）。

name = "Bob"  
age = 25  
print("Hello, {}. You are {} years old.".format(name, age))  
# 或者使用关键字参数  
print("Hello, {name}. You are {age} years old.".format(name=name, age=age))  
# 输出: Hello, Bob. You are 25 years old.

总结

• 如果你正在使用Python 3.6或更高版本，并且追求代码的简洁性和性能，那么f-strings是首选。
• 如果你需要更复杂的格式化选项，或者你的代码需要兼容Python 2.x版本，那么.format()方法可能更适合你。
• 在大多数情况下，f-strings由于其简洁性和性能优势，被推荐为Python字符串格式化的首选方法。