Python——字符串

最新推荐文章于 2024-09-25 22:48:05 发布

时光·漫步zth

最新推荐文章于 2024-09-25 22:48:05 发布

阅读量797

点赞数 1

分类专栏： Python3

本文链接：https://blog.csdn.net/qq_41573234/article/details/81429518

版权

Python3 专栏收录该内容

40 篇文章 7 订阅

订阅专栏

一. 字符串的基本操作

1. 创建字符串

使用引号（' 或 "）创建字符串，只要为变量分配一个值即可。在 Python 中，字符串由内置的 str 类型定义。

>>> str1 = " Hello ,World"      #创建字符串 Hello ,World 并赋值给变量 str1
>>> str1
' Hello ,World'
>>> type(str1)
<class 'str'>

2. 访问字符串中的值

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

Python 访问子字符串，可以使用方括号来截取字符串。

>>> str1 = "Hello ,World"
>>> str1[0]             #访问第 1 个字符
'H'
>>> str1[-1]            #访问倒数第 1 个字符
'd'
>>> str1[23]            #索引必须在范围内
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range
>>> str1[2.3]           #索引必须是整数
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: string indices must be integers

3. 切片

切片操作的语法格式：

str`[start:stop:step]`

s[:] 形式会忽略开始和结束索引，总是获得一个完整的副本。是 pythonic 使用的方式，用于复制序列（例如：字符串或列表）。
对于任何索引 n，s[:n] + s[n:] == s 是一个整齐的切片，甚至对于负数或超出界限的值也是如此。换一种说法，s[:n]和 s[n:] 总是将字符串分成两部分，来保存所有的字符。

>>> str1 = "Hello ,World"
>>> str1[1:4]           # 第 2 个到第 4 个字符
'ell'
>>> str1[1:]            # 第 2 个到最后一个字符（将索引默认设置为字符串的开始或结束）
'ello ,World'
>>> str1[1:100]         # 索引太大，被截断至字符串长度处
'ello ,World'
>>> str1[:]             # 所有字符（从开始到结束）
'Hello ,World'
>>> str1[-4:-1]         # 倒数第 4 个到倒数第 1 个字符
'orl'

4. 字符串更新

字符串是不可变的，也就是说，一旦分配了字符串的元素就不能被更改。但是可以截取字符串的一部分并与其他字段拼接或将不同的字符串重新分配给同一个变量。

无法从字符串中删除字符，但是可以使用关键字 del 完全删除字符串

>>> str1 = "Hello ,World"

>>> str1[1] = 'z'        
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment


>>> print ("已更新字符串 : ", str1[:6] + 'Runoob!')
已更新字符串 :  Hello Runoob!

>>> str1
'Hello ,World'

>>> str1= 'Hello Python'

>>> str1
'Hello Python'

5. Python 转义字符

转义字符	描述
\(在行尾时)	续行符
\\	反斜杠符号
\'	单引号
\"	双引号
\a	响铃
\b	退格(Backspace)
\e	转义
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy代表的字符，例如：\o12代表换行
\xyy	十六进制数，yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出

>>> print('一念净心 花开遍世界\n每临绝境 峰回路又转')   #使用\n换行
一念净心 花开遍世界
每临绝境 峰回路又转
>>> print('\'一念净心 花开遍世界\'\n\'每临绝境 峰回路又转\'')   #使用\n换行
'一念净心 花开遍世界'
'每临绝境 峰回路又转'

>>> print('\'一念净心 花开遍世界\'\n\'每临绝境 峰回路又转\'')   #使用\n换行、使用转义字符单引号
'一念净心 花开遍世界'
'每临绝境 峰回路又转'

>>> print('\'一念净心 花开遍世界\'\n\'\t\a每临绝境 峰回路又转\'')   #使用\n换行、使用转义字符单引号、横向制表符、响铃
'一念净心 花开遍世界'
'       每临绝境 峰回路又转'

6. Python字符串运算符

操作符	描述
+	字符串连接
*	重复输出字符串
[]	通过索引获取字符串中字符
[:]	截取字符串中的一部分
in	成员运算符 - 如果字符串中包含给定的字符返回 True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。
%	格式字符串

