十六、深入 Python 字符串

 关注
发布于: 2020 年 10 月 18 日
@Author ：Runsen
﻿
python日常处理字符串较多，本文总结一下Python的日常使用。
﻿
什么字符串﻿
字符串是由独立字符组成的一个序列，通常包含在单引号（‘ ’），双引号（”“）
﻿
三引号（''' '''）
﻿
s1 = 'hello'
s2 = "hello"
s3 = """hello"""
s1 == s2 == s3
True
三引号字符串常用于函数的注释
﻿
def calculate_similarity(item1, item2):
    """
    Calculate similarity between two items
    Args:
        item1: 1st item
        item2: 2nd item
    Returns:
      similarity score between item1 and item2
    """
﻿
转义字符﻿
用 \ 开头的字符串，来表示一些特定意义的字符
﻿
s = 'a\nb\tc'
print(s)
a
b	  c
len(s)
5
﻿
代码中的'\n'，表示一个字符——换行符；'\t'也表示一个字符，四个空格
﻿
字符 a，换行，字符 b，然后制表符，最后打印字符 c
最后打印的输出横跨了两行，但是整个字符串 s 仍然只有 5 
﻿
具体的如下面表格所示。
﻿
﻿
创建字符串﻿
name = 'Runsen'
name[0]
'R'
name[1:3]
'un'
for char in name:
    print(char)   
R
u
n
s
e
n
注意python的字符串是不可变的，这个和元组一样。
﻿
s = 'Runsen'
s[0] = 'r'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
﻿
python的字符串只能通过创建，从而产生新的字符串
﻿
s = 'H' + s[1:]
s = s.replace('h', 'H')
﻿
在Java中有可变的字符串，StringBuilder  ，每次改变字符串，无需创建新的字符串，时间复杂度为O（1） 
﻿
但是在python中如果想要改变字符串，往往需要O（n)的时间复杂度，n是新字符串的长度
﻿
 拼接字符串﻿
str1 += str2  # 表示 str1 = str1 + str2
# 这个时间复杂度是多少
s = ''
for n in range(0, 100000):
    s += str(n)
在python2中总的时间复杂度就为 O(1) + O(2) + … + O(n) = O（n^2)
﻿
但是在python3中 str1 += str2 首先会检测str1 是否有其他的引用
﻿
所以在python3中时间复杂度是O（n）
﻿
l = []
for n in range(0, 100000):
    l.append(str(n))
l = ' '.join(l) 
由于列表的 append 操作是 O(1) 复杂度，时间复杂度为 n*O(1)=O(n)。
﻿
去空格及特殊符号﻿
s.strip().lstrip().rstrip(',')
﻿
split分割﻿
s = 'Runsen is a coder'
print(s.split(' '))
﻿
['Runsen', 'is', 'a', 'coder']
这里还说说 strip() 方法，它比较常用，可以去除字符串前后的空格，不仅如此，它还可以删除首末位置的指定的字符。
﻿
s = '******Runsen is a coder******'
s.strip('*') 
﻿
'Runsen is a coder'
﻿
查找字符串查找字符串一个是find，一个是index
find() 方法与 index() 方法的效果一样，它们的最大的区别只在于，找不到内容时的返回值不同，一个返回 -1，一个抛出异常 ：
﻿
s = 'Runsen is a coder'
print(s.find('is'))
print(s.index('is'))
print(s.find('runsen'))
print(s.index('runsen'))
﻿
7
7
-1
substring not found
﻿
字符串格式化字符串格式化有两种，一个format，一个%s
﻿
print('%s %s' % ('Hello', 'Runsen'))
>>> Hello Runsen
print('{} {}.'.format('Hello', 'Runsen'))
>>> Hello Runsen
print('%s %s . I am %d' % ('Hello', 'Runsen',21 ))
>>> Hello Runsen . I am 21
﻿
%s 表示字符串型，%d 表示整型
﻿
一个format使用需要花括号{}做占位符，在format方法中再转入实际的拼接值。
﻿
补充：format中的填充与精度与进制
﻿
公式：:[填充字符][对齐方式 <^>][宽度]
﻿
>>> '{0:*>10}'.format(10)  ##右对齐
'********10'
>>> '{0:*<10}'.format(10)  ##左对齐
'10********'
>>> '{0:*^10}'.format(10)  ##居中对齐
'****10****'
﻿
在｛｝里继续嵌套一次｛｝，并在format的参数里增加一项即可
b=10
print("{0:*^{width}}".format("Runsen", width=b))
b=30
print("{0:*^{width}}".format("Runsen", width=b))
最后得到的输出如dao下
**Runsen**
************Runsen************
﻿
format中的如何设置精度与进制
>>> '{0:.2f}'.format(1/3)
'0.33'
>>> '{0:.3f}'.format(1/3)
'0.333'
>>> '{0:b}'.format(10)    #二进制 b
'1010'
>>> '{0:o}'.format(10)     #八进制 o
'12'
>>> '{0:x}'.format(10)     #16进制 x
'a'
>>> '{0:e}'.format(10)     #科学计算法 e
'1.000000e+01'
>>> '{:,}'.format(12369132698)  #千分位格式化
'12,369,132,698'
﻿
具体查看下面的图片，图片来源书籍《Python3基础教程》
﻿
﻿
﻿
扩展：思考两种字符串拼接操作，哪个更好﻿
第一种通过+=
s = ''
for n in range(0, 100000):
    s += str(n)
第二种通过列表append
l = []
for n in range(0, 100000):
    l.append(str(n))
    
s = ' '.join(l)
﻿
第三种map
﻿
s = ''.join(map(str, range(0, 1000000)))
﻿
对于上面的两种拼接操作，计算运行时间，即可判断出效率。
﻿
# 第一个 +=
import time
start_time  =time.perf_counter()
s = ''
for n in range(0,1000000):
    s += str(n)
end_time = time.perf_counter()
# 5.7604558070000005
print(end_time - start_time)
# 第二个 join
import time
start_time  =time.perf_counter()
s = []
for n in range(0,1000000):
    s.append(str(n))
''.join(s)
end_time = time.perf_counter()
# 0.622547053
print(end_time - start_time)
# 第三个 map
import time
start_time = time.perf_counter()
s = ''.join(map(str, range(0, 1000000)))
end_time = time.perf_counter()
# 0.403433529
print(end_time - start_time)
﻿
结果：
对于数据量大的map好过join，join好过 +=
﻿
对于数据量小的map 好过 += 好过join
﻿
﻿
参考：https://time.geekbang.org/column/article/95897
﻿
本文已收录 GitHub，传送门~ ，里面更有大厂面试完整考点，欢迎 Star。
﻿