Python字符串学习总结

时间：2023-01-04 10:12:35

Python2字符串类型

Python2.7中字符串主要分为两种str和unicode，两者显式上的区别是str前面可以有b，unicode前面要有u。这种情况是跟Python默认地使用str有关的：
>>> b'abc'
'abc'
>>> u'abc'
u'abc'
>>> 'abc'
'abc'
>>> type(b'abc')
<type 'str'>
>>> type('abc')
<type 'str'>
>>> type(u'abc')
<type 'unicode'>
两者为basestring派生出来的子类，
# encoding:utf-8for i in [u'中文', '中文']:    if isinstance(i, basestring):        print('is a basestring')    else:        print('is not a basestring')    if isinstance(i, unicode):        print('is a unicode')    else:        print('is not a unicode')    if isinstance(i, str):        print('is a str')    else:        print('is not a str')
运行结果：
is a basestringis a unicodeis not a stris a basestringis not a unicodeis a str[Finished in 0.1s]
然而str实际上是相当于Java中的byte，而实际上unicode相当于char，也就是说str实际上是字节流，而unicode才是真正的字符串，这是Python2一直为人所诟病的地方，不过这是具有一定的历史原因和为了让版本稳定许迁移而做出的让步。到了Python3中明确地声明了str为字符，而bytes为字节流。
两者的相互转换以及与乱码的关系可以看这里
下面主要的是总结对str的操作因为涉及到unicode只是在IO操作的时候

Python的三种字符串表示方式

单引号

这种方式可能更加符合PHP程序员的风格。
>>> type('abc')
<type 'str'>

双引号

这种方式可能更加符合Java和C程序员的风格。
>>> type("abc")
<type 'str'>

三引号

这种是Python独有的了，可以作为多选注释用。
>>> type('''abc''')
<type 'str'>
以上的三种方式在使用上并无区别，只是有以下的几种情况需要注意：

单引号字符串中出现单引号

如果单引号字符串中出现“  ’  ”时，即出现单引号时，需要对单引号进行转义，否则报错
>>> print 'I'm OK'
  File "<stdin>", line 1
    print 'I'm OK'
             ^
SyntaxError: invalid syntax
>>> print 'I\'m OK'
I'm OK
除了进行转义，还可以将单引号字符串改为双引号字符串
>>> print "I'm OK"I'm OK

双引号字符串中出现双引号

与之相应
>>> print "Common sense no "common""
  File "<stdin>", line 1
    print "Common sense no "common""
                                 ^
SyntaxError: invalid syntax
>>> print "Common sense no \"common\""
Common sense no "common"
>>> print 'Common sense no \"common\"'
Common sense no "common"
以上的两种情况统一的解决方法
>>> print '''Common sense no \"common\" '''Common sense no "common">>> print '''I ' m OK'''I ' m OK

DocString

文档字符串可以由三引号生成。
>>> def a():
...             ''' this is function for test'''
...             pass
...
>>> a.__doc__
' this is function for test'
>>> help(a)
Help on function a in module __main__:

a()
    this is function for test

字符串中出现“ \  ”时

这里想要输出“ \ ”，需要在字符串前面加上“r”，否则会进行转义
>>> print 'book or \n cancel'
book or
 cancel
>>> print r'book or \n cancel'
book or \n cancel
此时r字符串称为原始字符串

字符串操作

索引和切片

>>> x = 'abcd'
>>> x[0]
'a'
>>> x[-1]
'd'
>>> x[::-1]
'dcba'

字符串不能更改

>>> x[0] = 'A'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

字符串“ + ”与“ * ”操作

>>> y = x*4
>>> y
'abcdabcdabcdabcd'
>>> y = x+x
>>> y
'abcdabcd'

字符串“in”与“not in”操作

>>> 'a' in x
True
>>> 'a' not in x
False

格式化输出

使用格式化操作符

