当前位置： 首页 > news >正文

5.字符串

news 2025/2/25 15:44:39

文章目录

      • Python 字符串总结
        • 1. 字符串的创建与表示
        • 2. 访问字符串中的字符
        • 3. 字符串的操作
        • 4. 转义字符
        • 5. 字符串格式化
          • 使用 `%` 操作符
          • 使用 `str.format()`
          • 使用 f-string（Python 3.6+）
        • 6. Unicode 字符串
        • 7. 常用字符串方法
        • 8. 三引号字符串
        • 9. 字符串编码与解码
      • 总结
      • 1. 字符串的内部表示
        • Unicode 内部表示
        • 字符串的内存布局
      • 2. 不可变性的影响
        • 性能优化技巧
      • 3. 正则表达式处理
        • 常用的正则表达式函数
        • 示例
        • 高级正则表达式技巧
        • 示例
      • 4. 不常见的字符串方法和特性
        • `string.maketrans()` 和 `translate()`
        • `string.format_map(mapping)`
        • `string.casefold()`
        • `string.removesuffix(suffix)` 和 `string.removeprefix(prefix)`
        • `string.isidentifier()`
        • `string.isprintable()`
      • 5. 字符串的性能优化
      • 6. 字符串的多线程和并发处理
      • 7. 字符串的国际化和本地化
        • 示例
      • 总结

Python 字符串总结

字符串是 Python 中最常用的数据类型之一，用于表示和操作文本数据。Python 提供了丰富的字符串创建、访问、操作和格式化功能，使得处理文本变得非常方便。以下是关于 Python 字符串的详细总结，涵盖了字符串的创建、访问、操作、格式化以及常用方法。

1. 字符串的创建与表示

