没吃饱的笨蛋

外观

字符串

约 3266 字大约 11 分钟

2025-04-04

基本用法

字符串在 Python 中的构造方法为 str。在 Python 中，只要用引号引起来的就是字符串

Python 不区分字符和字符串，所以既可以使用单引号 ' 也可以使用双引号 " 表示字符串。至于实际编程中到底应该使用那种引号，这是需要因项目，因公司，因个人习惯而异的。但是在同一个项目中，应该尽量使用同一种引号表示字符串。Python 官方更倾向于使用单引号表示字符串，我个人也更喜欢单引号，因为它不需要按 shift 键

字符串使用示例：

a = "你好"
b = '你好'
"""你好"""	# 三引号可以表示多行字符串，多行注释的原理就是一个未赋值的字符串
'''你好'''
print(a, b)

需要注意的是，使用 print 函数时，不要在变量的两端加引号：

a = 'Sure'
b = '123'
print("a, b")
print(a, b)

字符串的 + 操作：

a = 'Sure'
b = "Best"
c = a + b  # 字符串拼接
print(c)

a = 'Python is the best'
b = '必须的'
c = a + b  # 字符串拼接
print(c)

字符串的 * 操作

a = '坚强'
print(a * 8)   # 字符串的乘法

a = '坚持'
b = '学习'
print(a + b * 5)

字符串的操作需知：

  • + 拼接：必须都是字符串才能相加
  • * 拼接：字符串和整数相乘（即便是 2.0 这种实数也是不可以的）

同整型一样，字符串也是一个不可变的数据类型：

name = 'Sure'
print(id(name)) # 2388909933712
name = name + '最帅了'
print(id(name)) # 2388910157296

在 Python 中，对于字符串的赋值，还会有这样一个有趣的情况：

name = 'Sure'
name1 = 'Sure'
print(id(name)) # 2313349022864
print(id(name1)) # 2313349022864

明明是两次赋值，两个字符串的内存地址居然是相同的。这是因为 Python 中有一个小数据池，小数据会驻留。在小数据驻留期间对相同的数据有新的赋值操作，不会新开辟一个内存空间，而是将变量指向已有数据的内存地址。小数据池机制是为了节省内存空间

字符串格式化

有这样一个字符串：

msg = """
------info------
name:meet
age:18
sex:男
hobby:女
-------end------
"""

如果我们想让用户输入名字，年龄，性别和爱好，然后程序按照上面的格式给打印出来。从目前我们所学的知识，我们可以用这样的代码来实现：

a = '------info------'
b = 'name: '
c = 'age: '
d = 'sex: '
e = 'hobby: '
f = '-------end------'
name = input(b)
age = input(c)
sex = input(d)
hobby = input(e)
print(a)
print(b + name)
print(c + age)
print(d + sex)
print(e + hobby)
print(f)

% 格式化

不过虽然我们实现了需求，但是太过繁琐。这里就可以用到格式化的方法。格式化，就是在字符串中需要自定义的位置放入占位符，然后通过给占位符提供数据，从而构建新的字符串。提供的数据需要和占位符一一对应，否则将会报错。

Python中常用的占位符有：

  • %s 字符串：%s 可以填充字符串也可以填充数字（其实也可以是其他数据类型）
  • %d | %i 整型：必须填充数字
  • %% 转义：变成普通的 %

有了格式化的方法，上面的例子我们就可以简化成这个样子：

name = input('name: ')
age = input('age: ')
sex = input('sex: ')
hobby = input('hobby: ')
a = '哈哈啊'
msg = """
------info------
name: %s
age: %s
sex: %s
hobby: %s
-------end------
"""
print(msg % (name, int(age), sex, hobby))

字符串的 .format() 方法

.format() 方法是另外一种字符串格式化的方法：

s = 'alice{}bob{}tom{}r'
s1 = s.format('你好', '我好', '大家好')
print(s1)    # alice你好bob我好tom大家好r

.format() 方法除了向上面这种按照位置格式化之外，还可以按照索引格式化：

s = 'alice{0}bob{2}tom{1}r'
s1 = s.format('你好', '我好', '大家好')
print(s1)    # alice你好bob大家好tom我好r

.format() 方法还可以按照关键字进行格式化：

s = 'alice{a}bob{c}tom{b}r'
s1 = s.format(b = '你好', a = '我好', c = '大家好')
print(s1)    # alice我好bob大家好tom你好r

f-strings 格式化

在 Python 3.6 及以后的版本中引入了一个新的 f-strings 方法格式字符串，把上面的格式化方法进一步简化，这也是日常使用最广泛的字符串格式化方法。具体做法为：

msg = f"""
------info------
name: {input('name: ')}
age: {input('age: ')}
sex: {input('sex: ')}
hobby: {input('hobby: ')}
-------end------
"""
print(msg)