字符串格式化使用字符串格式化操作符，即百分呈%来实现；而字符串中注明替换位置的%xx则称为转换说明符，xx代表的数据类型。
注：%也可以用作模运算
在%的左侧是一个字串，右边可以是单个变量或者元组，还可以是字典。
如果右边是元组的话，则其中的每一个元素都会被单独格式化，每个值都需要一个对应的转换说明符。
如下由于缺少一个转换说明符而出错
>>> '%s plus %s equals %s' % (1,1,2)
'1 plus 1 equals 2'
>>> '%s plus %s equals %s' % (1,1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: not enough arguments for format string
注意：如果需要转换的元组作为转换表达式的一部分存在，那么必须将它用圆括号括起来，心避免出错。
使用string模块提供的方法
>>> '%s plus %s equals %s' % (1,1,2)
'1 plus 1 equals 2'
>>> '%s plus %s equals %s' % 1,1,2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: not enough arguments for format string
注意：如果使用列表或者其他序列代替元组，那么序列就会被解释为一个值。只有元组和字典可以格式化一个以上的值。
>>> '%s' % range(10)'[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]'>>> '%s %s' % range(10)Traceback (most recent call last):  File "<stdin>", line 1, in <module>TypeError: not enough arguments for format string
注意：如果要在格式化字符串里面包括百分号，那么必须使用%%，这样Python就不会将百分号误认为是转换说明符
>>> '%s %%' % 35'35 %'>>> '%s %' % 35Traceback (most recent call last):  File "<stdin>", line 1, in <module>ValueError: incomplete format
基本的转换说明符。注意的是，这些项的顺序是最为关键的。
（1）%字符：标记转换说明符的开始。
（2）转换标志（可选）：-表示对齐；+表示在转换值之前要加上正负号；“ ”空白字符表示之前保留空格；0表示转换值若位数不够则用0填充。
（3）最小字段宽度（可选）：转换后的字符串至少应该具有该值指定的宽度。如果是*，则宽度会从元组中读出。
（4）点(.)后跟精度值（可选）：如果转换的是实数，精度值就表示出现小数点后的位数。如果转换的是字符串，那么该数字就表示最大字段宽度。如果是*，那么精度将会从元组中读出。
（5）转换类型：
%s    字符串 (采用str()的显示)
%r     字符串 (采用repr()的显示)
%c     单个字符
%b     不带符号二进制整数
%o   不带符号八进制整数
%x   不带符号十六进制整数
%d     带符号十进制整数
%i   带符号十进制整数
%e     科学计数法（基底写为e）
%E   科学计数法（基底写为E）
%f     浮点数
%F     浮点数，与上相同
%g     指数(e)或浮点数 (根据显示长度)
%G     指数(E)或浮点数 (根据显示长度)
%%     字符"%"

使用元组或单个变量

简单转换

>>> 'Price of eggs: $%d' % 42
'Price of eggs: $42'
>>> 'Hexadecimal price of eggs: $%x' % 42
'Hexadecimal price of eggs: $2a'
>>> from math import pi
>>> 'Pi : %f...'% pi
'Pi : 3.141593...'
>>> pi
3.141592653589793
>>> 'Pi : %f'% pi
'Pi : 3.141593'
>>> 'Very inexact estimate of pi: %i' % pi
'Very inexact estimate of pi: 3'
>>> 'Using str: %s' % 42L
'Using str: 42'
>>> 'Using repr: %r' % 42L
'Using repr: 42L'

字段宽度和精度

转换说明符可以包括字段宽度和精度。字段宽度是转换后的值所保留的最小字符个数，精度（对于数字转换来说）则是结果中应该包含的小数位数，或者（对于字符串转换来说）是转换后的值所能包含的最大字符个数。
这两个参数都是整数（首先是字段宽度，然后是精度），通过点号（.）分隔。虽然两个都是可选的参数，但如果只绘出精度，就必须包含点号：
>>> '%10f' % pi                 #字段宽度为10
'  3.141593'
>>> '%10.2f' % pi               #字段宽度为10，精度为2
'      3.14'
>>> '%.2f' % pi                 #精度为2
'3.14'
>>> '%.5s'  %  'Guido van Rossum'
'Guido'
>>> '%.*s'  %  (5,'Guido van Rossum')
'Guido'

符号、对齐和0填充

在字段宽度和精度值之前还可以放置一个“标表”，该标表可以是零、加号、减号或空格。零表示数字将会用0进行填充。
>>> '%010.2f' % pi
'0000003.14'
减号（-）左对齐数据
>>> '%-10.2f' % pi'3.14      '
空白（“ ”）意味着在正数前面加上空格，这在需要对齐负数时很有用。
>>> print ('% 5d' % 10) + '\n' + ('% 5d' % -10)
   10
  -10
加号（“+”）表示不管正数还是负数前面都加上符号，这同样对对齐很有用。
>>> print ('%+5d' % 10) + '\n' + ('%+5d' % -10)  +10  -10

例子打印价格列表

# encoding:utf-8

width = input('Please enter width \n')

price_width = 10
item_width = width - price_width

header_format = '%-*s%*s'
format = '%-*s%*.2f'

print '=' * width

print header_format % (item_width, 'item', price_width, "Price")

print '-' * width

print format % (item_width, 'Apple', price_width, 0.4)
print format % (item_width, 'Pears', price_width, 0.5)
print format % (item_width, 'Cantaloupes', price_width, 1.92)
print format % (item_width, 'Dred Apricots (16 oz.)', price_width, 8)
print format % (item_width, 'Prunes (4 lbs.)', price_width, 12)

print '=' * width
运行结果：
Please enter width40========================================item                               Price----------------------------------------Apple                               0.40Pears                               0.50Cantaloupes                         1.92Dred Apricots (16 oz.)              8.00Prunes (4 lbs.)                    12.00========================================***Repl Closed***

使用字典

>>> phonebook = { "Beth":"9102","Alice":"2341","Cecil":"3258" }
>>> phonebook
{'Beth': '9102', 'Alice': '2341', 'Cecil': '3258'}
>>> "Cecil's phone number is %(Cecil)s" % phonebook
"Cecil's phone number is 3258"
除了增加的字符串键之外，转换说明符还是像以前一样工作。当以这种方式使用字典的时候，只要所有给出的键都能在字典中找到，就可以获得任意数量的转换说明符。这类字符串格式化在模板系统中非常有用，如html
>>> template = '''<html>... <head><title>%(title)s</title></head>... <body>... <h1>%(title)s</h1>... <p>%(text)s</p>... </body>'''>>> data{'text': 'welcome to my home page!', 'title': 'my home page'}>>> print template % data<html><head><title>my home page</title></head><body><h1>my home page</h1><p>welcome to my home page!</p></body>

使用模块String提供的Template进行格式化

String提供另外一种格式化值的方法：模板字符串。它的工作方式类似很多UNIX Shell里的变量替换。
如下所示，substitute这个模板方法会用传递进来的关键字参数foo替换字符串中的$foo
>>> from string import Template
>>> s = Template('$x. glorious $x!')
>>> s.substitute
<bound method Template.substitute of <string.Template object at 0x00000000027F50F0>>
>>> s.substitute(x='slurm')
'slurm. glorious slurm!'
如果替换字段是单词的一部分，那么参数名就必须用括号括起来，从而准确指明结尾
>>> s = Template("It's $[x}tastic!")
>>> s.substitute(x='slurm')
"It's slurmtastic"
可以使用$$插入美元符号。
>>> s = Template("make $$ sell $x!")>>> s.substitute(x='slurm')'make $ sell slurm!'
除了关键字参数以外，还可以使用字典
>>> s = Template('A $thing must never $action.')>>> d = {}>>> d['thing'] = 'gentlemen'>>> d['action'] = 'show his socks'>>> s.substitute(d)'A gentlemen must never show his socks.'
使用safe_substitute方法防止参数不足而报错
>>> from string import Template>>> s = Template('$who likes $what')>>> s.substitute(who='tim', what='kung pao')'tim likes kung pao'>>> d = dict(who='tim')>>> Template('Give $who $100').substitute(d)Traceback (most recent call last):...ValueError: Invalid placeholder in string: line 1, col 11>>> Template('$who likes $what').substitute(d)Traceback (most recent call last):...KeyError: 'what'>>> Template('$who likes $what').safe_substitute(d)'tim likes $what'

使用str对象提供的format函数进行格式化

格式字符串为花括号{}包围的替换字段。所有括号外的内容均被视作文本，不做改变复制到输出。 如果您需要在文本中包括花括号字符，它可以通过双花括号字符来进行转义： { { 和 } }。

"格式说明符"位于格式字符串的被置换区域中，用于定义每一个值如何显示。它们也可以直接传递给内置的format ()函数。每个 formattable 的类型都可以定义格式描述如何被解释。

大多数内置类型都实现了以下的格式描述选项中，虽然一些格式选项只支持数值类型。

标准格式说明符的一般形式为：

format_spec ::=  [[fill]align][sign][#][0][width][,][.precision][type]
fill  ::=  <any character>
align  ::=  "<" | ">" | "=" | "^"
sign  ::=  "+" | "-" | " "
width  ::=  integer
precision  ::=  integer
type  ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"

不同的对齐方式选项的含义如下所示：

Option Meaning
'<' Forces the field to be left-aligned within the available space (this is the default for most objects).
'>' Forces the field to be right-aligned within the available space (this is the default for numbers).
'=' Forces the padding to be placed after the sign (if any) but before the digits. This is used for printing fields in the form ‘+000000120’. This alignment option is only valid for numeric types.
'^' Forces the field to be centered within the available space.

请注意除非定义最小字段宽度，则字段宽度总是将大小相同的数据，来填满它，以便对齐选项已经没有任何意义在这种情况下。

sign

只是有效的数字类型，并且可以将下列操作之一：

Option Meaning
'+' indicates that a sign should be used for both positive as well as negative numbers.
'-' indicates that a sign should be used only for negative numbers (this is the default behavior).
space indicates that a leading space should be used on positive numbers, and a minus sign on negative numbers.

'#'

有效期仅为整数，只为二进制、 八进制或十六进制输出。如果存在，它指定输出将前缀为'0b'、 '0o'或'0 x'，分别。

'，'

信号为数千个使用逗号分隔符。为区域设置意识到分离器，改用n的整数演示文稿类型。

width

是定义最小字段宽度的十进制整数。如果未指定，那么将由内容决定字段宽度。

由零 ('0') 字符前面宽度字段启用标志意识到零填充的数值类型。这是相当于'0'和'='的对齐类型填充字符。

precision

是指示应显示多少位数后浮动小数点点用'f'和'F'，格式化的值或之前和之后小数点点为浮点值, 的十进制数字的格式与'g'或'G'。对于非数字类型字段指示的最大字段大小 — — 换句话说，将从字段内容使用多少个字符。精度是不允许使用整数值。

type

确定数据的显示方式。

可用字符串类型有：

Type Meaning
's' String format. This is the default type for strings and may be omitted.
None The same as 's'.

可用整数类型有：

Type Meaning
'b' Binary format. Outputs the number in base 2.
'c' Character. Converts the integer to the corresponding unicode character before printing.
'd' Decimal Integer. Outputs the number in base 10.
'o' Octal format. Outputs the number in base 8.
'x' Hex format. Outputs the number in base 16, using lower- case letters for the digits above 9.
'X' Hex format. Outputs the number in base 16, using upper- case letters for the digits above 9.
'n' Number. This is the same as 'd', except that it uses the current locale setting to insert the appropriate number separator characters.
None The same as 'd'.

除了上述的演示文稿类型，可以用浮动格式化整数点 （除了n和没有） 下面列出的演示文稿类型。当这样做的过程中， float()用于该整数转换为浮点数格式之前。

可用的演示文稿类型为浮点数和小数的值有：

Type Meaning
'e' Exponent notation. Prints the number in scientific notation using the letter ‘e’ to indicate the exponent. The default precision is 6.
'E' Exponent notation. Same as 'e' except it uses an upper case ‘E’ as the separator character.
'f' Fixed point. Displays the number as a fixed-point number. The default precision is 6.
'F' Fixed point. Same as 'f'.
'g'

常规格式。对于给定的精度p > = 1，这将数字四舍五入到p位数，然后设置格式结果中任一定点格式或科学记数法，根据其大小。

精确的规则如下： 假设结果格式化为演示文稿类型'e' ，且精度p 1会有指数exp。然后，如果-4 < = exp < p，与演示文稿类型'f'和精度p 1 exp格式化的数字。否则，以演示文稿类型'e'和精度p 1格式化的数字。这两种情况微不足道的尾随零是从有效数，移除，并小数点是还是否跟随它没有任何剩余的数字。

正和负无穷大，积极和消极的零和 nan，格式化为inf、 -inf， 0， -0和nan(Not A Number)分别，无论精度。

一个精度为0被视为等同于一个精度为1。默认精度为6。
'G' General format. Same as 'g' except switches to 'E' if the number gets too large. The representations of infinity and NaN are uppercased, too.
'n' Number. This is the same as 'g', except that it uses the current locale setting to insert the appropriate number separator characters.
'%' Percentage. Multiplies the number by 100 and displays in fixed ('f') format, followed by a percent sign.
None The same as 'g'.

例子

  • 访问参数按位置：
    >>>
    >>> '{0}, {1}, {2}'.format('a', 'b', 'c')
    'a, b, c'
    >>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ only
    'a, b, c'
    >>> '{2}, {1}, {0}'.format('a', 'b', 'c')
    'c, b, a'
    >>> '{2}, {1}, {0}'.format(*'abc')      # unpacking argument sequence
    'c, b, a'
    >>> '{0}{1}{0}'.format('abra', 'cad')   # arguments' indices can be repeated
    'abracadabra'
  • 按名称访问参数：
    >>>>>> 'Coordinates: {latitude}, {longitude}'.format(latitude='37.24N', longitude='-115.81W')'Coordinates: 37.24N, -115.81W'>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}>>> 'Coordinates: {latitude}, {longitude}'.format(**coord)'Coordinates: 37.24N, -115.81W'
  • 访问这些参数的属性：
    >>>>>> c = 3-5j>>> ('The complex number {0} is formed from the real part {0.real} '...  'and the imaginary part {0.imag}.').format(c)'The complex number (3-5j) is formed from the real part 3.0 and the imaginary part -5.0.'>>> class Point(object):...     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)'
  • 访问参数的项：
    >>>>>> coord = (3, 5)>>> 'X: {0[0]};  Y: {0[1]}'.format(coord)'X: 3;  Y: 5'
  • 替换%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')  # use '*' as a fill char'***********centered***********'
  • 替换%+ f、 %f和% f ，并指定一个标志：
    >>>>>> '{:+f}; {:+f}'.format(3.14, -3.14)  # show it always'+3.140000; -3.140000'>>> '{: f}; {: f}'.format(3.14, -3.14)  # show a space for positive numbers' 3.140000; -3.140000'>>> '{:-f}; {:-f}'.format(3.14, -3.14)  # show only the minus -- same as '{:f}; {:f}''3.140000; -3.140000'
  • 替换%x和&并将值转换为不同的基础：
    >>>>>> # format also supports binary numbers>>> "int: {0:d};  hex: {0:x};  oct: {0:o};  bin: {0:b}".format(42)'int: 42;  hex: 2a;  oct: 52;  bin: 101010'>>> # with 0x, 0o, or 0b as prefix:>>> "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.5>>> total = 22>>> 'Correct answers: {:.2%}'.format(points/total)'Correct answers: 88.64%'
  • 使用特定于类型的格式：
    >>>>>> import datetime>>> d = datetime.datetime(2010, 7, 4, 12, 15, 58)>>> '{:%Y-%m-%d %H:%M:%S}'.format(d)'2010-07-04 12:15:58'
  • 嵌套参数和更复杂的例子：
    >>>>>> 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'>>> 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),...     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