在 Python 中，字符串可以用单引号 (') 或双引号 (") 来表示。此外，还可以使用三引号 (''' 或 """) 来创建多行字符串。

# 单引号和双引号
single_quoted = 'Hello, World!'
double_quoted = "Python is fun."# 三引号（多行字符串）
multi_line = '''This is a
multi-line string.'''
2. 访问字符串中的字符

字符串是不可变的序列类型，可以通过索引和切片来访问其中的字符或子字符串。

  • 索引：使用方括号 [] 和索引值来访问单个字符。索引从 0 开始，负索引从 -1 开始。
  • 切片：使用 [start:end:step] 语法来获取子字符串。
var1 = 'Hello, World!'
print(var1[0])          # 输出: H
print(var1[-1])         # 输出: !
print(var1[7:12])       # 输出: World
print(var1[:5])         # 输出: Hello
print(var1[7:])         # 输出: World!
print(var1[::2])        # 输出: Hlo ol!
3. 字符串的操作

Python 提供了多种字符串操作符，用于连接、重复、检查成员等操作。

  • 连接 (+)：将两个字符串连接在一起。
  • 重复 (*)：将字符串重复指定次数。
  • 索引 ([])：访问字符串中的单个字符。
  • 切片 ([:])：获取子字符串。
  • 成员检查 (in 和 not in)：检查子字符串是否存在于字符串中。
a = "Hello"
b = "Python"print(a + b)           # 输出: HelloPython
print(a * 3)           # 输出: HelloHelloHello
print(a[1])            # 输出: e
print(a[1:4])          # 输出: ell
print("H" in a)        # 输出: True
print("M" not in a)    # 输出: True
4. 转义字符

在字符串中使用特殊字符时，可以使用反斜杠 \ 进行转义。常见的转义字符包括：

转义字符描述
\\反斜杠符号
\'单引号
\"双引号
\n换行
\t横向制表符
\r回车
\v纵向制表符
\b退格 (Backspace)
\f换页
\xhh十六进制数
\ooo八进制数
print('Hello\nWorld')  # 输出:
# Hello
# Worldprint('Hello\tWorld')  # 输出: Hello   World
5. 字符串格式化

Python 提供了多种方式来格式化字符串，包括 % 操作符、str.format() 方法和 f-string（Python 3.6+）。

使用 % 操作符
name = "Alice"
age = 30
print("My name is %s and I am %d years old." % (name, age))
# 输出: My name is Alice and I am 30 years old.
使用 str.format()
print("My name is {} and I am {} years old.".format(name, age))
# 输出: My name is Alice and I am 30 years old.print("My name is {0} and I am {1} years old.".format(name, age))
# 输出: My name is Alice and I am 30 years old.print("My name is {name} and I am {age} years old.".format(name="Bob", age=25))
# 输出: My name is Bob and I am 25 years old.
使用 f-string（Python 3.6+）
print(f"My name is {name} and I am {age} years old.")
# 输出: My name is Alice and I am 30 years old.# 支持表达式
print(f"Next year, I will be {age + 1} years old.")
# 输出: Next year, I will be 31 years old.
6. Unicode 字符串

Python 3 中所有字符串默认都是 Unicode 字符串。可以在字符串前加上 u 前缀来显式声明 Unicode 字符串（虽然这不是必需的）。

unicode_str = u"Hello, 世界!"
print(unicode_str)  # 输出: Hello, 世界!
7. 常用字符串方法

Python 提供了许多内置的字符串方法，用于处理和操作字符串。以下是一些常用的字符串方法：

  • capitalize()：将字符串的第一个字符大写，其余字符小写。
  • center(width)：返回一个居中对齐的字符串，宽度为 width，两边填充空格。
  • count(sub)：返回子字符串 sub 在字符串中出现的次数。
  • endswith(suffix)：检查字符串是否以指定的后缀结尾。
  • find(sub)：返回子字符串 sub 第一次出现的索引，未找到则返回 -1。
  • index(sub)：类似于 find()，但找不到时会抛出 ValueError。
  • isalnum()：检查字符串是否只包含字母和数字。
  • isalpha()：检查字符串是否只包含字母。
  • isdigit()：检查字符串是否只包含数字。
  • islower()：检查字符串是否全为小写字母。
  • isupper()：检查字符串是否全为大写字母。
  • join(iterable)：将可迭代对象中的元素用字符串连接起来。
  • lower()：将字符串中的所有字符转换为小写。
  • upper()：将字符串中的所有字符转换为大写。
  • replace(old, new)：将字符串中的 old 子字符串替换为 new。
  • split(sep)：根据分隔符 sep 将字符串分割成列表。
  • strip()：去除字符串两端的空白字符。
  • startswith(prefix)：检查字符串是否以指定的前缀开头。
  • title()：将字符串中的每个单词首字母大写。
  • zfill(width)：返回长度为 width 的字符串，原字符串右对齐，前面填充 0。
text = "hello world"print(text.capitalize())      # 输出: Hello world
print(text.center(20))        # 输出:       hello world       
print(text.count("l"))        # 输出: 3
print(text.endswith("world")) # 输出: True
print(text.find("o"))         # 输出: 4
print(text.isalpha())         # 输出: False
print(text.isdigit())         # 输出: False
print(text.islower())         # 输出: True
print(" ".join(["a", "b", "c"]))  # 输出: a b c
print(text.lower())           # 输出: hello world
print(text.upper())           # 输出: HELLO WORLD
print(text.replace("world", "Python"))  # 输出: hello Python
print(text.split(" "))        # 输出: ['hello', 'world']
print(text.strip())           # 输出: hello world
print(text.startswith("hello"))  # 输出: True
print(text.title())           # 输出: Hello World
print(text.zfill(20))         # 输出: 00000000000000hello world
8. 三引号字符串

三引号字符串允许字符串跨越多行，并保留原始的换行符、制表符等特殊字符。这对于编写多行文本（如 HTML、SQL 查询等）非常有用。

html = '''
<html>
<head>
<title>Example</title>
</head>
<body>
<p>Hello, World!</p>
</body>
</html>
'''sql_query = """
CREATE TABLE users (id INTEGER PRIMARY KEY,name TEXT NOT NULL,email TEXT UNIQUE
);
"""print(html)
print(sql_query)
9. 字符串编码与解码

Python 提供了 encode() 和 decode() 方法来处理字符串的编码和解码。常用的编码格式包括 UTF-8、ASCII 等。

original = "你好，世界！"
encoded = original.encode('utf-8')
print(encoded)  # 输出: b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8c\xe4\xb8\x96\xe7\x95\x8c\xef\xbc\x81'decoded = encoded.decode('utf-8')
print(decoded)  # 输出: 你好，世界！

总结

通过上述详细的解释，我们全面介绍了 Python 字符串的创建、访问、操作、格式化、Unicode 支持、常用方法以及三引号字符串等内容。这些知识不仅涵盖了字符串的基本用法，还包括了许多高级功能，帮助你在编程中更高效地处理文本数据。

如果你有任何具体问题或需要进一步的解释，请随时告诉我！

理解到您希望获取更深入的信息，我将针对 Python 字符串提供一些更为高级和深入的内容，包括字符串的内部表示、不可变性的影响、性能优化技巧、正则表达式处理、以及一些不常见的字符串方法和特性。

1. 字符串的内部表示

Unicode 内部表示

在 Python 3 中，所有字符串都是 Unicode 字符串。Python 使用 UTF-8、UTF-16 或者 UCS-4（即 UTF-32）来内部存储这些字符串，具体取决于编译时的配置。默认情况下，Python 3 使用 UTF-8 编码，这是最节省空间的方式，尤其对于 ASCII 字符集。

  • UTF-8：每个字符占用 1 到 4 个字节。
  • UTF-16：每个字符占用 2 或 4 个字节。
  • UCS-4 (UTF-32)：每个字符固定占用 4 个字节。
字符串的内存布局

Python 的字符串对象是由 C 结构体 PyUnicodeObject 表示的，它包含以下字段：

  • ob_base：继承自 PyObject，包含引用计数和类型信息。
  • length：字符串的长度。
  • hash：字符串的哈希值（如果已计算）。
  • state：状态标志，指示字符串是否是 ASCII、是否需要重新计算哈希等。
  • wstr 或 utf8：实际存储的字符数据，根据使用的编码方式不同而变化。

2. 不可变性的影响

字符串的不可变性意味着一旦创建，就不能更改其内容。这不仅影响了如何操作字符串，还对性能有重要影响：

  • 性能影响：每次修改字符串（如拼接、替换等），都会创建一个新的字符串对象。因此，频繁修改字符串可能会导致性能问题，特别是在循环中。
  • 内存管理：由于字符串是不可变的，Python 可以安全地进行字符串共享。例如，相同的短字符串可能会在多个地方重用同一个对象，从而节省内存。
  • 缓存机制：Python 对小整数和短字符串进行了缓存。例如，'hello' + 'world' 和 'helloworld' 可能会指向同一个内存地址。
性能优化技巧

  • 使用 join() 而不是 +：在循环中拼接字符串时，使用 join() 比直接使用 + 更高效。join() 会在一次操作中分配足够的内存并完成拼接，而 + 每次都会创建新的字符串对象。

    # 不推荐
result = ""
for word in words:result += word# 推荐
result = ''.join(words)

  • 使用生成器表达式：当处理大量数据时，使用生成器表达式可以减少内存占用。

    # 不推荐
result = ''.join([str(x) for x in range(1000000)])# 推荐
result = ''.join(str(x) for x in range(1000000))

  • 避免不必要的字符串创建：尽量减少不必要的字符串创建，特别是在循环或递归中。例如，使用 f-string 代替 + 拼接。

    # 不推荐
print("Processing item " + str(i))# 推荐
print(f"Processing item {i}")

3. 正则表达式处理

Python 提供了强大的正则表达式模块 re，用于复杂的字符串匹配和操作。正则表达式不仅可以用于简单的模式匹配，还可以用于提取、替换、分割等操作。

常用的正则表达式函数
  • re.match(pattern, string)：从字符串的开头开始匹配，如果匹配成功返回一个匹配对象，否则返回 None。
  • re.search(pattern, string)：在整个字符串中搜索匹配，返回第一个匹配的对象，如果没有找到则返回 None。
  • re.findall(pattern, string)：返回所有匹配的子字符串，作为一个列表。
  • re.sub(pattern, repl, string)：将字符串中所有匹配 pattern 的部分替换为 repl。
  • re.split(pattern, string)：根据 pattern 分割字符串，返回一个列表。
示例
import retext = "The rain in Spain falls mainly in the plain."# 匹配以 "The" 开头的字符串
match = re.match(r"The", text)
print(match.group())  # 输出: The# 查找所有以 "ai" 结尾的单词
matches = re.findall(r"\b\w*ai\w*\b", text)
print(matches)  # 输出: ['rain', 'Spain', 'mainly']# 替换 "ain" 为 "ane"
new_text = re.sub(r"ain", "ane", text)
print(new_text)  # 输出: The rane in Spne falls meneley in the plane.# 根据空格分割字符串
words = re.split(r"\s+", text)
print(words)  # 输出: ['The', 'rain', 'in', 'Spain', 'falls', 'mainly', 'in', 'the', 'plain.']
高级正则表达式技巧
  • 捕获组：使用圆括号 () 来捕获匹配的部分，并可以通过 group() 方法访问。
  • 非捕获组：使用 (?:...) 来定义一个非捕获组，不会保存匹配结果。
  • 前瞻断言：使用 (?=...) 来定义一个正向前瞻断言，确保某个模式出现在当前位置之后。
  • 后顾断言：使用 (?<=...) 来定义一个正向后顾断言，确保某个模式出现在当前位置之前。
  • 惰性匹配：使用 .*? 来实现惰性匹配，尽可能少地匹配字符。
示例
# 捕获组
match = re.search(r"(\d{3})-(\d{2})-(\d{4})", "My SSN is 123-45-6789")
if match:print(match.groups())  # 输出: ('123', '45', '6789')# 前瞻断言
matches = re.findall(r"\w+(?=!)","Hello world!")
print(matches)  # 输出: ['world']# 后顾断言
matches = re.findall(r"(?<=\d{3}-)\d{2}", "My SSN is 123-45-6789")
print(matches)  # 输出: ['45']# 惰性匹配
match = re.search(r"<.*?>", "<b>bold</b> and <i>italic</i>")
print(match.group())  # 输出: <b>

4. 不常见的字符串方法和特性

string.maketrans() 和 translate()

maketrans() 和 translate() 是两个非常有用的字符串方法，用于执行字符替换和删除操作。maketrans() 创建一个翻译表，translate() 使用该表进行字符替换。

# 创建翻译表
trans_table = str.maketrans("aeiou", "AEIOU")# 使用翻译表进行字符替换
text = "hello world"
translated = text.translate(trans_table)
print(translated)  # 输出: hEllO wOrld# 删除指定字符
trans_table = str.maketrans("", "", "aeiou")
translated = text.translate(trans_table)
print(translated)  # 输出: hll wrld
string.format_map(mapping)

format_map() 是 str.format() 的一个变种，它接受一个映射对象（如字典）作为参数，而不是位置参数或关键字参数。这对于动态生成格式化字符串非常有用。

class DefaultDict(dict):def __missing__(self, key):return f"{{{key}}}"template = "Name: {name}, Age: {age}, Country: {country}"
data = {"name": "Alice", "age": 30}
formatted = template.format_map(DefaultDict(data))
print(formatted)  # 输出: Name: Alice, Age: 30, Country: {country}
string.casefold()

casefold() 是一个比 lower() 更强大的方法，专门用于忽略大小写的比较。它能够处理更多语言中的特殊情况，例如德语中的 “ß”。

text1 = "Straße"
text2 = "STRASSE"print(text1.lower() == text2.lower())  # 输出: False
print(text1.casefold() == text2.casefold())  # 输出: True
string.removesuffix(suffix) 和 string.removeprefix(prefix)

这两个方法分别用于移除字符串的前缀和后缀。它们是在 Python 3.9 中引入的，提供了更简洁的语法。

filename = "example.txt"
print(filename.removesuffix(".txt"))  # 输出: examplepath = "/home/user/documents"
print(path.removeprefix("/home/"))  # 输出: user/documents
string.isidentifier()

isidentifier() 用于检查字符串是否是一个有效的 Python 标识符（如变量名、函数名等）。标识符必须以字母或下划线开头，后面可以跟字母、数字或下划线。

print("my_var".isidentifier())  # 输出: True
print("123var".isidentifier())  # 输出: False
print("my-var".isidentifier())  # 输出: False
string.isprintable()

isprintable() 用于检查字符串中的所有字符是否都是可打印的字符（即不是控制字符）。这对于验证用户输入或文件内容非常有用。

print("Hello, World!".isprintable())  # 输出: True
print("Hello, World!\n".isprintable())  # 输出: False

5. 字符串的性能优化

除了前面提到的使用 join() 和生成器表达式外，还有一些其他优化技巧可以帮助提高字符串操作的性能：

  • 使用 io.StringIO：当需要构建大字符串时，可以使用 io.StringIO 作为缓冲区，避免频繁的字符串拼接。

    from io import StringIObuffer = StringIO()
for i in range(1000000):buffer.write(str(i))
result = buffer.getvalue()

  • 预分配内存：如果你知道最终字符串的大概长度，可以在初始化时预分配足够的内存，减少内存重新分配的次数。

    result = bytearray(1000000)

  • 使用 array.array：对于特定类型的字符（如 ASCII），可以使用 array.array 来存储字符，最后再转换为字符串。

    import arraychars = array.array('u', 'hello')
result = chars.tounicode()

  • 避免不必要的解码和编码：如果你只需要处理字符串而不涉及文件 I/O 或网络传输，尽量避免不必要的编码和解码操作，因为这些操作会带来额外的开销。

    # 不推荐
encoded = original.encode('utf-8').decode('utf-8')# 推荐
result = original

6. 字符串的多线程和并发处理

在多线程或并发环境中，字符串的不可变性实际上是一个优势，因为它避免了多个线程同时修改同一个字符串时可能出现的竞争条件。然而，如果你需要在多个线程之间共享和修改字符串，建议使用线程安全的数据结构，如 queue.Queue 或 threading.Lock 来保护共享资源。

7. 字符串的国际化和本地化

Python 提供了 gettext 模块来支持国际化和本地化（i18n 和 l10n）。gettext 允许你为应用程序的不同语言版本提供翻译文件，并在运行时根据用户的语言设置选择合适的翻译。

示例
import gettext# 加载翻译文件
translator = gettext.translation('messages', localedir='locales', languages=['fr'])
_ = translator.gettextprint(_("Hello, World!"))  # 输出: Bonjour, le monde!

总结

通过上述深入的探讨，我们涵盖了 Python 字符串的内部表示、不可变性的影响、性能优化技巧、正则表达式的高级用法、不常见的字符串方法以及多线程和国际化方面的内容。这些知识点不仅帮助你更好地理解和使用 Python 字符串，还能让你在编写高性能、可维护的代码时做出更明智的选择。

如果您有任何更具体的问题或需要进一步的解释，请随时告诉我！


http://www.mrgr.cn/news/80240.html

相关文章：

  • 12.16周一F34-Day27打卡
  • 三七互娱Android面试题及参考答案
  • R-CNN
  • 【图像处理】利用numpy、opencv、python实现车牌检测
  • OELOVE 6.0城市列表模板
  • 智能时代的基石：神经网络
  • AI学习记录 - 依据 minimind 项目入门
  • 算法刷题Day18: BM41 输出二叉树的右视图
  • gitee仓库的使用
  • 【考前预习】3.计算机网络—数据链路层
  • 【conda/cuda/cudnn/tensorrt】一份简洁的深度学习环境安装清单
  • Mac上使用ln指令创建软链接、硬链接
  • HarmonyOS Next 元服务新建到上架全流程
  • 算法题（2）：三步问题
  • 金蝶云资料汇总
  • C++----类与对象（上篇）
  • AOF和RDB【Redis持久化篇】
  • etcd节点扩/缩容
  • 【图像处理lec3、4】空间域的图像增强
  • ubuntu 下的sqlite3