Python-字符串总结（创建、操作符、方法、相关内置函数、相关模块）

太过爱你忘了你带给我的痛 2022-12-04 01:08 248阅读 0赞

**目录**

简介

创建

操作符

赋值（操作符=）

访问（序列操作符切片）

判断子串（成员操作符in,not in）

拼接（连接符+）

重复（重复操作符\*）

比较（==、!=、>、<、>=、<=）

删除

格式化

f"\{\}"

转义字符

原始字符串（操作符r）

方法

拆分

拼接

替换

移除前导、末尾字符

统计子串

寻找子串索引

转换大小写

判断字符串类型

大小写

对齐

格式化

其他

相关模块

思考题

参考

--------------------

# 简介 #

字符串属于不可变的序列，由单引号、双引号或三引号包含。

# 创建 #

字符串

> >>> "Hello World"  
> 'Hello World'

字符（长度为1的字符串，文章后续的字符均指长度为1的字符串）

> >>> 'H'  
> 'H'

三引号

> >>> '''he  
> ... llo'''  
> 'he\\nllo'

# 操作符 #

## 赋值（操作符=） ##

赋值操作符：=，使变量指向字符串。

> >>> s = "Hello World"  
> >>> s  
> 'Hello World'

## 访问（序列操作符切片） ##

序列操作符切片有三种形式：\[index\]、\[start:stop\]、\[start:stop:step\]

*  \[index\]返回字符，也称为索引，部分教程与切片分开
 *  \[start:stop\]返回从start开始，到stop-1的字符串，不包含stop，start默认为0，stop默认为 最后一个index+1。
 *  \[start:stop:step\]返回从start开始，到stop-1的字符串,每step个取一个字符。step>0时，start默认为0,stop默认为最后一个index+1。step<0时，start默认为-1,stop默认为第一个index-1。start,stop>0时，step默认为1。start,stop<0时，step默认为-1。

注意：

*  index超出范围时引发**IndexError**。start与stop一样或start在stop右边，返回空列表。step为0时引发**ValueError**。
 *  在Pycharm中import builtins，选中builtins,按Ctrl+B，打开builtins.pyi，找到class slice，查看更多详细内容。

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td><span style="color:#f33b45;"><strong>&gt;=0时的index</strong></span></td> 
   <td><span style="color:#7c79e5;">0</span></td> 
   <td><span style="color:#7c79e5;">1</span></td> 
   <td><span style="color:#7c79e5;">2</span></td> 
   <td><span style="color:#7c79e5;">3</span></td> 
   <td><span style="color:#7c79e5;">4</span></td> 
   <td><span style="color:#7c79e5;">5</span></td> 
   <td><span style="color:#7c79e5;">6</span></td> 
   <td><span style="color:#7c79e5;">7</span></td> 
   <td><span style="color:#7c79e5;">8</span></td> 
   <td><span style="color:#7c79e5;">9</span></td> 
   <td><span style="color:#7c79e5;">10</span></td> 
  </tr> 
  <tr> 
   <td><span style="color:#f33b45;"><strong>字符串</strong></span></td> 
   <td>H</td> 
   <td>e</td> 
   <td>l</td> 
   <td>l</td> 
   <td>o</td> 
   <td></td> 
   <td>W</td> 
   <td>o</td> 
   <td>r</td> 
   <td>l</td> 
   <td>d</td> 
  </tr> 
  <tr> 
   <td><span style="color:#f33b45;"><strong>&lt;0时的index</strong></span></td> 
   <td><span style="color:#3399ea;">-11</span></td> 
   <td><span style="color:#3399ea;">-10</span></td> 
   <td><span style="color:#3399ea;">-9</span></td> 
   <td><span style="color:#3399ea;">-8</span></td> 
   <td><span style="color:#3399ea;">-7</span></td> 
   <td><span style="color:#3399ea;">-6</span></td> 
   <td><span style="color:#3399ea;">-5</span></td> 
   <td><span style="color:#3399ea;">-4</span></td> 
   <td><span style="color:#3399ea;">-3</span></td> 
   <td><span style="color:#3399ea;">-2</span></td> 
   <td><span style="color:#3399ea;">-1</span></td> 
  </tr> 
 </tbody> 
