标签：python

在Python中，字符串对应对象str，字符串是使用Unicode编码的不可变序列。

构造字符串

字符串可以使用下面几种语法：
    1）单引号：‘allows embedded "double" quotes‘
    2）双引号："allows embedded ‘single‘ quotes"
    3）三引号：‘‘‘Three single quotes‘‘‘, """Three double quotes"""
三引号的字符串可以在多行扩展——所有空格都将被包含在字符串中，例如：

>>> '''three
single
qiptes'''
'three\nsingle\nqiptes'

>>> "spam " "eggs"
'spam eggs'

>>> str(b'test!')
"b'test!'"

class StrTest():
    def __str__(self):
        return "this is StrTest"
    
print(str(StrTest()))

字符串方法

字符串实现了所有序列的公共方法，并增加了许多额外的方法。

str.capitalize()

返回字符串的一个拷贝，第一个字符大写，其它字符小写。

str.casefold()

返回一个字符串的casefolded拷贝，casefolded字符串可以被用于caseless匹配。
Casefolding类似于小写，但是更进一步，因为它移除在字符串中的所有差异。例如，德语的小写字母对应于"ss"，由于它已经是小写，所以lower()将不做任何事，但casefold()会将它转换为"ss"。

str.center(width[, fillchar])

返回长度为width的字符串，若width大于len(s)，则用fillchar（默认空格）填充，并将s放在中心位置，如：

>>> s = 'test'
>>> s.center(10,'*')
'***test***'

str.count(sub[, start[, end]])

返回sub在str中出现的次数，可选参数start和end用于限制返回。

str.encode(encoding="utf-8", errors="strict")

返回一个使用encoding编码的bytes对象。

str.endswith(suffix[, start[, end]])

如果字符串以suffix结尾，则返回true，suffix可以是一个元组，只要其中一个元素匹配则返回true，例如：

>>> s = 'test'*4
>>> s.endswith('test')
True
>>> s.endswith(('test1','test2','test'))
True

str.expandtabs(tabsize=8)

返回一个str的拷贝，其中所有的tab字符被一个或者多个空格代替，依靠指定的tabsize，默认8。

>>> '01\t012\t0123\t01234'.expandtabs()
'01      012     0123    01234'
>>> '01\t012\t0123\t01234'.expandtabs(4)
'01  012 0123    01234'

str.find(sub[, start[, end]])

返回sub在str中被发现的最小索引，如果未发现则返回-1。
注意find应该只用于查询sub的位置，如果判断sub是否在字符串中，用in操作即可：

>>> 'Py' in 'Python'
True

str.format(*args, **kwargs)

执行字符串的格式化操作。使用该方法的字符串能够使用括号{}包含的替换域，每个替换域或者使用位置编号，或者使用变量名，返回字符串的拷贝，并且所有替换域都被替换。

>>> "The sum of 1 + 2 is {0}".format(1+2)
'The sum of 1 + 2 is 3'

str.format_map(mapping)

在3.2版本中添加，看下面的例子：

>>> class Default(dict):
	def __missing__(self, key):
		return key
>>> '{name} was born in {country}'.format_map(Default(name='Guido'))
'Guido was born in country'

str.index(sub[, start[, end]])

同find()，除了当子串未发现时抛出ValueError异常。

str.isalnum()

如果字符串中的所有字符都是字母数字，则返回true，只要一个字符非字母数字，则返回false。字符c是字母数字，表示以下方法的其中之一返回true：c.isalpha()，c.isdecimal()，c.isdigit()或者 c.isnumeric()。

str.isalpha()

如果字符串中的所有字符都是字母，则返回true。

str.isdecimal()

如果字符串中的所有字符都是十进制数字，则返回true。

str.isdigit()

如果字符串中的所有字符都是数字，则返回true。

str.isidentifier()

字符串是否是有效的标识符。

str.islower()

字符串中的所有字符都是小写，则返回true。

str.isnumeric()

如果字符串中所有的字符都是数字字符，则返回true。

str.isprintable()

