python学习笔记--字符串函数

概述

python的字符串函数一共有40个，如下表：

序号	方法	描述
1	capitalize()	将字符串的第一个字符转换为大写
2	center(width, fillchar)	返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
3	count(str, beg= 0,end=len(string))	返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
4	bytes.decode(encoding=“utf-8”, errors=“strict”)	Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。
5	encode(encoding=‘UTF-8’,errors=‘strict’)	以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’
6	endswith(suffix, beg=0, end=len(string))	检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
7	expandtabs(tabsize=8)	把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
8	find(str, beg=0, end=len(string))	检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
9	index(str, beg=0, end=len(string))	跟find()方法一样，只不过如果str不在字符串中会报一个异常.
10	isalnum()	如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
11	isalpha()	如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
12	isdigit()	如果字符串只包含数字则返回 True 否则返回 False
13	islower()	如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
14	isnumeric()	如果字符串中只包含数字字符，则返回 True，否则返回 False
15	isspace()	如果字符串中只包含空白，则返回 True，否则返回 False.
16	istitle()	如果字符串是标题化的(见 title())则返回 True，否则返回 False
17	isupper()	如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
18	join(seq)	以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
19	len(string)	返回字符串长度
20	ljust(width[, fillchar])	返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
21	lower()	转换字符串中所有大写字符为小写.
22	lstrip()	截掉字符串左边的空格或指定字符。
23	maketrans()	创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
24	max(str)	返回字符串 str 中最大的字母。
25	min(str)	返回字符串 str 中最小的字母。
26	replace(old, new [, max])	把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。
27	rfind(str, beg=0,end=len(string))	类似于 find()函数，不过是从右边开始查找.
28	rindex( str, beg=0, end=len(string))	类似于 index()，不过是从右边开始.
29	rjust(width,[, fillchar])	返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
30	rstrip()	删除字符串字符串末尾的空格.
31	split(str="", num=string.count(str))	num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串
32	splitlines([keepends])	按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
33	startswith(substr, beg=0,end=len(string))	检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
34	strip([chars])	在字符串上执行 lstrip()和 rstrip()
35	swapcase()	将字符串中大写转换为小写，小写转换为大写
36	title()	返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
37	translate(table, deletechars="")	根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
38	upper()	转换字符串中的小写字母为大写
39	zfill (width)	返回长度为 width 的字符串，原字符串右对齐，前面填充0
40	isdecimal()	检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

（摘抄于菜鸟教程 原地址）

详细介绍

1. capitalize() 和 title()
capitalize() 将字符串的第一个字符大写，也只会将第一个字母大写，后续的单词不会被改变，与之类似的 title() 方法则会将每个单词的首字母大写。两个方法都没有参数。
示例：

>>> b = "abc de fg"
>>> b.capitalize()
'Abc de fg'
>>> b.title()
'Abc De Fg'

2.center(width， [fillchar])，ljust(width，[fillchar])， rjust(width，[fillchar])，zfill(width)；
strip() ，lstrip()，rstrip()

str.center()会生成一个长度为 width，将 str 居中以 fillchar 填补空缺的字符串 。
当 width 小于字符串的长度时，会返回本身。当width为奇数时会优先填充左边，为偶数时优先填充右边。

ljust()会返回一个左对齐的，长度为width，以fillchar填充尾部的字符串
rjust()则是返回一个右对齐的，长度为width，以fillchar填充头部的字符串。
同样的当当 width 小于字符串的长度时，会返回本身。
fillchar 默认为空格

zfill(width)：返回右对齐的，长度为width，填充 ‘0’ 的字符串。

strip() 函数的功能刚好与之相反，是去掉字符串两边的空格或指定字符（可以是单个字符，也可以是短字符串）。
lstrip() 则是去掉左边的空格或指定字符，rstrip()则是右边的。
这三个函数参数默认值都为空格。

示例：

>>> b.center(8, '*')      #当width 小于字符串长度时，返回本身
'abc de fg'
>>> b.center(9, "*")
'abc de fg'
>>> b.center(11, '*')  
'*abc de fg*'

>>> c = 'ad'
>>> c.center(3, "*")      #当width 为奇数时 优先填充左边
'*ad'
>>> c = "abc"
>>> c.center(4, "*")    #右边当width 为偶数时优先填充
'abc*'
>>> b.ljust(11, "*")    #左对齐，填充尾部
'abc de fg**'
>>> b.rjust(11, "*")     #右对齐，填充头部
'**abc de fg'

>>> b.zfill(11)       #右对齐，填充 '0'
'00abc de fg'

>>> c = b.center(13, '*')
>>> print(b, c, c.strip('*'))    #去掉两边的指定字符
abc de fg **abc de fg** abc de fg

