字符串

在Python中，字符串是一个不可变的序列，由一系列Unicode字符组成。

字符串可以用单引号、双引号、三引号来表示，其中单引号和双引号的作用是相同的，而三引号则可以用来表示多行字符串。

字符串定义

使用单引号表示字符串

s1 = 'Hello, world!'
print(s1)  # Output: Hello, world!

使用双引号表示字符串

s2 = "Hello, world!"
print(s2)  # Output: Hello, world!

使用三引号表示多行字符串

s3 = """Hello,
world!"""
print(s3)  # Output: Hello,
           #         world!

字符串处理

r 前缀

r 前缀就是告诉字符串不要转义了

在Python中，字符串可以使用r前缀来表示一个“原始字符串”，它的作用是告诉Python解释器，这个字符串中的所有字符都应该按照它们的字面意义来处理，而不进行任何转义。

对于Python中的字符串，r前缀可以大写也可以小写，它的作用是告诉Python将字符串视为“原始字符串”，即不会对其中的转义字符进行转义。无论是大写的R还是小写的r，它们的作用是一样的，都可以用来表示“原始字符串”。

范例

在某些情况下，使用r前缀可以让代码更加清晰易懂，特别是当你需要表示一些包含大量反斜杠的字符串时，避免手动进行转义可以让代码更加简洁，易读。

例如，假设我们要表示一个Windows路径：

path = "C:\\Users\\Bob\\Documents\\example.txt"

这个路径中包含了很多反斜杠（\），而反斜杠是一个转义字符，因此需要使用两个反斜杠来表示一个反斜杠。

但是，如果我们使用r前缀，则可以让Python将字符串视为“原始字符串”，这样就不需要使用两个反斜杠来表示一个反斜杠了，例如：

path = r"C:\Users\Bob\Documents\example.txt"

在这个字符串中，反斜杠不再是一个转义字符，而是一个普通的字符，因此只需要使用单个反斜杠来表示它即可。

在上面的例子中，r前缀告诉Python解释器，字符串中的反斜杠应该被当作普通字符来处理，而不是表示转义字符，因此这个字符串可以直接被用于Windows路径的表示，而不需要对反斜杠进行转义。

f 前缀

使用f-字符串，我们可以在字符串中使用大括号{}来引用Python表达式，例如变量、函数调用、算术运算等等。在字符串被解析和格式化时，大括号内的表达式将被计算并替换为其结果。

范例

下面是一个使用f-字符串进行格式化输出的示例：

name = "Alice"
age = 30
height = 1.65

print(f"My name is {name}, and I am {age} years old. My height is {height:.2f} meters.")

在这个例子中，我们使用f-字符串来输出一句话，包括名字、年龄和身高。在字符串中，我们使用大括号{}来引用变量name、age和height，并使用点号.来表示要对height进行小数位精度控制。在输出时，Python会计算这些表达式并替换大括号内的内容，最终输出的结果为：

My name is Alice, and I am 30 years old. My height is 1.65 meters.

相比于传统的字符串格式化方式，使用f-字符串可以使代码更加简洁易读，并且提供了更多的灵活性和可读性。

f前缀 & format()

f前缀

import time
import threading
import logging

FORMAT = '%(asctime)s %(message)s'

logging.basicConfig(format=FORMAT, level=logging.INFO)

lock = threading.Lock()

x = lock.acquire()

print(x)

def worker(l: threading.Lock):
    name = threading.current_thread().name
    logging.info(f'{name} wants to get locker')  # Fixed the logging format here
    logging.info(l.acquire())
    logging.info(f'{name} finished')  # Fixed the logging format here
    l.release()  # Release the lock after finishing the task

for i in range(5):
    threading.Thread(target=worker, name=f'w{i}', args=(lock,)).start()

format()

import time
import threading
import logging

FORMAT = '%(asctime)s %(message)s'

logging.basicConfig(format=FORMAT, level=logging.INFO)

lock = threading.Lock()

x = lock.acquire()

print(x)

def worker(l: threading.Lock):
    name = threading.current_thread().name
    logging.info('{} wants to get locker'.format(name))  # Using .format() for string formatting
    logging.info(l.acquire())
    logging.info('{} finished'.format(name))  # Using .format() for string formatting
    l.release()  # Release the lock after finishing the task

