字符串

定义一个字符串

name = "小满"
age = 3

sentence = """
山腰的风景很美
然而
我还是
想去山顶看看
"""

字符串的嵌套

外面是单引号, 里面的字符串使用双引号

外面是双引号, 里面的字符串使用单引号

content = '编程里有一个DRY原则: "Don\'t repeat your self."'
print(content)  # 编程里有一个DRY原则: "Don't repeat your self."

content = "编程里有一个DRY原则: 'Do not repeat your self.'"
print(content)  # 编程里有一个DRY原则: 'Do not repeat your self.'

原始字符串

使用原始字符串, 就是在字符串最前面加上一个r, 一般情况下正则用的会比较多

# 未使用原始字符串
path = "c:\teacher\homework"
print(path) # c:	eacher\homework

# 使用了原始字符串
path = r"c:\teacher\homework"
print(path)  # c:\teacher\homework

字符串相加

first_name = "jack"
last_name = "chen"
full_name = first_name + " " + last_name

print(full_name)  # jack chen

字符串相乘

word = "ha"
sentence = "He said " + word * 5

print(sentence)  # He said hahahahaha

字符串索引

索引从0开始，在字符串中取值可以使用str[index]的方法去取值，-1为最后一个值。

sentence = "下雨了别跑，反正前面也是雨。"

print(sentence[0])  # 下
print(sentence[-2])  # 雨

查看索引

# 方法1 index
# 找到了返回对应位置，找不到就报错

sentence = "下雨了别跑，反正前面也是雨。"
print(sentence.index("别跑"))  # 3

sentence = "下雨了别跑，反正前面也是雨。"
print(sentence.index("别跑啦"))  # 报错 ValueError: substring not found


# 方法2 find
# 找到了返回对应位置，找不到返回-1

sentence = "下雨了别跑，反正前面也是雨。"
print(sentence.find("前面"))  # 8

sentence = "下雨了别跑，反正前面也是雨。"
print(sentence.find("后面"))  # -1

切片

sentence = "下雨了别跑，反正前面也是雨。"

print(sentence[:3])  # 下雨了
print(sentence[-6:-1])  # 前面也是雨
print(sentence[:])  # 下雨了别跑，反正前面也是雨

统计次数

sentence = "下雨了别跑，反正前面也是雨。"

print(sentence.count("雨"))  # 2
print(sentence.count("跑"))  # 1
print(sentence.count("走"))  # 0

字符串转义

转义字符	说明
\n	换行符，将光标位置移到下一行开头。
\r	回车符，将光标位置移到本行开头。
\t	水平制表符，也即 Tab 键，一般相当于四个空格。
\a	蜂鸣器响铃。注意不是喇叭发声，现在的计算机很多都不带蜂鸣器了，所以响铃不一定有效。
\b	退格（Backspace），将光标位置移到前一列。
\	反斜线
'	单引号
"	双引号
\	在字符串行尾的续行符，即一行未完，转到下一行继续写。

字符串格式化输出

f-string格式化

f-string 是在 Python 3.6 版本引入的一种字符串格式化方法，它允许在字符串中嵌入表达式，并在运行时对它们进行求值。使用 f-string 可以更简洁和直观地进行字符串格式化。

f-string 的语法很简单，只需在字符串前加上字母 'f' 或 'F'，然后在字符串中使用花括号 {} 括起表达式。在花括号中，你可以放置变量、表达式或调用函数。

food = "冰淇淋"
number = 2
sentence = f"“我不会因为一个{food}和你走！” “{number}个” “好那我去收拾行李。”"

print(sentence)  # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。” 

进制格式化，结果不含前缀

num = 42

# 二进制
binary = f"Binary: {num:b}"
print(binary)  # 输出: Binary: 101010

# 八进制
octal = f"Octal: {num:o}"
print(octal)  # 输出: Octal: 52

# 十六进制
hex_lower = f"Hex (lowercase): {num:x}"
print(hex_lower)  # 输出: Hex (lowercase): 2a

