目录
- 1、创建字符串
- 1.1 使用 ’ ’ 或 " " 创建字符串
- 1.2 使用 str()函数 转换为字符串
- 2、访问字符串
- 2.1 下标索引访问
- 2.2 切片访问
- 2.3 for循环遍历字符串
- 2.4 检查元素是否存在
- 3、字符串基础知识
- 3.1 字符串更新
- 3.2 字符串连接(合并)/复制(重复)
- 3.3 转义字符
- 3.4 打印原始字符 r / R
- 3.5 格式字符串
- 3.6 三引号
- 3.7 f-string
- 3.8 Unicode 字符串
- 4、内置函数
- 4.1 打印输出 print()
- 4.2 确定字符串长度 len()
- 4.3 返回变量类型 type()
- 4.4 转换为字符串 str()
- 4.5 字符串最大/小字符 max()、min()
- 4.6 删除字符串 del
- 5、内置方法
- 5.1 转换
- 5.1.1 字符(串)转换 capitalize()、casefold()、lower()、upper()、title()、swapcase()
- 5.1.2 判断大小写 islower()、isupper()、istitle()
- 5.2 搜索值
- 5.2.1 返回出现次数 count()
- 5.2.2 从左搜索并返回 find()、index()
- 5.2.3 从右搜索并返回 rfind()、rindex()
- 5.3 以 str 开头/结束 startswith()、endswith()
- 5.4 编/解码 encode()、decode()
- 5.5 填充对齐 center()、ljust()、rjust()、zfill()
- 5.6 删除左/右指定字符 lstrip()、rstrip()、strip()
- 5.7 判断字符(串)
- 5.7.1 空白字符 isspace()
- 5.7.2 可打印 isprintable()
- 5.7.3 标识符 isidentifier()
- 5.7.4 字母/数字 isalnum()
- 5.7.5 字母/中文 isalpha()
- 5.7.6 数字 isdigit()、isnumeric()、isdecimal()
- 5.8 格式字符串中指定值 format()、format_map()
- 5.9 拆分/截取字符串 split()、rsplit()、splitlines()
- 5.10 拆分字符串(返回元组) partition()、rpartition()
- 5.11 字符串转换 maketrans()、translate()
- 5.12 元组项目连接到字符串 join()
- 5.13 字符串替换 replace()
- 5.14 字符串 Tab 转换 expandtabs()
- 6、总结
- 总结
字符串是Python中最常用的数据类型
1、创建字符串
1.1 使用 ’ ’ 或 " " 创建字符串
创建字符串很简单，我们可以使用引号（’ ’ 或 " "）来创建字符串，只需为变量分配一个值即可。
str1 = 'Hello Python' str2 = "hello python"
1.2 使用 str()函数 转换为字符串
当然，除了使用引号直接创建字符串之外，我们还可以使用 str() 函数将其他数据类型或对象转换为字符串，其具体用法见下方内置函数。
2、访问字符串
和列表、元组一样，我们既可以使用下标索引访问字符串中的某个元素（得到是一个字符），也可以使用切片访问字符串中的一组元素（得到是子字符串）。
2.1 下标索引访问
下标索引访问字符串分为两大类，即正向索引和反向索引，格式为 str_name[i] ，其中，str_name 表示字符串名，i表示索引值，i可以是正数（正向索引）也可以是负数（反向索引）。
可以得知，str_name[0]表示字符串的第一个字符，str_name[-1]则表示字符串的最后一个字符。
str1 = 'Hello Py' print(str1[0]) print(str1[-1])
H
y
正向索引：从第一个（下标0）开始、第二个（下标1）…
反向索引：从倒数第一个（下标-1）、倒数第二个（下标-2）…
2.2 切片访问
如若对上方描述不太理解，可参考下表：
| 字符串值 | H | e | l | l | o | P | y | |
|---|---|---|---|---|---|---|---|---|
| 正向索引 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
| 反向索引 | -8 | -7 | -6 | -5 | -4 | -3 | -2 | -1 |
Python访问子字符串，可以使用中括号 [ ] 来截取字符串，即切片访问。
使用切片访问字符串的格式为 str_name[strat : end : step] ，其中，start 表示起始索引，end 表示结束索引，step 表示步长。
str1 = 'Hello Py' print(str1[0:5]) print(str1[-8:-1]) print(str1[:]) print(str1[::2])
Hello
Hello P
Hello Py
HloP
截取字符串的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。
2.3 for循环遍历字符串
使用 for 循环遍历字符串时，将会输出字符串中的每一个字符。
str_h = 'Hi Py'
for char in str_h:
print(char)
H
i
P
y
2.4 检查元素是否存在
如果我们需要确定在一个字符串中，是否存在相同的字符或者子字符串，可以使用成员运算符中的 in 和 not in 关键字。
| 关键字 | 描述 |
|---|---|
| in | 如果字符串中包含给定的字符返回 True。 |
| not in | 如果字符串中不包含给定的字符返回 True。 |
str1 = 'Hello Python'
print('H' in str1)
print('Python' not in str1)
True
False
3、字符串基础知识
3.1 字符串更新
我们可以截取字符串的一部分并与其他字段拼接，如下实例：
str1 = 'Hello World' print(str1[:6] + 'Python')
Hello Python
3.2 字符串连接(合并)/复制(重复)
同列表和元组一样，字符串之间可以使用 + 号和 * 号分别实现字符串的连接（合并）和复制（重复），这意味着它们可以生成一个新的字符串。
1、+连接（合并）
a = 'Hello' b = 'Python' print(a + b)
HelloPython
2、*复制（重复）
c = 'Hello' print(c * 5)
HelloHelloHelloHelloHello
3.3 转义字符
如果需要在字符中使用特殊字符时，则使用反\斜杠 \ 转义字符，如下表：
3.4 打印原始字符 r / R
原始字符串：所有的字符串都是直 接按照字面的意思来使用，没有转义特殊或不能打印的字符。
原始字符串除在字符串的第一个引号前加上字母 r / R （可以大小写）以外，与普通字符串有着几乎完全相同的语法。
print(r'\n') print(R'\n') print(r'\t') print(r'\a')
\n
\n
\t
\a
3.5 格式字符串
Python支持格式化字符串的输出。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
print('我叫 %s ,今年 %d 岁！' % ('pink', 21))
我叫 pink ,今年 21 岁！
在Python中，字符串格式化使用与 C语言 中 printf() 函数一样的用法。
Python字符串格式化符号如下表所示：
| 符 号 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整型 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | %f和%e的简写 |
| %G | %f 和 %E 的简写 |
| %p | 用十六进制数格式化变量的地址 |
格式化操作符辅助指令：
| 符号 | 功能 |
|---|---|
| * | 定义宽度或者小数点精度 |
| - | 用做左对齐 |
| + | 在正数前面显示加号( + ) |
| <sp> | 在正数前面显示空格 |
| # | 在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’) |
| 0 | 显示的数字前面填充’0’而不是默认的空格 |
| % | ‘%%‘输出一个单一的’%’ |
| (var) | 映射变量(字典参数) |
| m.n. | m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话) |
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
3.6 三引号
Python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。实例如下：
str1 = """这是一个多行字符串 多行字符串可以使用制表符 TAB[\t] 也可以使用换行符[\n] """ print(str1)
这是一个多行字符串
多行字符串可以使用制表符
TAB[ ]
也可以使用换行符[
]
三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。
当你需要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义将会非常的繁琐。
errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
cursor.execute('''
CREATE TABLE users (
login VARCHAR(8),
uid INTEGER,
prid INTEGER)
''')
3.7 f-string
f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。
之前我们习惯用百分号 (%):
name = 'pink'
print('Hello %s' % name)
f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例如下：
name = 'pink'
print(f'Hello {name}')
print(f'{1 + 2}')
baidu = {'name': 'Baidu', 'url': 'https://www.baidu.com'}
print(f'{baidu["name"]}:{baidu["url"]}')
Hello pink
3
Baidu:https://www.baidu.com
用了这种方式明显更简单了，不用再去判断使用 %s，还是 %d。
在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果：
x = 1
print(f'{x + 1}')
y = 1
print(f'{x + 1 = }')
2
x + 1 = 2
3.8 Unicode 字符串
在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。
在Python3中，所有的字符串都是Unicode字符串。
4、内置函数
4.1 打印输出 print()
1、print()函数
print() 函数的功能我们已经非常熟悉了，就是打印输出。
str1 = 'Hello Python' print(str1)
Hello Python
4.2 确定字符串长度 len()
2、len()函数
当我们要确定一个字符串中有多少个字符时，我们可以使用 len() 函数。
str2 = 'Hello Python' print(len(str2))
12
4.3 返回变量类型 type()
3、type()函数
使用 type() 函数可以确定变量是什么类型（字符串、列表、元组、字典或集合）。
str3 = 'Hello Python' print(type(str3))
<class 'str'>
当对 str3 使用 type() 确定变量类型时，会返回
<class 'str'>，表明这是一个字符串。
4.4 转换为字符串 str()
4、str()函数
我们可以使用 str() 函数将列表、元组、字典、集合和区间等对象转换为字符串，以下将会一一介绍：
将列表转换为字符串
list1 = ['a', 'b', 'c'] print(type(str(list1))) print(str(list1))
<class 'str'>
['a', 'b', 'c']
将元组转换为字符串
tuple1 = ('A', 'B', 'C')
print(type(str(tuple1)))
print(str(tuple1))
<class 'str'>
('A', 'B', 'C')
将字典转换为字符串
dict1 = {'name': 'pink'}
print(type(str(dict1)))
print(str(dict1))
<class 'str'>
{'name': 'pink'}
将集合转换为字符串
set1 = {'name', 'gender'}
print(type(str(set1)))
print(str(set1))
<class 'str'>
{'name', 'gender'}
将区间转换为字符串
range1 = range(0, 10) print(type(str(range1))) print(str(range1))
<class 'str'>
range(0, 10)
4.5 字符串最大/小字符 max()、min()
5、max()函数和min()函数
max() 函数的作用是返回字符串中最大的字符。min() 函数的作用是返回字符串中最小的字符。
str_m = 'AazZ' print(max(str_m)) print(min(str_m))
z
A
4.6 删除字符串 del
在Python中，del 函数并不支持删除字符串中的单个字符，但我们可以使用 del 函数删除整个字符串：
str1 = 'Hello Python' del str1 print(str1)
当我们使用 del 函数删除某字符串后，如果再使用 print() 函数打印输出时，会报错
NameError: name 'str1' is not defined，表明该字符串未被定义。
5、内置方法
5.1 转换
5.1.1 字符(串)转换 capitalize()、casefold()、lower()、upper()、title()、swapcase()
1、 capitalize()方法
capitalize() 将字符串的第一个字母变成大写，其他字母变小写。
语法
string.capitalize()
参数值
无参数
实例
str1 = 'hello python' print(str1.capitalize())
Hello python
2、casefold()方法
casefold() 方法返回一个字符串，其中所有字符均为小写。
语法
string.casefold()
参数值
无参数
实例
str1 = 'Hello Python' print(str1.casefold())
hello python
此方法与 lower() 方法相似，但是 casefold() 方法更强大，更具攻击性，这意味着它将更多字符转换为小写字母，并且在比较两个用 casefold() 方法转换的字符串时会找到更多匹配项。
3、lower()方法
lower() 方法转换字符串中所有大写字符为小写（符号和数字将被忽略）。
语法
string.lower()
参数值
无参数
实例
str1 = 'Hello Python' print(str1.lower())
hello python
4、upper()方法
upper() 方法将字符串中的小写字母转为大写字母（符号和数字将被忽略）。
语法
string.upper()
参数值
无参数
实例
str1 = 'Hello Python' print(str1.upper())
HELLO PYTHON
5、title()方法
title() 方法返回"标题化"的字符串,就是说所有单词的首个字母转化为大写，其余字母均为小写。
语法
string.title()
参数值
无参数
实例
str1 = 'HELLO Python' print(str1.title())
Hello Python
6、swapcase()方法
swapcase() 方法用于对字符串的大小写字母进行转换，即将大写字母转换为小写字母，小写字母会转换为大写字母。
语法
string.swapcase()
参数值
无参数
实例
str1 = 'Hello Python' print(str1.swapcase())
hELLO pYTHON
5.1.2 判断大小写 islower()、isupper()、istitle()
1、islower()方法
islower() 方法检测字符串是否由小写字母组成。
语法
string.islower()
参数值
无参数
str1 = 'Hello Python' print(str1.islower())
False
如果所有字符均为小写，则 islower() 方法返回 True，否则返回 False。不检查数字、符号和空格，仅检查字母字符。
2、isupper()方法
isupper() 方法检测字符串中所有的字母是否都为大写。
语法
string.isupper()
参数值
无参数
实例
str1 = 'Hello Python' print(str1.isupper())
False
如果所有字符均大写，则 isupper() 方法返回 True，否则返回 False。不检查数字、符号和空格，仅检查字母字符。
3、istitle()方法
istitle() 方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。
语法
string.istitle()
参数值
无参数
实例
str1 = 'Hello Python' print(str1.istitle())
True
如果文本中的所有单词均以大写字母开头，而单词的其余部分均为小写字母，则 istitle() 方法返回 True。否则返回 False。符号和数字将被忽略。
5.2 搜索值
5.2.1 返回出现次数 count()
count()方法
count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
语法
string.count(value, start, end)
参数值
| 参数 | 描述 |
|---|---|
| value | 必需。字符串。要检索的字符串。 |
| start | 可选。整数。开始检索的位置。默认是 0。 |
| end | 可选。整数。结束检索的位置。默认是字符串的结尾。 |
实例
txt = "I love apples, apple are my favorite fruit"
print(txt.count("apple", 10, 24))
1
5.2.2 从左搜索并返回 find()、index()
1、find()方法
find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果指定范围内如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回 -1。
语法
string.find(value, start, end)
参数值
| 参数 | 描述 |
|---|---|
| value | 必需。要检索的值。 |
| start | 可选。开始检索的位置。默认是 0。 |
| end | 可选。结束检索的位置。默认是字符串的结尾。 |
实例
字母 “e” 在文本总首次出现的位置：
txt = "Hello, welcome to my world."
x = txt.find("e")
print(x)
1
如果只搜索位置 5 到 10 时，字母 “e” 在文本总首次出现的位置：
txt = "Hello, welcome to my world."
x = txt.find("e", 5, 10)
print(x)
8
如果找不到该值，则 find() 方法返回 -1，但是 index() 方法将引发异常：
txt = "Hello, welcome to my world."
print(txt.find("q"))
print(txt.index("q"))
Traceback (most recent call last):
File "C:\Users\MK\Desktop\Python方法\str.py", line 4, in <module>
print(txt.index("q"))
ValueError: substring not found
-1
2、index()方法
index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 find() 方法一样，只不过如果str不在 string中会报一个异常。
语法
string.index(value, start, end)
参数值
| 参数 | 描述 |
|---|---|
| value | 必需。要检索的值。 |
| start | 可选。在哪里开始检索。默认是 0。 |
| end | 可选。在哪里结束检索。默认是字符串的末尾。 |
实例
字母 “e” 在文本中首次出现在哪里？
txt = "Hello, welcome to my world."
x = txt.index("e")
print(x)
1
如果只在位置 5 和 10 之间搜索时，字母 "e"首次首先在哪里？
txt = "Hello, welcome to my world."
x = txt.index("e", 5, 10)
print(x)
8
如果找不到该值，则 find() 方法返回 -1，但是 index() 方法将引发异常：
txt = "Hello, welcome to my world."
print(txt.find("q"))
print(txt.index("q"))
-1
Traceback (most recent call last):
File "C:\Users\MK\Desktop\Python方法\str.py", line 3, in <module>
print(txt.index("q"))
ValueError: substring not found
3、find() 和 index() 区别
find() 方法与 index() 方法几乎相同，唯一的区别是，如果找不到该值，index() 方法将引发异常，则 find() 方法将返回 -1。
5.2.3 从右搜索并返回 rfind()、rindex()
1、rfind()方法
rfind() 返回字符串最后一次出现的位置，如果没有匹配项则返回 -1 。
语法
string.rfind(value, start, end)
参数值
| 参数 | 描述 |
|---|---|
| value | 必需。要检索的值。 |
| start | 可选。从何处开始检索。默认是 0。 |
| end | 可选。在何处结束检索。默认是到字符串的末尾。 |
实例
在哪里最后出现文本中的字母 “e”？
txt = "Hello, welcome to my world."
x = txt.rfind("e")
print(x)
13
如果只在位置 5 和位置 10 之间搜索，文本中最后出现的字母 “e” 在何处？
txt = "Hello, welcome to my world."
x = txt.rfind("e", 5, 10)
print(x)
8
如果找不到该值，则 rfind() 方法返回 -1，但是 rindex() 方法将引发异常：
txt = "Hello, welcome to my world."
print(txt.rfind("q"))
print(txt.rindex("q"))
-1
Traceback (most recent call last):
File "C:\Users\MK\Desktop\Python方法\str.py", line 3, in <module>
print(txt.rindex("q"))
ValueError: substring not found
2、rindex()方法
rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间。
语法
string.rindex(value, start, end)
参数值
| 参数 | 描述 |
|---|---|
| value | 必需。要检索的值。 |
| start | 可选。从何处开始检索。默认是 0。 |
| end | 可选。在何处结束检索。默认是到字符串的末尾。 |
实例
在哪里最后出现文本中的字母 “e”？
txt = "Hello, welcome to my world."
x = txt.rindex("e")
print(x)
13
如果只在位置 5 和位置 10 之间搜索，文本中最后出现的字母 “e” 在何处？
txt = "Hello, welcome to my world."
x = txt.rindex("e", 5, 10)
print(x)
8
如果找不到该值，则 rfind() 方法返回 -1，但是 rindex() 方法将引发异常：
txt = "Hello, welcome to my world."
print(txt.rfind("q"))
print(txt.rindex("q"))
-1
Traceback (most recent call last):
File "C:\Users\MK\Desktop\Python方法\str.py", line 3, in <module>
print(txt.rindex("q"))
ValueError: substring not found
3、rfind() 和 rindex() 区别
rfind() 和 rindex() 都是查找指定值的最后一次出现。如果找不到该值，则 rfind() 方法将返回 -1，而 rindex() 方法将引发异常。
5.3 以 str 开头/结束 startswith()、endswith()
1、startswith()方法
startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。
语法
string.startswith(value, start, end)
参数值
| 参数 | 描述 |
|---|---|
| value | 必需。检查字符串是否以其开头的值。 |
| start | 可选。整数，规定从哪个位置开始搜索。 |
| end | 可选。整数，规定结束搜索的位置。 |
实例
检查位置 7 到 20 是否以字符 “wel” 开头：
txt = "Hello, welcome to my world."
x = txt.startswith("wel", 7, 20)
print(x)
True
如果字符串以指定的值开头，则 startswith() 方法返回 True，否则返回 False。
2、endswith()方法
endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回 True，否则返回 False。可选参数 “start” 与 “end” 为检索字符串的开始与结束位置。
语法
string.endswith(value, start, end)
参数值
| 参数 | 描述 |
|---|---|
| value | 必需。检查字符串是否以之结尾的值。 |
| start | 可选。整数。规定从哪个位置开始检索。 |
| end | 可选。整数。规定从哪个位置结束检索。 |
实例
检查字符串是否以短语 “my world.” 结尾：
txt = "Hello, welcome to my world."
x = txt.endswith("my world.")
print(x)
True
检查位置 5 至 11 是否以短语 “my world.” 结尾：
txt = "Hello, welcome to my world."
x = txt.endswith("my world.", 5, 11)
print(x)
False
如果字符串以指定值结尾，则 endswith() 方法返回 True，否则返回 False。
5.4 编/解码 encode()、decode()
encode()和 decode()
encode() 方法以指定的编码格式编码字符串，decode() 方法以指定的解码格式解码字符串。
errors参数可以指定不同的错误处理方案。
语法
string.encode(encoding=encoding, errors=errors)
string.decode(decoding=decoding, errors=errors)
参数值
| 参数 | 描述 |
|---|---|
| encoding / decoding | 可选。字符串。规定要使用的编码/解码。默认是 UTF-8。 |
| errors | 可选。字符串。规定错误方法。合法值是： ‘backslashreplace’ - 使用反斜杠代替无法编码的字符 ‘ignore’ - 忽略无法编码的字符 ‘namereplace’ - 用解释字符的文本替换字符 ‘strict’ - 默认值，失败时引发错误 ‘replace’ - 用问号替换字符 ‘xmlcharrefreplace’ - 用 xml 字符替换字符 |
实例
str = 'pink老师'
str_utf8 = str.encode("UTF-8")
str_gbk = str.encode("GBK")
print("UTF-8 编码：", str_utf8)
print("GBK 编码：", str_gbk)
print("UTF-8 解码：", str_utf8.decode('UTF-8', 'strict'))
print("GBK 解码：", str_gbk.decode('GBK', 'strict'))
UTF-8 编码： b'pink\xe8\x80\x81\xe5\xb8\x88'
GBK 编码： b'pink\xc0\xcf\xca\xa6'
UTF-8 解码： pink老师
GBK 解码： pink老师
5.5 填充对齐 center()、ljust()、rjust()、zfill()
1、center()方法
center() 方法返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
语法
string.center(length, character)
参数值
| 参数 | 描述 |
|---|---|
| length | 必需。所返回字符串的长度。 |
| character | 可选。填补两侧缺失空间的字符。默认是 " "（空格）。 |
实例
使用字母 “O” 作为填充字符：
txt = "banana" x = txt.center(20, "O") print(x)
OOOOOOObananaOOOOOOO
2、ljust()方法
ljust() 方法返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
语法
string.ljust(length, character)
参数值
| 参数 | 描述 |
|---|---|
| length | 必需。所返回字符串的长度。 |
| character | 可选。用于填充缺少空间（在字符串的右侧）的字符。默认值为 " "（空格）。 |
实例
使用字母 “O” 作为填充字符：
txt = "banana" x = txt.ljust(20, "O") print(x)
bananaOOOOOOOOOOOOOO
3、rjust()方法
rjust() 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。
语法
string.rjust(length, character)
参数值
| 参数 | 描述 |
|---|---|
| length | 必需。所返回字符串的长度。 |
| character | 可选。用于填充缺失空间（在字符串的左侧）字符。默认值为 " "（空格）。 |
实例
使用字母 “O” 作为填充字符：
txt = "banana" x = txt.rjust(20, "O") print(x)
OOOOOOOOOOOOOObanana
4、zfill()方法
zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0。
语法
string.zfill(len)
参数值
| 参数 | 描述 |
|---|---|
| len | 必需。数字，规定要删除的元素的位置。 |
实例
用零填充字符串，直到它们长为 10 个字符：
a = "hello" b = "welcome to my world" c = "10.000" print(a.zfill(10)) print(b.zfill(10)) print(c.zfill(10))
00000hello
welcome to my world
000010.000
zfill() 方法在字符串的开头添加零（0），直到达到指定的长度。如果 len 参数的值小于字符串的长度，则不执行填充。
5.6 删除左/右指定字符 lstrip()、rstrip()、strip()
1、lstrip()方法
lstrip() 方法用于截掉字符串左边的空格或指定字符。
语法
string.lstrip(characters)
参数值
| 参数 | 描述 |
|---|---|
| characters | 可选。一组作为前导字符要删除的字符。 |
实例
删除前导字符：
txt = ",,,,,ssaaww.....banana"
x = txt.lstrip(",.asw")
print(x)
banana2、rstrip()方法
rstrip() 删除 string 字符串末尾的指定字符，默认为空白符，包括空格、换行符、回车符、制表符。
语法
string.rstrip(characters)
参数值
| 参数 | 描述 |
|---|---|
| characters | 可选。一组作为结尾字符要删除的字符。 |
实例
删除结尾字符：
txt = "banana,,,,,ssaaww....."
x = txt.rstrip(",.asw")
print(x)
banan
3、strip()方法
strip() 方法用于移除字符串头尾指定的字符（默认为空格）或字符序列。
语法
string.strip(characters)
参数值
| 参数 | 描述 |
|---|---|
| characters | 可选。一组字符，要删除的前导/尾随字符的字符。 |
实例
删除前导和尾随字符：
txt = ",,,,,rrttgg.....banana....rrr"
x = txt.strip(",.grt")
print(x)
banana
5.7 判断字符(串)
5.7.1 空白字符 isspace()
1、isspace()方法
isspace() 方法检测字符串是否只由空白字符组成。
语法
string.isspace()
参数值
无参数
实例
txt = " s " x = txt.isspace() print(x)
False
如果字符串中的所有字符都是空格，则 isspace() 方法将返回 True，否则返回 False。
5.7.2 可打印 isprintable()
2、isprintable()方法
isprintable() 方法检查文本中的所有字符是否可打印。
语法
string.isprintable()
参数值
无参数
实例
txt = "Hello!\nAre you #1?" x = txt.isprintable() print(x)
False
如果所有字符都是可打印的，则 isprintable() 方法返回 True，否则返回 False。不可打印的字符可以是回车和换行符。
5.7.3 标识符 isidentifier()
3、isidentifier()方法
isidentifier() 方法检查字符串是否是有效标识符。
语法
string.isidentifier()
参数值
无参数
实例
a = "MyFolder" b = "Demo002" c = "2bring" d = "my demo" print(a.isidentifier()) print(b.isidentifier()) print(c.isidentifier()) print(d.isidentifier()
True
True
False
False
如果字符串是有效标识符，则 isidentifier() 方法返回 True，否则返回 False。
如果字符串仅包含字母数字字母（a-z）和（0-9）或下划线（_），则该字符串被视为有效标识符。有效的标识符不能以数字开头或包含任何空格。
5.7.4 字母/数字 isalnum()
4、isalnum()方法
isalnum() 方法检测字符串是否由字母和数字组成。
语法
string.isalnum()
参数值
无参数
实例
检查文本中的所有字符是否都是字母数字：
txt = "Company 12" x = txt.isalnum() print(x)
False
如果所有字符均为字母数字，即字母（a-z）和数字（0-9），则 isalnum() 方法返回 True。
非字母数字的例子：(space)!#%&? 等等。
5.7.5 字母/中文 isalpha()
5、isalpha()方法
isalpha() 方法检测字符串是否只由字母或文字组成。
语法
string.isalpha()
参数值
无参数
实例
检查文本中的所有字符是否都是字母：
txt = "Company10" x = txt.isalpha() print(x)
False
如果所有字符都是字母（a-z），则 isalpha() 方法将返回 True。
非字母的字符例子：(space)!#%&? 等等。
5.7.6 数字 isdigit()、isnumeric()、isdecimal()
6.1、isdigit()方法
isdigit() 方法检测字符串是否只由数字组成。
语法
string.isdigit()
参数值
无参数
实例
检查文本中的所有字符是否都是字母：
a = "\u0030" # unicode for 0 b = "\u00B2" # unicode for ² print(a.isdigit()) print(b.isdigit())
True
True
如果所有字符都是数字，则 isdigit() 方法将返回 True，否则返回 False。
指数（例如²）也被视作数字。
6.2、isnumeric()方法
isnumeric() 方法检测字符串是否只由数字组成，数字可以是： Unicode 数字，全角数字（双字节），罗马数字，汉字数字。
指数类似 ² 与分数类似 ½ 也属于数字。
语法
string.isnumeric()
参数值
无参数
实例
检查字符是否为数字：
a = "\u0030" # unicode for 0 b = "\u00B2" # unicode for ² c = "10km2" print(a.isnumeric()) print(b.isnumeric()) print(c.isnumeric())
True
True
False
如果所有字符均为数字（0-9），则 isumeric() 方法返回 True，否则返回 False。
指数（比如 ² 和 ¾）也被视为数字值。
6.3、isdecimal()方法
isdecimal() 方法检查 unicode 对象中的所有字符是否都是小数。
语法
string.isdecimal()
参数值
无参数
实例
检查 unicode 中的所有字符是否都是小数：
a = "\u0030" # unicode for 0 b = "\u0047" # unicode for G print(a.isdecimal()) print(b.isdecimal())
True
False
如果所有字符均为小数（0-9），则 isdecimal() 方法将返回 True。
此方法用于 unicode 对象。
5.8 格式字符串中指定值 format()、format_map()
1、format()方法
format() 方法格式化指定的值，并将其插入字符串的占位符内，占位符使用大括号 {} 定义。
语法
string.format(value1, value2...)
参数值
| 参数 | 描述 |
|---|---|
| value1, value2… | 必需。一个或多个应该格式化并插入字符串的值。值可以是数字，用于指定要删除的元素的位置。 这些值可以是用逗号分隔的值列表、键=值列表，或两者的组合。 这些值可以是任何数据类型。 |
占位符
可以使用命名索引 {price}、编号索引{0}、甚至空的占位符 {} 来标识占位符。
实例
使用不同的占位符值：
txt1 = "My name is {fname}, I'am {age}".format(fname="Bill", age=64)
txt2 = "My name is {0}, I'am {1}".format("Bill", 64)
txt3 = "My name is {}, I'am {}".format("Bill", 64)
print(txt1)
print(txt2)
print(txt3)
My name is Bill, I'am 64
My name is Bill, I'am 64
My name is Bill, I'am 64
格式化类型
在占位符内，您可以添加格式化类型以格式化结果：
| 格式化类型 | 描述 |
|---|---|
| :< | 左对齐结果（在可用空间内） |
| :> | 右对齐结果（在可用空间内） |
| :^ | 居中对齐结果（在可用空间内） |
| := | 将标志放置在最左侧 |
| :+ | 使用加号指示结果是正数还是负数 |
| :- | 负号仅用于负值 |
| : | 使用空格在正数之前插入一个多余的空格（在负数之前使用减号） |
| :, | 使用逗号作为千位分隔符 |
| :_ | 使用下划线作为千位分隔符 |
| :b | 二进制格式 |
| :c | 将值转换为相应的 unicode 字符 |
| :d | 十进制格式 |
| :e | 科学格式，带有小写字母 E |
| :E | 科学格式，带有大写字母 E |
| :f | 定点数字格式 |
| :F | 定点数字格式，以大写形式显示（将 inf 和 nan 显示为 INF 和 NAN） |
| :g | 通用格式 |
| :G | 通用格式（将大写 E 用作科学计数法） |
| 😮 | 八进制格式 |
| :x | 十六进制格式，小写 |
| :X | 十六进制格式，大写 |
| :n | 数字格式 |
| :% | 百分比格式 |
2、format_map()方法
format_map() 方法格式化字符串中的指定值。
语法
str.format_map(mapping)
参数值
参数描述mapping字典类型的数据。
实例
str_a = '我是 {name} 老师 {gender} {age} 岁'
dict_1 = {'name': 'pink', 'gender': '男', 'age': 21}
print(str_a.format_map(dict_1))
我是 pink 老师 男 21 岁
5.9 拆分/截取字符串 split()、rsplit()、splitlines()
1、split()方法
split() 通过指定分隔符从左侧对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串。
语法
string.split(separator, max)
参数值
| 参数 | 描述 |
|---|---|
| separator | 可选。规定分割字符串时要使用的分隔符。默认值为空白字符。 |
| max | 可选。规定要执行的拆分数。默认值为 -1，即“所有出现次数”。 |
实例
使用逗号后跟空格作为分隔符，分割字符串：
txt = "hello, my name is Bill, I am 63 years old"
x = txt.split(", ")
print(x)
['hello', 'my name is Bill', 'I am 63 years old']
使用 # 号字符作为分隔符：
txt = "apple#banana#cherry#orange"
x = txt.split("#")
print(x)
['apple', 'banana', 'cherry', 'orange']
将字符串拆分为最多 2 个项目的列表：
txt = "apple#banana#cherry#orange"
# 将 max 参数设置为 1，将返回包含 2 个元素的列表！
x = txt.split("#", 1)
print(x)
['apple', 'banana#cherry#orange']
split() 方法将字符串拆分为列表。
您可以指定分隔符，默认分隔符是任何空白字符。
**注释：**若指定 max，列表将包含指定数量加一的元素。
2、rsplit()方法
rsplit() 通过指定分隔符从右侧对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串。
语法
string.rsplit(separator, max)
参数值
| 参数 | 描述 |
|---|---|
| separator | 可选。规定分割字符串时要使用的分隔符。默认值为空白。 |
| max | 可选。指定要执行的拆分数。默认值为 -1，即“所有出现次数”。 |
实例
将字符串拆分为最多 2 个项目的列表：
txt = "apple, banana, cherry"
# 将 max 参数设置为 1，将返回包含 2 个元素的列表！
x = txt.rsplit(", ", 1)
print(x)
['apple, banana', 'cherry']
rsplit() 方法从右侧开始将字符串拆分为列表。
如果未指定 “max”，则此方法将返回与 split() 方法相同的结果。
注释： 若指定 max，列表将包含指定数量加一的元素。
3、splitlines()方法
splitlines() 按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
语法
string.splitlines(keeplinebreaks)
参数值
| 参数 | 描述 |
|---|---|
| keeplinebreaks | 可选。规定是否应包含换行符（True）或不包含（False）。默认值不包含（False）。 |
实例
拆分字符串，但保留换行符：
txt = "Thank you for your visiting\nWelcome to China" x = txt.splitlines(True) print(x)
['Thank you for your visiting\n', 'Welcome to China']
5.10 拆分字符串(返回元组) partition()、rpartition()
1、partition()方法
partition() 方法搜索指定的字符串，并将该字符串拆分为包含三个元素的元组。
第一个元素包含指定字符串之前的部分，第二个元素包含指定的字符串，第三个元素包含字符串后面的部分。
注释：此方法搜索指定字符串的第一个匹配项。
语法
string.partition(value)
参数值
| 参数 | 描述 |
|---|---|
| value | 必需。要检索的字符串。 |
实例
搜索单词 “bananas”，并返回包含三个元素的元组： 1 - “匹配”之前的所有内容2 - “匹配”3 - “匹配”之后的所有内容
txt = "I could eat bananas all day"
x = txt.partition("bananas")
print(x)
('I could eat ', 'bananas', ' all day')
如果找不到指定的值，则 partition() 方法将返回一个元组，其中包含：1 - 整个字符串，2 - 空字符串，3 - 空字符串：
txt = "I could eat bananas all day"
x = txt.partition("apples")
print(x)
('I could eat bananas all day', '', '')
2、rpartition()方法
rpartition() 方法搜索指定字符串的最后一次出现，并将该字符串拆分为包含三个元素的元组。
第一个元素包含指定字符串之前的部分，第二个元素包含指定的字符串，第三个元素包含字符串之后的部分。
语法
string.rpartition(value)
参数值
| 参数 | 描述 |
|---|---|
| value | 必需。要检索的字符串。 |
实例
搜索单词 “bananas” 的最后一次出现，并返回包含三个元素的元组：
- 1 - “匹配”之前的所有内容
- 2 - “匹配”
- 3 - “匹配”之后的所有内容
txt = "I could eat bananas all day, bananas are my favorite fruit"
x = txt.rpartition("bananas")
print(x)
('I could eat bananas all day, ', 'bananas', ' are my favorite fruit')
如果找不到指定的值，则 rpartition() 方法将返回一个元组，其中包含：1 - 整个字符串，2 - 一个空字符串，3 - 一个空字符串：
txt = "I could eat bananas all day, bananas are my favorite fruit"
x = txt.rpartition("apples")
print(x)
('', '', 'I could eat bananas all day, bananas are my favorite fruit')
5.11 字符串转换 maketrans()、translate()
1、maketrans()方法
maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
两个字符串的长度必须相同，为一一对应的关系。
语法
string.maketrans(x[, y[, z]])
参数值
| 参数 | 描述 |
|---|---|
| x | 必需，字符串中要替代的字符组成的字符串。 |
| y | 可选，相应的映射字符的字符串。 |
| z | 可选，要删除的字符。 |
2、translate()方法
translate() 返回被转换的字符串。
实例
字母 B 替换为 b
txt = "www.Baidu.com"
url = txt.maketrans('B', 'b')
print(txt.translate(url))
www.baidu.com
使用字符串设置要替换的字符，一一对应
x = "aeiou" y = "12345" trans = str.maketrans(x, y) str1 = "this is a string" print(str1.translate(trans))
th3s 3s 1 str3ng
设置要删除的字符参数：
txt = "baidu z alibaba Z tencent" x = "bat" y = "BAT" z = "zZ" # 设置删除的字符 trans = txt.maketrans(x, y, z) print(txt.translate(trans)) print(trans)
BAidu AliBABA TencenT
{98: 66, 97: 65, 116: 84, 122: None, 90: None
5.12 元组项目连接到字符串 join()
join()方法
join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
语法
string.join(iterable)
参数值
| 参数 | 描述 |
|---|---|
| iterable | 必需。所有返回值均为字符串的任何可迭代对象。 |
实例
使用哈希字符作为分隔符，将元组中的所有项目连接到字符串中：
tuple_1 = ("baidu", "alibaba", "tencent")
x = "#".join(tuple_1)
print(x)
baidu#alibaba#tencent
使用单词 “TEST” 作为分隔符，将字典中的所有项目连接成一个字符串：
dict_1 = {"name": "Bill", "country": "USA"}
separator = "TEST"
x = separator.join(dict_1)
print(x)
nameTESTcountry
5.13 字符串替换 replace()
replace()方法
replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
语法
string.replace(oldvalue, newvalue, count)
参数值
| 参数 | 描述 |
|---|---|
| oldvalue | 必需。要检索的字符串。 |
| newvalue | 必需。替换旧值的字符串。 |
| count | 可选。数字，指定要替换的旧值出现次数。默认为所有的出现。 |
实例
替换单词 “bananas”：
txt = "I like bananas"
x = txt.replace("bananas", "apples")
print(x)
I like apples
替换所有出现的单词 “one”：
txt = "one one was a race horse, two two was one too."
x = txt.replace("one", "three")
print(x)
three three was a race horse, two two was three too.
替换前两次出现的单词 “one”：
txt = "one one was a race horse, two two was one too."
x = txt.replace("one", "three", 2)
print(x)
three three was a race horse, two two was one too.
5.14 字符串 Tab 转换 expandtabs()
expandtabs()方法
expandtabs() 方法把字符串中的 tab 符号 \t 转为空格，tab 符号 \t 默认的空格数是 8，在第 0、8、16…等处给出制表符位置，如果当前位置到开始位置或上一个制表符位置的字符数不足 8 的倍数则以空格代替。
语法
string.exandtabs(tabsize)
参数值
| 参数 | 描述 |
|---|---|
| tabsize | 可选。规定制表符大小的数字。默认的 tabsize 是 8。 |
实例
将制表符大小设置为 2 个空格：
txt = "H\te\tl\tl\to" x = txt.expandtabs(2) print(x)
H e l l o
请看看不同制表符大小的结果：
txt = "H\te\tl\tl\to" print(txt) print(txt.expandtabs()) print(txt.expandtabs(2)) print(txt.expandtabs(4)) print(txt.expandtabs(10))
H e l l o
H e l l o
H e l l o
H e l l o
H e l l o
6、总结
| 函数 | 描述 |
|---|---|
| print() | 打印输出 |
| len() | 确定字符串长度 |
| type() | 返回变量类型 |
| str() | 转换为字符串 |
| max() | 字符串最大字符 |
| min() | 字符串最小字符 |
| del | 删除字符串 |
| 方法 | 描述 |
|---|---|
| capitalize() | 把首字符转换为大写 |
| casefold() | 把字符串转换为小写（处理其他语言且存在大小写） |
| lower() | 把字符串转换为小写 |
| islower() | 如果字符串中的所有字符都是小写，则返回 True |
| upper() | 把字符串转换为大写 |
| isupper() | 如果字符串中的所有字符都是大写，则返回 True |
| title() | 返回"标题化"字符串：所有单词都以大写开始，其余字母均为小写 |
| istitle() | 如果字符串遵循标题规则，则返回 True |
| swapcase() | 将字符串中大写转换为小写，小写转换为大写 |
| count(str, beg, end) | 返回str出现的次数，beg和end指定范围 |
| find(str, beg, end) | 搜索指定的值并返回该位置，beg 和 end 指定范围，不存在返回-1 |
| index(str, beg, end) | 搜索指定的值并返回该位置，beg 和 end 指定范围，不存在报异常 |
| rfind(str, beg, end) | 类似于 find() ，不过是从右边开始 |
| rindex( str, beg, end) | 类似于 index()，不过是从右边开始 |
| startswith(str, beg, end) | 检查是否以 str 开头，beg 和 end 指定范围，如果是，返回 True，否则返回 False |
| endswith(str, beg, end) | 检查是否以 str 结束，beg 和 end 指定范围，如果是，返回 True，否则返回 False |
| encode(‘UTF-8’, ‘strict’) | 编码，出错默认报 ValueError 异常，除非 errors 指定的是’ignore’或者’replace’ |
| decode(‘UTF-8’, ‘strict’) | 解码，出错默认报 ValueError 异常，除非 errors 指定的是’ignore’或者’replace’ |
| center(width, fillchar) | 返回一个指定的宽度width居中的字符串，fillchar为填充的字符，默认为空格 |
| ljust(width, fillchar) | 字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格 |
| rjust(width, fillchar) | 字符串右对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格 |
| zfill (width) | 返回长度为 width 的字符串，原字符串右对齐，前面填充0 |
| lstrip() | 删除字符串左边的空格或指定字符 |
| rstrip() | 删除字符串末尾的空格或指定字符 |
| strip() | 在字符串上执行 lstrip()和 rstrip()，返回字符串的剪裁版本 |
| isspace() | 如果字符串中的所有字符都是空白字符，则返回 True |
| isprintable() | 如果字符串中的所有字符都是可打印的，则返回 True |
| isidentifier() | 如果字符串是标识符，则返回 True |
| isalnum() | 如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True，否则返回 False |
| isalpha() | 如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False |
| isdigit() | 如果字符串只包含数字则返回 True ，否则返回 False |
| isnumeric() | 如果字符串中的所有字符都是数字，则返回 True |
| isdecimal() | 检查所有字符是否都是十进制数（0~9），是则返回 True, 否则返回 False |
| format() | 格式化字符串中的指定值 |
| format_map() | 格式化字符串中的指定值（字典） |
| split(str, num) | 以 str 为分隔符截取，若 num 指定，则截取 num+1 个子字符串，并返回列表（从左） |
| rsplit() | 以 str 为分隔符截取，若 num 指定，则截取 num+1 个子字符串，并返回列表（从右） |
| splitlines() | 在换行符处拆分字符串并返回列表 |
| partition() | 返回元组，其中的字符串分为三部分（搜索 str 第一次出现） |
| rpartition() | 返回元组，其中的字符串分为三部分（搜索 str 最后出现） |
| maketrans(x[, y[, z]]) | x – 必需，要替代的字符串， y – 可选，相应映射的字符串， z – 可选，要删除的字符 |
| translate() | 返回被转换的字符串 |
| join() | 使用字符作为分隔符，将元组中的所有项目连接到字符串中 |
| replace(old, new [, max]) | 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max |
| expandtabs(tabsize) | 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 |
总结
到此这篇关于Python字符串str超详细详解的文章就介绍到这了,更多相关Python字符串str详解内容请搜索本网站以前的文章或继续浏览下面的相关文章希望大家以后多多支持本网站！
您可能感兴趣的文章:
- 详细整理python 字符串(str)与列表(list)以及数组(array)之间的转换方法
- python字符串str和字节数组相互转化方法
- python3中str（字符串）的使用教程
- Python字符串str和json格式相互转换
- Python列表(list)、字典(dict)、字符串(string)基本操作小结
- Python实现string字符串连接的方法总结【8种方式】
- python字符串切割:str.split()与re.split()的对比分析
- python str()如何将参数转换为字符串类型
