Python字符串详解

字符串介绍

字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。

创建字符串很简单，只要为变量分配一个值即可。例如：

var1 = 'Hello World!'

var2 = "Runoob"

访问字符串中的值

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

Python 访问子字符串，可以使用方括号来截取字符串，如下实例：

//实例(Python 3.0+)
#!/usr/bin/python3
var1 = 'Hello World!'
var2 = "Runoob"

Print("var1:",var1)
print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])
以上实例执行结果：
var1:  Hello World!
var1[0]:  H
var2[1:5]:  unoo

Python的字符串列表有两种取值顺序：

　　正向：从左导右索引默认从0开始，最大范围是字符串长度减1

　　反向：从右到左索引默认从-1开始，最大范围是字符串开头

　　//如果需要取得一段子串，可以使用 变量[头下标 : 尾下标]，就可以截取到相应的字符串。其中下标是从0开始算起的，可以是整数或负数，下标可以为空，表示取到头或尾。

字符串更新

你可以截取字符串的一部分并与其他字段拼接，如下实例：

//实例(Python 3.0+)
str='hello world'
str=str[:6] + 'zhangsan'
print('已更新的字符串str：',str)
//执行结果
已更新的字符串str： hello zhangsan

 转义字符

　注意： 回车的意思是将光标定位到本行开头

字符串运算符

下表实例变量a值为字符串 "Hello"，b变量值为 "Python"：

//实例(Python 3.0+)
#!/usr/bin/python3
a = "Hello"
b = "Python"
print("a + b 输出结果：", a + b)
print("a * 2 输出结果：", a * 2)
print("a[1] 输出结果：", a[1])
print("a[1:4] 输出结果：", a[1:4])
if( "H" in a) :
    print("H 在变量 a 中")
else :
    print("H 不在变量 a 中")
if( "M" not in a) :
    print("M 不在变量 a 中")
else :
    print("M 在变量 a 中") 
