Python基础（二）：字符串方法总结

字符串方法

字符串拼接

直接通过（+）操作拼接

print('hello'+' '+'world'+'!')

> hello world!

使用这种方式进行字符串连接的操作效率低下，因为python中使用 + 拼接两个字符串时会生成一个新的字符串，生成新的字符串就需要重新申请内存，当拼接字符串较多时自然会影响效率。

通过str.join（）方法拼接

str_list = ['hello', ' ', 'world', '!']
print(''.join(str_list))

> hello world!

这种方式一般用在列表转字符串，''.join其中''可以是空字符，也可以是任意字符，当时任意字符时，列表中字符串会被该字符隔开。

str_list = ['hello', ' ', 'world', '!']
print(':'.join(str_list))

> hello: :world:!

通过str.format（）方法拼接

print('{} {}!'.format('hello', 'world'))

> hello world!

通过这种方式拼接字符串需要注意的是字符串中{}的数量要和format方法参数数量一致，否则会报错

通过（%）操作符拼接

print('测试 %s' % 'Hello')
print('测试 %s 测试 %s' % ('hello', 'world'))


> 测试 Hello
> 测试 hello 测试 world

也用于格式化字符串，%s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。

常见的占位符：

占位符	替换内容
%d	整数
%f	浮点数
%s	字符串
%x	十六进制整数

如果不确定用什么，%s永远起作用，它会把任何数据类型转换为字符串
有时候字符串里面的%是一个普通字符，就需要转义，用%%来表示一个%:

print('growth rate: %d %%' % 7)

通过（）多行拼接

print(
    'hello'
    ' '
    'world'
    '!'
)


> hello world!

python遇到未闭合的小括号，自动将多行拼接为一行。

通过string 模块中的Template对象拼接

from string import Template

s = Template('${s1} ${s2}')
t = s.safe_substitute(s1='hello', s2='world')
print(t)

> hello world

Template的实现方式是首先通过Template初始化一个字符串。这些字符串中包含了一个个key。通过调用substitute或safe_subsititute，将key值与方法中传递过来的参数对应上，从而实现在指定的位置导入字符串。这种方式的好处是不需要担心参数不一致引发异常

通过F-strings拼接

s1 = 'hello'
s2 = 'world'
s3 = f'{s1} {s2}!'
print(s3)

> hello world!

在python3.6.2版本中，PEP 498 提出一种新型字符串格式化机制，被称为“字符串插值”或者更常见的一种称呼是F-strings，F-strings提供了一种明确且方便的方式将python表达式嵌入到字符串中来进行格式化
而且F-strings的运行速度很快，比%-string和str.format()这两种格式化方法都快得多。

在F-strings中我们也可以执行函数：

def power(x):
    return x * x


x = 5
print(f'{x}*{x}={power(x)}')

字符串的格式化

通过(%)操作符

print('测试 %s' % 'Hello')
print('测试 %s 测试 %s' % ('hello', 'world'))


> 测试 Hello
> 测试 hello 测试 world

也用于格式化字符串，%s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。

常见的占位符：

占位符	替换内容
%d	整数
%f	浮点数
%s	字符串
%x	十六进制整数

如果不确定用什么，%s永远起作用，它会把任何数据类型转换为字符串
有时候字符串里面的%是一个普通字符，就需要转义，用%%来表示一个%:

print('growth rate: %d %%' % 7)

通过format()方法