在字符串的引号前，用小写字母 f （大写的 F 也可以，但是推荐使用小写）声明字符串为 f-strings 格式的字符串。用大括号将需要格式化的位置标记出来，在大括号里面填入变量或者数据，构建成新的字符串。

可以通过两个大括号来进行转义，表示普通的大括号：

f'{{ }}'

{} 中除了可以使用变量外，还可以放入函数：

def func(a,b):
    return a + b
msg = f'运行结果：{func(1, 2)}'
print(msg)

也可以放入列表和字典：

lst = [1, 2, 32, 34, 45, 5]
msg = f'运行结果：{lst[0: 3]}'
print(msg)

dic = {'key1': 1, 'key2': 22}
msg = f'运行结果：{dic["key1"]}'     # 如果出现这种需要嵌套使用引号的情况，需要使用不同的引号。虽然 Python3.12 版本支持使用相同引号，但是为了可读性起见仍建议使用不同引号
print(msg)

f-string 可以写成多行的形式，但依然打印成一行：

msg = f'窗前明月{"光"}，' \
      f'玻璃好上{"霜"}。' \
      f'要不及时{"擦"}，' \
      f'一会就得{"脏"}。'
print(msg)

要想打印多行字符串，还是要使用三对引号：

msg = f"""
窗前明月{'光'},
玻璃好上{'霜'}.
要不及时{'擦'},
一会就得{'脏'}.
"""
print(msg)

通过使用三元运算，配合 f-strings，我们可以进一步节省代码：

a = 10
b = 20
msg = f'{a if a < b else b}'
print(msg)

同时使用两个括号表示一个可以打印的大括号：

msg = f'{{"alice": "bob"}}'
print(msg)

字符串方法

字符串方法有很多，这里只讨论一些常用的，使用万能的点操作字符串的方法。

因为字符串是不可变数据类型，所以字符串方法不会在字符串本身进行修改，而是将修改后的新字符串作为返回值返回。故而若要使用字符串方法，需要使用变量来接收才行。

.upper

.upper 方法可以将字符串中的所有小写字母转换为大写字母：

name = 'Alice'
name1 = name.upper()  # 全部大写
print(name)    # Alice
print(name1)    # ALICE

.lower

.lower 方法与 .upper 方法刚好相反，是将字符串中所有的大写字母转换为小写字母：

name = 'Alice'
name1 = name.lower()  # 全部小写
print(name)    # Alice
print(name1)    # alice

.upper 和 .lower 方法的一个很常见的应用场景是一些不需要区分大小写的情况，比如输入验证码或用户名时：

yzm = '0G8k'
my_yzm = input('请输入验证码:[0G8k]')
if yzm.lower() == my_yzm.lower():
    print('ok')
else:
    print('滚')

.capitalize

.capitalize 方法用来将字符串的首字母大写：

s = 'alICE tom'
s1 = s.capitalize()
print(s1)    # Alice tom

.title

.title() 方法能将字符串每个单词的首字母大写，区分首字母的方式有空格、符号和数字等：

s = 'alICE tOm-bOB'
s1 = s.title()
print(s1)    # Alice Tom-Bob

.swapcase

.swapcase() 方法可以反转字符串中字母的大小写：

s = 'alICe'
s1 = s.swapcase()
print(s1)    # ALicE

.startswith

.startswith 方法用来判断字符串是否以指定的参数开头，返回的是布尔值：

name = 'alice'
print(name.startswith('a'))    # True

.startswith 方法还支持字符串的 切片，判断切片后的字符串是否是以相应的参数开头：

name = 'alice'
print(name.startswith('l', 1, 3))    # True

.endswith

.endswith 的用法跟 startswith 十分相似。不同的是，它是用来判断字符串是否以指定的字符串结尾，返回的同样是布尔值。.endswith 方法同样支持切片操作。

name = 'alice'
print(name.endswith('e'))    # True

.count

.count 方法用来统计输入的参数在字符串中出现的次数，例如：

name = 'alice_bob_tom'
print(name.count('o'))    # 2

.strip

.strip 方法用来去除字符串两端的空格、换行符和制表符：

name = '   \nalice   \t   '
print(name.strip())

.strip 方法也可以通过设定参数来指定去除头尾两端的内容：

name = 'aaaaa alice  \naa\ta\naaaaa'
print(name.strip('a'))

需要注意的是，当指定参数后，将不会清除空格、换行符和制表符。另外，strip 的参数并非指定单个前缀或后缀，而是会移除参数值的所有组合:

print('   spacious   '.strip())    # 'spacious'
print('www.example.com'.strip('cmowz.'))    # 'example'