hex_upper = f"Hex (uppercase): {num:X}"
print(hex_upper)  # 输出: Hex (uppercase): 2A

.format格式化

基本语法

food = "冰淇淋"
number = 2
sentence = "“我不会因为一个{}和你走！” “{}个” “好那我去收拾行李。”".format(food, number)

print(sentence)  # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”

位置参数

food = "冰淇淋"
number = 2
sentence = "“我不会因为一个{1}和你走！” “{0}个” “好那我去收拾行李。”".format(number, food)

print(sentence)  # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”

关键字参数

sentence = "“我不会因为一个{food}和你走！” “{number}个” “好那我去收拾行李。”".format(food="冰淇淋", number=2)
print(sentence)  # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”

混合使用位置参数和关键字参数

sentence = "“我不会因为一个{}和你走！” “{number}个” “好那我去收拾行李。”".format("冰淇淋", number=2)
print(sentence)  # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”

解包字典

data = {
    "food": "冰淇淋",
    "number": 2
}

sentence = "“我不会因为一个{food}和你走！” “{number}个” “好那我去收拾行李。”".format(**data)
print(sentence)  # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”

其他方法补充

# 保留几位小数
# {:.nf} n表示几位小数 
from math import pi

print("The value of pi is approximately: {:.2f}".format(pi))
# The value of pi is approximately: 3.14

# 填充与对齐

number = 42
# {:填充字符 对其方式 共几位} tips:中间无空格
# 尖角号朝左边就是左对齐
# 尖角号朝右边就是右对齐
# ^ 表示居中对齐  tips:英文模式下 shift + 6

# 左对齐 占位10位 右边填充指定字符
print("{:*<10}".format(number))  # 42********
# 右对齐 占位10位 左边填充指定字符
print("{:*>10}".format(number))  # ********42
# 居中对齐 占位10位 左右两侧填充指定字符
print("{:*^10}".format(number))  # ****42****

# 千位分隔符
# 语法 {:,} 

phone_number = 13800138000
print("谁能告诉我这是什么电话号码: {:,}".format(phone_number))  
# 谁能告诉我这是什么电话号码: 13,800,138,000

# 扩展知识
# 在python中，int类型和float类型，如果数字过长，可以使用 _ 下划线去连接

phone_number = 1380_0138_000

print(phone_number)  # 13800138000
print("谁能告诉我这是什么电话号码: {:,}".format(phone_number))
# 谁能告诉我这是什么电话号码: 13,800,138,000

指定宽度和精度

# {:n.3f} 
# n表示一共多少位字符 
	# tips: n的左侧可以填充对其方式以及填充字符 {:0>10.3f}
    #       如何不写默认是右对齐填充空白
# 3表示小数部分的精度
# f表示是一个浮点数

# 字符共10位 右对齐 不足的位置填充*号 小数点保留3位
print("{:*>10.3f}".format(number))
# 字符共10位 右对齐 不足的位置填充空白 小数点保留3位
print("{:10.3f}".format(number))
# 字符共10位 右对齐 不足的位置填充数字0 小数点保留3位
print("{:0>10.3f}".format(number))

# 结果如下

**1234.568
  1234.568
001234.568

进制格式化

decimal_number = 42

# 将整数格式化为二进制，无前缀 "0b"
binary_string = "Binary representation: {:b}".format(decimal_number)
print(binary_string)  # Hex representation with prefix: 101010

# 将整数格式化为八进制，无前缀 "0o"
octal_string = "Octal representation: {:o}".format(decimal_number)
print(octal_string)  # Hex representation with prefix: 52

# 将整数格式化为十六进制，无前缀 "0x"
hex_string = "Hex representation: {:x}".format(decimal_number)
print(hex_string)  # Hex representation with prefix: 2a

# 将整数格式化为十六进制，带有前缀 "0x"
hex_string_with_prefix = "Hex representation with prefix: {:#x}".format(decimal_number)
print(hex_string_with_prefix)  # Hex representation with prefix: 0x2a

