Python2字符串类型
Python2.7中字符串主要分为两种str和unicode，两者显式上的区别是str前面可以有b，unicode前面要有u。这种情况是跟Python默认地使用str有关的：>>> b'abc'两者为basestring派生出来的子类，
'abc'
>>> u'abc'
u'abc'
>>> 'abc'
'abc'
>>> type(b'abc')
<type 'str'>
>>> type('abc')
<type 'str'>
>>> type(u'abc')
<type 'unicode'>
# 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'此时r字符串称为原始字符串
book or
cancel
>>> print r'book or \n cancel'
book or \n cancel
字符串操作
索引和切片
>>> 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 的类型都可以定义格式描述如何被解释。
大多数内置类型都实现了以下的格式描述选项中，虽然一些格式选项只支持数值类型。
标准格式说明符的一般形式为：
不同的对齐方式选项的含义如下所示：
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
- string.ascii_lowercase
- string.ascii_uppercase
- string.digits
- string.hexdigits
- string.letters
- string.lowercase
- string.octdigits
- string.punctuation
- string.printable
- string.uppercase
- string.whitespace
常用的字符串方法
capitalize()方法
- 描述
- 语法
str.capitalize()
- 参数
- 返回值
- 实例
#!/usr/bin/python以上实例输出结果如下：
str = "this is string example....wow!!!";
print "str.capitalize() : ", str.capitalize()
str.capitalize() : This is string example....wow!!!
center()方法
- 描述
- 语法
str.center(width[, fillchar])
- 参数
fillchar -- 填充字符。
- 返回值
- 实例
#!/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()方法
- 描述
- 语法
str.count(sub, start= 0,end=len(string))
- 参数
start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。
- 返回值
- 实例
#!/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()方法
- 描述
- 语法
str.decode(encoding='UTF-8',errors='strict')
- 参数
errors -- 设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。
- 返回值
- 实例
#!/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()方法
- 描述
- 语法
str.encode(encoding='UTF-8',errors='strict')
- 参数
errors -- 设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。
- 返回值
- 实例
#!/usr/bin/python以上实例输出结果如下：
str = "this is string example....wow!!!";
print "Encoded String: " + str.encode('base64','strict')
Encoded String: dGhpcyBpcyBzdHJpbmcgZXhhbXBsZS4uLi53b3chISE=
endswith()方法
- 描述
- 语法
str.endswith(suffix[, start[, end]])
- 参数
start -- 字符串中的开始位置。
end -- 字符中结束位置。
- 返回值
- 实例
#!/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()方法
- 描述
- 语法
str.expandtabs(tabsize=8)
- 参数
- 返回值
- 实例
#!/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()方法
- 描述
- 语法
str.index(str, beg=0, end=len(string))
- 参数
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。
- 返回值
- 实例
#!/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()方法
- 描述
- 语法
str.index(str, beg=0, end=len(string))
- 参数
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。
- 返回值
- 实例
#!/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()方法
- 描述
- 语法
str.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()方法
- 描述
- 语法
str.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()方法
- 描述
注意:定义一个十进制字符串，只需要在字符串前添加 'u' 前缀即可。
- 语法
str.isdecimal()
- 参数
- 返回值
- 实例
#!/usr/bin/python以上实例输出结果如下：
str = u"this2009";
print str.isdecimal();
str = u"23443434";
print str.isdecimal();
FalseTrue
isdigit()方法
- 描述
- 语法
str.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()方法
- 描述
- 语法
str.islower()
- 参数
- 返回值
- 实例
#!/usr/bin/python以上实例输出结果如下：
str = "THIS is string example....wow!!!";
print str.islower();
str = "this is string example....wow!!!";
print str.islower();
FalseTrue
isnumeric()方法
- 描述
注：定义一个字符串为Unicode，只需要在字符串前添加 'u' 前缀即可，具体可以查看本章节例子。
- 语法
str.isnumeric()
- 参数
- 返回值
- 实例
#!/usr/bin/python以上实例输出结果如下：
str = u"this2009";
print str.isnumeric();
str = u"23443434";
print str.isnumeric();
FalseTrue
isspace()方法
- 描述
- 语法
str.isspace()
- 参数
- 返回值
- 实例
#!/usr/bin/python以上实例输出结果如下：
str = " ";
print str.isspace();
str = "This is string example....wow!!!";
print str.isspace();
TrueFalse
istitle()方法
- 描述
- 语法
str.istitle()
- 参数
- 返回值
- 实例
#!/usr/bin/python以上实例输出结果如下：
str = "This Is String Example...Wow!!!";
print str.istitle();
str = "This is string example....wow!!!";
print str.istitle();
TrueFalse
isupper()方法
- 描述
- 语法
str.isupper()
- 参数
- 返回值
- 实例
#!/usr/bin/python以上实例输出结果如下：
str = "THIS IS STRING EXAMPLE....WOW!!!";
print str.isupper();
str = "THIS is string example....wow!!!";
print str.isupper();
TrueFalse
join()方法
- 描述
- 语法
str.join(sequence)
- 参数
- 返回值
- 实例
#!/usr/bin/python以上实例输出结果如下：
str = "-";
seq = ("a", "b", "c"); # 字符串序列
print str.join( seq );
a-b-c
ljust()方法
- 描述
- 语法
str.ljust(width[, fillchar])
- 参数
fillchar -- 填充字符，默认为空格。
- 返回值
- 实例
#!/usr/bin/python以上实例输出结果如下：
str = "this is string example....wow!!!";
print str.ljust(50, '0');
this is string example....wow!!!000000000000000000
lower()方法
- 描述
- 语法
str.lower()
- 参数
- 返回值
- 实例
#!/usr/bin/python以上实例输出结果如下：
str = "THIS IS STRING EXAMPLE....WOW!!!";
print str.lower();
this is string example....wow!!!
lstrip()方法
- 描述
- 语法
str.lstrip([chars])
- 参数
- 返回值
- 实例
#!/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()方法
- 描述
注：两个字符串的长度必须相同，为一一对应的关系。
- 语法
str.maketrans(intab, outtab)
- 参数
outtab -- 相应的映射字符的字符串。
- 返回值
- 实例
#!/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()方法
- 描述
- 语法
max(str)
- 参数
- 返回值
- 实例
#!/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()方法
- 描述
- 语法
min(str)
- 参数
- 返回值
- 实例
#!/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() 方法
- 描述
如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。
partition() 方法是在2.5版中新增的。
- 语法
str.partition(str)
- 参数
- 返回值
- 实例
#!/usr/bin/python输出结果为：
str = "http://www.w3cschool.cc/"
print str.partition("://")
('http', '://', 'www.w3cschool.cc/')
replace()方法
- 描述
- 语法
str.replace(old, new[, max])
- 参数
new -- 新字符串，用于替换old子字符串。
max -- 可选字符串, 替换不超过 max 次
- 返回值
- 实例
#!/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()方法
- 描述
- 语法
str.rfind(str, beg=0 end=len(string))
- 参数
beg -- 开始查找的位置，默认为0
end -- 结束查找位置，默认为字符串的长度。
- 返回值
- 实例
#!/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()方法
- 描述
- 语法
str.rindex(str, beg=0 end=len(string))
- 参数
beg -- 开始查找的位置，默认为0
end -- 结束查找位置，默认为字符串的长度。
- 返回值
- 实例
#!/usr/bin/python以上实例输出结果如下：
str1 = "this is string example....wow!!!";
str2 = "is";
print str1.rindex(str2);
print str1.index(str2);
5
2
rjust()方法
- 描述
- 语法
str.rjust(width[, fillchar])
- 参数
fillchar -- 填充的字符，默认为空格。
- 返回值
- 实例
#!/usr/bin/python以上实例输出结果如下：
str = "this is string example....wow!!!";
print str.rjust(50, '0');
000000000000000000this is string example....wow!!!
rstrip()方法
- 描述
- 语法
str.rstrip([chars])参数
chars -- 指定删除的字符（默认为空格）
- 返回值
- 实例
#!/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()方法
- 描述
- 语法
str.split(str="", num=string.count(str)).
- 参数
num -- 分割次数。
- 返回值
- 实例
#!/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()方法
- 描述
- 语法
str.splitlines([keepends])
- 参数
- 返回值
- 实例
#!/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()方法
- 描述
- 语法
str.startswith(str, beg=0,end=len(string));
- 参数
strbeg -- 可选参数用于设置字符串检测的起始位置。
strend -- 可选参数用于设置字符串检测的结束位置。
- 返回值
- 实例
#!/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()方法
- 描述
- 语法
str.strip([chars]);
- 参数
- 返回值
- 实例
#!/usr/bin/python以上实例输出结果如下：
str = "0000000this is string example....wow!!!0000000";
print str.strip( '0' );
this is string example....wow!!!
swapcase()方法
- 描述
- 语法
str.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()方法
- 描述
- 语法
str.title();
- 参数
- 返回值
- 实例
#!/usr/bin/python以上实例输出结果如下：
str = "this is string example....wow!!!";
print str.title();
This Is String Example....Wow!!!
translate()方法
- 描述
- 语法
str.translate(table[, deletechars]);
- 参数
deletechars -- 字符串中要过滤的字符列表。
- 返回值
- 实例
#!/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()方法
- 描述
- 语法
str.upper()
- 参数
- 返回值
- 实例
#!/usr/bin/python以上实例输出结果如下：
str = "this is string example....wow!!!";
print "str.upper() : ", str.upper()
str.upper() : THIS IS STRING EXAMPLE....WOW!!!
zfill()方法
- 描述
- 语法
str.zfill(width)
- 参数
- 返回值
- 实例
#!/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!!!