</table>

> >>> s\[2\]  
> 'l'  
> >>> s\[-4\]  
> 'o'

>  >>> s\[2:5\]  
> 'llo'  
> >>> s\[1:\]  
> 'ello World'  
> >>> s\[:7\]  
> 'Hello W'  
> >>> s\[-2:\]  
> 'ld'  
> >>> s\[:-3\]  
> 'Hello Wo'

> >>> s\[1:6:\]  
> 'ello '  
> >>> s\[-8:-2:\]  
> 'lo Wor'  
> >>> s\[:8:\]  
> 'Hello Wo'  
> >>> s\[1::\]  
> 'ello World'  
> >>> s\[::-1\]  
> 'dlroW olleH'

小技巧：\[::-1\]常用来得到反转的字符串，原字符串不变

## 判断子串（成员操作符in,not in） ##

> >>> s = "Hello World"  
> >>> "Hello" in s  
> True  
> >>> "hello" not in s  
> True  
> >>> "world" in s  
> False

## 拼接（连接符+） ##

> >>> "Hello"+"World"  
> 'HelloWorld'

## 重复（重复操作符\*） ##

> >>> '-'\*10  
> '----------'

操作符r在特殊字符后

## 比较（==、!=、>、<、>=、<=） ##

python中不像c++，有compare函数，直接使用比较运算符比较字符串即可。

> >>> "hello"=="hi"  
> False  
> >>> "hello"!="hi"  
> True  
> >>> "hello">"hi"  
> False  
> >>> "hello"<"hi"  
> True  
> >>> "hello">="hi"  
> False  
> >>> "hello"<="hi"  
> True

# 删除 #

使用关键字del，删除后不可再用，否则NameError。没必要显式删除，Python会自动处理的。

> >>> del s  
> >>> s  
> Traceback (most recent call last):  
>   File "<stdin>", line 1, in <module>  
> NameError: name 's' is not defined

# 格式化 #

## % ##

<table style="width:500px;">  格式化符号  
 <thead> 
  <tr> 
   <th style="text-align:center;">符&nbsp;&nbsp; 号</th> 
   <th style="text-align:center;">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %c</td> 
   <td>&nbsp;格式化字符及其ASCII码</td> 
  </tr> 
  <tr> 
   <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %s</td> 
   <td>&nbsp;格式化字符串</td> 
  </tr> 
  <tr> 
   <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %d</td> 
   <td>&nbsp;格式化整数</td> 
  </tr> 
  <tr> 
   <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %u</td> 
   <td>&nbsp;格式化无符号整型</td> 
  </tr> 
  <tr> 
   <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %o</td> 
   <td>&nbsp;格式化无符号八进制数</td> 
  </tr> 
  <tr> 
   <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %x</td> 
   <td>&nbsp;格式化无符号十六进制数</td> 
  </tr> 
  <tr> 
   <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %X</td> 
   <td>&nbsp;格式化无符号十六进制数（大写）</td> 
  </tr> 
  <tr> 
   <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %f</td> 
   <td>&nbsp;格式化浮点数字，可指定小数点后的精度</td> 
  </tr> 
  <tr> 
   <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %e</td> 
   <td>&nbsp;用科学计数法格式化浮点数</td> 
  </tr> 
  <tr> 
   <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %E</td> 
   <td>&nbsp;作用同%e，用科学计数法格式化浮点数</td> 
  </tr> 
  <tr> 
   <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %g</td> 
   <td>&nbsp;%f和%e的简写</td> 
  </tr> 
  <tr> 
   <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %G</td> 
   <td>&nbsp;%F 和 %E 的简写</td> 
  </tr> 
  <tr> 
   <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; %p</td> 
   <td>&nbsp;用十六进制数格式化变量的地址</td> 
  </tr> 
 </tbody> 
