El procesamiento de datos de texto en Python utiliza una cadena de secuencia inmutable compuesta de codificación Unicode: objeto str. La representación de la cadena es la siguiente:
.Citas simples'Este artículo describe información sobre el objeto str '
. 双 引号 "Este artículo describe información sobre el objeto str"
.Triple comillas `` 'Este artículo describe información sobre el objeto str' ''
Las cadenas que utilizan comillas triples pueden abarcar varias líneas y todas las cadenas vacías se incluyen en el valor de la cadena.
El tipo str también es un tipo inmutable. Además de los tres métodos de construcción explícitos anteriores, también hay funciones de construcción para la construcción
Construcción de cuerdas
Función de construcción:
| función | Paráfrasis |
|---|---|
| str (objeto = b '') | Devuelve la cadena construida |
| str (objeto = '', codificación = 'uft-8', errores = 'estricto') | Devuelve una cadena formada por el objeto, si el objeto está vacío, se devuelve una cadena vacía si la codificación o los errores no se establecieron str(object) para regresar object.__str__(), que es el objeto de una representación de cadena "informal" o bien formateada. Para los objetos de cadena, esta es la cadena en sí. Si el objeto no es __str__() un método, str() retrocederá para regresar repr(object). Si se proporciona al menos uno de los errores de codificación o , el objeto debe ser un objeto de tipo bytes (por ejemplo, o ). En este caso, si objeto es un (o ) objeto, es equivalente a . De lo contrario, el objeto de bytes debajo del objeto de búfer se obtendrá antes de la llamada . Consulte Tipos de secuencia binaria: bytes, bytearray, memoryview y protocolo de búfer para obtener información sobre los objetos de búfer.bytesbytearraybytesbytearraystr(bytes, encoding, errors)bytes.decode(encoding, errors)bytes.decode() |
| I. StringIO () | Búfer de memoria de E / S de texto, si se llama al método close (), el búfer terminará |
>>> str(b'Zoot!')
"b'Zoot!'"
Acceso a cadenas
Puede acceder directamente a los caracteres de la cadena por índice, como la cadena s = 'abcdfdeff', s [0] = 'a', s [0: 3] = 'abc', s [0: 3] también es disponible Escrito como s [: 3], significa comenzar desde la posición 0 y tomar el byte antes del tercer carácter. El primer número significa comenzar desde el carácter y el último significa tomar el byte (la última palabra). Los caracteres de sección no son incluido).
Debido a que no hay un tipo de carácter separado, al indexar la cadena, se generará una cadena de longitud 1, es decirs[0] == s[0:1]
Valor literal
El valor literal de la cadena se define de la siguiente manera:
stringliteral ::= [stringprefix](shortstring | longstring)
stringprefix ::= "r" | "u" | "R" | "U" | "f" | "F"
| "fr" | "Fr" | "fR" | "FR" | "rf" | "rF" | "Rf" | "RF"
shortstring ::= "'" shortstringitem* "'" | '"' shortstringitem* '"'
longstring ::= "'''" longstringitem* "'''" | '"""' longstringitem* '"""'
shortstringitem ::= shortstringchar | stringescapeseq
longstringitem ::= longstringchar | stringescapeseq
shortstringchar ::= <any source character except "\" or newline or the quote>
longstringchar ::= <any source character except "\">
stringescapeseq ::= "\" <any source character>
bytesliteral ::= bytesprefix(shortbytes | longbytes)
bytesprefix ::= "b" | "B" | "br" | "Br" | "bR" | "BR" | "rb" | "rB" | "Rb" | "RB"
shortbytes ::= "'" shortbytesitem* "'" | '"' shortbytesitem* '"'
longbytes ::= "'''" longbytesitem* "'''" | '"""' longbytesitem* '"""'
shortbytesitem ::= shortbyteschar | bytesescapeseq
longbytesitem ::= longbyteschar | bytesescapeseq
shortbyteschar ::= <any ASCII character except "\" or newline or the quote>
longbyteschar ::= <any ASCII character except "\">
bytesescapeseq ::= "\" <any ASCII character>
El primer tipo de valor literal es describir el tipo str y el segundo tipo de valor literal es describir el tipo de bytes.
Si la cadena está precedida por un tipo de prefijo bytes como 'b' o 'B', el tipo generado es bytes; si la cadena está precedida por 'r', 'u', el tipo generado es str; si la cadena está precedida por 'r' o 'R', significa que la cadena no se escapará.
Para ser compatible con versiones anteriores de la serie Python 2, los u prefijos se permiten nuevamente para los literales de cadena . No tiene ningún efecto sobre el significado del valor literal de la cadena y no puede r aparecer al mismo tiempo que el prefijo.
Secuencia de escape y límite de línea
| Indicador | descripción |
|---|---|
| \norte | Envoltura |
| \ r | Retorno de carro |
| \ r \ n | Retorno de carro + salto de línea |
| \ v o \ x0b | Pestañas de fila-Vertical |
| \ f o \ x0c | Cambiar forma |
| \ x1c | Separador de archivos |
| \ x1d | Separador de grupos |
| \ x1e | Separador de registros |
| \ x85 | Proxima linea |
| \ u2018 | Separador de línea |
| \ u2029 | Separador de párrafos |
| \ | Carácter de continuación de línea al final de la línea |
| \ | Barra invertida |
| \ ' | apóstrofe |
| \ " | Doble comillas |
| \a | Tocar la campana |
| \B | Retroceso |
| \ 000 | aire |
| \ t | Pestaña horizontal |
| \Los | Número octal |
| \X | Número hexadecimal |
| \otro | Los demás caracteres se emiten en formato normal. |
Empalme literal
Para múltiples cadenas de caracteres adyacentes o literales de cadenas de bytes (separadas por espacios en blanco), las comillas utilizadas pueden ser diferentes entre sí y su significado es equivalente a empalmarlas todas. Por tanto, es "hello" 'world' equivalente a "helloworld". Esta función puede reducir el uso de barras diagonales inversas para dividir fácilmente una cadena larga en varias líneas físicas, e incluso cada parte de la cadena se puede comentar por separado.
Constante de cadena
Las constantes definidas por la cadena son:
| constante | descripción |
|---|---|
| ascii_letters | La combinación de empalme de ascii_lowercase y asscii_uppercase |
| ascii_lowercase | 26个小写字母’abcdefghijklmnopqrstuvwxyz’，不依赖本地，不可改变 |
| ascii_uppercase | 26个大写字母’ABCDEFGHIJKLMNOPQRSTUVWXYZ’，不依赖本地，不可改变 |
| digits | 字符串 '0123456789' |
| hexdigits | 字符串 '0123456789abcdefABCDEF' |
| octdigits | 字符串 '01234567' |
| punctuation | c标准库中的ASCII标点符号 |
| printable | 可打印的ASCII常量，是digts、ascii_letters、punctuation、whitespace的组合 |
| whitespace | 所有空白符的ASCII字符，如空格， tab，换行，回车，换页，制表符等 |
字符串格式化
一般字符格式化
string 模块中提供来一般字符格式化转换类，利用转换类中的转换函数可以格式化字符串。格式转换类为string模块中的Formatter类，Formatter类中的转换函数有：
| 函数 | 描述 |
|---|---|
| format(format_string, *args, **kwargs) 3.5版本后已移除 | 返回一串字符串，format_string为输入的格式化字符，是vformat函数的包装 |
| vformat(format_string, args, kwargs) | 完成字符格式化实际工作，虽然vformat()作为一个单独的函数使用，但是其实它是一些列函数的组合，vformat函数会调用表格后面的函数来完成字符串的格式化。 |
| parse(format_string) | 循环检测fromat_string，并返回一个iterable格式的元组(literal_text, field_name, format_spec, conversion).vformat（）使用该函数将字符串拆分为文本或替换字段。概念上元组中的值表示一个后面跟着替换字符的文本，如果文本为空或文本后面跟着两个替换字符，则文本将是零长度字符串。如果文本不为空，但是后面没有跟着替换字符，则元组中的自断值都是None |
| get_field(field_name, args, kwargs) | 返回parse()返回的field_name，args和kwargs都是vformat()函数传入的参数 |
| get_value(key, args, kwargs) | 检索给定的key值，给定的key值是整数或字符类型中的一种，如果是一个整数，则代表args参数中的位置坐标，如果是字符串则代表kwargs参数中的名称。args参数设置为vformat（）的位置参数列表，kwargs参数设置为关键字参数字典。 |
| check_unused_args(used_args, args, kwargs) | 对未使用的参数进行检查，参数来源是传给vformat函数的参数，以及在上面步骤中未使用的args参数 |
| format_fiedl(value, format_spec) | format_field（）只调用内置的global format（）。提供方法以便子类可以重写。 |
| convert_field(value,conversion) | 转换给定转换类型（如parse（）方法返回的元组）的值（由get_field（）返回）。默认的转换类型‘s’ (str), ‘r’ (repr) 和 ‘a’ (ascii) |
格式化字符串语法
str.format()方法和Formatter类为格式化字符串提供相同的语法，但是仍有一些不同。
格式字符串包含由大括号包围的“替换字段”{替换值}。不包含在大括号中的任何内容都被视为文本，它将原封不动地复制到输出中。如果需要在文本中包含大括号字符，则可以通过加倍对其进行转义： 。在一些比较正式的语法中，替换字段可以以字段名开始，该字段名指定要格式化其值并插入到输出中而不是替换字段中的对象。字段“名称”后面可选跟一个转换字段，转换字段前面加一个感叹号“！”和格式“spec”，前面是冒号“：”。它们为替换值指定非默认格式。
字段“名称”本身以数字或关键字的参数开头。如果是数字，则表示位置参数；如果是关键字，则表示命名关键字参数。如果格式字符串中的数字arg_名称按顺序是0、1、2，…，则可以全部省略，数字0、1、2，…）将自动按该顺序插入。因为arg_名称不是用引号分隔的，所以不能在格式字符串中指定任意字典键（例如字符串“10”或“：-]”）。参数名后面可以跟任意数量的索引或属性表达式。表单的表达式“.name”使用getattr（）选择命名属性，而表单的表达式“[index]”使用getitem()进行索引查找。
3.1版本中 str.format（）可以省略位置参数说明符，因此’{}{}’.format（a，b）等同于“0 1”格式 ‘{0} {1}’.format(a, b)。 3.5版本之后格式化程序可以省略位置参数说明符。
转换字段在格式化前导致类型强制。通常，格式化值的工作是由值本身的format()方法完成。但是，在某些情况下，需要强制将类型格式化为字符串，从而覆盖其自己的格式化定义。通过在调用format()之前将值转换为字符串，可以绕过正常的格式化逻辑。例如'!s' 会先调用 str()函数进行转换 , '!r' 会先调用repr()函数进行转换以及!a会先调用ascii()函数进行转换。
format_spec字段包含如何显示值的说明，包括字段宽度、对齐方式、填充、小数精度等详细信息。每个值类型都可以定义自己的Mini-Language或格式说明。format_spec字段还可以包含嵌套的替换字段。这些嵌套的替换字段可能包含字段名、转换标志和格式规范，但不允许进行更深层次的嵌套。format_spec中的替换字段在格式化format_spec字符串之前被替换。这样造成可以允许动态指定值的格式。
通过位置访问参数进行替换:
>>> '{0},{1},{2}'.format('a','b','c')
'a,b,c'
>>> '{},{},{}'.format('a','b','c')
'a,b,c'
>>> '{2},{1},{0}'.format('a','b','c')
'c,b,a'
>>> '{},{},{}'.format(*'abc')
'a,b,c'
>>> '{2},{1},{0}'.format(*'abc')
'c,b,a'
>>> '{0},{1},{0}'.format('abra', 'cad')
'abra,cad,abra'
通过name访问参数进行替换：
>>> 'Coordinates: {latitude},{longitude}'.format(latitude='37.24N', longitude='-115.81W')
'Coordinates: 37.24N,-115.81W'
>>> "I'm a girl and my job is {jobname}".format(jobname='Data Analysistic')
"I'm a girl and my job is Data Analysistic"
通过属性访问参数进行替换：
>>> c = 3-5j
>>> ('复数{0}是由实部{0.real} 和 虚部{0.imag}构成').format(c)
'复数(3-5j)是由实部3.0 和 虚部-5.0构成'
>>> class Point:
def __init__(self, x, y):
self.x, self.y = x, y
def __str__(self):
return 'Point({self.x}, {self.y})'.format(self=self)
>>> str(Point(4,2))
'Point(4, 2)'
通过items访问参数进行替换：
>>> coord = (3,4)
>>> 'X:{0[0]}; Y:{0[1]}'.format(coord)
'X:3; Y:4'
替换%s和%r：
>>> "repr() shows quotes:{!r}; str() doesn't:{!s}".format('test1','test2')
"repr() shows quotes:'test1'; str() doesn't:test2"
对齐文本并指定宽度：
>>> '{:<30}'.format('left aligned')
'left aligned '
>>> '{:>30}'.format('right aligned')
' right aligned'
>>> '{:^30}'.format('centered')
' centered '
>>> '{:*^30}'.format('centered')
'***********centered***********'
替换%+f, %-f, % f以及指定符号：
>>> '{:<30}'.format('left aligned')
'left aligned '
>>> '{:>30}'.format('right aligned')
' right aligned'
>>> '{:^30}'.format('centered')
' centered '
>>> '{:*^30}'.format('centered')
'***********centered***********'
替换%x,%o以及将值转换为不同的基数:
>>> "int:{0:d}; hex:{0:x}; oct:{0:o}; bin:{0:b}".format(42)
'int:42; hex:2a; oct:52; bin:101010'
>>> "int:{0:d}; hex:{0:#x}; oct:{0:#o}; bin:{0:#b}".format(42)
'int:42; hex:0x2a; oct:0o52; bin:0b101010'
>>>
使用逗号,作为千位分隔符:
>>> '{:,}'.format(1234567890)
'1,234,567,890'
>>>
百分数形式替换：
>>> points = 19
>>> total = 22
>>> 'Correct answers:{:.2%}'.format(points/total)
'Correct answers:86.36%'
特殊类型格式转换:
>>> import datetime
>>> d = datetime.datetime(2018,5,4,21,54,16)
>>> '{:%Y-%m-%d %H:%M:%S}'.format(d)
'2018-05-04 21:54:16'
嵌套参数和更复杂的示例：
>>> for align, text in zip('<^>', ['left', 'center', 'right']):
'{0:{fill}{align}16}'.format(text, fill=align, align=align)
'left<<<<<<<<<<<<'
'^^^^^center^^^^^'
'>>>>>>>>>>>right'
>>> octets = [192,168,0,1]
>>> '{:02X}{:02X}{:02X}{:02X}'.format(*octets)
'C0A80001'
>>> '{:02X}{:02X}{:02X}{:02X}'.format(*octets)
'C0A80001'
>>> int(_, 16)
3232235521
>>> width = 5
>>> for num in range(5, 12):
for base in 'dXob':
print('{0:{width}{base}}'.format(num, base=base, width=width), end='')
print()
5 5 5 101
6 6 6 110
7 7 7 111
8 8 10 1000
9 9 11 1001
10 A 12 1010
11 B 13 1011
>>>
格式化字符Mini-Language
格式化符号
| 符号 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整数 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数(大写) |
| %f | 格式化化浮点数字，可以指定小数点后的精度 |
| %e | 用科学记数法格式化浮点数 |
| %E | 作用同%e，用科学记数法格式化浮点数 |
| %g | %f和%e的简写 |
| %G | %f 和 %E 的简写 |
| %p | 用十六进制数格式化变量的地址 |
格式化旗标
| 标志 | 描述 |
|---|---|
| ‘#’ | 值的转换将使用”替代形式” |
| 0 | 转换将为数字值填充零字符 |
| ‘-‘ | 转换值左对齐，如果同时给出’0’转换，则会覆盖’0’转换 |
| ‘ ‘ | (空格) 符号位转换产生的正数（或空字符串）前将留出一个空格 |
| ‘+’ | 符号字符 ('+' 或 '-') 将显示于转换结果的开头（会覆盖 “空格” 旗标） |
格式化类型
| 转换符 | 描述 |
|---|---|
| ‘d’ | 有符号十进制整数 |
| ‘i’ | 有符号十进制整数 |
| ‘o’ | 有符号八进制数 |
| ‘u’ | 无符号十进制整数 |
| ‘a’ | 字符串(使用ascii()转换Python对象) |
| ‘e’ | 浮点指数格式(小写) |
| ‘E’ | 浮点指数格式(大写) |
| ‘f’ | 浮点十进制格式 |
| ‘F’ | 浮点十进制格式 |
| ‘g’ | 浮点格式，如果指数小于 -4 或不小于精度则使用小写指数格式，否则使用十进制格式。 |
| ‘G’ | 浮点格式。 如果指数小于 -4 或不小于精度则使用大写指数格式，否则使用十进制格式。 |
| ‘c’ | 单个字符(接受整数或单个字符的字符串) |
| ‘r’ | 字符串(使用repr()转换Python对象) |
| ‘s’ | 字符串(使用str()转换Python对象) |
| ‘x’ | 有符号十六进制数(小写) |
| ‘X’ | 有符号十六进制数(大写) |
| ‘%’ | 不转换参数，在结果中输出一个’%’字符 |
模板字符串
模板字符串提供来更简单的字符串替换形式，这样做重要的一点是国际化(i18n)，较简单的语法和功能比Python其它内置字符串格式化更容易链接编译。
模板字符串规则
模板字符串支持基于$的替换，使用以下规则：
. $$ is an escape; it is replaced with a single $
.$idenfifier 匹配字典中的名为’idenfifier’的key。默认情况下，’identifier’仅限于以下划线或ASCII字母开头的任何不区分大小写的ASCII字母数字字符串（包括下划线）, \$ 字符后的第一个非标识字符代表终止字符
.${identifier} 和 \$identifier 含义相同。当有效的标识字符跟在占位符之后但不是占位符的一部分(如\${noun}ification)的时候，必须采用\${identifier}的写法
字符串中出现的任何其他$都将导致引发ValueError。
木板字符串函数
string模块提供了Temple类执行以上规则，Temple类的方法有：
| 函数 | 描述 |
|---|---|
| class string.Template(template) | 构造函数，参数template是模板字符串 |
| substitute(mapping, **kwds) | 执行模板替换，返回新字符串。映射任何类似字典的对象，其键与模板中的占位符匹配。也可以提供关键字参数，其中关键字是占位符。当同时给出映射和kwds同时给出时，kwds中的占位符优先。 |
| safe_substitue(mapping, **kwds) | 与substitute（）类似，但不同的是如果在映射和kwd中缺少占位符，不会引发keyError异常，否则原始占位符将完整显示在结果字符串中。此外,任何以\$形式出现的字符串都不会引发VauleError。此方法被称为safe 替换函数，是因为当其它异常产生时，该方法总是尝试返回可用的字符串而不是引发异常。从另一种情况来说，safe_substitue()之所以称之为安全的方法，并非是因为它真正安全，而是因为它会默默地忽略格式错误的模板字符串，错误的模板字符串包含格式不完整的分隔符、不匹配的大括号、不是有效Python占位符的标识符。 |
| template() | 模板实例提供的公共数据属性，返回提供给Template参数的模板字符串值。一般来说，不应该更改它，但访问的时候也并不能指定为只读。 |
>>> from string import Template
>>> s = Template('$who likes $what')
>>> s.substitute(who='tim', what='running')
'tim likes running'
>>> d = dict(who='tim')
>>>#制造KeyError
>>> Template('Give $who $100').substitute()
Traceback (most recent call last):
File "<pyshell#33>", line 1, in <module>
Template('Give $who $100').substitute()
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/string.py", line 130, in substitute
return self.pattern.sub(convert, self.template)
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/string.py", line 123, in convert
return str(mapping[named])
KeyError: 'who'
>>>#制造valueError
>>> Template('Give $who $100').substitute(d)
Traceback (most recent call last):
File "<pyshell#34>", line 1, in <module>
Template('Give $who $100').substitute(d)
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/string.py", line 130, in substitute
return self.pattern.sub(convert, self.template)
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/string.py", line 127, in convert
self._invalid(mo)
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/string.py", line 103, in _invalid
(lineno, colno))
ValueError: Invalid placeholder in string: line 1, col 11
>>>#制造keyError
>>> Template('$who likes $what').substitute(d)
Traceback (most recent call last):
File "<pyshell#35>", line 1, in <module>
Template('$who likes $what').substitute(d)
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/string.py", line 130, in substitute
return self.pattern.sub(convert, self.template)
File "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/string.py", line 123, in convert
return str(mapping[named])
KeyError: 'what'
>>>#用safe_substitute函数避免Error
>>> Template('$who likes $what').safe_substitute(d)
'tim likes $what'
模板字符串高级用法
高级用法：
可以派生模板的子类，以自定义占位符语法、分隔符或用于分析模板字符串的整个正则表达式。为此，可以重写这些类属性：
delimiter – 描述引入分隔符的占位符的文本字符串,默认值为$。注意，这不能是正则表达式，如果想要传入正则表达式，需要根据具体的规则在此字符串上调用re.escape()。
idpattern –描述无效占位符的正则表达式(括号将根据需要自动添加)。默认值是正则表达式(?-i:[_a-zA-Z][_a-zA-Z0-9]*)
flags –正则表达式标志，在编译期间将正则表达式转换为实际应用规则时被使用。默认值是re.VERBOSE。值得注意的是re.VERBOSE无论如何都会被添加到标志中，所以自定义的ID模式必须符合详细的正则表达式规则。
或者，可以通过重写类属性模式来提供整个正则表达式模式。这么做的前提是该值必须是具有四个捕获组组成的正则表达式对象， 捕获组与给出的规则以及无效的占位符规则相对应:
escaped – 该捕获组与默认模式中的转义序列（例如$$）匹配
named – 该捕获组与无空格的占位符名称匹配，并且不能包含分隔符
braced – 该捕获组与括号内的占位符名称匹配，不能包含分隔符或括号
invalid – 该捕获组与任何其他分隔符模式（通常是单个分隔符）匹配，它应该出现在正则表达式的最后一个
字符串方法
| 函数 | 释义 |
|---|---|
| str.capitalize() | 返回字符串的副本，首个字符大写，其余为小写 |
| str.casefold() | 返回字符串消除大小写的副本，可以用于忽略大小写的匹配 |
| str.center(width, fillchar) | 返回长度为 width 的字符串，原字符串在其正中。 使用指定的 fillchar 填充两边的空位（默认使用 ASCII 空格符）。 如果 width 小于等于 len(s) 则返回原字符串的副本 |
| str.count(sub, start, end) | 反回子字符串 sub 在 [start, end] 范围内非重叠出现的次数。 可选参数 start 与 end 会被解读为切片表示法。 |
| str.encode(encoding=”utf-8”, errors=”strict”) | 返回原字符串编码为字节串对象的版本。 默认编码为 'utf-8'。 可以给出 errors 来设置不同的错误处理方案。 errors 的默认值为 'strict'，表示编码错误会引发 UnicodeError。 其他可用的值为 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace'等。 |
| str.endswith(suffix, start, end) | 如果字符串是以指定的suffix结束则返回True，否则返回Falsesuffix 也可以为由多个供查找的后缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。 |
| str.expandtabs(tabsize=8) | 返回字符串的副本，其中所有的制表符会由一个或多个空格替换，具体取决于当前列位置和给定的制表符宽度。 每 tabsize 个字符设为一个制表位（默认值 8 时设定的制表位在列 0, 8, 16 依次类推）。 要展开字符串，当前列将被设为零并逐一检查字符串中的每个字符。 如果字符为制表符 (\t)，则会在结果中插入一个或多个空格符，直到当前列等于下一个制表位。 （制表符本身不会被复制。） 如果字符为换行符 (\n) 或回车符 (\r)，它会被复制并将当前列重设为零。 任何其他字符会被不加修改地复制并将当前列加一，不论该字符在被打印时会如何显示 |
| str.find(sub,start,end) | 返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引。 可选参数 start 与 end会被解读为切片表示法。 如果 sub 未被找到则返回 -1。find()方法只在需要知道 sub 所在位置时使用。 要检查 sub 是否为子字符串，请使用in 操作符 |
| str.format(*args,**kwargs) | 执行字符串格式化操作。 调用此方法的字符串可以包含字符串字面值或者以花括号 {}括起来的替换域。 每个替换域可以包含一个位置参数的数字索引，或者一个关键字参数的名称。 返回的字符串副本中每个替换域都会被替换为对应参数的字符串值。当使用 n 类型 (例如: '{:n}'.format(1234)) 来格式化数字 (int、float、complex、decimal 及其子类) 的时候，该函数会临时性地将 LC_CTYPE 区域设置为 LC_NUMERIC 区域以解码 localeconv() 的 decimal_point和 thousands_sep 字段，如果它们是非 ASCII 字符或长度超过 1 字节的话，并且 LC_NUMERIC 区域会与 LC_CTYPE 区域不一致。 这个临时更改会影响其他线程。 |
| str.format_map(mapping) | 类似于 str.format(**mapping)，不同之处在于 mapping 会被直接使用而不是复制到一个 dict。 适宜使用此方法的一个例子是当 mapping 为 dict 的子类的情况。 |
| str.index(sub, start, end) | 类似于 find()，但在找不到子类时会引发 ValueError。 |
| str.isalnum() | 如果字符串中至少有一个字符且所有字符均为字母或数字则返回真值，否则返回假值。 |
| str.isalpha() | 如果字符串中至少有一个字符且所有字符均为字母则返回真值，否则返回假值 |
| str.isdecimal() | 如果字符串中至少有一个字符且所有字符均为十进制数字符则返回真值，否则返回假值 |
| str.isdigit() | 如果字符串中至少有一个字符且所有字符均为数字字符则返回真值，否则返回假值。 |
| str.isidentifier() | 如果字符串根据语言定义属于有效的标识符则返回真值 |
| str.islower() | 如果字符串中至少有一个区分大小写的字符, 字符均为小写则返回真值，否则返回假值。 |
| str.isnumeric() | 如果字符串中至少有一个字符且所有字符均为数值字符则返回真值，否则返回假值。 |
| str.isprintable() | 如果字符串中所有字符均为可打印字符或字符串为空则返回真值，否则返回假值。 |
| str.isspace() | 如果字符串中至少有一个字符且所有字符均为空白字符则返回真值，否则返回假值。 |
| str.istitle() | 如果字符串中至少有一个字符且为标题字符串则返回真值，例如大写字符之后只能带非大写字符而小写字符必须有大写字符打头。 否则返回假值。 |
| str.isupper() | 如果字符串中至少有一个区分大小写的字符 具此类字符均为大写则返回真值，否则返回假值。 |
| str.join(iterable) | 返回一个由 iterable 中的字符串拼接而成的字符串。 如果 iterable 中存在任何非字符串值包括 bytes 对象则会引发 TypeError。 调用该方法的字符串将作为元素之间的分隔。 |
| str.ljust(width, fillchar) | 返回长度为 width 的字符串，原字符串在其中靠左对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。 |
| str.lower() | 返回原字符串的副本，其所有区分大小写的字符 均转换为小写。 |
| str.lstrip(chars) | 返回原字符串的副本，移除其中的前导字符.chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 |
| static str.maketrans(x,y,z) | 此静态方法返回一个可供 str.translate() 使用的转换对照表。如果只有一个参数，则它必须是一个将 Unicode 码位序号（整数）或字符（长度为 1 的字符串）映射到 Unicode 码位序号、（任意长度的）字符串或 None 的字典。 字符键将会被转换为码位序号。如果有两个参数，则它们必须是两个长度相等的字符串，并且在结果字典中，x 中每个字符将被映射到 y 中相同位置的字符。 如果有第三个参数，它必须是一个字符串，其中的字符将在结果中被映射到 None。 |
| str.partition(sep) | 在 sep 首次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含字符本身以及两个空字符串。 |
| str.replace(old, new, count) | 返回字符串的副本，其中出现的所有子字符串 old 都将被替换为 new。 如果给出了可选参数 count，则只替换前 count 次出现。 |
| str.rfind(sub, start, end) | 返回子字符串 sub 在字符串内被找到的最大（最右）索引，这样 sub 将包含在 s[start:end] 当中。 可选参数 start 与 end 会被解读为切片表示法。 如果未找到则返回 -1。 |
| str.rindex(sub,start,end) | 类似于 rfind()，但在子字符串 *sub* 未找到时会引发 ValueErrorttps://)。 |
| str.rjust(width, fillchar) | 返回长度为 width 的字符串，原字符串在其中靠右对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。 |
| str.rpartition(sep) | 在 sep 最后一次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含两个空字符串以及字符串本身。 |
| str.rsplit(sep,maxsplit=-1) | 返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分，从 最右边 开始。 如果 sep 未指定或为 None，任何空白字符串都会被作为分隔符。 |
| str.rstrip(chars) | 返回原字符串的副本，移除其中的末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 |
| str.split(sep, maxsplit=-1) | 返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分（因此，列表最多会有 maxsplit+1 个元素）。 如果 maxsplit 未指定或为 -1，则不限制拆分次数（进行所有可能的拆分）。如果给出了 sep，则连续的分隔符不会被组合在一起而是被视为分隔空字符串。 |
| str.splitlines(keepends) | 返回由原字符串中各行组成的列表，在行边界的位置拆分。 结果列表中不包含行边界，除非给出了 keepends 且为真值。 |
| str.startswith(prefix, start,end) | 如果字符串以指定的 prefix 开始则返回 True，否则返回 False。 prefix 也可以为由多个供查找的前缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。 |
| str.strip(chars) | 返回原字符串的副本，移除其中的前导和末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 |
| str.swapcase() | 返回原字符串的副本，其中大写字符转换为小写，反之亦然。 |
| str.title() | 返回原字符串的标题版本，其中每个单词第一个字母为大写，其余字母为小写。 |
| str.translate(table) | 返回原字符串的副本，其中每个字符按给定的转换表进行映射。 转换表必须是一个使用 __getitem__() 来实现索引操作的对象，通常为 mapping 或 sequence。 当以 Unicode 码位序号（整数）为索引时，转换表对象可以做以下任何一种操作：返回 Unicode 序号或字符串，将字符映射为一个或多个字符；返回 None，将字符从结果字符串中删除；或引发 LookupError 异常，将字符映射为其自身。 |
| str.upper() | 返回原字符串的副本，其中所有区分大小写的字符均转换为大写。 |
| str.zfill(width) | 返回原字符串的副本，在左边填充 ASCII '0' 数码使其长度变为 width。 正负值前缀 ('+'/'-') 的处理方式是在正负符号 之后填充而非在之前。 如果 width 小于等于 len(s) 则返回原字符串的副本。 |
| str.capwords(s, sep=None) | 使用str.split（）将参数拆分为单词，使用str.capitalize（）将每个单词大写，并使用str.join（）连接大写单词。如果可选的第二个参数sep不存在或没有，则运行的空白字符将替换为单个空格，并删除前导空格和尾随空格，否则sep用于拆分和联接单词。 |
>>> string = 'string synatx custom string formatting'
>>> string.capitalize()
'String synatx custom string formatting'
>>> string = string.capitalize()
>>> print (string)
String synatx custom string formatting
>>> string = string.casefold()
>>> print (string)
string synatx custom string formatting
>>> string.center(15, '*')
'string synatx custom string formatting'
>>> string.center(50, '*')
'******string synatx custom string formatting******'
>>> string.count('a', 0, 30)
1
>>> string.endswith('.com', 0)
False
>>> string.endswith('.com')
False
>>> '01\t012\t0123\t01234'.expandtabs()
'01 012 0123 01234'
>>> '01\t012\t0123\t01234'.expandtabs(5)
'01 012 0123 01234'
>>> string.find('f')
28
>>> 'f' in string
True
>>> 'The sum of 4 + 5 is {0}'.format(4+5)
'The sum of 4 + 5 is 9'
>>> class Default(dict):
def __missing__(self, key):
return key
>>> '{name} was born in {country}'.format_map(Default(name='Joy'))
'Joy was born in country'
>>> '{name} was born in {country}'.format_map(Default(name='Joy', country='Chinese'))
'Joy was born in Chinese'
>>> string.isalnum()
False
>>> print (string)
string synatx custom string formatting
>>> string.isalpha()
False
>>> string.isdecimal()
False
>>> string.isdigit()
False
>>> string.isidentifier()
False
>>> string.islower()
True
>>> string.isnumeric()
False
>>> string.isprintable()
True
>>> string.isspace()
False
>>> string.istitle()
False
>>> string.isupper()
False
>>> string.join(['len', 'type'])
'lenstring synatx custom string formattingtype'
>>> ' '.join(['red','blue','green'])
'red blue green'
>>> string.ljust(50, '*')
'string synatx custom string formatting************'
>>> string.partition('syn')
('string ', 'syn', 'atx custom string formatting')
>>> string.replace('s', 'S', 2)
'String Synatx custom string formatting'
>>> string.rfind('syn')
7
>>> string.rindex('syn')
7
>>> string.rjust(50, '-')
'------------string synatx custom string formatting'
>>> string.rsplit()
['string', 'synatx', 'custom', 'string', 'formatting']
>>> string.rstrip()
'string synatx custom string formatting'
>>> string.split()
['string', 'synatx', 'custom', 'string', 'formatting']
>>> string.splitlines()
['string synatx custom string formatting']
>>> string.startswith('str')
True
>>> string.strip()
'string synatx custom string formatting'
>>> string.swapcase()
'STRING SYNATX CUSTOM STRING FORMATTING'
>>> string.title()
'String Synatx Custom String Formatting'
>>> string.upper()
'STRING SYNATX CUSTOM STRING FORMATTING'
>>> string.zfill(50)
'000000000000string synatx custom string formatting'