字符串常量

在此string中定义的常量有：
  • string.ascii_letters
ascii_lowercase和ascii_uppercase常量的连接串，如下所述。此值不是依赖于区域设置的。
  • string.ascii_lowercase
小写字母'abcdefghijklmnopqrstuvwxyz'。此值不是依赖于区域设置的并且不会改变。
  • string.ascii_uppercase
大写的字母'ABCDEFGHIJKLMNOPQRSTUVWXYZ'。此值不是依赖于区域设置的并且不会改变。
  • string.digits
字符串'0123456789'。
  • string.hexdigits
字符串'0123456789abcdefABCDEF'。
  • string.letters
The concatenation of the strings lowercase and uppercase described below.特定的值依赖于区域设置，并调用locale.setlocale()时将更新。
  • string.lowercase
一个字符串，包含所有被认为是小写字母的字符。在大多数系统上，这是字符串'abcdefghijklmnopqrstuvwxyz'。特定的值依赖于区域设置，并调用locale.setlocale()时将更新。
  • string.octdigits
字符串'01234567'。
  • string.punctuation
在C语言中的标点字符的 ASCII 字符的字符串。
  • string.printable
可打印的字符的字符串。这是一个组合的数字、字母、标点符号和空格。
  • string.uppercase
一个字符串，包含所有被认为是大写字母的字符。在大多数系统上，这是'ABCDEFGHIJKLMNOPQRSTUVWXYZ'的字符串。特定的值依赖于区域设置，并调用locale.setlocale()时将更新。
  • string.whitespace