for i in range(5):
    threading.Thread(target=worker, name='w{}'.format(i), args=(lock,)).start()

字符串连接

字符串可以通过"+“操作符连接起来，例如：

str1 = 'Hello'
str2 = 'World'
result = str1 + ' ' + str2
print(result)  # Output: Hello World

其它方式

s4 = 'Hello,'
s5 = ' world!'
s6 = s4 + s5
print(s6)  # Output: Hello, world!

字符串的切片

s7 = 'Hello, world!'
print(s7[0:5])  # Output: Hello
print(s7[7:])   # Output: world!

这段代码定义了一个字符串变量 s7 并将其赋值为 'Hello, world!'。接着使用字符串的切片操作获取字符串的子串。
s7[0:5] 表示获取 s7 中下标从 0 到 5（不包含 5）的子串，即字符串的前 5 个字符，所以输出结果为 Hello。
s7[7:] 表示获取 s7 中下标从 7 到字符串末尾的子串，即字符串的第 8 个字符到最后一个字符，所以输出结果为 world!。
需要注意的是，字符串的下标从 0 开始，即第一个字符的下标为 0，第二个字符的下标为 1，以此类推。同时，切片操作包含左端点而不包含右端点。因此 s7[0:5] 表示获取下标从 0 到 4 的字符，而不包含下标为 5 的字符。而 s7[7:] 表示获取下标从 7 到字符串末尾的所有字符。

删除最后一个字符

root@local-test:~/python# cat 1.py 
#!/usr/local/bin/python3
text = "Hello  World\n"
print(text)
root@local-test:~/python# ./1.py 
Hello  World

root@local-test:~/python# 


root@local-test:~/python# cat 1.py 
#!/usr/local/bin/python3
text = "Hello  World\n"
print(text[:-1])  # [:-1]，删除最后一个字符
root@local-test:~/python# ./1.py 
Hello  World
root@local-test:~/python# 

字符串格式化

字符串格式化可以通过占位符（%）来实现，例如：

name = 'Alice'
age = 25
result = 'My name is %s and I am %d years old.' % (name, age)
print(result)  # Output: My name is Alice and I am 25 years old.

这段代码定义了两个变量 name 和 age，分别存储字符串类型的名字 'Alice' 和整数类型的年龄 25。接着使用字符串格式化操作生成一个新的字符串 result，其中 %s 表示格式化字符串，将会被替换成一个字符串类型的变量；%d 表示格式化整数，将会被替换成一个整数类型的变量。
在本例中，'%s' 格式化字符串将会被替换成 name 变量中存储的 'Alice' 字符串，'%d' 格式化整数将会被替换成 age 变量中存储的 25 整数。因此，最终生成的字符串为 'My name is Alice and I am 25 years old.'。
最后，使用 print() 函数将 result 字符串输出到控制台。输出结果为 My name is Alice and I am 25 years old.。
还可以使用f-string来进行字符串格式化，例如：
常用

name = 'Alice'
age = 25
result = f'My name is {name} and I am {age} years old.'
print(result)  # Output: My name is Alice and I am 25 years old.

字符串分割和连接

字符串可以使用split()方法来按照指定的分隔符将其分割成一个列表，例如：

s = 'apple,banana,orange'
result = s.split(',')
print(result)  # Output: ['apple', 'banana', 'orange']

而join()方法则可以将一个列表中的字符串连接起来，例如：

lst = ['apple', 'banana', 'orange']
result = ','.join(lst)
print(result)  # Output: 'apple,banana,orange'

字符串的大小写转换

字符串可以使用lower()方法将其转换为小写，使用upper()方法将其转换为大写，例如：

s = 'Hello World'
result1 = s.lower()
result2 = s.upper()
print(result1)  # Output: 'hello world'
print(result2)  # Output: 'HELLO WORLD'

字符串的查找和替换

字符串可以使用find()方法来查找子串在字符串中的位置，如果找到则返回其在字符串中的索引，否则返回-1，例如：

s = 'Hello World'
result = s.find('World')
print(result)  # Output: 6

replace()方法则可以用来替换字符串中的子串，例如：

s = 'Hello World'
result = s.replace('World', 'Python')
print(result)  # Output: 'Hello Python'

其他用法

