python字符串、字符串处理函数及字符串相关操作
python字符串、字符串处理函数及字符串相关操作
字符串介绍
python字符串表⽰
Python除处理数字外还可以处理字符串，字符串⽤单撇号或双撇号包裹：
>>> 'spam eggs'
'spam eggs'
>>> 'doesn/'t'
"doesn't"
>>> "doesn't"
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "/"Yes,/" he said."
'"Yes," he said.'
>>> '"Isn/'t," she said.'
'"Isn/'t," she said.'
字符串输出格式与输⼊的样⼦相同，都是⽤撇号包裹，撇号和其它特殊字符⽤⽤反斜杠转义。如果字符串中有单撇号⽽没有双撇号则⽤双撇号包裹，否则应该⽤单撇号包裹。后
⾯要介绍的print语句可以不带撇号或转义输出字符串。
多⾏的长字符串也可以⽤⾏尾反斜杠续⾏，续⾏的⾏⾸空⽩不被忽略，如
hello = "This is a rather long string containing/n several lines of text just as you would do in C./n Note that whitespace at the beginning of the line is significant./n" print hello
结果为
This is a rather long string containing
several lines of text just as you would do in C.
Note that whitespace at the beginning of the line is significant.
对于特别长的字符串（⽐如包含说明的⼏段⽂字），如果⽤上⾯的⽅式每⾏都⽤/n/结尾是很⿇烦的，特别是这样⽆法⽤象Emacs这样的功能强⼤的编辑器重新编排。对这种情
况，可以使⽤三重撇号，例如
hello = """
This string is bounded by triple double quotes (3 times ").
Unescaped newlines in the string are retained, though it is still possible/nto use all normal escape sequences.
Whitespace at the beginning of a line is
significant. If you need to include three opening quotes
you have to escape at least one of them, e.g. /""".
This string ends in a newline.
"""
三重撇号字符串也可以⽤三个单撇号，没有任何语义差别。
多⾏的字符串常量可以直接连接起来，字符串常量之间⽤空格分隔则在编译时可以⾃动连接起来，这样可以把⼀个长字符串连接起来⽽不需要牺牲缩进对齐或性能，不象⽤加号
连接需要运算，也不象字符串串内的换⾏其⾏⾸空格需要保持。
字符串连接和重复
字符串可以⽤+号连接起来，⽤*号重复：
>>> word = 'Help' + 'A'
>>> word
'HelpA'
>>> '<' + word*5 + '>'
'<HelpAHelpAHelpAHelpAHelpA>'
字符串连接的⼏种不同⽅式
def concat1():
z = x + y
return z
def concat2():
z = "%s%s" % (x, y)
return z
def concat3():
z = "{}{}".format(x, y)
return z
def concat4():
z = "{0}{1}".format(x, y)
return z
[]
字符串索引
字符串可以象在C中那样⽤下标索引，字符串的第⼀个字符下标为0。
Python没有单独的字符数据类型，⼀个字符就是长度为⼀的字符串。象在Icon语⾔中那样，可以⽤⽚段(slice)记号来指定⼦串，⽚段即⽤冒号隔开的两个下标。
>>> word[4]
'A'
>>> word[0:2]
'He'
>>> word[2:4]
'lp'
⽚段有很好的缺省值：第⼀下标省略时缺省为零，第⼆下标省略时缺省为字符串的长度。
>>> word[:2] # 前两个字符
'He'
>>> word[2:] # 除前两个字符串外的部分
'lpA'
注意s[:i] + s[i:] 等于 s 是⽚段运算的⼀个有⽤的恒等式。
>>> word[:2] + word[2:]
'HelpA'
>>> word[:3] + word[3:]
'HelpA'
不合理的⽚段下标可以很好地得到解释：过⼤的下标被换成字符串长度，上界⼩于下界时返回空串。
>>> word[1:100]
'elpA'
>>> word[10:]
''
>>> word[2:1]
''
下标允许为负数，这时从右向左数。例如：
>>> word[-1] # 最后⼀个字符
'A'
>>> word[-2] # 倒数第⼆个字符
'p'
>>> word[-2:] # 最后两个字符
'pA'
>>> word[:-2] # 除最后两个字符外的部分
'Hel'
但要注意的是 -0 实际还是 0，所以它不会从右向左数！
>>> word[-0] # (因为 -0 等于 0)
'H'
超出范围的⽚段下标被截断，但在⾮⽚段的情况下不要这样：
>>> word[-100:]
'HelpA'
>>> word[-10] # 错误
Traceback (innermost last):
File "<stdin>", line 1
IndexError: string index out of range
记住⽚段意义的最好⽅法是把下标看成是字符之间的点，第⼀个字符的左边界号码为0。有n个字符的字符串的最后⼀个字符的右边界下标为n，例如：
+---+---+---+---+---+
| H | e | l | p | A |
+---+---+---+---+---+
0 1 2 3 4 5
-5 -4 -3 -2 -1
第⼀⾏数字给出字符串中下标0到5的位置，第⼆⾏给出相应的负下标。从i到j的⽚段由在边界i和j之间的字符组成。
对于⾮负下标，如果下标都在界内，则⽚段的长度为下标的差。例如，word[1:3] 的长度为 2。
字符串的分⽚
定义⼀个字符串以后，我们可以截取其中的任意部分形成新串。这种操作被称作字符串的分⽚(slice)。字符串分⽚跟列表的分⽚(slicing lists)原理是⼀样的，从直观上也说得通，因为字符串本⾝就是⼀些字符序列。
>>> a_string = "My alphabet starts where your alphabet ends."
>>> a_string[3:11]
"alphabet"
>>> a_string[3:-3]
"alphabet starts where your alphabet en"
>>> a_string[0:2]
"My"
>>> a_string[:18]
"My alphabet starts"
>>> a_string[18:]
" where your alphabet ends."
1. 我们可以通过指定两个索引值来获得原字符串的⼀个slice。该操作的返回值是⼀个新串，依次包含了从原串中第⼀个索引位置开始，直到但是不包含第⼆个索引位置之间
的所有字符。
2. 就像给列表做分⽚⼀样，我们也可以使⽤负的索引值来分⽚字符串。
3. 字符串的下标索引是从0开始的，所以a_string[0:2]会返回原字符串的前两个元素，从a_string[0]开始，直到但不包括a_string[2]。
4. 如果省略了第⼀个索引值，Python会默认它的值为0。所以a_string[:18]跟a_string[0:18]的效果是⼀样的，因为从0开始是被Python默认的。
5. 同样地，如果第2个索引值是原字符串的长度，那么我们也可以省略它。所以，在此处a_string[18:]跟a_string[18:44]的结果是⼀样的，因为这个串的刚好有44个字符。这种
规则存在某种有趣的对称性。在这个由44个字符组成的串中，a_string[:18]会返回前18个字符，⽽a_string[18:]则会返回除了前18个字符以外字符串的剩余部分。事实上a_string[:n]总是会返回串的前n个字符，⽽a_string[n:]则会返回其余的部分，这与串的长度⽆关。
字符串长度
内置函数len()返回字符串的长度：
>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34
Python内置的字符串处理函数
python字符串⼦串
python没有substring函数，因为直接使⽤str[start:end]就可以啦。
字母处理
全部⼤写：str.upper()
全部⼩写：str.lower()
⼤⼩写互换：str.swapcase()
⾸字母⼤写，其余⼩写：str.capitalize()
⾸字母⼤写：str.title()
print '%s lower=%s' % (str,str.lower())
print '%s upper=%s' % (str,str.upper())
print '%s swapcase=%s' % (str,str.swapcase())
print '%s capitalize=%s' % (str,str.capitalize())
print '%s title=%s' % (str,str.title())
格式化相关
获取固定长度，右对齐，左边不够⽤空格补齐：str.ljust(width)
获取固定长度，左对齐，右边不够⽤空格补齐：str.ljust(width)
获取固定长度，中间对齐，两边不够⽤空格补齐：str.ljust(width)
获取固定长度，右对齐，左边不⾜⽤0补齐
print '%s ljust=%s' % (str,str.ljust(20))
print '%s rjust=%s' % (str,str.rjust(20))
print '%s center=%s' % ((20))
print '%s zfill=%s' % (str,str.zfill(20))
字符串搜索相关
搜索指定字符串，没有返回-1：str.find('t')
python字符串查指定多个⼦字符串的所有位置：
a = "dhvka,feovj.dlfida?dfka.dlviaj,dlvjaoid,vjaoj?"
b = [i for i, j in enumerate(a) if j in [',', '.', '?']]
print(b)
[5, 11, 18, 23, 30, 39, 45]
指定起始位置搜索：str.find('t',start)
指定起始及结束位置搜索：str.find('t',start,end)
从右边开始查：str.rfind('t')
搜索到多少个指定字符串：unt('t')
上⾯所有⽅法都可⽤index代替，不同的是使⽤index查不到会抛异常，⽽find返回-1
print '%s find nono=%d' % (str,str.find('nono'))
print '%s find t=%d' % (str,str.find('t'))
print '%s find t from %d=%d' % (str,1,str.find('t',1))
print '%s find t from %d to %d=%d' % (str,1,2,str.find('t',1,2))
#print '%s index nono ' % (str,str.index('nono',1,2))
print '%s rfind t=%d' % (str,str.rfind('t'))
print '%s count t=%d' % (unt('t'))
python判断字符串是否包含⼦串的⽅法
1. if 'abcde'.__contains__("abc")
2. if "abc" in 'abcde'
3.'abcde'.find('bcd') >= 0
4.'abcde'.count('bcd') > 0
<:
string.index(ls,ss)
print 'find it'
except(ValueError):
print 'fail'
[blog.csdn/elvis_kwok/article/details/7405083]
[]
字符串替换相关
替换old为new：place('old','new')
替换指定次数的old为new：place('old','new',maxReplaceTimes)
print '%s replace t to *=%s' % (place('t', '*'))
print '%s replace t to *=%s' % (place('t', '*',1))
字符串⼀次替换多个不同字符
将字符串中的[ ] '替换成空格
methon1: tags = re.sub("
||
|'", "", str(music_tag[music_name]))
methon3:
字符串去空格及去指定字符
去两边空格：str.strip()
去左空格：str.lstrip()
去右空格：str.rstrip()
去两边字符串（⽀持正则）：s.strip('{|}')
按指定字符分割字符串为数组：str.split(' ')
默认按空格分隔
指定分隔符str,str.split('-')
字符串判断相关
是否以start开头：str.startswith('start')
是否以end结尾：dswith('end')
是否全为字母或数字：str.isalnum()
是否全字母：str.isalpha()
是否全数字：str.isdigit()字符串长度函数是什么
是否全⼩写：str.islower()
是否全⼤写：str.isupper()
str='python String function'
[]
字符串相关操作
repr(反引号)操作
在Python 2⾥，为了得到⼀个任意对象的字符串表⽰，有⼀种把对象包装在反引号⾥(⽐如`x`)的特殊语法。在Python 3⾥，这种能⼒仍然存在，但是你不能再使⽤反引号获得这种字符串表⽰了。你需要使⽤全局函数repr()。
Notes Python 2Python 3
①`x`repr(x)
②`'PapayaWhip' + `2``repr('PapayaWhip'+ repr(2))
1. 记住，x可以是任何东西 — ⼀个类，函数，模块，基本数据类型，等等。repr()函数可以使⽤任何类型的参数。
2. 在Python 2⾥，反引号可以嵌套，导致了这种令⼈费解的(但是有效的)表达式。2to3⾜够智能以将这种嵌套调⽤转换到repr()函数。
字符串分割
使⽤多个界定符分割字符串
解决⽅案1：【】
string对象的 split() ⽅法只适应于⾮常简单的字符串分割情形，它并不允许有多个分隔符或者是分隔符周围不确定的空格。当你需要更加灵活的切割字符串的时候，最好使⽤re.split() ⽅法：
>>> line = 'asdf fjdk; afed, fjek,asdf, foo'
>>> import re
>>> re.split(r'[;,\s]\s*', line)
['asdf', 'fjdk', 'afed', 'fjek', 'asdf', 'foo']
解决⽅案2：
s = 'Hello!This?Is!What?I!Want'
for i in ('!', '?'):
s = s.replace(i,' ')
list1 = s.split()
解决⽅案3：
def my_split(s, seps):
res = [s]
for sep in seps:
s, res = res, []
for seq in s:
res += seq.split(sep)
return res
my_split(s, ['!', '?'])
格式化字符串
⾃python2.6开始，新增了⼀种格式化字符串的函数str.format()，可谓威⼒⼗⾜。跟之前的%型格式化字符串相⽐是优越的存在。
语法
它通过{}和：来代替%。
“映射”⽰例
通过位置
In [1]: '{0},{1}'.format('kzc',18)
Out[1]: 'kzc,18'
In [2]: '{},{}'.format('kzc',18)
Out[2]: 'kzc,18'
In [3]: '{1},{0},{1}'.format('kzc',18)
Out[3]: '18,kzc,18'
字符串的format函数可以接受不限个参数，位置可以不按顺序，可以不⽤或者⽤多次，不过2.6不能为空{}，2.7才可以。
通过关键字参数
In [5]: '{name},{age}'.format(age=18,name='kzc')
Out[5]: 'kzc,18'
通过对象属性
class Person:
def __init__(self,name,age):
self.name,self.age = name,age
def __str__(self):
return 'This guy is {self.name},is {self.age} old'.format(self=self)
In [2]: str(Person('kzc',18))
Out[2]: 'This guy is kzc,is 18 old'
通过下标
In [7]: p=['kzc',18]
In [8]: '{0[0]},{0[1]}'.format(p)
Out[8]: 'kzc,18'
有了这些便捷的“映射”⽅式，我们就有了偷懒利器。基本的python知识告诉我们，list和tuple可以通过“打散”成普通参数给函数，⽽dict可以打散成关键字参数给函数（通过和*）。所以可以轻松的传个list/tuple/dict给format函数。⾮常灵活。
格式限定符
它有着丰富的的“格式限定符”（语法是{}中带：号），⽐如：
填充与对齐
填充常跟对齐⼀起使⽤
^、<、>分别是居中、左对齐、右对齐，后⾯带宽度；：号后⾯带填充的字符，只能是⼀个字符，不指定的话默认是⽤空格填充。
⽐如
In [15]: '{:>8}'.format('189')
Out[15]: ' 189'
In [16]: '{:0>8}'.format('189')
Out[16]: '00000189'
In [17]: '{:a>8}'.format('189')
Out[17]: 'aaaaa189'
print('{:*^60}'.format(' 每个TERMINALNO 数据记录数 '))
******************** 每个TERMINALNO 数据记录数 ******************** （中⽂字符居然只算1个字符，所以有中⽂字符时候输出不同⾏还是对不齐）
Note: 如果是使⽤{：>20}格式化列表，要先将列表转化成str()，否则报错TypeError: unsupported format string passed to list.__format__．
精度与类型f
精度常跟类型f⼀起使⽤
In [44]: '{:.2f}'.format(321.33345)
Out[44]: '321.33'
其中.2表⽰长度为2的精度，f表⽰float类型。
其他类型
主要就是进制了，b、d、o、x分别是⼆进制、⼗进制、⼋进制、⼗六进制。
In [54]: '{:b}'.format(17)
Out[54]: '10001'
In [55]: '{:d}'.format(17)
Out[55]: '17'
In [56]: '{:o}'.format(17)
Out[56]: '21'
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论