python基础数据结构 - 字符串

方法集

strip	lstrip	rstrip	replace	join
split	rsplit	splitlines	startswith	endswith
zfill	find	rfind	ljust	rjust
partition	rpartition	title	istitle	capitalize
lower	islower	upper	isupper	index
rindex	isspace	isdigit	isalnum	isalpha
isascii	isdecimal	isidentifier	isidentifier	isnumeric
isprintable	format	center	casefold	count
encode	expandtabs	maketrans	swapcase	translate

方法说明

strip

语法：strip(chars=None, /) -> str
说明：返回删除了字符串前后空格（或者自定义的chars）的副本，
示例：

# 1. 删除左右两边的空格
In [16]: s = "python "
In [17]: s.strip()
Out[17]: 'python'

# 2. 删除左右两边自定义的chars 
In [18]: s = "xpythonx"
In [19]: s.strip("x")
Out[19]: 'python'

lstrip

语法：lstrip(chars=None, /) -> str
说明：返回删除了字符串左空格（或者自定义的chars）的副本
示例：

# 1. 删除左边的空格
In [20]: s = " python "
In [21]: s.lstrip()
Out[21]: 'python '

# 2. 删除左边自定义chars
In [22]: s = "xpythonx"
In [23]:  s.lstrip("x")
Out[23]: 'pythonx'

rstrip

语法：rstrip(chars=None, /) -> str
说明：返回删除了字符串后空格的副本
示例：

# 1. 删除右边的空格
In [26]: s = " python "
In [27]: s.rstrip()
Out[27]: ' python'

# 2. 删除右边自定义的chars
In [28]: s = "xpythonx"
In [29]: s.rstrip("x")
Out[29]: 'xpython'

replace

语法：replace(old, new, count=-1, /) -> str
说明：返回所有出现的子字符串 old 替换为 new 的副本，-1（默认值）表示替换所有匹配项
示例:

# 1. 替换所有匹配项
In [31]: s = "python go java go"
In [32]: s.replace("go", "python")
Out[32]: 'python python java python'

# 2. 只替换一个匹配项
In [33]: s.replace("go", "python", 1)
Out[33]: 'python python java go'

join

语法：join(iterable, /) -> str
说明：调用其方法的字符串插入到每个给定字符串之间。结果作为新字符串返回
示例：'.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs

# 1. 按照给定连接符连接把列表转换成字符串
In [34]: l = ["python", "go", "jave"]
In [35]: "#".join(l)
Out[35]: 'python#go#jave'

split

语法：split(sep=None, maxsplit=-1) -> list
说明：返回字符串中单词的列表，使用 sep 作为分隔符字符串。-1（默认值）表示没有限制
    sep
        分割字符串所依据的分隔符。None（默认值）表示根据任何空格进行拆分，并从结果中丢弃空字符串。
    maxsplit
        要进行的最大拆分数-1（默认值）表示没有限制
示例：

# 1. 按照默认分隔符空格分割
In [37]: s = "python go java"
In [38]: s.split()
Out[38]: ['python', 'go', 'java']

# 2. 按照给定分隔符分割
In [39]: s = "python#go#java"
In [40]: s.split("#")
Out[40]: ['python', 'go', 'java']

# 3. 只分割一个
In [41]: s = "python#go#java"
In [42]: s.split("#", 1)
Out[42]: ['python', 'go#java']

rsplit

语法：rsplit(sep=None, maxsplit=-1) -> list
说明：使用 sep 作为分隔符字符串，返回字符串中单词的列表
    sep
        分割字符串所依据的分隔符。None（默认值）表示根据任何空格进行拆分，并从结果中丢弃空字符串。
    maxsplit
        要进行的最大拆分数-1（默认值）表示没有限制
示例：

# 1. 从右边按照默认空格分割
In [51]: s = "python go java"
In [52]: s.rsplit()
Out[52]: ['python', 'go', 'java']

# 2. 从右边按照给定序列分割
In [53]: s = "python#go#java"
In [55]: s.rsplit("#")
Out[55]: ['python', 'go', 'java']

 # 3. 从右边按照给定序列分割一次
In [56]: s = "python#go#java"
In [57]: s.rsplit("#", 1)
Out[57]: ['python#go', 'java']

splitlines

语法：splitlines(keepends=False) -> list
说明：返回字符串中的行列表，在行边界处中断。
    keepends
        是否包含换行符
示例：

# 1. 按照空格分割
In [58]: s = "python\ngo\njava"
In [59]: s.splitlines()
Out[59]: ['python', 'go', 'java']