print (r'
')
print (R'
')
//以上实例输出结果为：
a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中

字符串格式化

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。

//实例(Python 3.0+)
#!/usr/bin/python3
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
//以上实例输出结果：
我叫 小明 今年 10 岁!

 字符串格式化符号

格式化操作符辅助指令:

Python三引号

python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。实例如下

//实例(Python 3.0+)
#!/usr/bin/python3
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( 	 )。
也可以使用换行符 [ 
 ]。
"""
print (para_str)
以上实例执行结果为：
这是一个多行字符串的实例
多行字符串可以使用制表符
TAB (    )。
也可以使用换行符 [ 
 ]。

字符串转换成字典（eval()）

//代码
arg='''{
    'backend':'www.oldboy.org',
    'record':{
        'server':'100.1.7.9',
        'weight':'20',
        'maxcon':'3'
        }
}'''
print(type(arg))
data=eval(arg)
print(type(data))
print(data['backend'])

//执行结果
<class 'str'>
<class 'dict'>
www.oldboy.org

 Python字符串的内置方法：

Python 的字符串常用内置方法如下：

capitalize() 将字符串的第一个字符转换为大写

//描述
Python capitalize()将字符串的第一个字母变成大写,其他字母变小写。
//语法
capitalize()方法语法：
str.capitalize()
//参数
无。
//返回值
该方法返回一个首字母大写的字符串。
//实例
以下实例展示了capitalize()方法的实例：
#!/usr/bin/python3
str = "this is string example from runoob....wow!!!"

print ("str.capitalize() : ", str.capitalize())
以上实例输出结果如下：
str.capitalize() :  This is string example from runoob....wow!!!

center(width, fillchar) 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。

center() 方法返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
//语法
center()方法语法：
str.center(width[, fillchar])
//参数
width -- 字符串的总宽度。
fillchar -- 填充字符。
//返回值
返回一个指定的宽度 width 居中的字符串，如果 width 小于字符串宽度直接返回字符串，否则使用 fillchar 去填充。
//实例
以下实例展示了center()方法的实例：
#!/usr/bin/python3
str = "[www.runoob.com]"
print ("str.center(40, '*') : ", str.center(40, '*'))
以上实例输出结果如下：
str.center(40, '*') :  ************[www.runoob.com]************

//需要注意的地方：
str.center(width[, fillchar]) 函数：
1、如果 width 小于字符串宽度直接返回字符串，不会截断:
>>> str = "[www.runoob.com]"
>>> print ("str.center(4, '*') : ", str.center(4, '*'))
str.center(4, '*') :  [www.runoob.com]         // width 小于字符串宽度
>>>
2、fillchar 默认是空格
>>> str = "[www.runoob.com]"
>>> print ("str.center(40) : ", str.center(40))
str.center(40) :              [www.runoob.com]   // fillchar默认是空格
3、fillchar 只能是单个字符
>>> str = "[www.runoob.com]"
>>> print ("str.center(40, '?!') : ", str.center(40, '?!'))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: The fill character must be exactly one character long

count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数。

//描述
count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
//语法
count()方法语法：
str.count(sub, start= 0,end=len(string))
//参数
sub -- 搜索的子字符串
start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。
//返回值
该方法返回子字符串在字符串中出现的次数。
//实例
以下实例展示了count()方法的实例：
#!/usr/bin/python3
str="www.runoob.com"
sub='o'
print ("str.count('o') : ", str.count(sub))
sub='run'
print ("str.count('run', 0, 10) : ", str.count(sub,0,10))
以上实例输出结果如下：
str.count('o') :  3
str.count('run', 0, 10) :  1

decode(encoding="utf-8", errors="strict") Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。

//描述
decode() 方法以指定的编码格式解码 bytes 对象。默认编码为 'utf-8'。
//语法
decode()方法语法：
bytes.decode(encoding="utf-8", errors="strict")
//参数
encoding -- 要使用的编码，如"UTF-8"。
errors -- 设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。
//返回值
该方法返回解码后的字符串。
//实例
以下实例展示了decode()方法的实例：
实例(Python 3.0+)
#!/usr/bin/python3
str = "菜鸟教程";
str_utf8 = str.encode("UTF-8")
str_gbk = str.encode("GBK")

print(str)
print("UTF-8 编码：", str_utf8)
print("GBK 编码：", str_gbk) 
print("UTF-8 解码：", str_utf8.decode('UTF-8','strict'))
print("GBK 解码：", str_gbk.decode('GBK','strict'))
以上实例输出结果如下：
菜鸟教程
UTF-8 编码： b'xe8x8fx9cxe9xb8x9fxe6x95x99xe7xa8x8b'
GBK 编码： b'xb2xcbxc4xf1xbdxccxb3xcc'
UTF-8 解码： 菜鸟教程
GBK 解码： 菜鸟教程

encode(encoding='utf-8',errors='strict') 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'。

//描述
encode() 方法以指定的编码格式编码字符串。errors参数可以指定不同的错误处理方案。
//语法
encode()方法语法：
str.encode(encoding='UTF-8',errors='strict')
//参数
encoding -- 要使用的编码，如: UTF-8。
errors -- 设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。
//返回值
该方法返回编码后的字符串，它是一个 bytes 对象。
//实例
以下实例展示了encode()方法的实例：
实例(Python 3.0+)
#!/usr/bin/python3
 
str = "菜鸟教程";
str_utf8 = str.encode("UTF-8")
str_gbk = str.encode("GBK")
 
print(str)
print("UTF-8 编码：", str_utf8)
print("GBK 编码：", str_gbk) 
print("UTF-8 解码：", str_utf8.decode('UTF-8','strict'))
print("GBK 解码：", str_gbk.decode('GBK','strict'))
以上实例输出结果如下：
菜鸟教程
UTF-8 编码： b'xe8x8fx9cxe9xb8x9fxe6x95x99xe7xa8x8b'
GBK 编码： b'xb2xcbxc4xf1xbdxccxb3xcc'
UTF-8 解码： 菜鸟教程
GBK 解码： 菜鸟教程

endswith(suffix, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.

//描述
endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。
//语法
endswith()方法语法：
str.endswith(suffix[, start[, end]])
//参数
suffix -- 该参数可以是一个字符串或者是一个元素。
start -- 字符串中的开始位置。
end -- 字符中结束位置。
//返回值
如果字符串含有指定的后缀返回True，否则返回False。
//实例
以下实例展示了endswith()方法的实例：
#!/usr/bin/python3
Str='Runoob example....wow!!!'
suffix='!!'
print (Str.endswith(suffix))
print(Str.endswith("!!!"))
print (Str.endswith(suffix,20))
suffix='run'
print (Str.endswith(suffix))
print (Str.endswith(suffix, 0, 19))
//以上实例输出结果如下：
True
True
True
False
False

expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。

//描述
expandtabs() 方法把字符串中的 tab 符号('	')转为空格，tab 符号('	')默认的空格数是 8。
//语法
expandtabs()方法语法：
str.expandtabs(tabsize=8)
//参数
tabsize -- 指定转换字符串中的 tab 符号('	')转为空格的字符数。
//返回值
该方法返回字符串中的 tab 符号('	')转为空格后生成的新字符串。
//实例
以下实例展示了expandtabs()方法的实例：
#!/usr/bin/python3
str = "this is 	string example....wow!!!"
print ("原始字符串: " + str)
print ("替换 \t 符号: " + str.expandtabs())
print ("使用16个空格替换 \t 符号: " + str.expandtabs(16))
以上实例输出结果如下：
原始字符串: this is     string example....wow!!!
空格替换 	 符号: this is string example....wow!!!
使用16个空格替换 	 符号: this is         string example....wow!!!

find(str, beg=0 end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1

//描述
find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果指定范围内如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1。
//语法
find()方法语法：
str.find(str, beg=0, end=len(string))
//参数
str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。
//返回值
如果包含子字符串返回开始的索引值，否则返回-1。
//实例
以下实例展示了find()方法的实例：
//实例(Python 3.0+)
#!/usr/bin/python3
str1 = "Runoob example....wow!!!"
str2 = "exam";
print (str1.find(str2))
print (str1.find(str2, 5))
print (str1.find(str2, 10))
以上实例输出结果如下：
7
7
-1
//实例(Python 3.0+)
>>>info = 'abca'
>>> print(info.find('a'))      # 从下标0开始，查找在字符串里第一个出现的子串，返回结果：0
0
>>> print(info.find('a', 1))   # 从下标1开始，查找在字符串里第一个出现的子串：返回结果3
3
>>> print(info.find('3'))      # 查找不到返回-1
-1
>>>

index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在字符串中会报一个异常.

//描述
index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。
//语法
index()方法语法：
str.index(str, beg=0, end=len(string))
//参数
str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。
//返回值
如果包含子字符串返回开始的索引值，否则抛出异常。
//实例
以下实例展示了index()方法的实例：
#!/usr/bin/python3
str1 = "Runoob example....wow!!!"
str2 = "exam";
print (str1.index(str2))
print (str1.index(str2, 5))
print (str1.index(str2, 10))
以上实例输出结果如下(未发现的会出现异常信息)：
7
7
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print (str1.index(str2, 10))
ValueError: substring not found

isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False。

//描述
isalnum() 方法检测字符串是否由字母和数字组成。
//语法
isalnum()方法语法：
str.isalnum()
//参数
无。
//返回值
如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
//实例
以下实例展示了isalnum()方法的实例：
实例(Python 2.0+)
#!/usr/bin/python3
 
str = "runoob2016"  # 字符串没有空格
print (str.isalnum())
str = "www.runoob.com"
print (str.isalnum())
以上实例输出结果如下：
True
False

isalpha() 如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False。

//描述
Python isalpha() 方法检测字符串是否只由字母组成。
//语法
isalpha()方法语法：
str.isalpha()
//参数
无。
//返回值
如果字符串至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
实例
以下实例展示了isalpha()方法的实例：
#!/usr/bin/python3
str = "runoob"
print (str.isalpha())
str = "Runoob example....wow!!!"
print (str.isalpha())
以上实例输出结果如下：
True
False

isdigit() 如果字符串只包含数字则返回 True 否则返回 False.

//描述
Python isdigit() 方法检测字符串是否只由数字组成。
语法
isdigit()方法语法：
str.isdigit()
//参数
无。
//返回值
如果字符串只包含数字则返回 True 否则返回 False。
//实例
以下实例展示了isdigit()方法的实例：

#!/usr/bin/python3
str = "123456"; 
print (str.isdigit())
str = "Runoob example....wow!!!"
print (str.isdigit())
以上实例输出结果如下：
True
False

islower()检测字符串是否由小写字母组成

描述
islower() 方法检测字符串是否由小写字母组成。
语法
islower()方法语法：
str.islower()
参数
无。
返回值
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False

实例
以下实例展示了islower()方法的实例：
#!/usr/bin/python3

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

str = "runoob example....wow!!!"
print (str.islower())
以上实例输出结果如下：
False
True

isspace() 方法检测字符串是否只由空白字符组成

描述
Python isspace() 方法检测字符串是否只由空白字符组成。
语法
isspace() 方法语法：
str.isspace()
参数
无。
返回值
如果字符串中只包含空格，则返回 True，否则返回 False.
实例
以下实例展示了isspace()方法的实例：
实例
#!/usr/bin/python3
str = "       " 
print (str.isspace())
str = "Runoob example....wow!!!"
print (str.isspace())
以上实例输出结果如下：

True
False

isupper() 方法检测字符串中所有的字母是否都为大写

描述
isupper() 方法检测字符串中所有的字母是否都为大写。

语法
isupper()方法语法：
str.isupper()
参数
无。
返回值
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

实例
以下实例展示了isupper()方法的实例：
#!/usr/bin/python3
str = "THIS IS STRING EXAMPLE....WOW!!!"
print (str.isupper())
str = "THIS is string example....wow!!!"
print (str.isupper())
以上实例输出结果如下：
True
False

isidentifier()  判断是否是一个合法的标识符（变量名是否合法）。

//代码
wtf='aj_username'
print(wtf.isidentifier())
//执行结果
True

isprintable() 判断是否可以打印。

对于字符串不需要考虑这个问题，这个一般用在像一些设备文件（Drive file）和tty file上
//代码
wtf='aj_username'
print(wtf.isprintable())
//执行结果
True

istitle() 如果字符串是标题化的(见 title())则返回 True，否则返回 False。

//描述
istitle() 方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。
//语法
istitle()方法语法：
str.istitle()
//参数
无。
//返回值
如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False.
//实例
以下实例展示了istitle()方法的实例：
#!/usr/bin/python3
str = "This Is String Example...Wow!!!"
print (str.istitle())
str = "This is string example....wow!!!"
print (str.istitle())
以上实例输出结果如下：
True
False

join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串。

//描述
Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
//语法
join()方法语法：
str.join(sequence)
//参数
sequence -- 要连接的元素序列。
//返回值
返回通过指定字符(不是数字)连接序列中元素后生成的新字符串。
//实例
以下实例展示了join()的使用方法：
#!/usr/bin/python3
s1 = "-"
s2 = ""
seq = ("r", "u", "n", "o", "o", "b") # 字符串序列
print (s1.join( seq ))
print (s2.join( seq ))
以上实例输出结果如下：
r-u-n-o-o-b
runoob

len(string) 返回字符串长度。

//描述
Python len() 方法返回对象（字符、列表、元组等）长度或项目个数。
//语法
len()方法语法：
len( s )
//参数
s -- 对象。
//返回值
返回对象长度。
//实例
以下实例展示了 len() 的使用方法：
>>>str = "runoob"
>>> len(str)             # 字符串长度
6
>>> l = [1,2,3,4,5]
>>> len(l)               # 列表元素个数
5

ljust(width[, fillchar]) 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。(rjust是返回一个原字符串右对齐)。

//描述
ljust() 方法返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
//语法
ljust()方法语法：
str.ljust(width[, fillchar])
//参数
width -- 指定字符串长度。
fillchar -- 填充字符，默认为空格。
//返回值
返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
//实例
以下实例展示了ljust()的使用方法：
#!/usr/bin/python3
str = "Runoob example....wow!!!"

print (str.ljust(50, '*'))
以上实例输出结果如下：
Runoob example....wow!!!**************************

lower() 转换字符串中所有大写字符为小写.

//描述
Python lower() 方法转换字符串中所有大写字符为小写。
//语法
lower()方法语法：
str.lower()
//参数
无。
//返回值
返回将字符串中所有大写字符转换为小写后生成的字符串。
//实例
以下实例展示了lower()的使用方法：
#!/usr/bin/python3
str = "Runoob EXAMPLE....WOW!!!"
print( str.lower() )
以上实例输出结果如下：
runoob example....wow!!!

lstrip() 截掉字符串左边的空格或指定字符(或者换行符)。

//描述
lstrip() 方法用于截掉字符串左边的空格或指定字符。
//语法
lstrip()方法语法：
str.lstrip([chars])
//参数
chars --指定截取的字符。
//返回值
返回截掉字符串左边的空格或指定字符后生成的新字符串。
//实例1
以下实例展示了lstrip()的使用方法：
#!/usr/bin/python3
str = "     this is string example....wow!!!     ";
print( str.lstrip() );
str = "88888888this is string example....wow!!!8888888";
print( str.lstrip('8') );
以上实例输出结果如下：
this is string example....wow!!!     
this is string example....wow!!!8888888
//实例2
#代码
str='     
   111   zhangsan'
print(str.lstrip() )
print( str.lstrip() )
//执行结果
111   zhangsan
111   zhangsan

replace(old, new [, max]) 把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。

//描述
replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
//语法
replace()方法语法：
str.replace(old, new[, max])
//参数
old -- 将被替换的子字符串。
new -- 新字符串，用于替换old子字符串。
max -- 可选字符串, 替换不超过 max 次
//返回值
返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次。

//实例
以下实例展示了replace()函数的使用方法：
#!/usr/bin/python3
str = "www.w3cschool.cc"
print ("菜鸟教程旧地址：", str)
print ("菜鸟教程新地址：", str.replace("w3cschool.cc", "runoob.com"))
以上实例输出结果如下：
菜鸟教程旧地址： www.w3cschool.cc
菜鸟教程新地址： www.runoob.com
//实例
name='my name is is is is jiangchun'
print(name.replace('is','was',3))
输出结果
my name was was was is jiangchun

rfind(str, beg=0,end=len(string)) 类似于 find()函数。

//描述
Python rfind() 返回搜索的字符串最后一次出现的位置的索引，如果没有匹配项则返回-1。（find是返回搜索的字符串第一次出现的位置的索引）
//语法
rfind()方法语法：
str.rfind(str, beg=0 end=len(string))
/参数
str -- 查找的字符串
beg -- 开始查找的位置，默认为0
end -- 结束查找位置，默认为字符串的长度。
/返回值
返回字符串最后一次出现的位置，如果没有匹配项则返回-1。
//实例
以下实例展示了rfind()函数的使用方法：
#!/usr/bin/python3
str1 = "this is really a string example....wow!!!"
str2 = "is"
print (str1.rfind(str2))

print (str1.rfind(str2, 0, 10))
print (str1.rfind(str2, 10, 0))

print (str1.find(str2))
print (str1.find(str2, 0, 10))
print (str1.find(str2, 10, 0))
以上实例输出结果如下：

5
5
-1
2
2
-1

rindex( str, beg=0, end=len(string)) 类似于 index()，不过是从右边开始.

//描述
rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间。
//语法
rindex()方法语法：
str.rindex(str, beg=0 end=len(string))
//参数
str -- 查找的字符串
beg -- 开始查找的位置，默认为0
end -- 结束查找位置，默认为字符串的长度。
//返回值
返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常。
实例
以下实例展示了rindex()函数的使用方法：
#!/usr/bin/python3
str1 = "this is really a string example....wow!!!"
str2 = "is"
print (str1.rindex(str2))
print (str1.rindex(str2,10))
以上实例输出结果如下：
5
Traceback (most recent call last):
  File "test.py", line 6, in <module>
    print (str1.rindex(str2,10))
ValueError: substring not found

rstrip() 删除 string 字符串末尾的指定字符（默认为空格）。

//描述
rstrip() 删除 string 字符串末尾的指定字符（默认为空格）.
//语法
rstrip()方法语法：
str.rstrip([chars])
//参数
chars -- 指定删除的字符（默认为空格）
//返回值
返回删除 string 字符串末尾的指定字符后生成的新字符串。
//实例
以下实例展示了rstrip()函数的使用方法：
#!/usr/bin/python3
str = "     this is string example....wow!!!     "
print (str.rstrip())
str = "*****this is string example....wow!!!*****"
print (str.rstrip('*'))
以上实例输出结果如下：
     this is string example....wow!!!
*****this is string example....wow!!!

split(str="", num=string.count(str)) num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个子字符串。

//描述
split()通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串
//语法
split()方法语法：
str.split(str="", num=string.count(str))
//参数
str -- 分隔符，默认为所有的空字符，包括空格、换行(
)、制表符(	)等。
num -- 分割次数。
//返回值
返回分割后的字符串列表。
//实例
以下实例展示了split()函数的使用方法：
#!/usr/bin/python3
str = "this is string example....wow!!!"
print (str.split( ))
print (str.split('i',1))
print (str.split('w'))
以上实例输出结果如下：
['this', 'is', 'string', 'example....wow!!!']
['th', 's is string example....wow!!!']
['this is string example....', 'o', '!!!']

rsplit方法

# 描述
rsplit() 方法通过指定分隔符对字符串进行分割并返回一个列表，默认分隔符为所有空字符，包括空格、换行(
)、制表符(	)等。类似于 split() 方法，只不过是从字符串最后面开始分割。

# 语法
rsplit() 方法语法：
S.rsplit([sep=None][,count=S.count(sep)])

# 参数
sep -- 可选参数，指定的分隔符，默认为所有的空字符，包括空格、换行(
)、制表符(	)等。
count -- 可选参数，分割次数，默认为分隔符在字符串中出现的总次数。
返回分割后的字符串列表。

splitlines([keepends]) 按照行(' ', ' ', ')分隔，返回一个包含各行作为元素的列表，(不同系统上换行符不一样)。

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

//语法
splitlines()方法语法：
str.splitlines([keepends])
//参数
keepends -- 在输出结果里是否去掉换行符('
', '
', 
')，默认为 False，不包含换行符，如果为 True，则保留换行符。
//返回值
返回一个包含各行作为元素的列表。
//实例
以下实例展示了splitlines()函数的使用方法：
>>> 'ab c

de fg
kl
'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c

de fg
kl
'.splitlines(True)
['ab c
', '
', 'de fg
', 'kl
']
>>>

strip([chars]) 在字符串上执行 lstrip()和 rstrip()。

//代码1
str='     
   111   zhangsan    111   
      '
print(str.strip() )
print( str.strip() )
执行结果
111   zhangsan    111
111   zhangsan    111

//代码2：
msg="</?abc=+"
res=msg.strip("*+=/?<")
print(res)
//执行结果
abc

maketrans() 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

//描述
maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

注：Python3.4已经没有string.maketrans()了，取而代之的是内建函数: bytearray.maketrans()、bytes.maketrans()、str.maketrans()
//语法
maketrans()方法语法：
str.maketrans(intab, outtab)
//参数
intab -- 字符串中要替代的字符组成的字符串。
outtab -- 相应的映射字符的字符串。
注意：
两个字符串的长度必须相同，为一一对应的关系。
//返回值
返回字符串转换后生成的新字符串。
//实例
以下实例展示了使用maketrans() 方法将所有元音字母转换为指定的数字：

#!/usr/bin/python3
intab = "aeiou"
outtab = "12345"
trantab = str.maketrans(intab, outtab)   # 制作翻译表
str = "this is string example....wow!!!"
print (str.translate(trantab))
以上实例输出结果如下：
th3s 3s str3ng 2x1mpl2....w4w!!!

translate(table, deletechars="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中

//描述
translate() 方法根据参数table给出的表(包含 256 个字符)转换字符串的字符,要过滤掉的字符放到 deletechars 参数中。
//语法
translate()方法语法：
str.translate(table)
bytes.translate(table[, delete])    
bytearray.translate(table[, delete]) 
//参数
table -- 翻译表，翻译表是通过 maketrans() 方法转换而来。
deletechars -- 字符串中要过滤的字符列表。
//返回值
返回翻译后的字符串,若给出了 delete 参数，则将原来的bytes中的属于delete的字符删除，剩下的字符要按照table中给出的映射来进行映射 。
//实例
以下实例展示了 translate() 函数的使用方法：
实例(Python 3.0+)
#!/usr/bin/python3
intab = "aeiou"
outtab = "12345"
trantab = str.maketrans(intab, outtab)   # 制作翻译表
str = "this is string example....wow!!!"
print (str.translate(trantab))以上实例输出结果如下：
th3s 3s str3ng 2x1mpl2....w4w!!!
//以下实例演示如何过滤掉的字符 o：
实例(Python 3.0+)
#!/usr/bin/python
# 制作翻译表
bytes_tabtrans = bytes.maketrans(b'abcdefghijklmnopqrstuvwxyz', b'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
# 转换为大写，并删除字母o
print(b'runoob'.translate(bytes_tabtrans, b'o'))
以上实例输出结果：
b'RUNB'

title() 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())

//描述
Python title() 方法返回"标题化"的字符串,就是说所有单词的首个字母转化为大写，其余字母均为小写(见 istitle())。
//语法
title()方法语法：
str.title();
//参数
NA。
//返回值
返回"标题化"的字符串,就是说所有单词的首字母都转化为大写。
//实例
以下实例展示了 title()函数的使用方法：
//实例(Python 3.0+)
#!/usr/bin/python3
str = "this is string example from runoob....wow!!!"
print (str.title())
以上实例输出结果如下：
This Is String Example From Runoob....Wow!!!
请注意，非字母后的第一个字母将转换为大写字母：
//实例(Python 3.0+)
#!/usr/bin/python3
txt = "hello b2b2b2 and 3g3g3g"
x = txt.title()
print(x)
输出结果为：

Hello B2B2B2 And 3G3G3G

upper() 转换字符串中的小写字母为大写

//描述
Python upper() 方法将字符串中的小写字母转为大写字母。
//语法
upper()方法语法：
str.upper()
//参数
NA。
//返回值
返回小写字母转为大写字母的字符串。
//实例
以下实例展示了 upper()函数的使用方法：
#!/usr/bin/python3
str = "this is string example from runoob....wow!!!";
print ("str.upper() : ", str.upper())
以上实例输出结果如下：
str.upper() :  THIS IS STRING EXAMPLE FROM RUNOOB....WOW!!!

startswith(str, beg=0,end=len(string)) 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。

//描述
startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。

//语法
startswith()方法语法：
str.startswith(str, beg=0,end=len(string));
//参数
str -- 检测的字符串。
strbeg -- 可选参数用于设置字符串检测的起始位置。
strend -- 可选参数用于设置字符串检测的结束位置。
//返回值
如果检测到字符串则返回True，否则返回False。
//实例
以下实例展示了startswith()函数的使用方法：
#!/usr/bin/python3
str = "this is string example....wow!!!"
print (str.startswith( 'this' ))
print (str.startswith( 'string', 8 ))
print (str.startswith( 'this', 2, 4 ))
以上实例输出结果如下：
True
True
False

swapcase() 将字符串中大写转换为小写，小写转换为大写

//描述
swapcase() 方法用于对字符串的大小写字母进行转换。
//语法
swapcase()方法语法：
str.swapcase();
//参数
NA。
//返回值
返回大小写字母转换后生成的新字符串。
//实例
以下实例展示了swapcase()函数的使用方法：
#!/usr/bin/python3
str = "this is string example....wow!!!"
print (str.swapcase())
str = "This Is String Example....WOW!!!"
print (str.swapcase())
以上实例输出结果如下：
THIS IS STRING EXAMPLE....WOW!!!
tHIS iS sTRING eXAMPLE....wow!!!

zfill (width) 返回长度为 width 的字符串，原字符串右对齐，前面填充0

//描述
Python zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0。
//语法
zfill()方法语法：
str.zfill(width)
//参数
width -- 指定字符串的长度。原字符串右对齐，前面填充0。
//返回值
返回指定长度的字符串。

//实例
以下实例展示了 zfill()函数的使用方法：
#!/usr/bin/python3
str = "this is string example from runoob....wow!!!"
print ("str.zfill : ",str.zfill(40))
print ("str.zfill : ",str.zfill(50))
以上实例输出结果如下：
str.zfill :  this is string example from runoob....wow!!!
str.zfill :  000000this is string example from runoob....wow!!!

万恶的字符串拼接：

python中的字符串在C语言中体现为是一个字符数组，每次创建字符串时候需要在内存中开辟一块连续的空，并且一旦需要修改字符串的话，就需要再次开辟空间，万恶的+号每出现一次就会在内从中重新开辟一块空间。

字符串格式化输出

name = "alex"
print "i am %s " % name
  
#输出: i am alex
PS: 字符串是 %s;整数 %d;浮点数%f

字符串常用功能：

移除空白

分割

长度

索引

切片