如果字符串为空，或者字符串中的数字都是可打印的，则返回true。不可打印的字符包括unicode字符集中标注为"Other"和"Separator"的。

str.isspace()

如果字符串中全是空格，则返回true。

str.istitle()

如果字符串是title，则返回true，即首字母大写。

str.isupper()

如果字符串中字符全是大写，则返回true。

str.join(iterable)

返回iterable中元素联合的字符串，iterable中元素使用str分隔。如果iterable存在非str的元素，则抛出TypeError异常。

>>> s = 'Asss'
>>> s.join(['1','2','3','4'])
'1Asss2Asss3Asss4'

str.ljust(width[, fillchar])

返回一个做适配长度width的字符串，空白使用fillchar填充，如果字符串长度大于等于width，原始字符串被返回。

>>> s = '12345678'
>>> s.ljust(6)
'12345678'
>>> s.ljust(15)
'12345678       '
>>> s.ljust(15,'%')
'12345678%%%%%%%'

str.lower()

返回一个所有字符小写的str的拷贝。

str.lstrip([chars])

返回移除指定起始字符的str的拷贝，如果chars不指定，则默认移除空格。

>>> s = '   spaciout   '
>>> s.lstrip()
'spaciout   '
>>> s.lstrip('s')
'   spaciout   '
>>> s.lstrip(' s')
'paciout   '
>>> s.lstrip(' sp')
'aciout   '
>>> s.lstrip(' p')
'spaciout   '

static str.maketrans(x[, y[, z]])

静态方法，用于为str.translate()生成一个转换表。
如果只有一个参数，则参数必须为字典；如果两个参数，则必须是等长的字符串；如果为3个参数，则第三个参数必须为字符串，并且该字符串的字符将被匹配为None。

>>> str.maketrans({'a':'A','b':'B'})
{97: 'A', 98: 'B'}
>>> str.maketrans('abc','ABC')
{97: 65, 98: 66, 99: 67}
>>> str.maketrans('abc','ABC','def')
{97: 65, 98: 66, 99: 67, 100: None, 101: None, 102: None}

str.partition(sep)

从第一个出现的sep部分分离字符串，得到一个3个元素的元组：sep之前的部分、sep、sep之后的部分。如果sep未找到，任然返回一个3个元素的元组：str、空字符串、空字符串。

>>> s = '123456789'
>>> s.partition('45')
('123', '45', '6789')
>>> s.partition('666')
('123456789', '', '')

str.replace(old, new[, count])

返回一个新的字符串，其中所有old都被new代替，count用于指定只替换前count个。

str.rfind(sub[, start[, end]])

返回sub在str中最后出现的索引号，返回-1表示未找到。

str.rindex(sub[, start[, end]])

同rfind，但如果sub未找到，则抛出ValueError。

str.rjust(width[, fillchar])

看ljust，rjust表示右适配。

str.rpartition(sep)

看partition，rpartition表示从右查找sep。

str.rsplit(sep=None, maxsplit=-1)

使用sep分隔str，maxsplit表示最大的划分数，sep不指定或为none，则使用空格分隔str。

>>> s = '12345' * 8
>>> s.rsplit('45')
['123', '123', '123', '123', '123', '123', '123', '123', '']
>>> s.rsplit('45',6)
['1234512345123', '123', '123', '123', '123', '123', '']

str.rstrip([chars])

返回str的拷贝，末尾的字符被移除，默认移除空格，chars表示移除的字符集。

>>> '   spacious   '.rstrip()
'   spacious'
>>> 'mississippi'.rstrip('ipz')
'mississ'

str.split(sep=None, maxsplit=-1)

看rsplit，返回一个使用sep分隔的列表，sep未指定则使用空格分隔。maxsplit表示最大分隔次数。

str.splitlines([keepends])

使用那个行结束符分隔str，返回一个行列表。keepends默认为false，表示行分隔符不包含在结果列表中。

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

1）对于空字符串，splitlines返回空列表，split返回包含一个空字符串的列表。

>>> "One line\n".splitlines()
['One line']
>>> 'Two lines\n'.split('\n')
['Two lines', '']