# 2. 没有换行符分割
In [60]: s = "python go java"
In [61]: s.splitlines()
Out[61]: ['python go java']

# 3. 有换行符，保留换行符分割
In [62]: s = "python\ngo\njava"
In [63]: s.splitlines(True)
Out[63]: ['python\n', 'go\n', 'java']

startswith

语法：S.startswith(prefix[, start[, end]]) -> bool
说明：如果 S 以指定的前缀开头，则返回 True，否则返回 False
    prefix
        前缀
    start
        开始位置，可选
    end
        结束位置，可选
示例：

# 1. 默认整个字符串匹配
In [70]: s = "python go java"
In [71]: s.startswith("python")
Out[71]: True

# 2. 给定start end匹配
In [72]: s.startswith("python", 1, 6)
Out[72]: False

# 3. 给定start end匹配
In [73]: s.startswith("python", 0, 6)
Out[73]: True

endswith

语法：S.endswith(suffix[, start[, end]]) -> bool
说明：如果 S 以指定的后缀开头，则返回 True，否则返回 False
    suffix
        后缀
    start
        开始位置，可选
    end
        结束位置，可选
示例：

# 1. 默认整个字符串匹配
In [70]: s = "python go java"
In [71]: s.endswith("java")
Out[71]: True

# 2. 给定start end匹配
In [72]: s.endswith("java", 10, 14)
Out[72]: True

# 3. 给定start end匹配
In [73]: s.endswith("java", 0, 6)
Out[73]: False

zfill

语法：S.zfill(width) -> str
说明：在S左侧用零填充给定宽度数字字符串，不会截断字符串
    width
        字符串宽度
示例：

# 1. 正常填充
In [91]: s = "python"

In [92]: s.zfill(6)
Out[92]: 'python'

In [93]: s.zfill(7)
Out[93]: '0python'

In [94]: s.zfill(8)
Out[94]: '00python'

# 2. 少于字符串长度，不会截断字符串
In [95]: s.zfill(5)
Out[95]: 'python'

find

语法：S.find(sub[, start[, end]]) -> int
说明：返回 S 中找到子字符串 sub 的最低索引
    sub
        需要查找的字串
    start
        查找的起始位置
    end
        查找的结束位置
示例：

In [99]: s = "python go java go"
# 1. 查找子串go， 返回最低索引7
In [100]: s.find("go")
Out[100]: 7
# 2. 在[7, 8]位置查找子串go，没有找到返回-1
In [102]: s.find("go", 7, 8)
Out[102]: -1
# 3. 在[7,9]位置查找子串go，返回最低索引7
In [103]: s.find("go", 7, 9)
Out[103]: 7

rfind

语法：S.rfind(sub[, start[, end]]) -> int
说明：返回 S 中找到子字符串 sub 的最高索引
    sub
        需要查找的字串
    start
        查找的起始位置
    end
        查找的结束位置
示例：

In [105]: s
Out[105]: 'python go java go'

In [106]: s.rfind("go")
Out[106]: 15

In [107]: s.rfind("goo")
Out[107]: -1

In [111]: s.rfind("go", 15, 17)
Out[111]: 15

In [112]: s.rfind("go", 15, 16)
Out[112]: -1

ljust

语法：S.ljust(width, fillchar=' ') -> str
说明：返回一个左对齐的长度宽度字符串，使用指定的填充字符（默认为空格）完成填充
    width
        字符串长度
    fillchar
        填充符号
示例：

In [114]: s = "go"
# 1. 宽度小于字符串长度，不阶段，返回原字符串
In [116]: s.ljust(1)
Out[116]: 'go'
# 2. 长度为3，默认空格填充
In [117]: s.ljust(3)
Out[117]: 'go '
# 3. 长度为10， 默认空格填充
In [118]: s.ljust(10)
Out[118]: 'go        '
# 4. 长度为10，使用*号填充
In [119]: s.ljust(10, "*")
Out[119]: 'go********'

rjust

语法：S.rjust(width, fillchar=' ') -> str
说明：返回一个右对齐的长度宽度字符串，使用指定的填充字符（默认为空格）完成填充
    width
        字符串长度
    fillchar
        填充符号
示例：

In [122]: s
Out[122]: 'go'
# 1. 小于字符串长度，返回原字符串
In [123]: s.rjust(1)
Out[123]: 'go'
# 3. 默认空格从右边填充
In [124]: s.rjust(3)
Out[124]: ' go'

In [125]: s.rjust(10)
Out[125]: '        go'
#  3. 使用*号填充
In [126]: s.rjust(10, "*")
Out[126]: '********go'