包含的所有字符都被视为空格的字符串。在大多数系统上，这包括空格符、 制表符、 换行符、 回车符、 换页符和垂直制表符。

常用的字符串方法

capitalize()方法

  • 描述
Python capitalize()将字符串的第一个字母变成大写,其他字母变小写。对于 8 位字节编码需要根据本地环境。
  • 语法
capitalize()方法语法：
str.capitalize()
  • 参数
无。
  • 返回值
该方法返回一个首字母大写的字符串。
  • 实例
以下实例展示了capitalize()方法的实例：
#!/usr/bin/python

str = "this is string example....wow!!!";

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

center()方法

  • 描述
Python center() 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串。默认填充字符为空格。
  • 语法
center()方法语法：
str.center(width[, fillchar])
  • 参数
width -- 字符串的总宽度。
fillchar -- 填充字符。
  • 返回值
该方法返回一个原字符串居中,并使用空格填充至长度 width 的新字符串。
  • 实例
以下实例展示了center()方法的实例：
#!/usr/bin/python

str = "this is string example....wow!!!";

print "str.center(40, 'a') : ", str.center(40, 'a')
以上实例输出结果如下：
str.center(40, 'a') :  aaaathis is string example....wow!!!aaaa

count()方法

  • 描述
Python count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
  • 语法