>>> "".splitlines()
[]
>>> ''.split('\n')
['']

str.startswith(prefix[, start[, end]])

字符串如果以prefix开头，则返回true；prefix可以是一个元组。

>>> s = 'Hello!world.'
>>> s.startswith('Hello')
True
>>> s.startswith(('Hello','hello'))
True

str.strip([chars])

返回str的拷贝，并移除首尾字符（默认空白）。

>>> '   spacious   '.strip()
'spacious'
>>> 'www.example.com'.strip('cmowz.')
'example'

str.swapcase()

返回str的拷贝，并转换大小写，注意s.swapcase().swapcase() == s。

>>> s = 'aBcDe'
>>> s.swapcase()
'AbCdE'

str.title()

返回str的拷贝，每个单词的首字母大写，其余字母小写。

>>> 'Hello woRld'.title()
'Hello World'
>>> "they're bill's friends from the UK".title()
"They'Re Bill'S Friends From The Uk"

str.translate(map)

对应看maketrans。返回str的拷贝，其中所有的字符都使用map做了映射。

>>> 'abcdefg-1234567'.translate(str.maketrans('abc', 'ABC'))
'ABCdefg-1234567'
>>> 'abcdefg-1234567'.translate(str.maketrans('abc', 'ABC', '456'))
'ABCdefg-1237'

str.upper()

返回str的拷贝，其中的字符都被转换到大写。注意如果str中包含了无大小写形式（uncased）的字符，str.upper().isupper()会得到false。

str.zfill(width)

返回一个str的拷贝，长度为width，左边用0填充，如果str以‘+‘/‘-‘开头，则从‘+‘/‘-‘之后开始填充。

>>> "42".zfill(5)
'00042'
>>> "-42".zfill(5)
'-0042'

字符串的格式化打印

字符串支持%操作，用于格式化字符串，类似于C语言中的sprintf()。
当格式化仅要求一个参数时，值可以为单个的字符串，否则，值必须是和参数长度相等的元组或者映射对象。
基本的转换说明符包括以下部分：
1）%字符：标记转换说明符位置；
2）转换标志（可选）：-表示左对齐；+表示在转换值之前要加上正负号；" "（空白字符）表示整数之前保留空格；0表示转换值若位数不够则填充0；
3）最小字符宽度（可选）：转换后的最小字符宽度；
4）点(.)后跟精度值（可选）：如果是实数，则表示出现在小数点后的位数；如果为字符串，表示最大字段宽度；
5）转换类型：
    d，i：带符号的十进制数
    0：不带符号的八进制
    u：不带符号的十进制
    x：不带符号的十六进制（大、小写均可）
    e：科学计数法表示的浮点数（大、小写均可）
    f：十进制浮点数（大、小写均可）
    g：如果指数大于-4或者小于进度值则同e，否则同f（大、小写均可）
    C：单字符（接受整数或者单字符字符串）
    r：字符串（使用repr转换任意Python对象）
    s：字符串（使用str转换任意Python对象）
看下面的例子。

直接转换

>>> "I'm %s. I'm %d year old" % ('Tomato', 30)
"I'm Tomato. I'm 30 year old"
>>> from math import pi
>>> 'Pi: %f...' % pi
'Pi: 3.141593...'

指定宽度和精度

>>> 'Pi: %10f' % pi
'Pi:   3.141593'
>>> 'Pi: %10.2f' % pi
'Pi:       3.14'
>>> '%.5s' % 'this is a test'
'this '

>>> '%.*s' % (8,'this is a test')
'this is '

符号、对齐和0填充

使用‘-‘表示左对齐：

>>> '%10.2f' % pi
'      3.14'
>>> '%-10.2f' % pi
'3.14      '

>>> '%010.2f' % pi
'0000003.14'

>>> print(('% 5d' % 10) + '\n' + ('% 5d' % -10))
   10
  -10

>>> print(('%+5d' % 10) + '\n' + ('%+5d' % -10))
  +10
  -10

python7：字符串

标签：python

原文地址：http://blog.csdn.net/tomato__/article/details/44856677