Python 3.6 字符串操作实例

电玩女神 2022-06-02 06:36 345阅读 0赞

## Python 3.6 字符串操作 ##

### 常见的字符串操作 ###

#### 字符串的格式化 ####

C语言使用函数printf()、sprintf()格式化输出结果，Python也提供了类似的功能。Python将若干值插入带有“%”标记的字符串中，从而可以动态地输出字符串。字符串的格式化语法如下所示。

"%s" % str1
    "%s %s" % (str1, str2)

【代码说明】第1行代码使用一个值格式化字符串。第2行代码使用多个值格式化字符串，用于替换的值组成一个元组。  
下面这段代码演示了字符串的格式化操作：

str1 = 'version'
    num = 1.0
    format = "%s" % str1
    
    print(format)
    
    format = "%s %d" % (str1, num)
    
    print(format)

【代码说明】

*  第4行代码用变量str1的值替换字符串中的%s。
 *  第5行代码输出结果是“version”。
 *  第6行代码分别用变量str1、num的值替换%s和%d的值。%d表示替换的值为整型。
 *  第7行代码输出结果为“version 1”。

**注意 如果要格式化多个值，元组中元素的顺序必须和格式化字符串中替代符的顺序一致，否则，可能出现类型不匹配的问题。如果将上例中的%s和%d调换位置，将抛出如下异常：**

**TypeError: int argument required**

使用%f可以格式化浮点数的精度，根据指定的精度做“四舍五入”。示例如下：

# 带精度的格式化
    print ("浮点型数字: %f" % 1.25)       # 以浮点数格式打印
    print ("浮点型数字: %.1f" % 1.25)     # 精确到小数点后1位
    print ("浮点型数字: %.2f" % 1.254)    # 精确到小数点后2位

【代码说明】

*  第2行代码格式化浮点数1.25。默认情况下，将输出小数点后6位数字。输出结果：浮点型数字: 1.250000
 *  第3行代码格式化小数点后1位数字，“四舍五入”后的结果为1.3。输出结果:浮点型数字: 1.3
 *  第4行代码格式化小数点后2位数字。输出结果：浮点型数字: 1.25

此外，Python还提供了对八进制、十六进制等数字进行格式化的替代符。下表列出了Python中格式化字符串的替代符及其含义。  
![SouthEast][]

前面使用了元素格式化多个值，也可以用字典格式化多个值，并指定格式化字符串的名称。下面这段代码说明了字典格式化字符串的用法。

#使用字典格式化字符串
    print ("%(version)s: %(num).1f" % {
       "version": "version", "num": 2})

【代码说明】第2行代码定义了一个匿名字典，该字典中的两个value值分别对应字符串中的%(version)s和%(num).1f。输出结果：version:2.0  
Python可以实现字符串的对齐操作，类似C语言中的“%\[\[+/-\]n\]s”。此外，还提供了字符串对齐的函数。

# 字符串对齐
    word = "version3.0"
    print (word.center(20))
    print (word.center(20, "*"))
    print (word.ljust(0))
    print (word.rjust(20))
    print ("%30s" % word)

【代码说明】

*  第3行代码调用center()输出变量word的值。变量word两侧各输出5个空格。
 *  第4行代码调用center()输出变量word的值，并指定第2个参数的值为“*”。变量word两侧各输出5个“*”。
 *  第5行代码调用ljust()输出变量word的值，ljust()输出结果左对齐。
 *  第6行代码调用rjust()输出变量word的值，rjust()输出结果右对齐。参数20表示一共输出20个字符，“version3.0”占10个字符，左边填充10个空格。
 *  第7行代码，“%30s”表示先输出30个空格，再输出变量word的值，类似于word.rjust(30)的作用。

全部代码为：

![SouthEast 1][]

运行结果为：  
![SouthEast 2][]

#### 字符串的转义符 ####

计算机中存在可见字符与不可见字符。可见字符是指键盘上的字母、数字和符号。不可见字符是指换行、回车等字符，对于不可见字符可以使用转义字符来表示。Python中转义字符的用法和Java相同，都是使用“\\”作为转义字符。

下面这段代码演示了转义字符的使用:

path = 'hello\tworld\n'
    print(path)
    print(len(path))
    path = r'hello\tworld\n'
    print(path)
    print(len(path))

【代码说明】

*  第2行代码，在“hello”和“world”之间输出制表符，在字符串末尾输出换行符。
 *  第4行代码输出字符串的长度，其中的“\\t”、“\\n”各占一个字符。输出结果为12。
 *  第5行代码，忽略转义字符的作用，直接输出字符串原始的内容。
 *  第6行代码输出结果：hello\\tworld\\n
 *  第7行代码输出字符串的长度。输出结果为“14”。

【运行结果】  
![SouthEast 3][]

**注意 Python的制表符只占1个字符，而不是2个或4个字符**  
![SouthEast 4][]

**注意 如果要在字符串中输出“\\”，需要使用“\\”。**  
Python还提供了函数strip()、lstrip()、rstrip()去掉字符串中的转义符。

print('===================')
    # strip()去掉转义字符
    word = '\thello world\n'
    print('直接输出：', word)
    print('strip()后输出：', word.strip())
    print('lstrip()后输出：', word.lstrip())
    print('rstrip()后输出：', word.rstrip())
    print('===================')

【代码说明】

*  第4行代码直接输出字符串。
 *  第5行代码调用strip()去除转义字符。
 *  第6行代码调用lstrip()去除字符串前面的转义字符“\\t”，字符串末尾的“\\n”依然存在。
 *  第7行代码调用rstrip()去除字符串末尾的转义字符“\\n”，字符串前面的“\\t”依然存在。

![SouthEast 5][]

#### 字符串的合并 ####

与Java语言一样，Python使用“+”连接不同的字符串。Python会根据“+”两侧变量的类型，决定执行连接操作或加法运算。如果“+”两侧都是字符串类型，则进行连接操作；如果“+”两侧都是数字类型，则进行加法运算；如果“+”两侧是不同的类型，将抛出异常。

TypeError: cannot concatenate 'str' and 'int' objects

下面的代码演示了字符串的连接方法:

【代码说明】

*  第7行代码，把变量str1、str2、str3的值连接起来，并把结果存放在变量result中。
 *  第9行代码，使用运算符“+=”连接变量result和str4。

【运行结果】  
![SouthEast 6][]

可见，使用“+”对多个字符串进行连接稍显烦琐。Python提供了函数join()连接字符串，join()配合列表实现多个字符串的连接十分方便。  
代码实例如下：

# 使用join()连接字符串
    print('==========# 使用join()连接字符串==========')
    strs = ['hello', 'world', 'hello', 'china']
    result = ''.join(strs)
    print(result)

【代码说明】

*  第2行代码用列表取代变量，把多个字符串存放在列表中。
 *  第3行代码调用join()，每次连接列表中的一个元素。

【运行结果】  
![SouthEast 7][]

reduce()的作用就是对某个变量进行累计。这里可以对字符串进行累计连接，从而实现多个字符串进行连接的功能。  
代码实现如下：

# 使用reduce()连接字符串
    print('=========# 使用reduce()连接字符串=========')
    from functools import reduce
    import operator
    strs = ['hello', 'world', 'hello', 'china']
    result = reduce(operator.add, strs, '')
    print(result)
    print('========================================')

【代码说明】

*  第3行代码导入模块operator，利用方法add()实现累计连接。
 *  第5行代码调用reduce()实现对空字符串“”的累计连接，每次连接列表strs中的一个元素。

【运行结果】  
![SouthEast 8][]

# 使用 + 链接字符串
    print('========# 使用 + 链接字符串==============')
    str1 = 'hello'
    str2 = 'world'
    str3 = 'hello'
    str4 = 'china'
    result = str1 + str2 + str3
    print(result)
    result += str4
    print(result)
    print('========================================')
    
    # 使用join()连接字符串
    print('==========# 使用join()连接字符串==========')
    strs = ['hello', 'world', 'hello', 'china']
    result = ''.join(strs)
    print(result)
    print('========================================')
    
    # 使用reduce()连接字符串
    print('=========# 使用reduce()连接字符串=========')
    from functools import reduce
    import operator
    strs = ['hello', 'world', 'hello', 'china']
    result = reduce(operator.add, strs, '')
    print(result)
    print('========================================')

