Python字符串全攻略:从入门到精通

**摘要:**本文系统梳理 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'
  1. 如果 + 两边都是字符串,则拼接。
  2. 如果 + 两边都是数字,则加法运算
  3. 如果 + 两边类型不同,则抛出异常
  • 可以将多个字面字符串直接放到一起实现拼接。例 如: '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 特征判断方法

  1. isalnum() 是否为字母或数字
  2. isalpha() 检测字符串是否只由字母组成(含汉字)
  3. isdigit() 检测字符串是否只由数字组成
  4. isspace()检测是否为空白符
  5. isupper() 是否为大写字母
  6. 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岁

💡 进阶小技巧

  1. ‌复用同一参数‌:"{0}{0}{0}".format("哈") 输出 哈哈哈,索引可多次引用。
  2. ‌混合使用‌:位置参数和关键字参数可混用,但关键字参数必须放在位置参数后面。
  3. ‌解包传参‌:用 *元组 和 **字典 直接展开传参,适合动态数据。
  4. ‌数字格式化‌:{:.2f} 保留两位小数,{:,} 加千分位,{:0>3d} 补零对齐,非常实用

13.5.2 填充与对齐

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

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. 总结

把全文的核心结论浓缩成下面几条,方便快速回顾:

  1. 字符串不可变 :Python 中的字符串是 immutable 对象,a[3]='乾' 这类原地赋值会抛出 TypeError,任何"修改"都是创建并返回新对象。
  2. replace() 返回新串 :替换字符必须用 a = a.replace('h','乾') 重新绑定变量,原字符串对象保持不变。
  3. 索引与切片规则 :正向索引从 0 开始,反向索引从 -1 开始;切片格式为 [start:end:step],包头不包尾 ,a[::-1] 可反向取串,越界不会报错。
  4. join 优于 + 拼接 :+ 每次拼接都会生成临时对象,循环中性能差;join() 先计算总长度再一次性拷贝,仅新建一次对象,大数据量下优势明显。
  5. split() 与 join() 互为逆操作 :split() 按分隔符切分为列表,不指定分隔符时默认按空白字符切分;join() 则把序列拼回字符串。
  6. format() 格式化灵活 :支持位置参数 {}、索引参数 {0}、关键字参数 {name},配合 {:.2f}、{:,}、{:>3d} 等格式符可完成精度、千分位与对齐控制。
  7. 常用方法均返回新串 :strip()、upper()、capitalize()、center() 等都不会修改原字符串,需要重新赋值才能生效。
  8. 需要原地修改时用 io.StringIO :确实要频繁改动字符串内容,可用 io.StringIO 或 array 模块构造可变字符串,避免反复创建对象。
相关推荐
半杯咖啡半行码16 分钟前
Qt 隐式共享(Implicit Sharing)深度解析:机制、陷阱与 Qt6迁移
开发语言·数据库·qt
贾公子27 分钟前
异步检测的轮询与超时——别把「还没好」当成「失败了」
后端·python
吃我一窝jio30 分钟前
Docker+Jenkins+K8s全流程部署
java·开发语言·笔记·python
eggwyw44 分钟前
C++设计模式之解释器模式
开发语言·c++
欢乐马87912 小时前
优化|MPSolver 和 pywraplp 到底谁是谁?一次讲清 OR-Tools 的三层结构
python
mengge.cloud3 小时前
Python基础保姆级!从入门到入土
开发语言·python·云原生·pygame
在爪洼山玩泥巴4 小时前
fastjson2 JSONPath 取不存在路径,为什么会抛 “not support”?
java·开发语言·jsonpath·fastjson
qq_158895411117 小时前
Suno-API 是什么?官方 V6 模型与 Python / TypeScript 接入指南
python·ai音乐·suno api
星落梦生13 小时前
SpringAOP基础笔记(7)
java·开发语言