>>> str1 = 'Hello '
>>> str2 = 'Python'

>>> str1 + str2                #+
'Hello Python'

>>> str1*3                     #*
'Hello Hello Hello '

>>> str1[2]                    #[]
'l'

>>> str1[1:3]                  #[:]
'el'

>>> if('H' in str1):           #in
...     print('H 在变量 str1 中')
... else:
...     print('H 不在变量 str1 中')
...
H 在变量 str1 中

>>> 'H' not in str1            #not in 
False

>>> print('This is \x48\x45\x58')
This is HEX
>>> print(r'This is \x48\x45\x58')      #原始字符串
This is \x48\x45\x58

二. 字符串格式化

Python 的字符串格式化有两种方式:

%格式符方式
format方式

1. %格式符

语法：

% [(name)] [flags] [width].[precision] typecode

(name) 可选，用于选择指定的 key
flags 可选，可供选择的值有:

+	右对齐；正数前加正好，负数前加负号
-	左对齐；正数前无符号，负数前加负号
空格	右对齐；正数前加空格，负数前加负号
0	右对齐；正数前无符号，负数前加负号；用0填充空白处

width 可选，占有宽度
precision 可选，小数点后保留的位数
typecode 必选

符号	描述
%c	格式化字符及其ASCII码（整数：将数字转换成其unicode对应的值；字符：将字符添加到指定位置）
%s	格式化字符串
%d	将整数、浮点数转换成十进制表示，并将其格式化到指定位置
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
%e	将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）
%E	将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）
%g	自动调整将整数、浮点数转换成浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
%G	自动调整将整数、浮点数转换成浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
%p	用十六进制数格式化变量的地址

【注】：Python中百分号格式化是不存在自动将整数转换成二进制表示的方式

>>> print('Hello ,%s'%'World')
Hello ,World
>>> print('今年是 %s 年'%8012)
今年是 8012 年

格式化字符串的 %s 部分称为转换说明符，标记了需要放置转化值的位置，通用术语为占位符。
s 表示百分号右边的值会被格式化为字符串。如果不是字符串就会用 str 将其转换为字符串。

格式化操作符辅助指令:

符号	功能
*	定义宽度或者小数点精度
-	用做左对齐
+	在正数前面显示加号( + )
<sp>	在正数前面显示空格
#	在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
0	显示的数字前面填充'0'而不是默认的空格
%	'%%'输出一个单一的'%'
(var)	映射变量(字典参数)
m.n.	m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

(name) 可选，用于选择指定的 key

>>> print(a)
zth-->20
>>> print("今天是 %s 年 %d 月 %d 日"%(2018,8,5))
今天是 2018 年 8 月 5 日
>>>
>>> print("今天是 %s 年 %d 月 %d 日"%2018,8,5)        #没有足够的格式字符串参数
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: not enough arguments for format string

如果右操作数是元组，其中每个元素都会被单独格式化，每个值都需要一个对应的转换说明。
在有多个占位符的字符串中，可以使用元组传入多个格式化值。
如果使用列表或其他序列代替元组，序列就会被解释为一个值。
只有元组和字典可以格式化一个以上的值。

字段宽度和精度

字段宽度和精度都是整数，并通过点号（.）分隔。
两个都是可选参数，如果给出精度，就必须包含点号。
可以使用*（星号）作为宽度或精度（或两者都用*），数值从元组中读出。

>> print('圆周率 PI 的值为：%10f'%3.141593)            #字段宽度为 10
圆周率 PI 的值为：  3.141593               #字符串宽度为 10，被字符串占据 8 个空格，剩余两个空格



>>> print('保留 2 位小数，圆周率 PI 的值为：%10.2f'%3.141593)           #字段宽度为 10
保留 2 位小数，圆周率 PI 的值为：      3.14     #字符串宽度为 10，被字符串占据 4 个，剩余 6 个



>>> print('保留 2 位小数，圆周率 PI 的值为：%.2f'%3.141593)             #字段宽度为默认值
保留 2 位小数，圆周率 PI 的值为：3.14
>>>
>>>
>>> print('字符串精度获取：%.5s'%('Hello World'))        #打印字符串前 5 个字符
字符串精度获取：Hello
>>>
>>>
>>> print('从元组中获取字符串精度：%*.*s'%(10,5,'hello world'))
从元组中获取字符串精度：     hello            #输出字符串宽度为 10、精度为 5