count()方法语法：
str.count(sub, start= 0,end=len(string))
  • 参数
sub -- 搜索的子字符串
start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。
  • 返回值
该方法返回子字符串在字符串中出现的次数。
  • 实例
以下实例展示了count()方法的实例：
#!/usr/bin/python

str = "this is string example....wow!!!";

sub = "i";
print "str.count(sub, 4, 40) : ", str.count(sub, 4, 40)
sub = "wow";
print "str.count(sub) : ", str.count(sub)
以上实例输出结果如下：
str.count(sub, 4, 40) :  2str.count(sub, 4, 40) :  1

decode()方法

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

str = "this is string example....wow!!!";
str = str.encode('base64','strict');

print "Encoded String: " + str;
print "Decoded String: " + str.decode('base64','strict')
以上实例输出结果如下：
Encoded String: dGhpcyBpcyBzdHJpbmcgZXhhbXBsZS4uLi53b3chISE=Decoded String: this is string example....wow!!!

encode()方法

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

str = "this is string example....wow!!!";

print "Encoded String: " + str.encode('base64','strict')
以上实例输出结果如下：
Encoded String: dGhpcyBpcyBzdHJpbmcgZXhhbXBsZS4uLi53b3chISE=

endswith()方法

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

str = "this is string example....wow!!!";

suffix = "wow!!!";
print str.endswith(suffix);
print str.endswith(suffix,20);

suffix = "is";
print str.endswith(suffix, 2, 4);
print str.endswith(suffix, 2, 6);
以上实例输出结果如下：
TrueTrueTrueFalse

expandtabs()方法

  • 描述
Python expandtabs() 方法把字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是 8。
  • 语法
expandtabs()方法语法：
str.expandtabs(tabsize=8)
  • 参数
tabsize -- 指定转换字符串中的 tab 符号('\t')转为空格的字符数。
  • 返回值
该方法返回字符串中的 tab 符号('\t')转为空格后生成的新字符串。
  • 实例
以下实例展示了expandtabs()方法的实例：
#!/usr/bin/python

str = "this is\tstring example....wow!!!";

print "Original string: " + str;
print "Defualt exapanded tab: " +  str.expandtabs();
print "Double exapanded tab: " +  str.expandtabs(16);
以上实例输出结果如下：
Original string: this is        string example....wow!!!Defualt exapanded tab: this is string example....wow!!!Double exapanded tab: this is         string example....wow!!!

find()方法

  • 描述
Python find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。
  • 语法
find()方法语法：
str.index(str, beg=0, end=len(string))
  • 参数
str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。
  • 返回值
如果包含子字符串返回开始的索引值，否则返回-1。
  • 实例
以下实例展示了find()方法的实例：
#!/usr/bin/python

str1 = "this is string example....wow!!!";
str2 = "exam";

print str1.find(str2);
print str1.find(str2, 10);
print str1.find(str2, 40);
以上实例输出结果如下：
1515-1

index()方法

  • 描述
Python index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。
  • 语法
index()方法语法：
str.index(str, beg=0, end=len(string))
  • 参数
str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。
  • 返回值
如果包含子字符串返回开始的索引值，否则抛出异常。
  • 实例
以下实例展示了index()方法的实例：
#!/usr/bin/python

str1 = "this is string example....wow!!!";
str2 = "exam";

print str1.index(str2);
print str1.index(str2, 10);
print str1.index(str2, 40);
以上实例输出结果如下：
1515Traceback (most recent call last):  File "test.py", line 8, in   print str1.index(str2, 40);ValueError: substring not foundshell returned 1

isalnum()方法

  • 描述
Python isalnum() 方法检测字符串是否由字母和数字组成。
  • 语法
isalnum()方法语法：
str.isalnum()
  • 参数
无。
  • 返回值
如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
  • 实例