解包字典

如果你想在 format() 方法中不传递任何参数，并使用两个星号 ** 解包字典以获取字典的值，可以使用以下方法：

person = {"name": "Alice", "age": 25}

message = "My name is {} and I am {} years old.".format(*person.values())
print(message)

输出结果将是：

My name is Alice and I am 25 years old.

在这个示例中，我们使用 person.values() 来获取字典 person 中的所有值，并将其作为参数传递给 format() 方法。在 format() 方法中，我们使用花括号 {} 来表示占位符，而不传递任何参数。

通过这种方式，我们可以在 format() 方法中不传递任何参数，并使用两个星号 ** 解包字典以获取字典的值，并将其正确打印出来。

format_map格式化

str.format_map(mapping) 是 Python 字符串的方法之一，它用于使用映射对象（通常是字典）中的键值对来替换字符串中的占位符。这个方法类似于 str.format()，但是它接受一个字典作为参数，用字典中的键值对来填充字符串中的占位符。

以下是一个简单的示例：

# 使用 format_map 替换字符串中的占位符
person = {'name': 'Alice', 'age': 30}
sentence = "My name is {name} and I am {age} years old."
formatted_sentence = sentence.format_map(person)

print(formatted_sentence)

在这个例子中，{name} 和 {age} 是占位符，format_map(person) 使用字典中的键值对来替换这些占位符。输出结果将是：

My name is Alice and I am 30 years old.

需要注意的是，format_map() 方法在替换占位符时，如果字典中缺少对应的键，不会引发 KeyError，而是保留占位符不变。这与 format() 方法不同，format() 方法在遇到未知的键时会引发 KeyError。

# 使用 format_map 时不会引发 KeyError
person = {'name': 'Alice'}
sentence = "My name is {name} and I am {age} years old."
formatted_sentence = sentence.format_map(person)

print(formatted_sentence)

输出结果：

My name is Alice and I am {age} years old.

这使得 format_map() 方法在处理部分缺失的数据时更为灵活。

%格式化

food = "冰淇淋"

sentence = "“我不会因为一个%s和你走！” “2个” “好那我去收拾行李。”" % food
print(sentence)  # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”

number = 2

sentence = "“我不会因为一个冰淇淋和你走！” “%d个” “好那我去收拾行李。”" % number
print(sentence)  # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”

number = "2"  # 注意，这里是字符串

sentence = "“我不会因为一个冰淇淋和你走！” “%d个” “好那我去收拾行李。”" % number
print(sentence)  # 报错 TypeError: %d format: a real number is required, not str

# 当参数大于1个的时候，百分号右边需要用一共括号括起来

food = "冰淇淋"
number = 2

sentence = "“我不会因为一个%s和你走！” “%d个” “好那我去收拾行李。”" % (food, number)
print(sentence)  # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”

# %.nf 浮点数，n表示保留几位小数

from math import pi

print("The value of pi is approximately: %.2f" % pi)  
# The value of pi is approximately: 3.14

进制格式化

decimal_number = 42

# 将整数格式化为二进制，带有前缀 "0b"
binary_string = "Binary representation: %s" % bin(decimal_number)
print(binary_string)  # Binary representation: 0b101010

# 将整数格式化为八进制，无前缀 "0o"
octal_string = "Octal representation: %o" % decimal_number
print(octal_string)  # Octal representation: 52

# 将整数格式化为十六进制，无前缀 "0x"
hex_string = "Hex representation: %x" % decimal_number
print(hex_string)  # Hex representation: 2a

总结

更推荐使用f-string格式化或者.format格式化

字符串常用方法

dir(str)

text = "hello worLD"