如果想要移除字符串的前缀或者后缀，请使用 removeprefix 或 removesuffix 方法

.strip 方法的应用场景是当输入账号密码时，忽视首位无意间输入的或者复制粘贴过来的空格：

user = input('账号：').strip()
pwd = input('密码：').strip()
if user == 'alice' and pwd == 'alice123':
    print('ok')
else:
    print('滚')

另外，int 内部封装了 .strip 方法。故而当使用 int 函数将字符串转换为整型时，不需要额外的 .strip 操作：

num = ' \t 23 \n '
print(int(num))

.removeprefix

此方法于 Python3.9 版本引入，用于移除字符串的前缀：

s = 'TestTestAndTestTest'
print(s.removeprefix('Test'))    # TestAndTestTest
print(s.removeprefix('and'))    # TestTestAndTestTest

.removesuffix

此方法于 Python3.9 版本引入，用于移除字符串的前缀：

s = 'TestTestAndTestTest'
print(s.removesuffix('Test'))    # TestTestAndTest
print(s.removesuffix('and'))    # TestTestAndTestTest

.split

.split 方法用来分割字符串。默认按照空格、换行符和制表符来进行分割。分割后，空格、换行符和制表符将不存在。.split 方法输出的是列表：

a = ' alce bob\t\n   123  '
lst = a.split()
print(lst)    # ['alce', 'bob', '123']

.split() 方法可以指定参数，通过特定的内容进行分割：

a = ':alice::bob:123'
lst = a.split(':')
print(lst)    # ['', 'alice', '', 'bob', '123']

需要注意的是，split 方法带不带参数的处理逻辑是有差异的，不带参数时会先移除掉首尾空白字符，然后字符串中间的连续空白字符按一个空白字符处理。而如果带参数的话，则不会执行任何额外的处理逻辑

.partition

以指定的子串首次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含字符本身以及两个空字符串：

s = 'TestTestAndTestTest'
print(s.partition('And'))    # ('TestTest', 'And', 'TestTest')
print(s.partition('and'))    # ('TestTestAndTestTest', '', '')

.replace

.replace 方法可以替换字符串中的旧内容为新内容。.replace 有三个参数：参数 1 为旧值，参数 2 为新值，参数 3 为替换次数（默认全部替换）。例如：

name = 'alicebobbaby'
name = name.replace('b', 's', 2)
print(name)    # alicesosbaby

is 系列方法（判断系列）

is 系列方法有很多，主要用到的是如下几个：

  • name.isalnum()：用来判断是不是由字母、中文或数字组成，返回的是布尔值
  • name.isalpha()：用来判断是否由字母或中文组成，返回布尔值
  • name.isdigit()：用来判断是否由阿拉伯数字组成，返回布尔值。有一个 bug 是，像 ⑤ 这样的字符也会被认作阿拉伯数字
  • name.isdecimal()：用来判断是不是由十进制组成，返回的是布尔值
  • name.islower()：用来判断字符串中的字母（包括英文字母和希腊字母等）是不是全部小写，中文和数字不考虑（如果全部是中文和数字或是空字符串，返回 False）
  • name.isupper()：用来判断字符串中的字母（包括英文字母和希腊字母等）是不是全部大写，中文和数字不考虑（如果全部是中文和数字或是空字符串，返回 False）

.index

.index() 方法用来通过元素查找索引，查找不到时会报错：

s = 'alice bob'
print(s.index('e'))    # 4
print(s.index('tom'))    # 报错

.find

.find() 方法同样用来通过元素查找索引，与 .index() 方法不同的是，.find() 方法查找不到时会返回 -1，而不会报错：

s = 'alice bob'
print(s.find('b'))    # 6
print(s.find('tom'))    # -1

如果字符串中有多个要查找的元素片段，.index() 和 .find() 方法都只会找第一个元素的索引：

a = 'abcabc'
print(a.index('a'))
print(a.find('a'))

.center

.center() 方法用来进行居中操作，会在字符串两端插入等量的空格，使得字符串总长度等于输入的参数：

s = 'alice bob'
print(s.center(20))
print(s.center(20, '-'))    # 也可以指定两端填充的内容

.ljust 和 .rjust

这两个方法与 center 方法类似，用于填充指定的字符。ljust 方法会在字符串的右侧填充字符，rjust 会在字符串左侧填充字符。默认填充空格，也可以指定填充字符的内容：

>>> a = 'abc'
>>> a.rjust(5)
'  abc'
>>> a.ljust(5)
'abc  '
>>> a.rjust(5, '-')
'--abc'
>>> a.ljust(5, '-')
'abc--'
>>> a.rjust(2)
'abc'

版权归属：Shuo Liu

许可证：署名-非商业性 4.0 国际 (CC-BY-NC-4.0)