s8 = 'Hello, world!'
s9 = s8.replace('world', 'Python')
print(s9)        # Output: Hello, Python!

s10 = 'Hello, world!'
idx = s10.find('world')
print(idx)       # Output: 7

字符串对齐显示

除了使用字符串的 ljust()、rjust() 和 center() 方法之外，还可以使用格式化字符串来实现对齐显示。你可以使用字符串的格式化方法 % 或者 format() 方法来实现。

使用 % 格式化字符串：

text = "Hello"

## 左对齐，总宽度为10，不足部分用空格填充
left_aligned = "%-10s" % text
print("Left aligned:", left_aligned)

## 右对齐，总宽度为10，不足部分用空格填充
right_aligned = "%10s" % text
print("Right aligned:", right_aligned)

## 居中对齐，总宽度为10，不足部分用空格填充
center_aligned = "%^10s" % text
print("Center aligned:", center_aligned)

使用 format() 方法：

text = "Hello"

## 左对齐，总宽度为10，不足部分用空格填充
left_aligned = "{:<10}".format(text)
print("Left aligned:", left_aligned)

## 右对齐，总宽度为10，不足部分用空格填充
right_aligned = "{:>10}".format(text)
print("Right aligned:", right_aligned)

## 居中对齐，总宽度为10，不足部分用空格填充
center_aligned = "{:^10}".format(text)
print("Center aligned:", center_aligned)

这两种方法都提供了类似的功能，你可以根据个人喜好选择其中一种来实现字符串对齐显示。

字符串常用方法

strip()

strip() 是 Python 字符串对象的一个方法，用于移除字符串开头和结尾的指定字符（默认为空格字符）。这个方法返回一个新字符串，原始字符串不受影响。以下是 strip() 方法的详细说明：

string.strip([chars])

string: 要处理的字符串。
chars（可选）：指定要从字符串开头和结尾移除的字符集。如果没有指定，则默认移除空格字符。

strip() 方法的作用是移除字符串开头和结尾的指定字符（或空格字符）。例如：

text = "   Hello, World!   "
result = text.strip()
print(result)

输出：

Hello, World!

在这个例子中，strip() 移除了字符串 text 开头和结尾的空格，得到了去除空格的新字符串。

如果提供了 chars 参数，strip() 将从开头和结尾依次移除指定字符集中包含的字符。例如：

text = "===Hello, World!==="
result = text.strip('=')
print(result)

输出：

Hello, World!

在这个例子中，strip('=') 移除了字符串 text 开头和结尾的等号，得到了新的字符串。

总之，strip() 是一个方便的方法，用于处理字符串的前导和尾随空格或指定字符。

1

如果 pattern 的部分内容是通过执行 shell 命令提取的，那么你需要小心处理可能的特殊字符和空白。执行 shell 命令可能返回带有换行符等特殊字符的文本，这可能会影响正则表达式的匹配。

确保在使用从 shell 命令返回的文本作为正则表达式模式时进行适当的转义。你可以使用 re.escape 函数来确保字符串中的特殊字符不被解释为正则表达式的元字符。

例如：

import re
import subprocess

## 通过 shell 命令获取 pattern
command_output = subprocess.run(["your_shell_command"], stdout=subprocess.PIPE, text=True)
pattern = re.escape(command_output.stdout.strip())

text = """这是一段文本，其中包含一些关键词。
关键词可以是任何你想要过滤的内容。
这行不包含关键词。
另一行包含关键词，关键词在末尾。"""

matches = re.findall(pattern, text)

for match in matches:
    print(match.strip())

这样，你可以确保从 shell 命令中获取的文本被正确处理，避免可能的正则表达式问题。如果问题仍然存在，你可能需要检查从 shell 命令中返回的确切文本，并相应地调整你的正则表达式模式。

startswith() 是否以指定前缀开头

在 Python 中，str.startswith() 是一个用于检查字符串是否以指定的前缀开头的方法。该方法返回一个布尔值，表示字符串是否以指定的前缀开始。

以下是该方法的基本语法：

str.startswith(prefix[, start[, end]])

prefix：要检查的前缀字符串。
start（可选）：指定开始检查的位置的索引。如果提供了这个参数，startswith() 将从指定索引开始检查前缀。默认值为 0。
end（可选）：指定结束检查的位置的索引。如果提供了这个参数，startswith() 将在指定索引之前停止检查前缀。默认值为字符串的长度。