print(f"text的值为 '{text}'")
print("text.title() 输出", text.title())
print("text.lower() 输出", text.lower())
print("text.upper() 输出 ", text.upper())
print("text.swapcase() 输出", text.swapcase())
print("text.center(20, '*') 输出", text.center(20, "*"))
print("text.ljust(20, '=') 输出", text.ljust(20, "="))
print("text.rjust(20, '=') 输出", text.rjust(20, "="))
print("text.zfill(20) 输出", text.zfill(20))
print("text.strip('LD') 输出", text.strip("LD"))
print("text.rstrip('LD') 输出", text.rstrip("LD"))
print("text.lstrip('h') 输出", text.lstrip('h'))
print("text.split() 输出", text.split())
print("text.casefold() 输出", text.casefold())
print("text.find('1') 输出", text.find('1'), "解析: 如果使用find查找, 找不到就是-1")
print("text.find('L') 输出", text.find('L'))
print("text.find('L', 1) 输出", text.find('L', 1), "解析: 第二个参数表示从哪里开始找")
print("text.count('L')  输出", text.count('L'), "解析: 如果找不到不会报错, 会返回0")
print("text.startswith('hello') 输出", text.startswith('hello'))
print("text.endswith('hello') 输出", text.endswith('hello'))
print("'11'.isdigit() 输出", '11'.isdigit())
print("'11'.isalnum() 输出", '11'.isalnum())
print("'11'.isaplha() 输出", '11'.isalpha())
print("'11'.isnumeric() 输出", '11'.isnumeric())
print("'hello'.islower() 输出", 'hello'.islower())
print("'hello'.isupper() 输出", 'hello'.isupper())
print("'hello'.istitle() 输出", 'hello'.istitle())
print("text.replace('worLD', '小满') 输出", text.replace('worLD', '小满'))
# str.isspace() 是 Python 字符串对象的一个方法，用于检查字符串是否全由空白字符组成。空白字符包括空格、制表符、换行符等。
print("'hello world'.isspace() 输出", "hello world".isspace())
# str.isprintable() 是 Python 字符串对象的方法，用于检查字符串是否可打印。
# 可打印字符是指除了空白字符之外的字符，这些字符在屏幕上会有可见的表示，例如字母、数字、标点符号等。
print(r'"\n\t".isprinttable() 输出', "\n\t".isprintable())
print("'-'.join(['love', 'you']) 输出", '-'.join(['love', 'you']))
# python3.9新增的两个方法
# removeprefix 移除开始的指定字符，如不存在返回整个字符
# removesuffix 移除结尾的指定字符，如不存在返回整个字符
print("text.removeprefix('hello') 输出", text.removeprefix("hello"))
print("text.removesuffix('worLD') 输出", text.removesuffix("worLD"))

结果如下

text的值为 'hello worLD'
text.title() 输出 Hello World
text.lower() 输出 hello world
text.upper() 输出  HELLO WORLD
text.swapcase() 输出 HELLO WORld
text.center(20, '*') 输出 ****hello worLD*****
text.ljust(20, '=') 输出 hello worLD=========
text.rjust(20, '=') 输出 =========hello worLD
text.zfill(20) 输出 000000000hello worLD
text.strip('LD') 输出 hello wor
text.rstrip('LD') 输出 hello wor
text.lstrip('h') 输出 ello worLD
text.split() 输出 ['hello', 'worLD']
text.casefold() 输出 hello world
text.find('1') 输出 -1 解析: 如果使用find查找, 找不到就是-1
text.find('L') 输出 9
text.find('L', 1) 输出 9 解析: 第二个参数表示从哪里开始找
text.count('L')  输出 1 解析: 如果找不到不会报错, 会返回0
text.startswith('hello') 输出 True
text.endswith('hello') 输出 False
'11'.isdigit() 输出 True
'11'.isalnum() 输出 True
'11'.isaplha() 输出 False
'11'.isnumeric() 输出 True
'hello'.islower() 输出 True
'hello'.isupper() 输出 False
'hello'.istitle() 输出 False
text.replace('worLD', '小满') 输出 hello 小满
'hello world'.isspace() 输出 False
"\n\t".isprinttable() 输出 False
'-'.join(['love', 'you']) 输出 love-you
text.removeprefix('hello') 输出  worLD
text.removesuffix('worLD') 输出 hello 