</table>

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

> >>> 'grade:%f' % 12.345678  
> 'grade:12.345678'
> 
> >>> 'grade:%.2f' % 92.2354  
> 'grade:92.24'
> 
> >>> 'grade:%c' % 66  
> 'grade:B'
> 
> >>> 'grade:%s' % 'good'  
> 'grade:good'

更多内容，读者自行尝试吧。

## f"\{\}" ##

python版本>=3.6

比上面的，以及.format()效率要高。如果你的python版本高一点，建议使用这个。

同样，格式化符号有很多，博主不再黏贴，针对数字，字符串，时间之类的都有，黏贴的话文章太长。

例如，[datetime的格式化符号][datetime]。

举例

代码：

> from datetime import datetime  
> now = datetime.now()  
> print(f'datetime\_now:\{now:%F %X\}')

terminal:

> datetime\_now:2020-09-05 09:39:15

pycharm里面敲的，不是交互式。

# 转义字符 #

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

代码:

> print('hello\\nworld')

terminal:

> hello  
> world

# 原始字符串（操作符r） #

这个没有放到前面的操作符中，因为在转义字符后面讲比较好。r可以使字符串里面就是字符串内容本身，没有转义等。

代码：

> print(r'hello\\nworld')

terminal:

> hello\\nworld

在pycharm中不加r时，字符串中的\\n是橘色的，加了后就是绿色了。

# 方法 #

> >>> s = 'hello world'  
> >>> type(s)  
> <class 'str'>

一个字符串是类str的一个对象，也就可以调用str类的方法。

## 拆分 ##

`split`(*sep=None*, *maxsplit=-1*)

返回一个由字符串内单词组成的列表，使用 *sep* 作为分隔字符串。 如果给出了 **maxsplit**，则**最多**进行 **maxsplit** 次拆分（因此，列表最多会有 `maxsplit+1` 个元素）。 如果 *maxsplit* 未指定或为 `-1`，则不限制拆分次数（进行所有可能的拆分）。

如果给出了 *sep*，则连续的分隔符不会被组合在一起而是被视为分隔空字符串 (例如 `'1,,2'.split(',')` 将返回 `['1', '', '2']`)。 *sep* 参数可能由多个字符组成 (例如 `'1<>2<>3'.split('<>')` 将返回 `['1', '2', '3']`)。 使用指定的分隔符拆分空字符串将返回 `['']`。

**sep**没给的话是**默认是空格**，几个空格都可以。

> >>> "hello world,i'm lady\_killer".split(',')  
> \['hello world', "i'm lady\_killer"\]  
> >>> "hello wor   ld,i'm    lady\_killer".split()  
> \['hello', 'wor', "ld,i'm", 'lady\_killer'\]

rsplit方法参数相同，不同的是从右边开始

## 拼接 ##

`join`(*iterable*)

返回一个由 *iterable* （可迭代的对象）中的字符串拼接而成的字符串。 如果 *iterable* 中存在任何非字符串值包括`bytes`对象则会引发`TypeError`。 调用该方法的字符串将作为元素之间的分隔。

> >>> ':'.join("2020 09 05 13 54".split())  
> '2020:09:05:13:54'

## 替换 ##

`replace`(*old*, *new*\[, *count*\])

返回字符串的副本，其中出现的**所有**子字符串 *old* 都将被替换为 *new*。 如果给出了可选参数 *count*，则只替换前 *count* 次出现。

>  >>> "".join("hello world,i'm lady killer"\[::-1\]).replace('dlrow','world')  
> "rellik ydal m'i,world olleh"

## 移除前导、末尾字符 ##

`strip`(\[*chars*\])

返回原字符串的副本，移除其中的前导和末尾字符。 *chars* 参数为指定要移除字符的字符串。 如果省略或为 `None`，则 *chars* 参数**默认移除空格符**。 实际上 *chars* 参数并非指定单个前缀或后缀；而是会移除参数值的所有组合。