3.count(str, beg = 0, end = len(string))
返回短字符串str 在 长字符串 string中 出现的次数。当str 的长度大于 string的长度或string中没有短字符串 str时，将返回 0.
beg默认为0， end 默认为字符串长度。同时注意 end 应为从 1 开始的下标（即实际长度）
示例：

>>> b
'abc de fg
>>> b.count("abc de fgh")
0
>>> b.count(" ", 0, 4)      #此处end = 4，相当于 b[0:4] 即 "abc "
1
>>> b.count(" ", 0, 3)     #此处end = 3，相当于 b[0:3] 即 "abc"
0
>>> b.count(' ')
2
>>> b.count('*')
0

4.encode(encoding = ‘utf-8’, errors = 'strict) 与 decode(encoding = ‘utf-8’, errors = 'strict)
参数：
encoding – 要使用的编码，如"UTF-8"，默认值为 ‘utf-8’。
errors – 设置不同错误的处理方案。默认为 ‘strict’,意为编码错误引起一个UnicodeError。 其他可能得值有 ‘ignore’, ‘replace’, ‘xmlcharrefreplace’, ‘backslashreplace’ 以及通过 codecs.register_error() 注册的任何值。

encode() 方法是对字符串进行编码，编码的格式一般有 ascii，GBK，Unicode，utf-8等等。可以参考myIvan的博客。
编码后字符串会变为bytes类型。此时要注意，虽然编码前后看起来是一样的，但是两个字符串已经不是同一个字符串了。
decode() 其实应为bytes 的方法，因为 string 编码后会转化为bytes类型，所以才能使用。一个string类型是没有 decode() 方法的。
示例：

>>> c = 'abc'
>>> d = c.encode()
>>> print(c, d, c == d)
abc b'abc' False
>>> c.decode()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'str' object has no attribute 'decode'
>>> d.decode()
'abc'

5.endswith(suffix, [beg= 0, [end = len(string)]]) 与startswith(suffix, [beg= 0, [end = len(string)]])
这两个方法是类似的，startswith() 判断字符串是否以 str开始，endswith()判断是否以 str 结束。

endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回 True，否则返回 False。可选参数 “start” 与 “end” 为检索字符串的开始与结束位置。
参数：
suffix – 该参数可以是一个字符串或者是一个元素。
start – 字符串中的开始位置。
end – 字符中结束位置

这个方法一般用于判断文件的类型，因为文件路径是以字符串的形式存在的，可以通过判断字符串带有哪种后缀，来识别是那一种文件。
示例：

import os
src_path = 'C:\\Users\\hasee\\Pictures\\lovewallpaper'
for file in os.listdir(src_path):
    if file.endswith('.jpg'):
        print(file, 'True')
    else:
        print(file, "False")

运行结果：

240043-0.jpg True
248922-106.jpg True
318737-106.jpg True
新建文本文档.txt False

6.expandtabs(tabsize=8)
将字符串中的制表符（’\t’）转换为空格。对原始字符无效
示例：

>>> a = r'abc\tde'
>>> a.expandtabs()
'abc\\tde'
>>> a = 'abc\tde'
>>> a.expandtabs()
'abc     de'
>>> a.expandtabs(16)
'abc             de'

