在python3中你是如何处理字符串的？也许有你用的到的(二)

字符串（二）

---

更新信息

2018-11-21 添加字符串格式化方法 f-string python3.6以上版本支持

---

最短匹配

考虑如下字符串：

In [1]: text1 = 'Computer says "no."'

目前假如我只想匹配到双引号中的内容 no.
我可以利用正则这样写:

In [2]: import re

In [3]: sre = re.compile(r'\"(.*)\"')

In [4]: sre.findall(text1)
Out[4]: ['no.']

上面的正则模式和返回结果好像没什么, 别急，看看下面的

In [5]: text2 = 'Computer says "no." Phone says "yes."'

In [6]: sre.findall(text2)
Out[6]: ['no." Phone says "yes.']

上面的情况显然不是我们想要的，我们本来只想要 no. 和 yes.

因为这里的正则模式中使用了 *, 在正则中它代表了贪婪, 会尽可能多的去匹配。

要解决这个问题，只需要在后面加上一个问号即可 ?， 它代表了是非贪婪，会尽可能少的去匹配。

In [7]: sre2 = re.compile(r'\"(.*?)\"')

In [8]: sre2.findall(text2)
Out[8]: ['no.', 'yes.']

在一 个模式字符串中，点 (.) 匹配除了换行外的任何字符。然而，如果你将点 (.) 号放在开始 与结束符 (比如引号) 之间的时候，那么匹配操作会查找符合模式的最长可能匹配。这样通常会导致很多中间的，那些被开始与结束符所包含的文本被忽略掉，并最终被包含在匹配 结果字符串中返回。通过在 * 或者 + 这样的操作符后面添加一个 ? 可以强制匹配算法 改成寻找最短的可能匹配。

多行匹配

假如你想用一个模式在整个文本中进行多行内容的匹配，你想如何办到？
比如去匹配 JavaScript 中的多行注释

In [15]: text3 = "/*我是单行注释*/"

In [16]: text4 = """/*
    ...: 在 JavaScript 中我其实是
    ...: 实现多行注释的
    ...: */"""

In [17]: sre3 = re.compile(r'/\*(.*?)\*/')

In [18]: sre3.findall(text3)
Out[18]: ['我是单行注释']

In [19]: sre3.findall(text4)
Out[19]: []

注意： findall() 方法中的分组，之后保留被分组捕获的内容。
在这里最容易忽略的是点 (.)是不能够匹配到换行符的。

于是在这里需要加上对换行符的支持，re.DOTALL 可以办到，它可以让点 . 匹配到换行符在内的任意字符。可以把它传给 re.compile()函数的第二个参数。这个叫做正则的标志参数。

In [21]: sre4 = re.compile(r'/\*(.*?)\*/', re.DOTALL)

In [22]: sre4.findall(text3)
Out[22]: ['我是单行注释']

In [23]: sre4.findall(text4)
Out[23]: ['\n在 JavaScript 中我也是\n实现多行注释的\n']

---

---

删除一些字符串中不想要的字符

大家都知道 strip() 函数可以去除字符串两端的空白字符, 就像这样：

In [25]: s = " shark xiguatian   \n"

In [26]: s.strip()
Out[26]: 'shark xiguatian'

它也可以去除字符串两端的其他字符

In [27]: s1 = "===shark xiguatian====="

In [28]: s1.strip('=')
Out[28]: 'shark xiguatian'

lstrip() 和 rstrip() 分别从左边和右边去除不需要的字符

In [29]: s2 = "===shark xiguatian*****"

In [30]: s2.lstrip('=')
Out[30]: 'shark xiguatian*****'

In [31]: s2.lstrip('=').rstrip('*')
Out[31]: 'shark xiguatian'

其实也不用这么麻烦，可以像下面这样

In [33]: s2.strip('=*')
Out[33]: 'shark xiguatian'

假如想要去除的字符是在整个字符串的中间，可以用 replace() 和 正则的 re.sub()

In [37]: s3 = ' hello world \n'

In [38]: s3.replace(' ', '')
Out[38]: 'helloworld\n'

In [39]: re.sub(r'[\s+|\n]', '', s3)
Out[39]: 'helloworld'

