**摘要:**本文系统梳理 Python 字符串的核心用法,从 Unicode 编码与 ord()、chr() 转换讲起,依次介绍引号创建字符串、空字符串与 len()、转义字符、拼接与复制、不换行打印、replace() 替换、str() 类型转换、索引提取与切片操作,以及 split() 与 join() 的分割合并技巧;随后汇总 strip()、大小写转换、格式排版、特征判断、format() 格式化与可变字符串等常用方法,最后给出完整的类型转换总结,适合作为 Python 字符串入门的速查手册。
目录
- [1. 字符串的编码](#1. 字符串的编码)
- [2. 引号创建字符串](#2. 引号创建字符串)
- [3. 空字符串和len()函数](#3. 空字符串和len()函数)
- [4. 转义字符](#4. 转义字符)
- [5. 字符串拼接](#5. 字符串拼接)
- [6. 字符串复制](#6. 字符串复制)
- [7. 不换行打印](#7. 不换行打印)
- [8. replace() 实现字符串替换](#8. replace() 实现字符串替换)
- [9. str() 实现转换数据类型为字符串](#9. str() 实现转换数据类型为字符串)
- [10. 使用 提取字符](#10. 使用 [ ] 提取字符)
- [11. 字符串切片 slice 操作](#11. 字符串切片 slice 操作)
- [12. split() 分割和 join() 合并](#12. split() 分割和 join() 合并)
- [13. 字符串常用方法汇总](#13. 字符串常用方法汇总)
1. 字符串的编码
Python3 直接支持 Unicode,可以表示世界上任何书面语言的字符。Python3 的字符默认就是 16 位 Unicode 编码,ASCII 码是 Unicode 编码的子集。

使用内置函数 ord() 可以把字符转换成对应的 Unicode 码;
使用内置函数 chr() 可以把十进制数字转换成对应的字符。
python
ord('B') #66
chr(66) #'B'
ord('唐') #21776
chr(21776) #'唐'
ord('谦') #35878
chr(35878) #'谦'
2. 引号创建字符串
可以通过单引号或双引号创建字符串。例如: a='ab' 、b="six" ,使用两种引号的好处是可以创建本身就包含引号的字符串,而不用使用转义字符。例如:
python
a = "I'm a student"
print(a)
b = 'my name is "json"'
print(b)
连续三个单引号或三个双引号,可以帮助我们创建多行字符串。在长字符串中会保留原始的格式。例如:
python
S ='''
I
Love
U
'''
print(S)
3. 空字符串和len()函数
Python 中允许存在空字符串,不包含任何字符且长度为 0。例如:
python
a = ''
print(len(a))

len() 用于计算字符串含有多少个字符。例如:
python
c = '天道酬勤'
print(len(c))

4. 转义字符
我们可以使用 \+特殊字符 ,实现某些难以用字符表示的效果。比如:换行等。常见的转义字符有这些:
|----------|---------------|
| 转义字符 | 描述 |
| (在行尾时) | 续行符 |
| \ | 反斜杠符号 |
| ' | 单引号 |
| " | 双引号 |
| \b | 退格(Backspace) |
| \n | 换行 |
| \t | 横向制表符 |
| \r | 回车 |
python
a = 'I\nlove\nU'
print(a)
print("aaa\\bb")

5. 字符串拼接
- 可以使用 + 将多个字符串拼接起来。例如: 'aa'+ 'bb' 结果 是 'aabb'
- 如果 + 两边都是字符串,则拼接。
- 如果 + 两边都是数字,则加法运算
- 如果 + 两边类型不同,则抛出异常
- 可以将多个字面字符串直接放到一起实现拼接。例 如: 'aa''bb' 结果是 'aabb'
【操作】字符串拼接操作
python
print('aaa'+'bb') #aaabb
print('aab''bcd') #aabbcd

6. 字符串复制
使用*实现字符串复制
python
a = "start"*3
print(a)

7. 不换行打印
我们调用print时,会自动打印一个换行符。有时,我们不想换行,不想自动添加换行符。我们可以自己通过参数end = "任意字符串"。实现末尾添加任何内容:
python
print("sxt",end='**')
print("sxt",end=' ')
print("sxt")

从控制台读取字符串
可以使用input()从控制台读取键盘输入的内容。
python
myname = input("请输入名字:")
print("您的名字是:"+myname)

8. replace() 实现字符串替换
字符串是"不可改变"的,通过\[\]可以获取字符串指定位置的字符,但是我们不能改变字符串。我们尝试改变字符串中某个字符,发现报错了:
python
a = 'adfhjhjkcncvmb'
print(a)
#'adfhjhjkcncvmb'
print(a[3])
#'h'
print(a[3]='乾')
#Traceback (most recent call last):
# File "<pyshell#42>", line 1, in <module>
# a[3]='乾'
#TypeError: 'str' object does not support item assignment
直接修改字符串报错:

字符串不可改变。但是,有时候需要替换某些字符。这时,只能通过创建新的字符串来实现。
python
a = 'adfhjhjkcncvmb'
print(a)
a = a.replace('h','乾')
print(a)
b = 'adfhjhjkcncvmb'
b = b.replace(b[-1],'乾')
print(b)
运行结果:

整个过程中,实际上我们是创建了新的字符串对象,并指向了变量 a,而不是修改了以前的字符串。
9. str()实现转换数据类型为字符串
str()可以帮助我们将其他数据类型转换为字符串。例如:
python
a = str(5) #结果是:a = '5'
print(a,type(a))
b = str(3.14e2) #结果是:b = '314.0'
print(b,type(b))
c = str(True) #结果是:c = 'True'
print(c,type(c))

❤️当我们调用print()函数时,解释器自动调用了str()将非字符串的对象转成了字符串。
10. 使用 提取字符
字符串的本质就是字符序列,可以通过在字符串后面添加\[\], 在\[\]里面指定偏移量,可以提取该位置的单个字符。
正向搜索: 最左侧第一个字符,偏移量是0,第二个偏移量是1,以此类推。 直到len(str)-1为止。
反向搜索: 最右侧第一个字符,偏移量是-1,倒数第二个偏移量是-2,以此 类推,直到-len(str)为止。

【操作】使用\[\]提取字符串中的字符
python
a = 'abcdefghijklmnopqrstuvwxyz'
print(a[0])
print(a[1])
print(a[-1])
print(a[-2])

超过字符序列会报错

11. 字符串切片slice操作

切片slice操作可以让我们快速的提取子字符串。标准格式为:
起始偏移量start:终止偏移量end:步长step
典型操作(三个量为正数的情况)如下:
|-------------------------------------------|-------------------|----------|
| 操作和说明 | 示例 | 结果 |
| : 提取整个字符串 | "abcdef": | "abcdef" |
| start: 从start索引开始到结尾 | "abcdef"2: | "cdef" |
| :end 从头开始知道end-1 | "abcdef":2 | "ab" |
| start:end 从start到end-1 | "abcdef"2:4 | "cd" |
| start:end:step 从start提取到end-1,步长是step | "abcdef"1:5:2 | "bd" |
其他操作(三个量为负数)的情况:
python
a = "abcdefghijklmnopqrstuvwxyz"
|------------|---------------------|------------------------------|
| 示例 | 说明 | 结果 |
| a-3: | 倒数三个 | "xyz" |
| a-8:-3 | 倒数第八个到倒数第三 个(包头不包尾) | 'stuvw' |
| a::-1 | 步长为负,从右到左反向提取 | 'zyxwvutsrqponmlkjihgfedcba' |
切片操作时,起始偏移量和终止偏移量不在**0,字符串长度-1**这个范围,也不会报错。起始偏移量小于0则会当做0,终止偏移量大于"长度-1"会被当成-1。例如:
python
"abcdefg"[3:50]

12. split()分割和join()合并
**split()**可以基于指定分隔符将字符串分隔成多个子字符串(存储到列表中)。如果不指定分隔符,则默认使用空白字符(换行符/空格/制表 符)。示例代码如下:
python
a = 'nice to me too'
a.split()
#['nice', 'to', 'me', 'too']
a.split('to')
#['nice ', ' me ', 'o']
**join()**的作用和split()作用刚好相反,用于将一系列子字符串连接起 来。示例代码如下:
python
a = ['nice', 'to', 'me', 'too']
'=='.join(a)
#'nice==to==me==too'

拼接字符串要点:
使用字符串拼接符 + ,会生成新的字符串对象,因此不推荐使用 + 来拼接字符串。推荐使用 join 函数,因为 join 函数在拼接字符串之前会计算所有字符串的长度,然后逐一拷贝,仅新建一次对象。
python
import time
time01 = time.time() #初始时间
a = ''
for i in range(1000):
a += 'six'
time02 = time.time() #结束时间
print('计算过程时间:',str(time02-time01))
time03 = time.time() #初始时间
li = []
for i in range(1000):
li.append('six')
a = ''.join(li)
time04 = time.time() #结束时间
print('计算过程时间:',str(time04-time03))

字符串驻留机制和字符串比较
字符串驻留:常量字符串只保留一份。
python
c = "dd#"
d = "dd#"
print(c is d) #True
字符串比较和同一性
我们可以直接使用**==、!=** 对字符串进行比较,是否含有相同的字符。
我们使用 is、not is,判断两个对象是否同一个对象。比较的是对象的 地址,即 id(obj1) 是否和 id(obj2) 相等。
python
a = 'abc'
b = 'abc'
print(a==b)
print(a is b,id(a),'-'*5+'>',id(b))
print(a!=b)

成员操作符判断子字符串
in 、not in关键字,判断某个字符(子字符串)是否存在于字符串中。
python
"ab" in "abcdefg" #true

13. 字符串常用方法汇总
示例文本:
a='''我是frank,我在xx科技上班。我的儿子叫json,他6岁了。我是一个编程教育的普及者,希望影响6000万学习编程的中国人。我儿子现在也开始学习编程,希望他18岁的时候可以超过我'''
|-------------------------|----------------|--------|
| 方法和使用案例 | 说明 | 结果 |
| len(a) | 字符串长度 | 90 |
| a.startswith('我是frank') | 以指定字符串开头 | True |
| a.endswith('过我') | 以指定字符串结尾 | True |
| a.find('他') | 第一次出现指定字符串的位置 | 27 |
| a.rfind('他') | 最后一次出现指定字符串的位置 | 78 |
| a.count("编程") | 指定字符串出现了几次 | 3 |
| a.isalnum() | 所有字符全是字母或数字 | False |

13.1 去除首尾信息
可以通过**strip()去除字符串首尾指定信息。通过lstrip()**去除字符 串左边指定信息,**rstrip()**去除字符串右边指定信息。
【操作】去除字符串首尾信息
python
>>> "*s*x*t*".strip("*")
#'s*x*t'
>>> "*s*x*t*".lstrip("*")
#'s*x*t*'
>>> "*s*x*t*".rstrip("*")
#'*s*x*t'
>>> " s xt ".strip()
#'s xt'

13.2 大小写转换
编程中关于字符串大小写转换的情况,经常遇到。将相关方法汇总到这里。为了方便学习,先设定一个测试变量:
a = "frank love programming, love SXT"
|----------------|--------------------|------------------------------------|
| 示例 | 说明 | 结果 |
| a.capitalize() | 产生新的字符串,首字母大写 | 'Frank love programming, love sxt' |
| a.title() | 产生新的字符串,每个单词都首字母大写 | 'Frank Love Programming, Love Sxt' |
| a.upper() | 产生新的字符串,所有字符全转成大写 | 'FRANK LOVE PROGRAMMING, LOVE SXT' |
| a.lower() | 产生新的字符串,所有字符全转成小 写 | 'frank love programming, love sxt' |
| a.swapcase() | 产生新的,所有字母大小写转换 | 'FRANK LOVE PROGRAMMING, LOVE sxt' |

13.3 格式排版
**center() 、 ljust() 、 rjust()**这三个函数用于对字符串实现排版。示例如 下:
python
a = 'honker'
a.center(10,'*')
#'**honker**'
a.center(10)
#' honker '
a.ljust(10,'*')
#'honker****'
a.rjust(10,'*')
#'****honker'

13.4 特征判断方法
- isalnum() 是否为字母或数字
- isalpha() 检测字符串是否只由字母组成(含汉字)
- isdigit() 检测字符串是否只由数字组成
- isspace()检测是否为空白符
- isupper() 是否为大写字母
- islower() 是否为小写字母

13.5 字符串的格式化
13.5.1 format() 基本用法
基本语法是通过 {} 和 : 来代替以前的 % 。
**format()**函数可以接受不限个数的参数,位置可以不按顺序。

位置参数 :按顺序填,{} 依次对应 format() 里的参数。
python
"{}的{}成绩是{}".format("张三", "数学", 95)
# 输出:张三的数学成绩是95
索引参数:用数字指定取哪个参数,可重复用、可打乱顺序。
python
"{0}的{2}成绩是{1}".format("张三", 95, "数学")
# 输出:张三的数学成绩是95
关键字参数:用参数名直接对应,最清晰,顺序随意。
python
"{name}今年{age}岁".format(age=25, name="小明")
# 输出:小明今年25岁
💡 进阶小技巧
- 复用同一参数:"{0}{0}{0}".format("哈") 输出 哈哈哈,索引可多次引用。
- 混合使用:位置参数和关键字参数可混用,但关键字参数必须放在位置参数后面。
- 解包传参:用 *元组 和 **字典 直接展开传参,适合动态数据。
- 数字格式化:{:.2f} 保留两位小数,{:,} 加千分位,{:0>3d} 补零对齐,非常实用

13.5.2 填充与对齐
- 填充常跟对齐一起使用
- ^ 、 < 、 > 分别是居中、左对齐、右对齐,后面带宽度
- : 号后面带填充的字符,只能是一个字符,不指定的话默认是用空格填充

13.5.3 数字格式化
浮点数通过 f,整数通过d进行需要的格式化。案例如下式化:
python
a = "我是{0},我的存款有{1:.2f}"
a.format("frank",3888.234342)

其他格式,供大家参考:
|------------|----------|-----------|-------------------|
| 数字 | 格式 | 输出 | 描述 |
| 3.1415926 | {:.2f} | 3.14 | 保留小数点后两位 |
| 3.1415926 | {:+.2f} | +3.14 | 带符号保留小数点后两位 |
| 2.71828 | {:.0f} | 3 | 不带小数 |
| 5 | {:0>2d} | 05 | 数字补零 (填充左边, 宽度为2) |
| 5 | {:x<4d} | 5xxx | 数字补x (填充右边, 宽度为4) |
| 10 | {:x<4d} | 10xx | 数字补x (填充右边, 宽度为4) |
| 1000000 | {:,} | 1,000,000 | 以逗号分隔的数字格式 |
| 0.25 | {:.2%} | 25.00% | 百分比格式 |
| 1000000000 | {:.2e} | 1.00E+09 | 指数记法 |
| 13 | {:10d} | 13 | 右对齐 (默认, 宽度为10) |
| 13 | {:<10d} | 13 | 左对齐 (宽度为10) |
| 13 | {:^10d} | 13 | 中间对齐 (宽度为10) |
13.6 可变字符串
- Python中,字符串属于不可变对象,不支持原地修改,如果需要修改其中的值,只能创建新的字符串对象。
- 确实需要原地修改字符串,可以使用io.StringIO对象或array模块
python
import io
s = "hello, sxt"
sio = io.StringIO(s) #可变字符串
print(sio)
v1 = sio.getvalue()
print("v1:",v1)
char7 = sio.seek(7) #指针知道索引7这个位置
sio.write("frank")
v2 = sio.getvalue()
print("v2:",v2)

类型转换总结
|------------------------|--------------------------------|
| 类型转换 | |
| int(x ,base) | 将x转换为一个整数 |
| long(x ,base ) | 将x转换为一个长整数 |
| float(x) | 将x转换到一个浮点数 |
| complex(real,imag) | 创建一个复数 |
| str(x) | 将对象 x 转换为字符串 |
| repr(x) | 将对象 x 转换为表达式字符串 |
| eval(str) | 用来计算在字符串中的有效Python表达式,并返回一个对象 |
| Complex(A) | 将参数转换为复数型 |
| tuple(s) | 将序列 s 转换为一个元组 |
| list(s) | 将序列 s 转换为一个列表 |
| set(s) | 转换为可变集合 |
| dict(d) | 创建一个字典。d 必须是一个序列 (key,value)元组 |
| frozenset(s) | 转换为不可变集合 |
| chr(x) | 将一个整数转换为一个字符 |
| unichr(x) | 将一个整数转换为Unicode字符 |
| ord(x) | 将一个字符转换为它的整数值 |
| hex(x) | 将一个整数转换为一个十六进制字符串 |
| oct(x) | 将一个整数转换为一个八进制字符串 |
python
#类型转换
#转换为int
print('int()默认情况下为:', int())
print('str字符型转换为int:', int('010'))
print('float浮点型转换为int:', int(234.23))
#十进制数10,对应的2进制,8进制,10进制,16进制分别是:1010,12,10,0xa
print('int(\'0xa\', 16) = ', int('0xa', 16))
print('int(\'10\', 10) = ', int('10', 10))
print('int(\'12\', 8) = ', int('12', 8))
print('int(\'1010\', 2) = ', int('1010', 2))
#转换为float
print('float()默认情况下为:', float())
print('str字符型转换为float:',float('123.01'))
print('int浮点型转换为float:', float(32))
#转换为complex
print('创建一个复数(实部+虚部):', complex(12,43))
print('创建一个复数(实部+虚部):', complex(12))
#转换为str字符串
print('str()默认情况下为:', str())
print('float型转换为str:', str(232.33))
print('int转换为str:', str(32))
lists = ['a', 'b', 'e', 'c', 'd', 'a']
print('列表list转换为str:', ''.join(lists))
#转换为list
strs = 'hongten'
print('序列strs转换为list:', list(strs))
#转换为tuple
print('列表list转换为tuple:', tuple(lists))
#字符和整数之间的转换
print('整数转换为字符chr:', chr(67))
print('字符chr转换为整数:', ord('C'))
print('整数转16进制数:', hex(12))
print('整数转8进制数:', oct(12))

14. 总结
把全文的核心结论浓缩成下面几条,方便快速回顾:
- 字符串不可变 :Python 中的字符串是 immutable 对象,
a[3]='乾'这类原地赋值会抛出TypeError,任何"修改"都是创建并返回新对象。 - replace() 返回新串 :替换字符必须用
a = a.replace('h','乾')重新绑定变量,原字符串对象保持不变。 - 索引与切片规则 :正向索引从 0 开始,反向索引从 -1 开始;切片格式为
[start:end:step],包头不包尾 ,a[::-1]可反向取串,越界不会报错。 - join 优于 + 拼接 :
+每次拼接都会生成临时对象,循环中性能差;join()先计算总长度再一次性拷贝,仅新建一次对象,大数据量下优势明显。 - split() 与 join() 互为逆操作 :
split()按分隔符切分为列表,不指定分隔符时默认按空白字符切分;join()则把序列拼回字符串。 - format() 格式化灵活 :支持位置参数
{}、索引参数{0}、关键字参数{name},配合{:.2f}、{:,}、{:>3d}等格式符可完成精度、千分位与对齐控制。 - 常用方法均返回新串 :
strip()、upper()、capitalize()、center()等都不会修改原字符串,需要重新赋值才能生效。 - 需要原地修改时用 io.StringIO :确实要频繁改动字符串内容,可用
io.StringIO或array模块构造可变字符串,避免反复创建对象。