7.find(str, beg = 0, end = len(string)) 与 index(str, beg = 0, end = len(string)，
rfind()，rindex()
find() 在字符串 string 中寻找短字符串 str 的第一次出现的首字符下标。找到则返回下标，否则返回 -1.
因此常用 string.find(str) >= 0 来判断 string 是否包含 str。
index() 方法与find() 类似，只是当 str 不存在时报错。
find(),index()都是从左开始查找的，rfind()，rindex()功能相同，不过是从右侧开始查找的。返回值同样是正序的下标

>>> b
'abc de fg'
>>> b.find('de')
4
>>> d = 'abc ab c'  
>>> d.find('c')    #当有多个 c 同时存在时，从左开始查找，返回第一个找到的下标
2
>>> d.find('*')    #找不到时返回 -1，
-1
>>> d.index('c')
2
>>> d.rfind('c')     #从右开始查找，返回第一个找到的下标
7
>>> d.index('*')    #查找失败
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

8. isalnum()，isalpha()，isdigit()，islower()，isnumeric()，isspace()，istitle()，isupper()，isdecimal()
这几个方法具有类似的表现，都是用来判断字符串的内容的。都要求字符串至少有一个元素。
isalnum() ：当字符串至少有一个字符，且其只有字母和数字是返回 True ，否则 False。
isdigit(), isnumeric() :都是判断只有数字的。
islower(), isupper(): 只对字符串中有大小写区分的字符进行判断，数字等其他符号不影响判断。
istitle() :是与 title() 方法相对应的，判断是否每个单词首字母是否大写，数字等其他符号不影响判断
isspace() :判断是否只为空格。字符串为空时，返回false.
isalpha() :判断是否只为字母。
isdecimal() :检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

>>> d = '*** Ab Cd,*** 123'
>>> d.istitle()
True
>>> a = '1323qwe'
>>> a.islower()
True
>>> a = 'QWE123'
>>> a.isupper()
True

9.join(seq)
这个方法是将 序列seq中的元素按指定分割符分隔组合成一个新的字符串。非常实用。seq可以是列表，元组，字符串。但是列表，元组中不能嵌套列表或者元组。字典不可以。
示例：

>>> t = ['abc', 'de', 'fg']
>>> '##'.join(t)
'abc##de##fg'
>>> a = 'abc de fg'
>>> '##'.join(a)
'a##b##c## ##d##e## ##f##g'
>>> t = ('a', 'b', 'c')
>>> '##'.join(t)
'a##b##c'

>>> dic = {}
>>> dic[1] = 'abc'
>>> dic[2] = 'de'
>>> dic[3] = 'fg'
>>> '##'.join(dic)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sequence item 0: expected str instance, int found
>>> t = [('1', 'a'), ('2', 'b'), ('3', 'c')]
>>> '##'.join(t)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sequence item 0: expected str instance, tuple found
>>> t = ['abc', 'de', 'fg']
>>> tuple = (t,)
>>> '##'.join(tuple)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sequence item 0: expected str instance, list found

10.len()
返回字符串长度。当字符串为空时返回0.
示例：

>>> a = ''
>>> len(a)
0

11.lower()，upper()，swapcase()
对有大小写变化的字符进行转化。
lower() 将所有大写字符转为小写， upper将所有小写字符转为大写。swapcase()则是将字符串中大写转换为小写，小写转换为大写。
示例：

>>> b
'abc de fg'
>>> b.upper()
'ABC DE FG'
>>> b.lower()
'abc de fg'
>>> b.swapcase()
'ABC DE FG'
>>> c = b.upper()
>>> c.swapcase()
'abc de fg'

12.min(string)，max(string)
返回字符串中最小/最大的字符。数字字母按ASCII表排序。中文字符也可以比较大小，应该是按照Unicode编码来比较的。

>>> b
'abc de fg'
>>> min(b)
' '
>>> max(b)
'g'
>>> c = "爱我中华"
>>> min(c)
'中'
>>> max(c)
'爱'

13.replace(old, new [, max])
将字符串中的某个元素替换为指定字符。max表示最大替换次数。
示例：

>>> a = '121213'
>>> a.replace('1', '4')
'424243'
>>> a.replace('1', '4', 2)
'424213'

14.split(str="", num=string.count(str))，rsplit(str="", num=string.count(str))
参数：
str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num – 分割次数。默认为 -1, 即分隔所有。有效最大次数为 str 在 string中出现的次数。
split()从左开始切割，rsplit() 则从又开始切割，这使得一些操作变得很方便。
示例：

>>> e = 'C:\\Users\\hasee\\Pictures\\lovewallpaper'
>>> e.rsplit('\\', 1)      #从右开始切割可以很方便的得到文件夹的路径
['C:\\Users\\hasee\\Pictures', 'lovewallpaper']  
>>> e.split('\\', 1)
['C:', 'Users\\hasee\\Pictures\\lovewallpaper']
>>> e.rsplit('\\')   #默认完全切割
>>> e.rsplit('\\', 6)    #超过最大有效切割次数，超过的次数无效
['C:', 'Users', 'hasee', 'Pictures', 'lovewallpaper']

15.splitlines([keepends])
splitlines() 按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。默认为False。
示例：

>>> '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']

16，translate(table) 与 maketrans(intab, outtab)
translate() 方法根据参数table给出的表(包含 256 个字符)转换字符串的字符,要过滤掉的字符放到 deletechars 参数中。可参考lingedeng的博客。
参数：
table – 翻译表，翻译表是通过 maketrans() 方法转换而来。
deletechars – 字符串中要过滤的字符列表。
maketrans(): 将intab，outtab 组成一个映射。
示例：

intab = "aeiou"
outtab = "12345"
trantab = str.maketrans(intab, outtab)   # 制作翻译表
 
str = "this is string example....wow!!!"
print (str.translate(trantab))

运行结果：

th3s 3s str3ng 2x1mpl2....w4w!!!

总结：最后一组方法还有点乱…

以上是我的学习经验，如果有发现错误的地方，欢迎指出来。