print('Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125))

使用字符串的format()方法，它会用传入的参数依次替换字符串内的占位符{0}、{1}……，不过这种方式写起来比%要麻烦得多：

字符串其他方法

字符串替换

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

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

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

s = 'abc'
print(s.replace('abc', 'e', 1))

> e

find 、index、rfind、rindex

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

• index：检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。

• rfind：类似于find()函数，只不过是从字符串右边开始查找。

• rindex：类似于index()函数，只不过是从字符串右边开始查找。

str1.find(str2, beg=0,  end=len(str1))
str1.index(str2, beg=0,  end=len(str1))

• str1 -- 指定检索的字符串
• str2 -- 要查找的子字符串
• beg -- 开始索引，默认为0。
• end -- 结束索引，默认为字符串的长度。

str1 = '0123456'
str2 = '23'
print(str1.find(str2))
print(str1.find(str2, 0))
print(str1.find(str2, 3))
print(str1.find(str2, 0, len(str1)))


> 2
> 2
> -1
> 2

用index方法，字符串中不包含要查找的子字符串

str1 = '0123456'
str2 = '23'

print(str1.index(str2,3))

> Traceback (most recent call last):
>  File "E:/python_ide/dc_test/test7.py", > > line 57, in <module>
>    print(str1.index(str2,3))
> ValueError: substring not found

count

统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。

str.count(sub, start= 0, end=len(string))

• sub -- 搜索的子字符串
• start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
• end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。
• 该方法返回子字符串在字符串中出现的次数。没有则返回0

str1 = '0123456'
print(str1.count('1'))
print(str1.count('1', 0))
print(str1.count('1', 0, len(str1)))
print(str1.count('1', 2, 3))

> 1
> 1
> 1
> 0

isalpha、isdigit、isalnum、isspace

• isalpha：检测字符串是否只由字母组成。
• isdigit：检测字符串是否只由数字组成。如果字符串只包含数字则返回 True 否则返回 False。
• isalnum：检测字符串是否由字母和数字组成。
• isspace：检测字符串是否只由空格组成。

str.isalpha()
str.isdigit()
str.isalnum()
str.isspace()

str1 = '0123456'
str2 = 'ABCDE'
str3 = 'AB123'
str4 = '  '
print(str1.isdigit())
print(str2.isalpha())
print(str3.isalnum())
print(str4.isspace())


> True
> True
> True
> True

isupper、islower

• isupper： 检测字符串中所有的字母是否都为大写。如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

str.isupper()

str = "THIS IS STRING EXAMPLE....WOW!!!"
print (str.isupper())

str = "THIS is string example....wow!!!"
print (str.isupper())

> True
> False

• islower：检测字符串是否由小写字母组成。如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False

str.islower()

str = "RUNOOB example....wow!!!"
print(str.islower())

str = "runoob example....wow!!!"
print(str.islower())

> False
> True

startswith、endswith

• startswith：检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。

str.startswith(substr, beg=0,end=len(str))

• str -- 检测的字符串。
• substr -- 指定的子字符串。
• strbeg -- 可选参数用于设置字符串检测的起始位置。
• strend -- 可选参数用于设置字符串检测的结束位置。

str = "this is string example....wow!!!"
print (str.startswith( 'this' ))   # 字符串是否以 this 开头
print (str.startswith( 'string', 8 ))  # 从第八个字符开始的字符串是否以 string 开头
print (str.startswith( 'this', 2, 4 )) # 从第2个字符开始到第四个字符结束的字符串是否以 this 开头

> True
> True
> False

• endswith：判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回 True，否则返回 False。可选参数 "start" 与 "end" 为检索字符串的开始与结束位置。

str.endswith(suffix[, start[, end]])

• suffix -- 该参数可以是一个字符串或者是一个元素。
• start -- 字符串中的开始位置。
• end -- 字符中结束位置。

Str='Runoob example....wow!!!'
suffix='!!'
print (Str.endswith(suffix))
print (Str.endswith(suffix,20))
suffix='run'
print (Str.endswith(suffix))
print (Str.endswith(suffix, 0, 19))

> True
> True
> False
> False

upper、lower、title、capitalize、swapcase

• lower：将字符串中的大写字母转为小写字母。
• upper：将字符串中的小写字母转为大写字母。
• title：将所有单词首字母转为大写，其余字母均转为小写。
• capitalize：将字符串的第一个字母转为大写,其他字母转为小写。
• swapcase：将字符串做大小写字母转换(大写->小写，小写->大写)

str.lower()
str.upper()
str.title()
str.capitalize()
str.swapcase()

>>> 'aBcDe'.upper()
'ABCDE'

>>> 'aBcDe'.lower()
'abcde'

>>> 'thIs is a exaMple'.title()
'This Is A Example'

>>> 'this is A example'.capitalize()
'This is a example'

>>> 'aBcDe'.swapcase()
'AbCdE'

strip、lstrip、rstrip

• strip()： 方法用于移除字符串头尾指定的字符（默认为空格）或字符序列。只能删除开头或是结尾的字符，不能删除中间部分的字符。
• lstrip() ：方法用于截掉字符串左边的空格或指定字符。
• rstrip()： 删除 string 字符串末尾的指定字符（默认为空格）.

str.strip([chars])
str.lstrip([chars]) 
str.rstrip([chars])

>>> ' abc '.strip() 
'abc'  
>>> ' abc'.lstrip() 
'abc'  
>>> 'abc '.rstrip() 
'abc'  
>>> 'abc'.strip('a') 
'bc'  
>>> 'abc'.lstrip('a') 
'bc'  
>>> 'abc'.rstrip('c') 
'ab'
>>> 'abc@163.com'.strip('cawm') 
'bc@163.co'  
>>> 'abc@163.com'.lstrip('cawm') 
'bc@163.com'  
>>> 'abc@163.com'.rstrip('cawm') 
'abc@163.co'

split、splitlines、partition、rpartition

• split：指定分隔符对字符串进行切片，如果参数 num 有指定值，则仅分隔 num 个子字符串。

• splitlines：按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

• partition：根据指定的分隔符将字符串进行分割。如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。

• rpartition：类似于partition()函数，只不过是从右边开始。

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

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

str = "this is string example....wow!!!"
print (str.split( ))       # 以空格为分隔符
print (str.split('i',1))   # 以 i 为分隔符
print (str.split('w'))     # 以 w 为分隔符



['this', 'is', 'string', 'example....wow!!!']
['th', 's is string example....wow!!!']
['this is string example....', 'o', '!!!']

str.splitlines([keepends])

• keepends -- 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

str.partition(str)

• str-- 指定的分隔符。

str.rpartition(str)

>>> 'www.example.com'.partition('.')
('www', '.', 'example.com')

>>> 'www.example.com'.rpartition('.')
('www.example', '.', 'com')

填充ljust、center、rjust

• ljust：返回一个指定的宽度 width 居左的字符串，fillchar 为填充的字符，默认为空格。如果指定的长度小于原字符串的长度则返回原字符串。

• center：返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。如果指定的长度小于原字符串的长度则返回原字符串。

• rjust：返回一个指定的宽度 width 居右的字符串，fillchar 为填充的字符，默认为空格。如果指定的长度小于原字符串的长度则返回原字符串。

str.ljust(width[, fillchar])
str.center(width[, fillchar])
str.rjust(width[, fillchar])

• width -- 字符串的总宽度。
• fillchar -- 填充字符。

>>> '[www.example.com]'.ljust(30, '*')
'[www.example.com]*************'

>>> '[www.example.com]'.rjust(30, '*')
'*************[www.example.com]'

>>> '[www.example.com]'.center(30, '*')
'******[www.example.com]*******'

>>> '[www.example.com]'.center(4, '*')
'[www.example.com]'