>>> print('从元组中获取字符串精度：%.*s'%(5,'hello world'))
从元组中获取字符串精度：hello            #输出精度为 5

符号、对齐和 0 填充

>>> print('圆周率 PI 的值为：%010.2f'%3.141593)                 #用 0 进行填充
圆周率 PI 的值为：0000003.14
>>>
>>> print('-PI 的值为：%010.2f'%-3.141593)                      #用 0 进行填充
-PI 的值为：-000003.14
>>>
>>>
>>> print('圆周率 PI 的值为：%-10.2f'%3.141593)                 #-：左对齐
圆周率 PI 的值为：3.14      #此处右侧为多出的空格
>>>
>>>
>>> print('圆周率 PI 的值为：%+10.2f'%3.141593)                 #+：右对齐；正数前加正好，负数前加负号
圆周率 PI 的值为：     +3.14
>>>
>>>
>>> print(('% 5d'%10)+'\n'+('% 5d'%-10))           空格    右对齐；正数前加空格，负数前加负号；
   10
  -10

typecode 必选

>>            #进制转换
...
>>> print('*****%c'%65)         #c，整数：将数字转换成其unicode对应的值，字符：将字符添加到指定位置
*****A
>>> print('*****%o'%8)          #将整数转换成 八  进制表示
*****10
>>> print('*****%x'%16)         #将整数转换成十六进制表示
*****10
>>>
>>>             #科学计数
...
>>> f = '-----%(num)e------%(num)E'%{'num':1000000000}
>>> print(f)
-----1.000000e+09------1.000000E+09
>>> g = '-----%(num)g------%(num1)G'%{'num':1000000000,'num1':100}
>>> print(g)
-----1e+09------100
>>>
>>>     #%，当字符串中存在格式化标志时，需要用 %%表示一个百分号(类似于转意效果)
...
>>> print('aaa %')
aaa %
>>> print('aaa %s %%'%('bbb'))
aaa bbb %
>>> print('aaa %s %%s %%'%('bbb'))
aaa bbb %s %

Python format 格式化函数

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

基本语法是通过 {} 和 : 来代替以前的 % 。

语法如下：