> >>> " hello world  ".strip()  
> 'hello world'  
> >>> "12.45 ".strip()  
> '12.45'  
> >>> "2323345623323".strip('32')  
> '456'

32可以组合成2、3、23、32等。 你可以理解为前后遍历含chars中任一字符便删除，无法删除时停止。

## 统计子串 ##

`count`(*sub*\[, *start*\[, *end*\]\])

返回子字符串 *sub* 在 \[*start*, *end*\] 范围内非重叠出现的次数，默认是整个字符串。 可选参数 *start* 与 *end，* 会被解读为切片表示法。

> >>> 'www.example.com'.count('com')  
> 1 
> 
> >>> 'www.example.com'.count('w',1,7)  
> 2

## 寻找子串索引 ##

`find`(*sub*\[, *start*\[, *end*\]\])

返回子字符串 *sub* 在 `s[start:end]` 切片内被找到的最小索引。 可选参数 *start* 与 *end* 会被解读为切片表示法。 如果 *sub* 未被找到则返回 `-1`。

> >>> 'www.example.com'.find('w',1,7)  
> 1  
> >>> 'www.example.com'.find('w',3,7)  
> \-1

rfind方法，参数相同，返回找到的最大的索引

index与rindex在未找到时会引发**ValueError**，不建议使用。

## 转换大小写 ##

**转为小写**

`lower`()

返回原字符串的副本，其所有区分大小写的字符均转换为小写。

> >>> 'WWW.example.com'.lower()  
> 'www.example.com'

**转为大写**

`upper`()

返回原字符串的副本，其中所有区分大小写的字符均转换为大写。 请注意如果 `s` 包含不区分大小写的字符或者如果结果字符的 Unicode 类别不是 "Lu" (Letter, uppercase) 而是 "Lt" (Letter, titlecase) 则 `s.upper().isupper()` 有可能为 `False`。

>  >>> 'www.example.com'.upper()  
> 'WWW.EXAMPLE.COM'

## 判断字符串类型 ##

**全是字母**

`isalpha`()

如果字符串中的所有字符都是字母，并且至少有一个字符，返回 `True` ，否则返回 `False` 。字母字符是指那些在 Unicode 字符数据库中定义为 "Letter" 的字符，即那些具有 "Lm"、"Lt"、"Lu"、"Ll" 或 "Lo" 之一的通用类别属性的字符。 注意，这与 Unicode 标准中定义的"字母"属性不同。

> >>> 'www.example.com'.isalpha()  
> False  
> >>> 'wwwexamplecom'.isalpha()  
> True

**全是数字**

`isdecimal`()

如果字符串中的所有字符都是十进制字符且该字符串至少有一个字符，则返回 `True` ， 否则返回 `False` 。十进制字符指那些可以用来组成10进制数字的字符，例如 U+0660 ，即阿拉伯字母数字0 。 严格地讲，十进制字符是 Unicode 通用类别 "Nd" 中的一个字符。

> >>> '1'.isdecimal()  
> True
> 
> >>> 'IV'.isdecimal()  
> False
> 
> >>> '六六六'.isdecimal()  
> False

`isdigit`()

如果字符串中的所有字符都是数字，并且至少有一个字符，返回 `True` ，否则返回 `False` 。 数字包括十进制字符和需要特殊处理的数字，如兼容性上标数字。这包括了不能用来组成十进制数的数字，如 Kharosthi 数。 严格地讲，数字是指属性值为 Numeric\_Type=Digit 或 Numeric\_Type=Decimal 的字符。

> >>> 'IV'.isdigit()  
> False  
> >>> '六六六'.isdigit()  
> False

`isnumeric`()

如果字符串中至少有一个字符且所有字符均为数值字符则返回 `True` ，否则返回 `False` 。 数值字符包括数字字符，以及所有在 Unicode 中设置了数值特性属性的字符，例如 U+2155, VULGAR FRACTION ONE FIFTH。 正式的定义为：数值字符就是具有特征属性值 Numeric\_Type=Digit, Numeric\_Type=Decimal 或 Numeric\_Type=Numeric 的字符。

