参考：Python 字符串函数
| 01 | capitalize | 把字符串的第一个字符大写，其他字母变小写。 | |
| 02 | center | 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串。默认填充字符为空格。 | |
| 03 | count | 用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。 | |
| 04 | endswith | 用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。 | |
| 05 | startswith | 用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。 | |
| 06 | expandtabs | 把字符串中的 tab 符号(' ')转为空格，tab 符号(' ')默认的空格数是 8。 | |
| 07 | find | 检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。 | |
| 08 | format | 增强了字符串格式化的功能。format 函数可以接受不限个参数，位置可以不按顺序。 | |
| 09 | 该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。 | ||
| 10 | ljust rjust |
返回一个原字符串左对齐，并使用空格填充至长度 width 的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。 | |
| 11 | lstrip rstrip |
用于截掉字符串左边的空格或指定字符。 | |
| 12 | zfill | 返回指定长度的字符串，原字符串右对齐，前面填充0。 | |
| 13 | partition rpartition |
用来根据指定的分隔符将字符串进行分割。如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。 | |
| 14 | replace | 把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。 | |
| 15 | split | 通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串。 | |
| 16 | splitlines | 按照行(' ', ' ', ')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 | |
| 17 | encode | 将 Unicode 对象转为字符串。 | |
| 18 | decode | 将字符串转为 Unicode 对象。对于有些函数的使用只针对于 Unicode 对象。 | |
| 19 | isalnum | 如果 string 中只包含数字字符，则返回 True，否则返回 False。 | |
| 20 | isalpha | 如果 string 至少有一个字符并且所有字符都是字母则返回 True，否则返回 False。 | |
| 21 | isdecimal | 如果 string 只包含十进制数字则返回 True 否则返回 False。 | |
| 22 | isdigit | 如果 string 只包含数字则返回 True 否则返回 False。 | |
| 23 | isnumeric | 如果 string 中只包含数字字符，则返回 True，否则返回 False。 | |
| 24 | islower isupper |
如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False。 | |
| 25 | lower upper |
转换 string 中所有字符为小写。 | |
| 26 | swapcase | 用于对字符串的大小写字母进行转换。 | |
| 27 | title | 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())。 | |
| 28 | istitle | Python istitle() 方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。 | |
| 29 | isspace | 如果 string 中只包含空格，则返回 True，否则返回 False。 | |
| 30 | isupper | 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False | |
| 31 | join | 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串。 | |
| 32 | isinstance | 判断一个对象是否是一个已知的类型，类似 type()。 | |
| 33 | type | 如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。 | |
| -------- |
---- |
----------------------------------------------------------------------------------------------------- |
| 序号 | 类名称 |
功能说明 |
语法 & 举例 | ||
| 01 | capitalize |
把字符串的第一个字符大写，其他字母变小写。 ====<<<< Syntax >>>>==== str.capitalize () |
>>> a = "ALEX"
>>> b = a.capitalize()
>>> b
'Alex'
|
||
| 02 | center |
返回一个原字符串居中,并使用空格填充至长度 width 的新字符串。默认填充字符为空格。 ====<<<< Syntax >>>>==== str.center (width[, fillchar]) ====<<<< Parameters >>>>==== ◈ width：字符串的总宽度。 |
>>> a = "ALEX"
>>> b = a.center(10)
>>> c = a.center(10, '-')
>>> b
' ALEX '
>>> c
'---ALEX---'
|
||
| 03 | count |
用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。 ====<<<< Syntax >>>>==== str.count (sub, start= 0,end=len(string)) ====<<<< Parameters >>>>==== ◈ sub：搜索的子字符串。 |
>>> a = "alex--alex--alex"
>>> print a.count('alex')
3
>>> print a.count('alex', 1)
2
>>> print a.count('alex', 6, 10)
1
|
||
| 04 | endswith |
用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。 ====<<<< Syntax >>>>==== str.endswith (suffix[, start[, end]]) ====<<<< Parameters >>>>==== ◈ suffix：该参数可以是一个字符串或者是一个元素。 |
>>> a = "alex--alex--alex"
>>> print a.endswith('alex')
True
>>> print a.endswith('alex', 6, 10)
True
|
||
| 05 | startswith |
用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。 ====<<<< Syntax >>>>==== str.startswith (str, beg=0,end=len(string)) ====<<<< Parameters >>>>==== ◈ str：检测的字符串。 |
>>> a = "alex lee"
>>> print a.startswith("alex")
True
>>> print a.startswith("alex", 2)
False
|
||
| 06 | expandtabs |
把字符串中的 tab 符号(' ')转为空格，tab 符号(' ')默认的空格数是 8。 ====<<<< Syntax >>>>==== str.expandtabs (tabsize=8) ====<<<< Parameters >>>>==== ◈ tabsize：指定转换字符串中的 tab 符号(' ')转为空格的字符数。 |
>>> a = " alex alex lee "
>>> print a
alex alex lee
>>> print a.expandtabs()
alex alex lee
>>> print a.expandtabs(1)
alex alex lee
|
||
| 07 | find rfind |
检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。 ====<<<< Syntax >>>>==== str.find (str, beg=0, end=len(string)) ====<<<< Parameters >>>>==== ◈ str：指定检索的字符串。 |
>>> a = "alex--alex--alex"
>>> print a.find("alex")
0
>>> print a.find("alex", 1, 5)
-1
>>> print a.find("alex", 2)
6
>>> print a.rfind("aa")
8
>>> print a.rfind("aa", 0, 7)
4
|
||
| 08 | format |
增强了字符串格式化的功能。format 函数可以接受不限个参数，位置可以不按顺序。 ====<<<< Syntax >>>>==== str.format () ====<<<< Parameters >>>>==== ◈ f：浮点数据
|
>>> # 不设置指定位置，按默认顺序
>>> print "{}-{}".format("Alex", "Lee")
Alex-Lee
>>> # 设置指定位置
>>> print "{0}-{1}".format("Alex", "Lee")
Alex-Lee
>>> print "{0}-{1}-{0}".format("Alex", "Lee")
Alex-Lee-Alex
>>> # 设置参数
>>> print "{name}-{surname}".format(name="Alex", surname="Lee")
Alex-Lee
>>> # 通过列表索引设置参数
>>> print "{0[0]}-{0[1]}-{0[2]}-{0[3]}".format("alex")
a-l-e-x
>>> # 保留小数点后两位
>>> print "{:.2f}".format(3.1415926)
3.14
>>> # 带符号保留小数点后两位
>>> print "{:+.2f}".format(3.1415926)
+3.14
>>> # 不带小数
>>> print "{:.0f}".format(3.1415926)
3
>>> # 数字补零 (填充左边, 宽度为2)
>>> print "{:0>2d}".format(5)
05
>>> print "{:0>3d}".format(5)
005
>>> # 数字补x (填充左边, 宽度为4)
>>> print "{:x>4d}".format(5)
xxx5
>>> # 其他字符
>>> print "{:->4d}".format(5)
---5
>>> print "{:0<3d}".format(5)
500
>>> print "{:x<3d}".format(5)
5xx
>>> print "{:*<3d}".format(5)
5**
>>> # 以逗号分隔的数字格式
>>> print "{:,}".format(1000000)
1,000,000
>>> # 百分比格式
>>> print "{:%}".format(0.25)
25.000000%
>>> print "{:.2%}".format(0.25)
25.00%
>>> # 指数记法
>>> print "{:.2e}".format(1000000000000)
1.00e+12
>>> # 右对齐 (默认, 宽度为10)
>>> print "{:10d}".format(13)
13
>>> # 左对齐 (宽度为10)
>>> print "{:<10d}|".format(13)
13 |
>>> # 中间对齐 (宽度为10)
>>> print "{:^10d}|".format(13)
13 |
|
||
| 09 | index rindex |
||||
| 10 | ljust rjust |
返回一个原字符串左对齐，并使用空格填充至长度 width 的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。 ====<<<< Syntax >>>>==== str.ljust (width[, fillchar]) ====<<<< Parameters >>>>====
◈ width：字符串的总宽度。 |
>>> "alex".ljust(10)
'alex '
>>> "alex".ljust(10,'-')
'alex------'
|
||
| 11 |
用于截掉字符串左边的空格或指定字符。 ====<<<< Syntax >>>>==== str.lstrip ([chars]) ====<<<< Parameters >>>>==== ◈ chars：指定截取的字符。 |
>>> a = " alex lee "
>>> a.lstrip()
'alex lee '
>>> a.rstrip()
' alex lee'
>>> b = "----alex--------"
>>> b.lstrip('-')
'alex--------'
>>> b.rstrip("-")
'----alex'
|
|||
| 12 |
返回指定长度的字符串，原字符串右对齐，前面填充0。 ====<<<< Syntax >>>>==== str.zfill (width) ====<<<< Parameters >>>>====
◈ width：指定字符串的长度。原字符串右对齐，前面填充0。 |
>>> for i in range(1, 20, 5):
... print str(i).zfill(2)
...
01
06
11
16
|
|||
| 13 |
用来根据指定的分隔符将字符串进行分割。如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。 ====<<<< Syntax >>>>==== str.partition (str) ====<<<< Parameters >>>>==== ◈ str：指定的分隔符。 |
>>> a = "alex/bn/lee"
>>> a.partition("/")
('alex', '/', 'bn/lee')
>>> a.rpartition("/")
('alex/bn', '/', 'lee')
>>> site = "http://www.baidu.com"
>>> site.partition("://")
('http', '://', 'www.baidu.com')
|
|||
| 14 |
把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。 ====<<<< Syntax >>>>==== str.replace (old, new[, max]) ====<<<< Parameters >>>>====
◈ old：将被替换的子字符串。 |
>>> a = "aa--aa--aa--aa"
>>> a.replace("aa", "bb")
'bb--bb--bb--bb'
>>> a.replace("aa", "bb", 3)
'bb--bb--bb--aa'
|
|||
| 15 |
通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串。 ====<<<< Syntax >>>>==== str.split (str="", num=string.count(str)) ====<<<< Parameters >>>>==== ◈ str：分隔符，默认为所有的空字符，包括空格、换行(
)、制表符( )等。 |
>>> a = "Line1:abcd
Line2:efg
Line3:mn"
>>> print a
Line1:abcd
Line2:efg
Line3:mn
>>> print a.split()
['Line1:abcd', 'Line2:efg', 'Line3:mn']
>>> b = "a,b,c,d,e,f,g"
>>> print b.split(',')
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> print b.split(',', 3)
['a', 'b', 'c', 'd,e,f,g']
>>> b = "a,-b,-c,-d,-e,-f,-g"
|
|||
| 16 |
按照行('
', '
',
')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 ====<<<< Syntax >>>>==== str.splitlines ([keepends]) ====<<<< Parameters >>>>====
◈ keepends：在输出结果里是否去掉换行符('
', '
',
')，默认为 False，不包含换行符，如果为 True，则保留换行符。 |
>>> a = "Line1:abcd
Line2:efg
Line3:mn"
>>> print a.splitlines()
['Line1:abcd', 'Line2:efg', 'Line3:mn']
>>> print a.splitlines(True)
['Line1:abcd
', 'Line2:efg
', 'Line3:mn']
|
|||
| 17 | encode |
将 Unicode 对象转为字符串。 ====<<<< Syntax >>>>==== str.encode () |
>>> a = "alex"
>>> a
'alex'
>>> a.decode()
u'alex'
>>> b = a.decode()
>>> b
u'alex'
>>> b.encode()
'alex'
|
||
| 18 | decode |
将字符串转为 Unicode 对象。对于有些函数的使用只针对于 Unicode 对象。 ====<<<< Syntax >>>>==== str.decode () |
|||
| 19 | isalnum |
如果 string 中只包含数字字符，则返回 True，否则返回 False。 = is-alphabet-number ====<<<< Syntax >>>>==== str.isalnum () |
>>> print "alex-lee".isalnum()
False
>>> print "start100".isalnum()
True
|
||
| 20 | isalpha |
如果 string 至少有一个字符并且所有字符都是字母则返回 True，否则返回 False。 = is-alphabet ====<<<< Syntax >>>>==== str.isalpha () |
>>> print "alex lee".isalpha()
False
>>> print "alex".isalpha()
True
|
||
| 21 | isdecimal |
如果 string 只包含十进制数字则返回 True 否则返回 False。 注意：定义一个十进制字符串，只需要在字符串前添加 'u' 前缀即可。这种方法是只针对unicode对象。 = is-decimal ====<<<< Syntax >>>>==== str.isdecimal () |
>>> a = "33.33"
>>> b = a.decode()
>>> b
u'33.33'
>>> b.isdecimal()
False
|
||
| 22 | isdigit |
如果 string 只包含数字则返回 True 否则返回 False。 = is-digit ====<<<< Syntax >>>>==== str.isdigit () |
>>> print "33.33".isdigit()
False
>>> print "3333".isdigit()
True
|
||
| 23 | isnumeric |
如果 string 中只包含数字字符，则返回 True，否则返回 False。 注意：定义一个十进制字符串，只需要在字符串前添加 'u' 前缀即可。这种方法是只针对unicode对象。 = is-numeric ====<<<< Syntax >>>>==== str.isnumeric () |
>>> a = "33.33"
>>> b = a.decode()
>>> b
u'33.33'
>>> print b.isnumeric()
False
>>> print ("33".decode()).isnumeric()
True
|
||
| 24 | islower isupper |
如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False。 = is-lower-alphabet ====<<<< Syntax >>>>==== str.islower () |
>>> print "alex-lee".islower()
True
>>> print "alex-1".islower()
True
>>> print "Alex".islower()
False
|
||
| 25 | lower upper |
转换 string 中所有字符为小写。 str.lower () |
>>> print "Alex".lower()
alex
>>> print "Alex".upper()
ALEX
|
||
| 26 | swapcase |
用于对字符串的大小写字母进行转换。 ====<<<< Syntax >>>>==== str.swapcase () |
>>> a = "Alex Lee"
>>> print a.swapcase()
aLEX lEE
|
||
| 27 | title |
返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())。 ====<<<< Syntax >>>>==== str.title () |
>>> a = "i am a good boy"
>>> print a.title()
I Am A Good Boy
|
||
| 28 | istitle |
Python istitle() 方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。 = is-title ====<<<< Syntax >>>>==== str.istitle () |
>>> print "Alex Lee".istitle()
True
>>> print "Alex is Good".istitle()
False
|
||
| 29 | isspace |
如果 string 中只包含空格，则返回 True，否则返回 False。 ====<<<< Syntax >>>>==== str.isspace () |
>>> print " ".isspace()
True
>>> print "alex lee".isspace()
False
|
||
| 30 | isupper |
如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False ====<<<< Syntax >>>>==== str.isupper () |
|||
| 31 | join |
以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串。 ====<<<< Syntax >>>>==== str.join (seq) ====<<<< Parameters >>>>==== ◈ seq：要连接的元素序列。 |
>>> s = "-"
>>> seq = ["a", "b", "c"]
>>> print s.join(seq)
a-b-c
|
||
| 32 | isinstance |
判断一个对象是否是一个已知的类型，类似 type()。 ====<<<< Syntax >>>>==== isinstance (object, classinfo) ====<<<< Parameters >>>>==== ◈ seq：实例对象。 |
>>> a = 2 >>> isinstance(a, int) True >>> # 是元组中的一个返回 True >>> isinstance (a,(str,int,list)) True >>> b = "中国" >>> isinstance(b, unicode) False |
||
| 33 | type |
如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。 isinstance() 与 type() 区别： ====<<<< Syntax >>>>==== class type (name, bases, dict) ====<<<< Parameters >>>>====
◈ name：类的名称。 |
>>> type(1)
<type 'int'>
>>> type('alex')
<type 'str'>
>>> type('中国')
<type 'str'>
>>> type([2,3])
<type 'list'>
>>> # 判断类型是否相等
>>> x = 1
>>> type( x ) == int
True
|
||
| ------ |
----- |
------------------------------------------------------- |
---------------------------------------------------------------------------------- |
| Num | Function | Syntax | Description |
|
01 |
capitalize |
把字符串的第一个字符大写 |
|
|
02 |
center |
返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 |
|
|
03 |
count |
返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
|
|
04 |
decode |
以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 'ignore' 或 者'replace' |
|
|
05 |
encode |
以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace' |
|
|
06 |
endswith |
检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. |
|
|
07 |
expandtabs |
把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。 |
|
|
08 |
find |
检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 |
|
|
09 |
format |
格式化字符串 |
|
|
10 |
index |
跟find()方法一样，只不过如果str不在 string中会报一个异常. |
|
| 11 | isalnum |
如果 string 至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False |
|
|
12 |
isalpha |
如果 string 至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False |
|
|
13 |
isdecimal |
如果 string 只包含十进制数字则返回 True 否则返回 False. |
|
|
14 |
isdigit |
如果 string 只包含数字则返回 True 否则返回 False. |
|
|
15 |
islower |
如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
|
|
16 |
isnumeric |
如果 string 中只包含数字字符，则返回 True，否则返回 False |
|
|
17 |
isspace |
如果 string 中只包含空格，则返回 True，否则返回 False. |
|
|
18 |
istitle |
如果 string 是标题化的(见 title())则返回 True，否则返回 False |
|
|
19 |
isupper |
如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
|
|
20 |
join |
以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
|
|
21 |
ljust |
返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 |
|
|
22 |
lower |
转换 string 中所有大写字符为小写. |
|
|
23 |
lstrip |
截掉 string 左边的空格 |
|
|
24 |
maketrans |
maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 |
|
|
25 |
max |
返回字符串 str 中最大的字母。 |
|
|
26 |
min |
返回字符串 str 中最小的字母。 |
|
|
27 |
partition |
有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string. |
|
|
28 |
replace |
把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. |
|
|
29 |
rfind |
类似于 find()函数，不过是从右边开始查找. |
|
|
30 |
rindex |
类似于 index()，不过是从右边开始. |
|
|
31 |
rjust |
返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 |
|
|
32 |
rpartition |
string.rpartition(str) |
类似于 partition()函数,不过是从右边开始查找. |
|
33 |
rstrip |
删除 string 字符串末尾的空格. |
|
|
34 |
split |
以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串 |
|
|
35 |
splitlines |
按照行(' ', ' ', ')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 |
|
|
36 |
startswith |
检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查. |
|
|
37 |
strip |
在 string 上执行 lstrip()和 rstrip() |
|
|
38 |
swapcase |
翻转 string 中的大小写 |
|
|
39 |
title |
返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) |
|
|
40 |
translate |
根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 del 参数中 |
|
|
41 |
upper |
转换 string 中的小写字母为大写 |
|
| 42 | zfill |
返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0 |
|
|
43 |
isdecimal |
isdecimal()方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。 |