name = "amigo123"

print(name.isalnum())    # 字符串中既可以包含数字也可以包含字母，True
print(name.isalpha())    # 字符串中只包含字母，False
print(name.isidentifier())  # 字符串是否是合法标识符，True
print(name.islower())    # 字符串是否是纯小写，True
print(name.isupper())    # 字符串是否是纯大写，False
print(name.isspace())    # 字符串是否全是空格，False
print(name.istitle())    # 字符串中的单词首字母是否都是大写，False

casefold方法

str.casefold() 是 Python 字符串对象的方法，用于执行字符串的大小写折叠（case folding）。大小写折叠是一种更加广泛的字符匹配方式，通常用于比较字符串而忽略大小写，并且比 str.lower() 更具有 Unicode 兼容性。

在 Python 中，str.casefold() 将字符串中的所有字符转换为小写，并且还考虑了一些特殊字符的 Unicode 等价物。这使得字符串比较更加严格，适用于不同语言和区域的情况。

以下是一个示例：

string1 = "Hello"
string2 = "heLLo"

# 使用 casefold 进行比较
if string1.casefold() == string2.casefold():
    print("Strings are case-insensitive equal.")
else:
    print("Strings are not case-insensitive equal.")

在这个例子中，string1.casefold() 和 string2.casefold() 都将字符串转换为小写，并进行大小写折叠比较。输出结果将是 "Strings are case-insensitive equal."。

使用 str.casefold() 在进行字符串比较时是一种推荐的方式，尤其是当你需要考虑多语言、特殊字符和 Unicode 等价性的情况。

maketrans方法

str.maketrans(x[, y[, z]]) 是 Python 字符串对象的一个类方法，用于创建一个转换表（translation table）对象，这个对象可以在字符串的 translate() 方法中使用，用来执行字符的映射或删除操作。

参数说明：

• x：单个字符的字符串，表示需要映射的字符集。
• y：与 x 具有相同长度的字符串，表示将 x 中的字符映射到的字符集。
• z：字符串，表示要删除的字符集。

如果只提供了 x 参数，它必须是一个长度为 256 的字符串，其中每个字符的 Unicode 码点与其在表中的位置相对应。如果提供了 x 和 y 两个参数，它们必须是等长的字符串，表示字符的一对一映射。如果提供了 z 参数，它是一个字符串，其中包含要删除的字符。

以下是一些示例：

# 创建一个简单的映射表，将 'abc' 映射到 '123'
translation_table = str.maketrans('abc', '123')

# 使用映射表进行字符串的映射
original_string = "abcxyz"
mapped_string = original_string.translate(translation_table)
print(mapped_string)

输出结果：

123xyz

在这个例子中，maketrans('abc', '123') 创建了一个映射表，该表将字符 'a' 映射到 '1'，'b' 映射到 '2'，'c' 映射到 '3'。然后，translate() 方法使用这个映射表将字符串中的字符进行映射。

这个方法常用于一些字符替换或字符删除的操作。

partition方法

str.partition(sep) 是 Python 字符串对象的一个方法，用于根据指定的分隔符 sep 将字符串分割成三部分：分隔符之前的部分、分隔符本身、分隔符之后的部分。如果字符串中不包含分隔符，那么将返回原始字符串和两个空字符串。

以下是一个简单的示例：

text = "python:is:fun"

# 使用 partition() 方法根据 ":" 分割字符串
result = text.partition(":")
print(result)

输出结果：

('python', ':', 'is:fun')

在这个例子中，partition(":") 方法根据冒号 : 将字符串分成三部分。结果是一个包含三个元素的元组，其中第一个元素是分隔符之前的部分，第二个元素是分隔符本身，第三个元素是分隔符之后的部分。

这个方法通常在需要从字符串中提取特定部分时很有用，特别是在处理具有固定格式的字符串时。

结果是元组