> >>> 'IV'.isnumeric()  
> False
> 
> >>> '六六六'.isnumeric()  
> True

## 大小写 ##

`isupper`()

如果字符串中至少有一个区分大小写的字符 [4][] 且此类字符均为大写则返回 `True` ，否则返回 `False` 。

`islower`()

如果字符串中至少有一个区分大小写的字符 [4][] 且此类字符均为小写则返回 `True` ，否则返回 `False` 。

## 对齐 ##

**居中**

`center`(*width*\[, *fillchar*\])

返回长度为 *width* 的字符串，原字符串在其正中。 使用指定的 *fillchar* 填充两边的空位（默认使用 ASCII 空格符）。 如果 *width* 小于等于 `len(s)` 则返回原字符串的副本。

**左对齐**

`ljust`(*width*\[, *fillchar*\])[¶][Link 1]

返回长度为 *width* 的字符串，原字符串在其中靠左对齐。 使用指定的 *fillchar* 填充空位 (默认使用 ASCII 空格符)。 如果 *width* 小于等于 `len(s)` 则返回原字符串的副本。

**右对齐**

`rjust`(*width*\[, *fillchar*\])

返回长度为 *width* 的字符串，原字符串在其中靠右对齐。 使用指定的 *fillchar* 填充空位 (默认使用 ASCII 空格符)。 如果 *width* 小于等于 `len(s)` 则返回原字符串的副本。

`zfill`(*width*)

返回原字符串的副本，在左边填充 ASCII `'0'` 数码使其长度变为 *width*。 正负值前缀 (`'+'`/`'-'`) 的处理方式是在正负符号 *之后* 填充而非在之前。 如果 *width* 小于等于 `len(s)` 则返回原字符串的副本。

## 格式化 ##

`format`(*\*args*, *\*\*kwargs*)

执行字符串格式化操作。 调用此方法的字符串可以包含字符串字面值或者以花括号 `{}` 括起来的替换域。 每个替换域可以包含一个位置参数的数字索引，或者一个关键字参数的名称。 返回的字符串副本中每个替换域都会被替换为对应参数的字符串值。

## 其他 ##

方法太多，上面列举了经常用的，其余的请查看官方文档。

[字符串的其他方法][Link 2]

# 相关内置函数 #

## 字符串长度 ##

不像c++ string，没有length()方法，但可以使用len函数返回长度。

`len`(*s*)

返回对象的长度（元素个数）。

> >>> len('hello world')  
> 11

## 字符的Unicode码 ##

`chr`(*i*)

返回 Unicode 码位为整数 *i* 的字符的字符串格式。

`ord`(*c*)

对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码点的整数。

> >>> chr(97)  
> 'a'  
> >>> ord('a')  
> 97

## 其他类型转为字符串 ##

*class* `str`(*object=b''*, *encoding='utf-8'*, *errors='strict'*)

返回一个str版本的*对象*

> >>> num = 65  
> >>> s = str(num)  
> >>> type(s)  
> <class 'str'>

# 常用函数 #

常在oj中使用的函数

## 获得所有非空子串 ##

列表表达式+切片

def get_substring(a_str):
        n = len(a_str)
        return [a_str[i:j + 1] for i in range(n) for j in range(i, n)]

## 获得所有非空子序列 ##

二进制+位运算

def get_subsequence(a_str):
        n = len(a_str)
        sub_sequence = []
        for i in range(1, 1 << n):
            substr = ""
            for j in range(n):
                if i >> j & 1 == 1:
                    substr += a_str[j]
            sub_sequence.append(substr)
        return sub_sequence

## 判断是不是非空字符串的非空子序列 ##

双指针

def is_subsequence(a, b):
        i, j, m, n = 0, 0, len(a), len(b)
        while j < n and i < m:
            if a[i] == b[j]:
                i += 1
                j += 1
            else:
                i += 1
        return j == n

## 判断是否为回文字符串 ##

双指针