以下实例展示了isalnum()方法的实例：
实例(Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
str = "this2009";  # 字符中没有空格
print str.isalnum();

str = "this is string example....wow!!!";
print str.isalnum();
以上实例输出结果如下：
TrueFalse

isalpha()方法

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

str = "this";  # No space & digit in this string
print str.isalpha();

str = "this is string example....wow!!!";
print str.isalpha();
以上实例输出结果如下：
TrueFalse

isdecimal()方法

  • 描述
Python isdecimal() 方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。
注意:定义一个十进制字符串，只需要在字符串前添加 'u' 前缀即可。
  • 语法
isdecimal()方法语法：
str.isdecimal()
  • 参数
无
  • 返回值
如果字符串是否只包含十进制字符返回True，否则返回False。
  • 实例
以下实例展示了 isdecimal()函数的使用方法：
#!/usr/bin/python


str = u"this2009";  
print str.isdecimal();

str = u"23443434";
print str.isdecimal();
以上实例输出结果如下：
FalseTrue

isdigit()方法

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

str = "123456";  # Only digit in this string
print str.isdigit();

str = "this is string example....wow!!!";
print str.isdigit();
以上实例输出结果如下：
TrueFalse

islower()方法

  • 描述
Python islower() 方法检测字符串是否由小写字母组成。
  • 语法
islower()方法语法：
str.islower()
  • 参数
无。
  • 返回值
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
  • 实例
以下实例展示了islower()方法的实例：
#!/usr/bin/python

str = "THIS is string example....wow!!!"; 
print str.islower();

str = "this is string example....wow!!!";
print str.islower();
以上实例输出结果如下：
FalseTrue

isnumeric()方法

  • 描述
Python isnumeric() 方法检测字符串是否只由数字组成。这种方法是只针对unicode对象。
注：定义一个字符串为Unicode，只需要在字符串前添加 'u' 前缀即可，具体可以查看本章节例子。
  • 语法
isnumeric()方法语法：
str.isnumeric()
  • 参数
无。
  • 返回值
如果字符串中只包含数字字符，则返回 True，否则返回 False
  • 实例
以下实例展示了isnumeric()方法的实例：
#!/usr/bin/python


str = u"this2009";  
print str.isnumeric();

str = u"23443434";
print str.isnumeric();
以上实例输出结果如下：
FalseTrue

isspace()方法

  • 描述
Python isspace() 方法检测字符串是否只由空格组成。
  • 语法
isspace()方法语法：
str.isspace()
  • 参数
无。
  • 返回值
如果字符串中只包含空格，则返回 True，否则返回 False.
  • 实例
以下实例展示了isspace()方法的实例：
#!/usr/bin/python

str = "       "; 
print str.isspace();

str = "This is string example....wow!!!";
print str.isspace();
以上实例输出结果如下：
TrueFalse

istitle()方法

  • 描述
Python istitle() 方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。
  • 语法
istitle()方法语法：
str.istitle()
  • 参数
无。
  • 返回值
如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False.
  • 实例
以下实例展示了istitle()方法的实例：
#!/usr/bin/python

str = "This Is String Example...Wow!!!";
print str.istitle();

str = "This is string example....wow!!!";
print str.istitle();
以上实例输出结果如下：
TrueFalse

isupper()方法

  • 描述
Python isupper() 方法检测字符串中所有的字母是否都为大写。
  • 语法
isupper()方法语法：
str.isupper()
  • 参数
无。
  • 返回值
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
  • 实例
以下实例展示了isupper()方法的实例：
#!/usr/bin/python

str = "THIS IS STRING EXAMPLE....WOW!!!"; 
print str.isupper();

str = "THIS is string example....wow!!!";
print str.isupper();
以上实例输出结果如下：
TrueFalse

join()方法

  • 描述
Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
  • 语法
join()方法语法：
str.join(sequence)
  • 参数
sequence -- 要连接的元素序列。
  • 返回值
返回通过指定字符连接序列中元素后生成的新字符串。
  • 实例
以下实例展示了join()的使用方法：
#!/usr/bin/python


str = "-";
seq = ("a", "b", "c"); # 字符串序列
print str.join( seq );
以上实例输出结果如下：
a-b-c

ljust()方法

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

str = "this is string example....wow!!!";

print str.ljust(50, '0');
以上实例输出结果如下：
this is string example....wow!!!000000000000000000

lower()方法

  • 描述
Python lower() 方法转换字符串中所有大写字符为小写。
  • 语法
lower()方法语法：
str.lower()
  • 参数
无。
  • 返回值
返回将字符串中所有大写字符转换为小写后生成的字符串。
  • 实例
以下实例展示了lower()的使用方法：
#!/usr/bin/python

str = "THIS IS STRING EXAMPLE....WOW!!!";

print str.lower();
以上实例输出结果如下：
this is string example....wow!!!

lstrip()方法

  • 描述
Python lstrip() 方法用于截掉字符串左边的空格或指定字符。
  • 语法
lstrip()方法语法：
str.lstrip([chars])
  • 参数
chars --指定截取的字符。
  • 返回值
返回截掉字符串左边的空格或指定字符后生成的新字符串。
  • 实例
以下实例展示了lstrip()的使用方法：
#!/usr/bin/python

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

maketrans()方法

  • 描述
Python maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
注：两个字符串的长度必须相同，为一一对应的关系。
  • 语法
maketrans()方法语法：
str.maketrans(intab, outtab)
  • 参数
intab -- 字符串中要替代的字符组成的字符串。
outtab -- 相应的映射字符的字符串。
  • 返回值
返回字符串转换后生成的新字符串。
  • 实例
以下实例展示了使用maketrans() 方法将所有元音字母转换为指定的数字：
#!/usr/bin/python
# -*- coding: UTF-8 -*-

from string import maketrans   # 必须调用 maketrans 函数。

intab = "aeiou"
outtab = "12345"
trantab = maketrans(intab, outtab)

str = "this is string example....wow!!!";
print str.translate(trantab);
以上实例输出结果如下：
th3s 3s str3ng 2x1mpl2....w4w!!!

max()方法

  • 描述
Python max() 方法返回字符串中最大的字母。
  • 语法
max()方法语法：
max(str)
  • 参数
str -- 字符串。
  • 返回值
返回字符串中最大的字母。
  • 实例
以下实例展示了max()函数的使用方法：
#!/usr/bin/python

str = "this is really a string example....wow!!!";
print "Max character: " + max(str);

str = "this is a string example....wow!!!";
print "Max character: " + max(str);
以上实例输出结果如下：
Max character: yMax character: x

min()方法

  • 描述
Python min() 方法返回字符串中最小的字母。
  • 语法
min()方法语法：
min(str)
  • 参数
str -- 字符串。
  • 返回值
返回字符串中最小的字母。
  • 实例
以下实例展示了min()函数的使用方法：
#!/usr/bin/python

str = "this-is-real-string-example....wow!!!";
print "Min character: " + min(str);

str = "this-is-a-string-example....wow!!!";
print "Min character: " + min(str);
以上实例输出结果如下：
Min character: !Min character: !

partition() 方法

  • 描述
partition() 方法用来根据指定的分隔符将字符串进行分割。
如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。
partition() 方法是在2.5版中新增的。
  • 语法
partition()方法语法：
str.partition(str)
  • 参数
str : 指定的分隔符。
  • 返回值
返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。
  • 实例
以下实例展示了使用 partition() 方法的使用：
#!/usr/bin/python

str = "http://www.w3cschool.cc/"

print str.partition("://")
输出结果为：
('http', '://', 'www.w3cschool.cc/')

replace()方法

  • 描述
Python replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
  • 语法
replace()方法语法：
str.replace(old, new[, max])
  • 参数
old -- 将被替换的子字符串。
new -- 新字符串，用于替换old子字符串。
max -- 可选字符串, 替换不超过 max 次
  • 返回值
返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次。
  • 实例
以下实例展示了replace()函数的使用方法：
#!/usr/bin/python


str = "this is string example....wow!!! this is really string";
print str.replace("is", "was");
print str.replace("is", "was", 3);
以上实例输出结果如下：
thwas was string example....wow!!! thwas was really stringthwas was string example....wow!!! thwas is really string

rfind()方法

  • 描述
Python rfind() 返回字符串最后一次出现的位置，如果没有匹配项则返回-1。
  • 语法
rfind()方法语法：
str.rfind(str, beg=0 end=len(string))
  • 参数
str -- 查找的字符串
beg -- 开始查找的位置，默认为0
end -- 结束查找位置，默认为字符串的长度。
  • 返回值
返回字符串最后一次出现的位置，如果没有匹配项则返回-1。
  • 实例
以下实例展示了rfind()函数的使用方法：
#!/usr/bin/python

str = "this is really a string example....wow!!!";
substr = "is";

print str.rfind(substr);
print str.rfind(substr, 0, 10);
print str.rfind(substr, 10, 0);

print str.find(substr);
print str.find(substr, 0, 10);
print str.find(substr, 10, 0);
以上实例输出结果如下：
55-122-1

rindex()方法

  • 描述
Python rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间。
  • 语法
rindex()方法语法：
str.rindex(str, beg=0 end=len(string))
  • 参数
str -- 查找的字符串
beg -- 开始查找的位置，默认为0
end -- 结束查找位置，默认为字符串的长度。
  • 返回值
返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常。
  • 实例
以下实例展示了rindex()函数的使用方法：
#!/usr/bin/python

str1 = "this is string example....wow!!!";
str2 = "is";

print str1.rindex(str2);
print str1.index(str2);
以上实例输出结果如下：
5
2

rjust()方法

  • 描述
Python rjust() 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。
  • 语法
rjust()方法语法：
str.rjust(width[, fillchar])
  • 参数
width -- 指定填充指定字符后中字符串的总长度.
fillchar -- 填充的字符，默认为空格。
  • 返回值
返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串
  • 实例
以下实例展示了rjust()函数的使用方法：
#!/usr/bin/python

str = "this is string example....wow!!!";

print str.rjust(50, '0');
以上实例输出结果如下：
000000000000000000this is string example....wow!!!

rstrip()方法

  • 描述
Python rstrip() 删除 string 字符串末尾的指定字符（默认为空格）.
  • 语法
rstrip()方法语法：
str.rstrip([chars])
参数
chars -- 指定删除的字符（默认为空格）
  • 返回值
返回删除 string 字符串末尾的指定字符后生成的新字符串。
  • 实例
以下实例展示了rstrip()函数的使用方法：
#!/usr/bin/python

str = "     this is string example....wow!!!     ";
print str.rstrip();
str = "88888888this is string example....wow!!!8888888";
print str.rstrip('8');
以上实例输出结果如下：
     this is string example....wow!!!88888888this is string example....wow!!!

split()方法

  • 描述
Python split()通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串
  • 语法
split()方法语法：
str.split(str="", num=string.count(str)).
  • 参数
str -- 分隔符，默认为空格。
num -- 分割次数。
  • 返回值
返回分割后的字符串列表。
  • 实例
以下实例展示了split()函数的使用方法：
#!/usr/bin/python

str = "Line1-abcdef \nLine2-abc \nLine4-abcd";
print str.split( );
print str.split(' ', 1 );
以上实例输出结果如下：
['Line1-abcdef', 'Line2-abc', 'Line4-abcd']['Line1-abcdef', '\nLine2-abc \nLine4-abcd']

splitlines()方法

  • 描述
Python splitlines() 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
  • 语法
splitlines()方法语法：
str.splitlines([keepends])
  • 参数
keepends -- 在输出结果里是否去掉换行符('\r', '\r\n', \n')，默认为 False，不包含换行符，如果为 True，则保留换行符。
  • 返回值
返回一个包含各行作为元素的列表。
  • 实例
以下实例展示了splitlines()函数的使用方法：
#!/usr/bin/python

str1 = 'ab c\n\nde fg\rkl\r\n'
print str1.splitlines();

str2 = 'ab c\n\nde fg\rkl\r\n'
print str2.splitlines(True)
以上实例输出结果如下：
['ab c', '', 'de fg', 'kl']['ab c\n', '\n', 'de fg\r', 'kl\r\n']

startswith()方法

  • 描述
Python startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。
  • 语法
startswith()方法语法：
str.startswith(str, beg=0,end=len(string));
  • 参数
str -- 检测的字符串。
strbeg -- 可选参数用于设置字符串检测的起始位置。
strend -- 可选参数用于设置字符串检测的结束位置。
  • 返回值
如果检测到字符串则返回True，否则返回False。
  • 实例
以下实例展示了startswith()函数的使用方法：
#!/usr/bin/python


str = "this is string example....wow!!!";
print str.startswith( 'this' );
print str.startswith( 'is', 2, 4 );
print str.startswith( 'this', 2, 4 );
以上实例输出结果如下：
TrueTrueFalse

strip()方法

  • 描述
Python strip() 方法用于移除字符串头尾指定的字符（默认为空格）。
  • 语法
strip()方法语法：
str.strip([chars]);
  • 参数
chars -- 移除字符串头尾指定的字符。
  • 返回值
返回移除字符串头尾指定的字符生成的新字符串。
  • 实例
以下实例展示了strip()函数的使用方法：
#!/usr/bin/python

str = "0000000this is string example....wow!!!0000000";
print str.strip( '0' );
以上实例输出结果如下：
this is string example....wow!!!

swapcase()方法

  • 描述
Python swapcase() 方法用于对字符串的大小写字母进行转换。
  • 语法
swapcase()方法语法：
str.swapcase();
  • 参数
NA。
  • 返回值
返回大小写字母转换后生成的新字符串。
  • 实例
以下实例展示了swapcase()函数的使用方法：
#!/usr/bin/python

str = "this is string example....wow!!!";
print str.swapcase();

str = "THIS IS STRING EXAMPLE....WOW!!!";
print str.swapcase();
以上实例输出结果如下：
this is string example....wow!!!

title()方法

  • 描述
Python title() 方法返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())。
  • 语法
title()方法语法：
str.title();
  • 参数
NA。
  • 返回值
返回"标题化"的字符串,就是说所有单词都是以大写开始。
  • 实例
以下实例展示了 title()函数的使用方法：
#!/usr/bin/python

str = "this is string example....wow!!!";
print str.title();
以上实例输出结果如下：
This Is String Example....Wow!!!

translate()方法

  • 描述
Python translate() 方法根据参数table给出的表(包含 256 个字符)转换字符串的字符, 要过滤掉的字符放到 del 参数中。
  • 语法
translate()方法语法：
str.translate(table[, deletechars]);
  • 参数
table -- 翻译表，翻译表是通过maketrans方法转换而来。
deletechars -- 字符串中要过滤的字符列表。
  • 返回值
返回翻译后的字符串。
  • 实例
以下实例展示了 translate()函数的使用方法：
#!/usr/bin/python

from string import maketrans   # 引用 maketrans 函数。

intab = "aeiou"
outtab = "12345"
trantab = maketrans(intab, outtab)

str = "this is string example....wow!!!";
print str.translate(trantab);
以上实例输出结果如下：
th3s 3s str3ng 2x1mpl2....w4w!!!
以下实例去除字符串中的 'x' 和 'm' 字符：
#!/usr/bin/pythonfrom string import maketrans   # Required to call maketrans function.intab = "aeiou"outtab = "12345"trantab = maketrans(intab, outtab)str = "this is string example....wow!!!";print str.translate(trantab, 'xm');
以上实例输出结果：
th3s 3s str3ng 21pl2....w4w!!!

upper()方法

  • 描述
Python upper() 方法将字符串中的小写字母转为大写字母。
  • 语法
upper()方法语法：
str.upper()
  • 参数
NA。
  • 返回值
返回小写字母转为大写字母的字符串。
  • 实例
以下实例展示了 upper()函数的使用方法：
#!/usr/bin/python

str = "this is string example....wow!!!";

print "str.upper() : ", str.upper()
以上实例输出结果如下：
str.upper() :  THIS IS STRING EXAMPLE....WOW!!!

zfill()方法

  • 描述
Python zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0。
  • 语法
zfill()方法语法：
str.zfill(width)
  • 参数
width -- 指定字符串的长度。原字符串右对齐，前面填充0。
  • 返回值
返回指定长度的字符串。
  • 实例
以下实例展示了 zfill()函数的使用方法：
#!/usr/bin/python

str = "this is string example....wow!!!";

print str.zfill(40);
print str.zfill(50);
以上实例输出结果如下：
00000000this is string example....wow!!!000000000000000000this is string example....wow!!!
标签：

相关文章