#### 字符串的截取 ####

字符串的截取是实际应用中经常使用的技术，被截取的部分称为“子串”。Java中使用函数substr()获取子串，C\#使用函数substring()获取子串。而Python由于内置了序列，可以通过前面介绍的索引、切片获取子串，也可以使用函数split()来获取。字符串也属于序列。  
下面这段代码使用序列的索引获取子串：

# 使用索引截取子串
    print('----------# 使用索引截取子串---------')
    word = 'world'
    print(word[4])

【代码说明】第4行代码，访问字符串第5个字符的值。输出结果为“d”。

【运行结果】  
![SouthEast 9][]

通过切片可以实现对字符串有规律的截取。切片的语法格式如下所示。

`string[start : end : step]`

【代码说明】其中string表示需要取子串的源字符串变量。\[start:end:step\]表示从string的第start个索引位置开始到第end个索引之间截取子串，截取的步长是step。即每次截取字符string\[start+step\]，直到第end个索引。索引从0开始计数。  
下面这段代码演示了使用切片截取子串的功能：

# 特殊切片截取子串
    print('---------# 特殊切片截取子串----------')
    str1 = 'hello world'
    print(str1[0:3])
    print(str1[::2])
    print(str1[1::2])
    str2 = 'ABCDEFG'
    print(str2[:3])
    print(str2[3:])
    print(str2[::2])
    print('-----------------------------------')

【代码说明】

*  第3行代码，截取字符串中第1个字符到第3个字符之间的部分。
 *  第4行代码，\[::2\]切片省略了开始和结束字符。从字符串的第1个字符开始，以2为步长逐个截取字符。
 *  第5行代码，切片中的数字1表示从字符串的第2个字符开始取字符，数字2表示以2为步长逐个截取字符。

【运行结果】  
![SouthEast 10][]

如果要同时截取多个子串，可以使用函数split()实现。函数split()的声明如下所示。

split([char] [,num])

【代码说明】

*  参数char表示用于分割的字符，默认的分割字符是空格。
 *  参数num表示分割的次数。如果num等于2，将把源字符串分割为3个子串。默认情况下，将根据字符char在字符串中出现的个数来分割子串。
 *  函数的返回值是由子串组成的列表。

代码如下：

# 使用split()获取子串
    print('-----------# 使用split()获取子串-----')
    sentence = "Tom said: a,b,c,d."
    print('使用空格获取子串:', sentence.split())
    print('使用逗号获取子串:', sentence.split(','))
    print('使用逗号获取3个子串:', sentence.split(',', 2))
    sentence1 = 'Uzi tell us : he is king and said : A, B, C, D.'
    print('使用空格获取子串:', sentence1.split())
    print('使用逗号获取子串:', sentence1.split(','))
    print('使用空格获取4个子串:', sentence1.split(' ',3))
    print('-----------------------------------')

【代码说明】

*  第3行代码根据空格来获取子串。字符串sentence中有5个空格，将返回由6个子串组成的列表。
 *  第4行代码根据逗号来获取子串。字符串sentence中有3个空格，将返回由4个子串组成的列表。
 *  第5行代码根据逗号来分割字符串，并把字符串sentence分割为3个子串。

【运行结果】  
![SouthEast 11][]

字符串连接后，Python将分配新的空间给连接后的字符串，源字符串保持不变。

# 字符串连接后，Python将分配新的空间给连接后的字符串，源字符串保持不变。
    print('字符串连接后，Python将分配新的空间给连接后的字符串，源字符串保持不变。')
    str3 = "a"
    print(id(str3))
    print(id(str3 + "b"))
    print('-------------------------------------')

【代码说明】

*  第2行代码输出str1的内部标识。输出结果为“4337916312”。
 *  第3行代码，进行字符串连接，新的字符串将获得新的标识。输出结果为“4337800168”。

【运行结果】  
![SouthEast 12][]

#### 字符串的比较 ####

Java使用equals()比较两个字符串的内容，Python直接使用“==”“!=”操作符比较两个字符串的内容。如果比较的两个变量的类型不相同，比较的内容也不相同。  
下面这段代码演示了Python中字符串的比较:

# 字符串的比较
    print('----------# 字符串的比较-------------')
    str1 = 1
    str2 = '1'
    
    if str1 == str2:
        print("相同")
    else:
        print("不相同")
    
    if str(str1) == str2:
        print("相同")
    else:
        print("不相同")
    print('-------------------------------------')

【代码说明】

*  第2行代码定义了1个数字类型的变量str1。
 *  第3行代码定义了1个字符串类型的变量str2。
 *  第4行代码比较str1和str2的值。由于str1和str2的类型不同，所以两者的内容也不相同。输出结果为“不相同”。
 *  第8行代码，把数字型的变量str1转换为字符串类型，数字1被转换为字符串“1”。然后再与str2进行比较。输出结果为“相同”。

【运行结果】  
![这里写图片描述][SouthEast 13]

如果要比较字符串中的一部分内容，可以先截取子串，再使用“==”操作符进行比较。如果要比较字符串的开头或结尾部分，更方便的方法是使用startswith()或endswith()函数。  
startswith()的声明如下所示。

startswith(substring, [,start [,end]])

【代码说明】

*  参数substring是与源字符串开头部分比较的子串。
 *  参数start表示开始比较的位置。
 *  参数end表示比较结束的位置，即在start:end范围内搜索子串substring。
 *  如果字符串以substring开头，则返回True；否则，返回False。  
    endswith()的参数和返回值类似startswith()，不同的是endswith()从源字符串的尾部开始搜索。

下面这段代码演示了startswith()和endswith()的使用。

# 比较字符串的开始和结束处
    print('------# 比较字符串的开始和结束处---------')
    word = 'hello world'
    print('hello' == word[0:5])
    print(word.startswith('hello'))
    print(word.endswith('ld', 6))
    print(word.endswith('ld', 6, 10))
    print(word.endswith('ld', 6, len(word)))
    print('-------------------------------------')

【代码说明】

*  第3行代码先获取子串\[0:5\]，再与“hello”进行比较。输出结果为“True”。
 *  第4行代码调用startswith()。比较字符串变量word的开头部分“hello”。输出结果为“True”。
 *  第5行代码，从字符串变量word的结尾到word\[6\]之间搜索子串“ld”。输出结果为“True”。
 *  第6行代码，从“分片”word\[6:10\]中搜索子串“ld”。由于搜索的字符不包括位置10所在的字符，所以在word\[6:10\]中搜索不到子串“ld”。输出结果为“False”。
 *  第7行代码，从“分片”word\[6:len(word)\]中搜索子串“ld”，len(word)的值为11。输出结果为“True”。

**注意 startswith()、endswith()相当于分片\[0:n\]，n是源字符串中最后一个索引。startswith()、endswith()不能用于比较源字符串中任意一部分的子串。**

【运行结果】  
![SouthEast 14][]

#### 字符串的反转 ####

字符串反转是指把字符串中最后一个字符移到字符串第一个位置，按照倒序的方式依次前移。Java中使用StringBuffer类处理字符串，并通过循环对字符串进行反转。  
Python没有提供对字符串进行反转的函数，也没有类似charAt()这样的函数。但是可以使用列表和字符串索引来实现字符串的反转，并通过range()进行循环。  
代码如下：

# 循环输出反转的字符串
    def reverse(str):
        out = ''
        li = list(str)
        for i in  range(len(li), 0, -1):
            out += ''.join(li[i-1])
        return out

【代码说明】

*  第2行代码定义了一个函数reverse()，参数str表示需要反转的字符串。
 *  第3行代码定义了一个返回变量out，用于存放字符串反转后的结果。
 *  第4行代码创建了一个列表li，字符串str中的字符成为列表li的元素。
 *  第5~6行代码从列表中的最后一个元素开始处理，依次连接到变量out中。
 *  第7行代码返回变量out的值。

不难发现，Python的实现代码更简短，而且更容易理解。用户还可以通过列表的reverse()函数实现字符串的反转，实现的代码将进一步简化。

# 使用list 的 reverse()
    def reverse2(s):
        li = list(s)
        li.reverse()
        s = ''.join(li)
        return s