def is_huiwen(a_str):
        left, right = 0, len(a_str) - 1
        while left < right:
            if a_str[left] != a_str[right]:
                return False
            left += 1
            right -= 1
        return True

# 相关模块 #

*  [string --- 常见的字符串操作][string ---]
 *  [re --- 正则表达式操作][re ---]
 *  [difflib --- 计算差异的辅助工具][difflib ---]
 *  [textwrap --- 文本自动换行与填充][textwrap ---]
 *  [unicodedata --- Unicode 数据库][unicodedata --- Unicode]
 *  [stringprep --- 因特网字符串预备][stringprep ---]
 *  [readline --- GNU readline 接口][readline --- GNU readline]
 *  [rlcompleter --- GNU readline 的补全函数][rlcompleter --- GNU readline]

模块过多，博主也没有学全，关于正则表达式及简单应用，可以看文章[python-正则表达式及应用(b站弹幕屏蔽)][python-_b]

# 思考题 #

以下代码的结果是什么？

s = "你不要过来啊"
    for i in range(-len(s), 0, 1):
        print(s[i:])

以下代码的sub是什么类型？值是多少？

sub = "hi" in "hi,lady_killer9"

给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。（来源：https://leetcode-cn.com/problems/reverse-words-in-a-string-iii）

示例：

输入："Let's take LeetCode contest"  
输出："s'teL ekat edoCteeL tsetnoc"  
以下代码是什么思路？

def reverseWords(s):
            return " ".join(word[::-1] for word in s.split(" "))
    
    def reverseWords(s):
            return " ".join(s.split(" ")[::-1])[::-1]
    
    def reverseWords(s):
             return " ".join(s[::-1].split(" ")[::-1])

答案见：[Python-列表总结（操作符、方法、内置函数、相关模块）][Python-]

# 参考 #

[文本序列类型-str][Link 2]

[序列类型][Link 3]

更多python相关内容：[【python总结】python学习框架梳理][python_python]

本人b站账号:[lady\_killer9][lady_killer9]

有问题请下方评论，转载请注明出处，并附有原文链接，谢谢！如有侵权，请及时联系。如果您感觉有所收获，自愿打赏，可选择支付宝18833895206（小于），您的支持是我不断更新的动力。

[datetime]: https://docs.python.org/zh-cn/3/library/datetime.html#strftime-and-strptime-behavior
[4]: https://docs.python.org/zh-cn/3/library/stdtypes.html#id15
[Link 1]: https://docs.python.org/zh-cn/3/library/stdtypes.html#str.ljust
[Link 2]: https://docs.python.org/zh-cn/3/library/stdtypes.html#text-sequence-type-str
[string ---]: https://docs.python.org/zh-cn/3/library/string.html
[re ---]: https://docs.python.org/zh-cn/3/library/re.html
[difflib ---]: https://docs.python.org/zh-cn/3/library/difflib.html
[textwrap ---]: https://docs.python.org/zh-cn/3/library/textwrap.html
[unicodedata --- Unicode]: https://docs.python.org/zh-cn/3/library/unicodedata.html
[stringprep ---]: https://docs.python.org/zh-cn/3/library/stringprep.html
[readline --- GNU readline]: https://docs.python.org/zh-cn/3/library/readline.html
[rlcompleter --- GNU readline]: https://docs.python.org/zh-cn/3/library/rlcompleter.html
[python-_b]: https://blog.csdn.net/lady_killer9/article/details/107630277?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522159927448919725247429784%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=159927448919725247429784&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_v1~rank_blog_v1-1-107630277.pc_v1_rank_blog_v1&utm_term=%E6%AD%A3%E5%88%99&spm=1018.2118.3001.4187
[Python-]: https://blog.csdn.net/lady_killer9/article/details/108453327
[Link 3]: https://docs.python.org/zh-cn/3/library/stdtypes.html#sequence-types-list-tuple-range
[python_python]: https://blog.csdn.net/lady_killer9/article/details/108763489
[lady_killer9]: https://space.bilibili.com/374432302