下面是一些示例：

## 示例 1
text = "Hello, World!"
result = text.startswith("Hello")
print(result)  # 输出 True

## 示例 2
result = text.startswith("World", 7)  # 从索引 7 开始检查
print(result)  # 输出 True

## 示例 3
result = text.startswith("Hello", 7, 12)  # 在索引 7 到 12 之间检查
print(result)  # 输出 False

在示例 1 中，startswith() 方法检查字符串 text 是否以 “Hello” 开头，并返回 True。

在示例 2 中，通过提供第二个参数，指定了开始检查的索引为 7，即从字符串的第 8 个字符开始检查是否以 “World” 开头。结果为 True。

在示例 3 中，通过提供第二个和第三个参数，指定了开始检查的索引为 7，结束检查的索引为 12。因此，方法会在索引 7 到 12 之间检查是否以 “Hello” 开头，结果为 False。

ljust()、rjust()、center()

在Python中，你可以使用字符串的 ljust()、rjust() 和 center() 方法来实现左对齐、右对齐和居中对齐显示。

这些方法的语法如下：

ljust(width[, fillchar]): 返回一个左对齐的字符串，并使用可选的 fillchar（默认为空格）填充至指定长度 width。
rjust(width[, fillchar]): 返回一个右对齐的字符串，并使用可选的 fillchar（默认为空格）填充至指定长度 width。
center(width[, fillchar]): 返回一个中心对齐的字符串，并使用可选的 fillchar（默认为空格）填充至指定长度 width。

以下是这些方法的简单示例：

text = "Hello"

## 左对齐，总宽度为10，不足部分用空格填充
left_aligned = text.ljust(10)
print("Left aligned:", left_aligned)

## 右对齐，总宽度为10，不足部分用空格填充
right_aligned = text.rjust(10)
print("Right aligned:", right_aligned)

## 居中对齐，总宽度为10，不足部分用空格填充
center_aligned = text.center(10)
print("Center aligned:", center_aligned)

输出：

    Left aligned: Hello     
Right aligned:      Hello
Center aligned:   Hello   
  

你可以根据需要调整总宽度和填充字符。

—

111

在 Python 中，字符串是一种不可变的序列类型，用于表示文本数据。字符串是由字符组成的，可以包含字母、数字、标点符号等字符。在 Python 中，字符串是使用单引号或双引号括起来的。

以下是关于 Python 字符串的一些重要概念和操作：

创建字符串

## 使用单引号创建字符串
string_single = 'Hello, World!'

## 使用双引号创建字符串
string_double = "Python Programming"

字符串索引和切片

字符串中的每个字符都有一个索引，可以使用索引访问单个字符，索引从0开始：

## 访问单个字符
char = string_single[0]  # 'H'

使用切片来获取子字符串：

## 获取子字符串
substring = string_double[7:11]  # 'Progr'

字符串连接

使用 + 运算符来连接两个字符串：

## 字符串连接
concatenated_string = string_single + " " + string_double
## 'Hello, World! Python Programming'

字符串长度

使用 len() 函数获取字符串的长度：

## 获取字符串长度
length = len(string_single)  # 13

字符串方法

Python 提供了许多字符串方法，用于执行各种操作，如查找子字符串、替换字符、转换大小写等。

## 查找子字符串
index = string_double.find("Pro")  # 7

## 替换字符
new_string = string_single.replace("Hello", "Hi")  # 'Hi, World!'

## 转换大小写
upper_case = string_double.upper()  # 'PYTHON PROGRAMMING'
lower_case = string_double.lower()  # 'python programming'

原始字符串

在字符串前面加上 r 或 R 可以创建原始字符串，其中的转义字符不会被处理：

raw_string = r"C:\Users\Username\Documents"

格式化字符串

使用字符串的 format() 方法或 f-string 进行字符串格式化：

name = "Alice"
age = 25
formatted_string = "My name is {} and I am {} years old.".format(name, age)

## 或者使用 f-string
f_string = f"My name is {name} and I am {age} years old."

以上只是 Python 字符串的一些基本操作和特性，Python 提供了更多丰富的字符串处理方法和函数，可以根据具体需求选择适合的方法。