【代码说明】

*  第4行代码调用列表的reverse()实现了for…in…循环的功能。
 *  第5行代码调用join()把反转后列表li的元素依次连接到变量s中。

Python的列表是对字符串进行处理的常用方式，灵活使用列表等内置数据结构处理字符串，能够简化编程的复杂度。利用序列的“切片”实现字符串的反转最为简洁，reverse()函数的主体只需要一行代码即可。

def reverse(s):  
return s\[::-1\]

【代码说明】-1表示从字符串最后一个索引开始倒序排列。

ALL:

# 循环输出反转的字符串
    def reverse(str):
        out = ''
        li = list(str)
        for i in  range(len(li), 0, -1):
            out += ''.join(li[i-1])
        return out
    
    # 使用list 的 reverse()
    def reverse2(s):
        li = list(s)
        li.reverse()
        s = ''.join(li)
        return s
    
    if __name__ == '__main__':
        print('手动实现：输出反转字符串：%s' % reverse('abcdef'))
        print('列表方法：输出反转字符串：%s' % reverse('ABCDEF'))

#### 字符串的查找和替换 ####

Java中字符串的查找使用函数indexOf()，返回源字符串中第1次出现目标子串的索引。如果需要从右往左查找可以使用函数lastIndexOf()。Python也提供了类似功能的函数，函数find()与indexOf()的作用相同，rfind()与lastIndexOf()的作用相同。find()的声明如下所示。

find(substring [, start [ ,end]])

【代码说明】

*  参数substring表示待查找的子串。
 *  参数start表示开始搜索的索引位置。
 *  参数end表示结束搜索的索引位置，即在分片\[start:end\]中查找。
 *  如果找到字符串substring，则返回substring在源字符串中第1次出现的索引。否则，返回-1。

rfind()的参数与find()相同，不同的是rfind()从字符串的尾部开始查找子串。  
下面这段代码演示了find()、rfind()的使用:

# 查找字符串
    sentence = "This is a apple."
    print("find()方法实例：")
    print(sentence.find("is", 3, 7))
    print(sentence.find('a'))
    print("rfind()方法实例：")
    print(sentence.rfind('is', 3, 7))
    print(sentence.rfind("a"))

【代码说明】

*  第5行代码使用函数find()，从sentence的头部开始查找字符串“a”。输出结果为“8”。
 *  第8行代码使用函数rfind()，从sentence的尾部开始查找字符串“a”。输出结果为“10”。

Java使用replaceFirst()、replaceAll()实现字符串的替换。replaceFirst()用于替换源字符串中第1次出现的子串，replaceAll()用于替换源字符串中所有出现的子串。这两个函数通过正则表达式来查找子串。而Python使用函数replace()实现字符串的替换，该函数可以指定替换的次数，相当于Java函数replaceFirst()和replaceAll()的合并。但是replace()不支持正则表达式的语法。  
replace()的声明如下所示：

replace(old, new [, max])

【代码说明】

*  参数old表示将被替换的字符串。
 *  参数new表示替换old的字符串。
 *  参数max表示使用new替换old的次数。
 *  函数返回一个新的字符串。如果子串old不在源字符串中，则函数返回源字符串的值。

下面这段代码演示了replace()的使用：

# 字符串的替换
    print('replace()方法实例：')
    string = 'hello world, hello china. I love china.'
    print(string.replace('he', 'HE'))
    print(string.replace('he', 'HE', 3))
    print(string.replace('he', 'HE', 1))
    print(string.replace('ABC', 'abc'))

【代码说明】

*  第3行代码把sentence中的“hello”替换为“hi”。由于没有给出参数max的值，所以sentence中的“hello”都将被“hi”替换。
 *  第4行代码，参数max的值为1，所以sentence中第1次出现的“hello”被“hi”替换，后面的出现的子串“hello”保持不变。
 *  第5行代码，由于sentence中没有子串“abc”，所以替换失败。replace()返回sentence的值。

**注意 replace()先创建变量sentence的拷贝，然后在拷贝中替换字符串，并不会改变变量sentence的内容。**

#### 字符串与日期的转换 ####

