python7：字符串

在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构造器来构造：
    class str(object='')
    class str(object=b'', encoding='utf-8', errors='strict')
str()返回一个字符串对象。如果object不提供，则默认返回空字符串，否则，str()的行为依赖于encoding或者errors是否提供：
    1）encoding和errors都不提供，str(object)返回object.__str__()，用于表示object的字符串描述；对于字符串，就是它本身。如果对象没有__str__()方法，则返回repr(object)；
    2）encoding和errors其中一个被提供，object应该是一个bytes-like object（例如：bytes或者bytearray）。假如object是一个bytes（或者bytearray），那么str(bytes, encoding, errors)等价于bytes.decode(encoding, errors)，否则，在调用bytes.decode()之前object下的字节对象将被获取。
注意未指定encoding或者errors的情况下对bytes对象使用str()相当于返回对象的描述信息，同1，如：

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

下面看一个例子：

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

打印结果为：this is 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}

更详细的使用看translate方法。

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

注意和split的区别：

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

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

2）对于行结束符结束的字符串，splitlines返回单个元素的列表，split返回两个元素的列表。

>>> "".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      '

使用0表示数字将会用0进行填充：

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

" "表示在整数前加上空格，负数不变，用于对齐正负数：

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

+表示不管整数还是负数，都表示出符号：

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