[ [fill] align ] [sign] [#] [width] [,] [.precision] [type]

fill 【可选】空白处填充的字符
align 【可选】对齐方式（需配合width使用）

<：内容左对齐
>：内容右对齐（默认）
＝：内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。即使：符号+填充物+数字
^，内容居中

sign 【可选】有无符号数字

+，正号加正，负号加负
-，正号不变，负号加负
空格，正号空格，负号加负

# 【可选】对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示
，【可选】为数字添加分隔符，如：1,000,000
width 【可选】格式化位所占宽度
.precision 【可选】小数位保留精度
type 【可选】格式化类型

1. 传入” 字符串类型 “的参数

$\bullet$ s，格式化字符串类型数据
$\bullet$ 空白，未指定类型，则默认是None，同s

   2. 传入“ 整数类型 ”的参数
      $\bullet$   b，将10进制整数自动转换成2进制表示然后格式化
      $\bullet$   c，将10进制整数自动转换为其对应的unicode字符
      $\bullet$   d，十进制整数
      $\bullet$   o，将10进制整数自动转换成8进制表示然后格式化；
      $\bullet$   x，将10进制整数自动转换成16进制表示然后格式化（小写x）
      $\bullet$   X，将10进制整数自动转换成16进制表示然后格式化（大写X）
   3. 传入“ 浮点型或小数类型 ”的参数
      $\bullet$   e，转换为科学计数法（小写e）表示，然后格式化；
      $\bullet$   E，转换为科学计数法（大写E）表示，然后格式化;
      $\bullet$   f ，转换为浮点型（默认小数点后保留6位）表示，然后格式化；
      $\bullet$   F，转换为浮点型（默认小数点后保留6位）表示，然后格式化；
      $\bullet$   g，自动在e和f中切换
      $\bullet$   G，自动在E和F中切换
      $\bullet$   %，显示百分比（默认显示小数点后6位）

format 函数可以接受不限个参数，位置可以不按顺序。

>>> "{}{}".format("Hello","World")              # 不设置指定位置，按默认顺序
'HelloWorld'
>>> "{0} {1}".format("Hello","World")           # 设置指定位置
'Hello World'
>>> "{1} {0} {1}".format("Hello","World")       # 设置指定位置
'World Hello World'

也可以设置参数：

>>> print("姓名： {name}, 年龄： {age}".format(name="zth", age = 20))
姓名： zth, 年龄： 20
>>>
>>>
>>> site = {"name":"zth","age":20}              # 通过字典设置参数
>>> print("姓名： {name}，年龄：{age}".format(**site))
姓名： zth，年龄：20
>>>
>>>
>>> li = ["zth",20]                     # 通过列表索引设置参数
>>> print("姓名：{0[0]}, 年龄： {0[1]}".format(li))  # "0" 是必须的
姓名：zth, 年龄： 20

str.format() 传入对象：

>>> class AssignValue(object):
...     def __init__(self, value):
...         self.value = value
...
>>> my_value = AssignValue(6)
>>> print('value 为: {0.value}'.format(my_value))       # "0" 是可选的
value 为: 6

数字格式化

>>> print("{:.2f}".format(3.1415926))
3.14

数字	格式	输出	描述
3.1415926	{:.2f}	3.14	保留小数点后两位
3.1415926	{:+.2f}	+3.14	带符号保留小数点后两位
-1	{:+.2f}	-1.00	带符号保留小数点后两位
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)
11	'{:b}'.format(11) '{:d}'.format(11) '{:o}'.format(11) '{:x}'.format(11) '{:#x}'.format(11) '{:#X}'.format(11)	1011 11 13 b 0xb 0XB	进制

^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
+ 表示在正数前显示 +，负数前显示 -；（空格）表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制。
[ [fill] align ] [sign] [#] [width] [,] [.precision] [type]

Python三引号

python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

>>> string = """行尽天涯 静默山水间
... 倾听晚风 拂柳笛声残
... \t踏破芒鞋 烟雨任平生\n
... 慧行坚勇 究畅恒无极
... """
>>> print(string)
行尽天涯 静默山水间
倾听晚风 拂柳笛声残
        踏破芒鞋 烟雨任平生

慧行坚勇 究畅恒无极

三. 字符串方法

通过 dir() 来查看方法列表：

>>> dir(str)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', 
'__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', 
'__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', 
'__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', 
'__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 
'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 
'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 
'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 
'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 
'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 
'swapcase', 'title', 'translate', 'upper', 'zfill']

1. find()

find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始）和 end（结束）范围，则检查是否包含在指定范围内，如果指定范围内如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1。

find()方法语法：

str.find( str, beg=0, end=len(string))

参数

str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。

返回值

如果包含子字符串返回开始的索引值，否则返回-1。

>>> string  = "Hello World"
>>> string.find('Hello')        #无参数
0
>>> string.find('o',2)          #提供起点
4
>>> string.find('o',5)          #提供起点
7
>>> string.find('o',5,len(string))              #提供起点和终点
7

2. join()方法

join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

语法

join()方法语法：

str.join(sequence)

参数

sequence -- 要连接的元素序列。

返回值

返回通过指定字符连接序列中元素后生成的新字符串。

【注】进行 join 操作的调用和被调用的对象必须都是字符串，任意一个不是字符串都会报错。

>>> str1 = '_'
>>> str2 = ''
>>> string = ('P', 'y', 't', 'h', 'o', 'n')     #字符串序列
>>>
>>> str1.join(string)
'P_y_t_h_o_n'
>>> str2.join(string)
'Python'

3. lower() 方法

lower() 方法转换字符串中所有大写字符为小写。

语法

lower()方法语法：

str.lower()

参数

无。

返回值

返回将字符串中所有大写字符转换为小写后生成的字符串。

>>> string = "Hello World"
>>> string.lower()
'hello world'

4. upper()方法

upper() 方法将字符串中的小写字母转为大写字母。