在开发中，经常把日期类型转换为字符串类型使用。字符串与日期的转换是工作中频繁遇到的问题。Java提供了SimpleDateFormat类实现日期到字符串的转换。Python提供了time模块处理日期和时间。  
函数strftime()可以实现从时间到字符串的转换。strftime()的声明如下所示：

strftime(format[, tuple]) -> string

【代码说明】

*  参数format表示格式化日期的特殊字符。例如，“%Y-%m-%d”相当于Java中的“yyyy-MM-dd”。
 *  参数tuple表示需要转换的时间，用元组存储。元组中的元素分别表示年、月、日、时、分、秒。
 *  函数返回一个表示时间的字符串。  
    参数format格式化日期的常用标记如下所示：  
    ![SouthEast 15][]  
    ![SouthEast 16][]

字符串到时间的转换需要进行两次转换，需要使用time模块和datetime类，转换过程分为如下3个步骤。  
1）调用函数strptime()把字符串转换为一个的元组，进行第1次转换。strptime()的声明如下所示。

strptime(string, format) -> struct_time

【代码说明】

*  参数string表示需要转换的字符串。
 *  参数format表示日期时间的输出格式。
 *  函数返回一个存放时间的元组。  
    2）把表示时间的元组赋值给表示年、月、日的3个变量。  
    3）把表示年、月、日的3个变量传递给函数datetime()，进行第2次转换。

datetime类的datetime()函数如下所示。

datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])

【代码说明】

*  参数year、month、day分别表示年、月、日，这3个参数必不可少。
 *  函数返回1个datetime类型的变量。

下面这段代码演示了时间到字符串、字符串到时间的转换过程：

import time
    import datetime
    
    # 时间到字符串的转换
    print("----------时间到字符串的转换-----------")
    print(time.strftime("%Y-%m-%d %X", time.localtime()))
    # 字符串到时间的转换
    print("----------字符串到时间的转换-----------")
    t = time.strptime("2017-12-25", "%Y-%m-%d")
    y,m,d = t[0:3]
    print(datetime.datetime(y, m, d))

【代码说明】

*  第4行代码中，函数localtime()返回当前的时间，strftime把当前的时间格式转化为字符串类型。
 *  第6行代码，把字符串“2017-12-25”转换为一个元组返回。
 *  第7行代码，把元组中前3个表示年、月、日的元素赋值给3个变量。
 *  第8行代码，调用datetime()返回时间类型。

**注意 格式化日期的特殊标记是区分大小写的，%Y与%y不相同。**

[SouthEast]: /images/20220602/5d4f775030ff40e08c7308cf290741b1.png
[SouthEast 1]: /images/20220602/fce5380848d640019a71a1bc36c586e3.png
[SouthEast 2]: /images/20220602/c93ef70c7d5d4efc8617782c9ae106cb.png
[SouthEast 3]: /images/20220602/037775a2484149178ec52ab38fff94ca.png
[SouthEast 4]: /images/20220602/5c021915d76f424cb8705578f231a22a.png
[SouthEast 5]: /images/20220602/3e6efc35ec284bc98f66c3bf4b87501d.png
[SouthEast 6]: /images/20220602/74135caef259450fadf86afa64805742.png
[SouthEast 7]: /images/20220602/81265a6b82ff4415abcc3218a046d62c.png
[SouthEast 8]: /images/20220602/4cf9a831e4734ee1a6b2326119c9623f.png
[SouthEast 9]: /images/20220602/dc6e9211e25346688171826d195269ba.png
[SouthEast 10]: /images/20220602/6fd6342703fb49deaf02d7448d1e8aec.png
[SouthEast 11]: /images/20220602/83308dad80794d31978cee745cc24825.png
[SouthEast 12]: /images/20220602/000a8f5eaf9d409fbdc70fa1f1f05e53.png
[SouthEast 13]: /images/20220602/00ee095624f649e48d10fb0f71f15403.png
[SouthEast 14]: /images/20220602/e5d5b7246192462fb92bf6e9633a9f1c.png
[SouthEast 15]: /images/20220602/52e4796679ac4dea8cc4c496ac995ddd.png
[SouthEast 16]: /images/20220602/f022c19d872d4c71800851ba0902e782.png