处理让你凌乱的字符

假如你遇到了这些字符需要清理

In [45]: s = 'pýtĥöñ\fis\tawesome\r\n'

In [46]: s
Out[46]: 'pýtĥöñ\x0cis\tawesome\r\n'

稳住！ 我们能赢！
首先要创建一个映射表

In [56]: remap = {
    ...:     ord('\f'): ' ',
    ...:     ord('\t'): ' ',
    ...:     ord('\r'): ''  # 删除
    ...: }

In [57]: tp_s = s.translate(remap）

In [58]: tp_s
Out[58]: 'pýtĥöñ is awesome\n'

先把 \f \t 映射成空格，再把 \r 删除

ord() 是 python 的内置函数，可以将字符装换为 ASCII 的数值或者 Unicode 数值，当然给的参数不可超出 ASCII 或者 Unicode 的范围，比如给个中文的字符就会抛出异常。
和它对应的还有 chr()

最后再来处理怪怪的字符

In [60]: import unicodedata

In [61]: import sys

In [62]: cmb_chrs = dict.fromkeys(c for c in range(sys.maxunicode)
    ...:                          if unicodedata.combining(chr(c)))

In [63]: tp_s.translate(cmb_chrs)
Out[63]: 'python is awesome\n'

上面的例子中，通过使用 dict.fromkeys() 方法构造一个字典，每个 Unicode 和音 符作为键，对应的值全部为 None 。然后再 调用 translate 函数删除所有重音符。同样的技术也可以被用来删除其他类型的字符

讲一下，简单的替换用 replace() 效率会更高,而 tanslate() 在进行更复杂映射的时候处理的更快。

对齐字符串

当我知道 format() 内置函数后， 我就立刻抛弃了字符串的 center() , ljust() 和 rjust() 三个方法。

In [80]: format(text, '>20')
Out[80]: '         Hello world'

In [81]: format(text, '*>20')
Out[81]: '*********Hello world'

In [82]: format(text, '<20')
Out[82]: 'Hello world         '

In [83]: format(text, '*^20')
Out[83]: '****Hello world*****'

In [84]: y = 3.1415926

In [85]: format(y, '.2f')
Out[85]: '3.14'

In [86]: format(y, '.2%')
Out[86]: '314.16%'

In [87]: format(y, '^10.2%')
Out[87]: ' 314.16%  '

format() 太通用了, 你说是吗？

合并字符串

你是否经常这样做

In [90]: b = 'world'

In [91]: s = a + b

In [92]: s
Out[92]: 'Helloworld'

+ 加号对应数量不多的字符串的拼接还是比较推荐的方法，比较简洁。

假如你需要对多个字符串进行拼接，应该使用字符串的 join() 方法

In [94]: li = ['a', 'b','c','d','e']

In [95]: ''.join(li)
Out[95]: 'abcde'

看下面这种情况:

In [96]: info = ['xiguatian', 25, 100]

这里不能简单的使用 join() 方法了， 因为字符串和整型不可以直接拼接，需要把里面的 int 类型的对象装换为字符串对象后再拼接。

可以利用生成器表达式，同时把它统一类型为 str

In [98]: '_'.join(str(w) for w in info)
Out[98]: 'xiguatian_25_100'

同时还需要尽量避免不必要的拼接操作, 比如

print(a + ':' + b + ':' + c)  # 菜鸟
print(':'.join([a, b, c]))  # 入行
print(a, b, c, sep=':')  # 老鸟

最后，你需要进行 I/O 操作写文件时，下面是我们需要注意的

# 适合两个字符串都很小的情况
f.write(chunk1 + chunk2)

# 适合两个字符串会是很大的情况
f.write(chunk1)
f.write(chunk2)

在 python3.6 版本中加入了 f-string , 用法就是在含有变量的字符串前加个 f 标识，就可以实现字符串的格式化。

In[150]: import sys

In [151]: sys.version
Out[141]: '3.6.4 (default, Jan  6 2018, 19:08:25) \n[GCC 4.2.1 Compatible Apple LLVM 9.0.0 (clang-900.0.39.2)]'

In [152]: name = 'shark'

In [153]: f'My name is {name}'
Out[153]: 'My name is shark'