语法

upper()方法语法：

str.upper()

参数

返回值

返回小写字母转为大写字母的字符串。

>>> string = "Hello World"
>>> string.upper()
'HELLO WORLD'

5. swapcase()

swapcase() 方法用于对字符串的大小写字母进行转换。

swapcase()方法语法：

str.swapcase();

参数

返回值

返回大小写字母转换后生成的新字符串。

>>> string = "Hello World"
>>> string.swapcase()
'hELLO wORLD'

6. replace()

replace() 方法把字符串中的 old（旧字符串）替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。

replace()方法语法：

str.replace( old, new [, max])

参数

old -- 将被替换的子字符串。
new -- 新字符串，用于替换 old 子字符串。
max -- 可选字符串, 替换不超过 max 次

返回值

返回字符串中的 old（旧字符串）替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次。

【注】原字符串不变。

>>> string = '00112233445566778899'
>>>
>>> print(string.replace('1','2'))              #用 2 替换 1
00222233445566778899
>>>
>>>
>>> string                      #原字符串没变
'00112233445566778899'
>>>
>>> print(string.replace('1','2',1))            #用 2 替换 1，最多 1 次
00212233445566778899

7. split()

split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则仅分隔 num 个子字符串。是 join 的逆方法。

split()方法语法：

str.split(str="", num=string.count(str))

参数

str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num -- 分割次数。

返回值

返回分割后的字符串列表。

>>> string = 'hello world'
>>>
>>> string.split()              #默认空格为分隔符
['hello', 'world']
>>>
>>> string.split('o',1)         #以 o 分隔，分隔 1 次
['hell', ' world']
>>>
>>> string.split('o')           #以 o 分隔
['hell', ' w', 'rld']
>>>
>>>
>>> 'o'.join(string.split('o'))         #split 是 join 的逆方法。
'hello world'

8. strip

strip() 方法用于移除字符串头尾指定的字符（默认为空格）或字符序列。

注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。

strip()方法语法：

str.strip([chars]);

参数

chars -- 移除字符串头尾指定的字符序列。

返回值

返回移除字符串头尾指定的字符序列生成的新字符串。

>>> string = '  hello world    '
>>>
>>> string.strip()              #默认移除空格
'hello world'
>>>
>>> string
'  hello world    '
>>>
>>> string = "123 Hello Wordld 23"
>>>
>>> string.strip('23')          #移除 23
'123 Hello Wordld '

9. translate()

translate() 方法根据参数 table 给出的表(包含 256 个字符)转换字符串的字符,要过滤掉的字符放到 deletechars 参数中。

translate()方法语法：

str.translate(table)
bytes.translate(table[, delete])
bytearray.translate(table[, delete])
参数

table -- 翻译表，翻译表是通过 maketrans() 方法转换而来。
deletechars -- 字符串中要过滤的字符列表。

返回值
返回翻译后的字符串,若给出了 delete 参数，则将原来的bytes中的属于delete的字符删除，剩下的字符要按照table中给出的映射来进行映射。

(1). makestrans()用法

语法: str.maketrans(intab, outtab]);

maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，
第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
注：两个字符串的长度必须相同，为一一对应的关系。

Python3.4 已经没有 string.maketrans()了，取而代之的是内建函数:
bytearray.maketrans()、bytes.maketrans()、str.maketrans()

>>> outtab = '12345'
>>> intab = 'abcde'
>>> trantab = str.maketrans(intab,outtab)
>>>
>>> string =  'Hello World'
>>>
>>> string.translate(trantab)
'H5llo Worl4'

(2). translate() 用法

# 若 table 参数为None，则只删除不映射

>>> trantab = bytes.maketrans(b'abcdefghijklmnopqrstuvwxyz', b'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
>>> print(b'Hello World'.translate(None, b'W'))
b'Hello orld'

# 若 table 参数不为NONE，则先删除再映射

>>> #制作翻译表
...
>>> trantab = bytes.maketrans(b'abcdefghijklmnopqrstuvwxyz', b'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
>>>
>>> # 转换为大写，并删除字母W
>>> print(b'Hello World'.translate(trantab, b'W'))
b'HELLO ORLD'