用Python作文本处理 第二章 -- 基本的字符串运用

用Python作文本处理/第二章

目录

?1第一节-- 常用的操作

?2主题-- 快速排序

?3主题-- 排版

?4主题-- 处理字段

?5主题-- 字词数统计

?6主题-- 以二进制数据传送ASCII码信息

?7主题-- 词频统计

第一节-- 常用的操作

主题-- 快速排序

排序是文字处理中大多数任务的关键所在。幸运的是，在Python里，使用`[].sort`的效率还不错。此外，在列表的任何不同对象都可以排序而不需要像C语言那样需要统一的元素（对于混合复数和Unicode字符串的列表排序在最近的几个Python版本里会触发'TypeError'异常）。

参考：[complex]

+++

列表排序的顺序有一种自然顺序，特别是不同类型混合的排序顺序都是Python的默认顺序。很多时候，你需要特定的顺序。特别是对于文本里的行做排序往往需要的不是简单的字母顺序。通常一行里有用的信息起始位置并不是第一个字符：人名里的姓往往是第二个单词；服务器日志里IP地址可能固定在某个字段；金额合计可能在每一行的第

70列等等。只使用默认排序这些内容只会毫无意义。

列表排序`[].sort()`支持自定义比较函数参数。这个比较函数的功能是返回-1则表示前者排在后者之前，返回0则表示二者顺序相同，返回1则表示后者排在前者之前。内置函数`cmp()`就是`[].sort()`的默认比较函数（在速度上'lst.sort()'远远超过'lst.sort(cmp)'）。

对于不太长的列表使用自定义比较函数可以快速的解决问题。在很多情况下，甚至可以直接使用一个'lambda'表达式来完成任务。

说到速度，使用自定义比较函数效率会很低。部分原因是Python的函数调用开销，函数本身也会增加花费的时间。不过有一种技术“Schwartzian转换”可以加速这种自定义排序。Schwartzian转换是兰德尔施瓦兹在Perl中最先开始使用的，但其中的技巧同样适用于Python。

使用Schwartzian转换主要包括三个步骤，（准确的来说这是Guttman-Rosler转换

(GRT)，同样基于Schwartzian转换）：

? 1. 将列表转换为可以用默认排序的列表。

? 2. 使用`[].sort()`排序。

? 3. 转回原先的格式。

这项技术的主要作用是花费仅仅O(2N)转换就可以使用默认的O(N log N)排序。如果

任务里排序时间是主要因素的话，使用这项技术将大大提高效率（唯一的限制就是转换花费的时间不会很多）。

下面是一个简单的例子。排序比较方式是比较每一行的第四个单词。有的行单词数少于4个。测试文件约20,000行（1兆左右）使用Schwartzian转换排序花费不到2秒，而使用自定义比较函数则花费12秒以上（排序结果一样）。确切时间不会很准确，但很明显效率提高了6倍。

#---------- schwartzian_sort.py ----------#

#- 测试按第四个单词排序的速度

#- 如果两行都有4个以上单词，则按照第4个第5个。。来排序

#- 没有4个单词的行排在有4个单词的行后面

#- 没有4个单词的行之间按照默认顺序排列

import sys, string, time

wrerr = sys.stderr.write

#- 自定义比较函数

def fourth_word(ln1,ln2):

lst1 = string.split(ln1)

lst2 = string.split(ln2)

#-- 比较4个单词以上的行

if len(lst1) >= 4 and len(lst2) >= 4:

return cmp(lst1[3:],lst2[3:])

#-- 少于4个单词的行排在后面

elif len(lst1) >= 4 and len(lst2) < 4:

return -1

#-- 少于4个单词的行排在后面

elif len(lst1) < 4 and len(lst2) >= 4:

return 1

else: # 默认顺序

return cmp(ln1,ln2)

#- 不计算读取时间

lines = open(sys.argv[1]).readlines()

#- 计时使用自定义比较函数排序

start = time.time()

lines.sort(fourth_word)

end = time.time()

wrerr("Custom comparison func in %3.2f secs\n" % (end-start))

# open('tmp.custom','w').writelines(lines)

#- 不计算读取时间

lines = open(sys.argv[1]).readlines()

#- 计时Schwartzian转换排序

start = time.time()

for n in range(len(lines)): # 开始转换

lst = string.split(lines[n])

if len(lst) >= 4: # 把排序内容放在前面

lines[n] = (lst[3:], lines[n])

else: # 少于4个单词的行排在后面

lines[n] = (['\377'], lines[n])

lines.sort() # 排序

for n in range(len(lines)): # 转换回原先内容

lines[n] = lines[n][1]

end = time.time()

wrerr("Schwartzian transform sort in %3.2f secs\n" % (end-start))

# open('tmp.schwartzian','w').writelines(lines)

这只有一个特别的例子，但读者应该能够用任何形式来使用这种技术，特别是对于大文件。

主题-- 排版

虽然使用ASCII文本作为通讯格式并不好--通常不会很复杂文件不会很大--但其生命力

还是很强的。README文件，HOWTO文件，电子邮件，新闻组，包括本书都仍然是

使用ASCII码文本（至少原文加工技术通常是很有价值的）。此外，许多像HTML和

Latex的格式往往也需要手动修改，清晰的排版是非常重要的。

段落排版对于文本文件来说是极为常见的工作。Python2.3增加了[textwrap]模块做一些有限的排版工作。在大多数情况下，这项工作可以使用文本编辑器来完成。不过，有时候自动化排版会更方便。这项工作很简单，比较奇怪的是，Python没有相应的标准

模块功能实现这一点。有一个`formatter.DumbWriter`类和

`formatter.AbstractWriter`抽象类可以用于此项工作。相关讨论在第5章，坦率地说，使用这些类需要大量的定制工作而且很复杂，往往不适合用于解决手头的任务。

下面是一种简单的解决办法，可以当作命令行工具（从标准输入读取和输出到标准输

出），或用于较大的应用程序。

#---------- reformat_para.py ----------#

# 简单排版。主要用于左右对齐。

LEFT,RIGHT,CENTER = 'LEFT','RIGHT','CENTER'

def reformat_para(para=,left=0,right=72,just=LEFT):

words = para.split()

lines = []

line =

word = 0

end_words = 0

while not end_words:

if len(words[word]) > right-left: # 过长的单词

line = words[word]

word +=1

if word >= len(words):

end_words = 1

else: # 收集一行可以容纳的单词

while len(line)+len(words[word]) <= right-left:

line += words[word]+' '

word += 1

if word >= len(words):

end_words = 1

break

lines.append(line)

line =

if just==CENTER:

r, l = right, left

return '\n'.join([' '*left+ln.center(r-l) for ln in lines])

elif just==RIGHT:

return '\n'.join([line.rjust(right) for line in lines])

else: # left justify

return '\n'.join([' '*left+line for line in lines])

if __name__=='__main__':

import sys

if len(sys.argv) <> 4:

print "Please specify left_margin, right_marg, justification"

else:

left = int(sys.argv[1])

right = int(sys.argv[2])

just = sys.argv[3].upper()

# 排版每一段

for p in sys.stdin.read().split('\n\n'):

print reformat_para(p,left,right,just),'\n'

留给读者一些改进任务。例如您可能需要首行缩进。或者有些段落需要的格式不适合用此排版（例如题头等等）。具体的应用程序还可能需要确定如何分段等等。

主题-- 处理字段

数据表，DBMS，日志文件以及平面数据库往往在每行放置同样的纪录，每条记录有相同的字段。通常这些字段要么是用分割符间隔要么是用固定位置来存放。

分析这些记录的结构很容易，进行表格计算上也同样很简单。对于各种文本结构数据，可以使用几乎相同的代码来做处理。

下面的例子中提供了一种通用的框架来处理结构化文本。

#---------- fields_stats.py ----------#

# 处理文本数据库里的多个字段

import operator

from types import *

from xreadlines import xreadlines # 需要Python2.1，提高效率

# 2.1以下使用.readline()

#-- 格式常量

DELIMITED = 1

FLATFILE = 2

#-- 一些简单的处理过程（使用函数式风格）

nillFunc = lambda lst: None

toFloat = lambda lst: map(float, lst)

avg_lst = lambda lst: reduce(operator.add, toFloat(lst))/len(lst)

sum_lst = lambda lst: reduce(operator.add, toFloat(lst))

max_lst = lambda lst: reduce(max, toFloat(lst))

class FieldStats:

"""统计资料

text_db 可以是字符串（包括Unicode字符串）或文件类对象

style 有2种格式(DELIMITED, FLATFILE)分隔符或位置

默认使用分隔符格式

column_positions 位置列表，第一列的位置为1。

例如：(1,7,40) 表示3个字段，起始位置分别为1,7,40 field_funcs 是字典，储存需要处理的字段和对应处理过程。

例如：{1:avg_lst, 4:sum_lst, 5:max_lst}

表示对第一个字段做求平均值处理

对第四个字段做合计处理，对第5个字段求最大值

其他字段不做处理。

"""

def __init__(self,

text_db=,

style=DELIMITED,

delimiter=',',

column_positions=(1,),

field_funcs={} ):

self.text_db = text_db

self.style = style

self.delimiter = delimiter

self.column_positions = column_positions

self.field_funcs = field_funcs

def calc(self):

"""计算"""

#-- 第一步先建立列表的列表来存放数据。

used_cols = self.field_funcs.keys()

used_cols.sort()

# : 不使用column[0]

columns = []

for n in range(1+used_cols[-1]):

# 提示: 这里可以使用'[[]]*num'来代替

columns.append([])

#-- 第二步生成需要计算的列表数据

# text_db是字符串对象

if type(self.text_db) in (StringType,UnicodeType):

for line in self.text_db.split('\n'):

fields = self.splitter(line)

for col in used_cols:

field = fields[col-1] # 注意这里是由0开始的索引

columns[col].append(field)

else: # text_db是文件对象

for line in xreadlines(self.text_db):

fields = self.splitter(line)

for col in used_cols:

field = fields[col-1] # 注意这里是由0开始的索引

columns[col].append(field)

#-- 第三步作处理计算

results = [None] * (1+used_cols[-1])

for col in used_cols:

results[col] = \

apply(self.field_funcs[col],(columns[col],))

#-- Finally, return the result list

return results

def splitter(self, line):

"""分解一行为字段表"""

if self.style == DELIMITED:

return line.split(self.delimiter)

elif self.style == FLATFILE:

fields = []

# 注意这里是以0开始的索引

# 最后加上结束位置

num_positions = len(self.column_positions)

offsets = [(pos-1) for pos in self.column_positions]

offsets.append(len(line))

for pos in range(num_positions):

start = offsets[pos]

end = offsets[pos+1]

fields.append(line[start:end])

return fields

else:

raise ValueError, \

"Text database must be DELIMITED or FLATFILE"

#-- 测试数据

# First Name, Last Name, Salary, Years Seniority, Department

delim =

Kevin,Smith,50000,5,Media Relations

Tom,Woo,30000,7,Accounting

Sally,Jones,62000,10,Management

.strip() # no leading/trailing newlines

# Comment First Last Salary Years Dept

flat =

tech note Kevin Smith 50000 5 Media Relations more filler Tom Woo 30000 7 Accounting yet more... Sally Jones 62000 10 Management

.strip() # no leading/trailing newlines

#-- Run self-test code

if __name__ == '__main__':

getdelim = FieldStats(delim, field_funcs={3:avg_lst,4:max_lst})

print 'Delimited Calculations:'

results = getdelim.calc()

print ' Average salary -', results[3]

print ' Max years worked -', results[4]

getflat = FieldStats(flat, field_funcs={3:avg_lst,4:max_lst},

style=FLATFILE,

column_positions=(15,25,35,45,52))

print 'Flat Calculations:'

results = getflat.calc()

print ' Average salary -', results[3]

print ' Max years worked -', results[4]

上面的例子中包括了一些效率上的考虑，可以用于大型数据集。首先，'FieldStats'类是动态处理文本，而没有保存整个数据。`xreadlines.xreadlines()`是一个极其快速和有效的行阅读器，但它需要Python2.1+，其他版本可以使用`FILE.readline()`或

`FILE.readlines()`。此外，只关心实际上需要用到的数据，以便节省内存。这里没有考虑同时使用多个相关字段做处理的应用，不过可以提取出数据作再次运算。

还有就是没有考虑在同一个字段上作多种处理，这个留给读者作思考。

主题-- 字词数统计

Unix系统下有个工具'wc'可以做这个任务。这是个基本工具不能统计段落。'wc'只能统计字符，单词和行。有几个命令选项可以控制显示的结果，不过我很少用到它们。

在写这一段的时候，我发现自己的系统里没有装'wc'。下面的例子实际上是一个增强版'wc'，不过缺少了很多命令行选项。在Python里可以非常简单的实现'wc'的功能。其主要使用的技术是`"".join()`和`"".split()`。

#---------- wc.py ----------#

# 统计字符数，单词数，行数和段落数

# 可以STDIN输入或使用文件通配符

import sys, glob

if len(sys.argv) > 1:

c, w, l, p = 0, 0, 0, 0

for pat in sys.argv[1:]:

for file in glob.glob(pat):

s = open(file).read()

wc = len(s), len(s.split()), \

len(s.split('\n')), len(s.split('\n\n'))

print '\t'.join(map(str, wc)),'\t'+file

c, w, l, p = c+wc[0], w+wc[1], l+wc[2], p+wc[3]

wc = (c,w,l,p)

print '\t'.join(map(str, wc)), '\tTOTAL'

else:

s = sys.stdin.read()

wc = len(s), len(s.split()), len(s.split('\n')), \

len(s.split('\n\n'))

print '\t'.join(map(str, wc)), '\tSTDIN'

这个小功能可以在一个函数里实现，不过它太过于紧凑。不过在使用解释器的环境下者只需要两行。

上面的解决方法符合Python的准则，用一种显而易见的方式来完成任务。还有个方法也可以完成同样的任务，读者可以思考一下（这只是好玩）：

>>> wc = map(len,[s]+map(s.split,(None,'\n','\n\n')))

如果再加上'print'语句，就可以用一行来解决问题了。

主题-- 以二进制数据传送ASCII码信息

许多文本信息都是采用7位ASCII编码。特别是用在互联网传送的时候非ASCII码的信息需要先编成7位ASCII码才能正常传送，否则会因为最高位被分解导致出现乱码。像简单邮件传输协议(SMTP)，网络新闻传输协议(NNTP)或HTTP的内容编码等等都会需要用到编解码。编码8位二进制数据成ASCII码有一些通用的技术。

编码技术大都是将二进制数据转换成十六进制数据。UU编码是一种很早的编码标准，

主要用于新闻组和BBS传输二进制文件。Binhex编码主要用于Mac的系统。base64

是MIME的一种编码方式。这些编码技术基本上是在四个字节的ASCII码和三个字节的二进制数据之间转换，开始标记和结束标记等略有不同。QP编码也是一种MIME编码，不过它的编码长度是可变的，主要用于非ASCII码信息，对7位ASCII文本无需再次编码，仅将8位数据转换为7位。

Python提供了上述几种编码的相关模块。包装好的模块[uu],[binhex],[base64]和

[quopri]操作起来和文件对象差不多。当然之间也略有不同。例如[binhex]是在编码以

后才关闭输出文件，这使得它无法用于像[cStringIO]之类的文件对象。所有的这些编码工具都要使用到底层的C模块[binascii]。实际上真正执行转换的是[binascii]模块，不

过它不会区分正确的编码块大小。

标准库并没有提供通用的编解码功能，不过很容易就可以实现一个通用的编解码程序：#---------- encode_binary.py ----------#

# Provide encoders for arbitrary binary data

# in Python strings. Handles block size issues

# transparently, and returns a string.

# Precompression of the input string can reduce

# or eliminate any size penalty for encoding.

import sys

import zlib

import binascii

UU = 45

BASE64 = 57

BINHEX = sys.maxint

def ASCIIencode(s=, type=BASE64, compress=1):

"""ASCII文本转换为二进制数据"""

# 先选择编码方式

if type == BASE64: encode = binascii.b2a_base64

elif type == UU: encode = binascii.b2a_uu

elif type == BINHEX: encode = binascii.b2a_hqx

else: raise ValueError, "Encoding must be in UU, BASE64, BINHEX"

# 再判断是否进行压缩

if compress: s = https://www.360docs.net/doc/603777107.html,press(s)

# 一块一块开始编码

offset = 0

blocks = []

while 1:

blocks.append(encode(s[offset:offset+type]))

offset += type

if offset > len(s):

break

# 返回编码后的数据

return .join(blocks)

def ASCIIdecode(s=, type=BASE64, compress=1):

"""由二进制数据解码至ASCII文本"""

# 解码

if type == BASE64: s = binascii.a2b_base64(s)

elif type == BINHEX: s = binascii.a2b_hqx(s)

elif type == UU:

s = .join([binascii.a2b_uu(line) for line in s.split('\n')])

# 判断是否进行解压缩

if compress: s = zlib.decompress(s)

# 返回结果

return s

# Encode/decode STDIN for self-test

if __name__ == '__main__':

decode, TYPE = 0, BASE64

for arg in sys.argv:

if arg.lower()=='-d': decode = 1

elif arg.upper()=='UU': TYPE=UU

elif arg.upper()=='BINHEX': TYPE=BINHEX

elif arg.upper()=='BASE64': TYPE=BASE64

if decode:

print ASCIIdecode(sys.stdin.read(),type=TYPE)

else:

print ASCIIencode(sys.stdin.read(),type=TYPE)

上面的例子并没有包含任何头数据或需要的分界数据，这些可以通过使用[uu],[mimify]或[MimeWriter]来解决。或者你也可以编写自己需要的'encode_binary.py'.

主题-- 词频统计

分析文本里单词的出现频率是很有用的。在文字处理里，几乎要么是处理字节要么是处理单词。创建词频统计很简单，只需要使用Python字典就可以了，不过不是每个人都能立即找到最明显的解决方案。下面的这个例子有很好的通用性，提供了多种实用功能，并且还可用于命令行操作模式。

#---------- histogram.py ----------#

# 统计词频

# 有几个工具函数可以提取需要的结果

from string import split, maketrans, translate, punctuation, digits import sys

from types import *

import types

def word_histogram(source):

"""对词作统计（不包括标点和数字）"""

hist = {}

trans = maketrans(,)

if type(source) in (StringType,UnicodeType): # 字符串

for word in split(source):

word = translate(word, trans, punctuation+digits)

if len(word) > 0:

hist[word] = hist.get(word,0) + 1

elif hasattr(source,'read'): # 文件

try:

from xreadlines import xreadlines # 测试是否可用

for line in xreadlines(source):

for word in split(line):

word = translate(word, trans, punctuation+digits)

if len(word) > 0:

hist[word] = hist.get(word,0) + 1

except ImportError: # 使用旧版本

line = source.readline() # 速度慢，但内存占用少

while line:

for word in split(line):

word = translate(word, trans, punctuation+digits)

if len(word) > 0:

hist[word] = hist.get(word,0) + 1

line = source.readline()

else:

raise TypeError, \

"source must be a string-like or file-like object"

return hist

def char_histogram(source, sizehint=1024*1024):

hist = {}

if type(source) in (StringType,UnicodeType): # 字符串

for char in source:

hist[char] = hist.get(char,0) + 1

elif hasattr(source,'read'): # 文件

chunk = source.read(sizehint)

while chunk:

for char in chunk:

hist[char] = hist.get(char,0) + 1

chunk = source.read(sizehint)

else:

raise TypeError, \

"source must be a string-like or file-like object"

return hist

def most_common(hist, num=1):

pairs = []

for pair in hist.items():

pairs.append((pair[1],pair[0]))

pairs.sort()

pairs.reverse()

return pairs[:num]

def first_things(hist, num=1):

pairs = []

things = hist.keys()

things.sort()

for thing in things:

pairs.append((thing,hist[thing]))

pairs.sort()

return pairs[:num]

if __name__ == '__main__':

if len(sys.argv) > 1:

hist = word_histogram(open(sys.argv[1]))

else:

hist = word_histogram(sys.stdin)

print "Ten most common words:"

for pair in most_common(hist, 10):

print '\t', pair[1], pair[0]

print "First ten words alphabetically:"

for pair in first_things(hist, 10):

print '\t', pair[0], pair[1]

# a more practical command-line version might use:

# for pair in most_common(hist,len(hist)):

# print pair[1],'\t',pair[0]

几个设计的选择有些武断。词频统计里去除了标点符号，只保留字母，同时还区分大小写，这可能不是理想的选择。'first_things()'和'most_common()'只返回最初的几项排序结果。

取自"https://www.360docs.net/doc/603777107.html,/index.php/Tpip_210"

?1第二节-- 标准模块

?2主题-- 字符串基本操作

o 2.1模块-- string : 字符串基本操作

? 2.1.1常数：

? 2.1.2函数：

第二节-- 标准模块

主题-- 字符串基本操作

模块[string]是Python文本处理的核心模块。有很多其他模块会引用这个模块。[string]模块里大多数操作都在Python1.6+复制到字符串对象上了。直接使用字符串对象的操作要比使用模块里相应函数的速度快一些。有些字符串对象的操作和模块里的并不等

价，但这里仍会作以介绍。

参考：[str], [UserString]

模块-- string : 字符串基本操作

[string]模块（只有函数和常数，没有类）的函数都有一些共同的东西。

? 1. 字符串是不可变对象。这意味着不能更改字符串自身（很多其他语言里，字符串操作都是直接更改自身的）。[string]里模块函数都需要一个字符串作参数，然后返回一个新的字符串对象。通常的做法大多是使用赋值语句将返回结果绑定到同一个变量名称上。

例如：

>>> import string

>>> str = "Mary had a little lamb"

>>> str = string.replace(str, 'had', 'ate')

>>> str

'Mary ate a little lamb'

第一个字符串对象并不会改变，但在第一次操作以后这个对象就不再和任何变量名称有关系了，在运行时这样的对象会作废料收集和处理。总之，[string]模块的函数不会改变任何已有的字符串，但通过名称重新绑定可以看起来像作了改变。

? 2. 很多[string]模块的函数同样应用在字符串对象自身的方法上。使用字符串对象方法并不需要导入[string]模块，而且通常要比使用[string]模块函数速度要快。这些大多数都是使用同一个方法实现的。

? 3. 一个建议是使用'string.join(string.split(...))'来处理字符串分割和合并。更详细的介绍参看`string.join()`和`string.split()`里的讨论。

? 4. 巧妙的使用`string.replace()`模式。利用`string.replace()`可以填充字符串，有时结合其他技术会有惊人的表现。请参看`string.replace()`的讨论和样例。

? 5. 一个可变的字符串可以通过使用内置的列表对象来实现（或[array]）。子串列表可以被修改或替换。使用[array]模块可以定义以字符为元素的字符串，同样具有索引下标操作和片操作。在需要完整字符串的时候用`"".join()`来建造一个真实的字符串。例如：>>> lst = ['spam','and','eggs']

>>> lst[2] = 'toast'

>>> print .join(lst)

spamandtoast

>>> print ' '.join(lst)

spam and toast

>>> import array

>>> a = array.array('c','spam and eggs')

>>> print .join(a)

spam and eggs

>>> a[0] = 'S'

>>> print .join(a)

Spam and eggs

>>> a[-4:] = array.array('c','toast')

>>> print .join(a)

Spam and toast

常数：

[string]模块的常数定义了一些常用的字符集。所有这些常数本身就是个字符串。如果你需要的话，还可以建立需要的字符集。例如：

>>> import string

>>> string.brackets = "[]{}()<>"

>>> print string.brackets

[]{}()<>

?string.digits

十进制数字("0123456789").

?string.hexdigits

十六进制数字("0123456789abcdefABCDEF").

?string.octdigits

八进制数字("01234567").

?string.lowercase

小写字母。

>>> import string

>>> string.lowercase

'abcdefghijklmnopqrstuvwxyz'

如果你需要使用特定的语言，不要直接修改`string.lowercase`，可以定义一个新的常数，如'string.spanish_lowercase'（有些函数会使用到这个常量）。

?string.uppercase

大写字母。

>>> import string

>>> string.uppercase

'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

如果你需要使用特定的语言，不要直接修改`string.uppercase`，可以定义一个新的常数，如'string.spanish_uppercase'（有些函数会使用到这个常量）。

?string.letters

所有的字母。(string.lowercase+string.uppercase).

?string.punctuation

标点符号。

>>> import string

>>> string.punctuation

'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'

?string.whitespace

空白字符。包括tab，换行，vtab，回车，空格：

>>> import string

>>> string.whitespace

'\011\012\013\014\015 '

不要修改`string.whitespace`（有些函数会使用到这个常量）。

?string.printable

所有可以打印的字符

(string.digits+string.letters+string.punctuation+string.whitespace)

函数：

?string.atof(s=...)

不推荐使用。应该使用`float()`。

转换字符串为浮点数。

参考：`eval()`, `float()`

?string.atoi(s=... [,base=10])

Python2.0+不推荐使用。应该使用`int()`。

转换字符串为一个整数（第二个参数是使用的进制）

参考：`eval()`, `int()`, `long()`

?string.atol(s=... [,base=10])

Python2.0+不推荐使用。应该使用`long()`。

转换字符串为一个长整数（第二个参数是使用的进制）

参考：`eval()`, `long()`, `int()`

?string.capitalize(s=...)

?"".capitalize()

转换第一个字符为大写，所有其他字符转换为小写：

>>> import string

>>> string.capitalize("mary had a little lamb!")

'Mary had a little lamb!'

>>> string.capitalize("Mary had a Little Lamb!")

'Mary had a little lamb!'

>>> string.capitalize("2 Lambs had Mary!")

'2 lambs had mary!'

Python1.6+，直接使用字符串对象的方法快一些。可以这样用：>>> "mary had a little lamb".capitalize()

'Mary had a little lamb'

参考：`string.capwords()`, `string.lower()`

?string.capwords(s=...)

?"".title()

每个单词的第一个字符都转换为大写。同等的表达式是：

#*----- 等价于-----#

string.join(map(string.capitalize,string.split(s))

注意多余的空白会被消除：

>>> import string

>>> string.capwords("mary HAD a little lamb!")

'Mary Had A Little Lamb!'

>>> string.capwords("Mary had a Little Lamb!")

'Mary Had A Little Lamb!'

Python1.6+同等的字符串对象方法更名为`"".title()`。

参考：`string.capitalize()`, `string.lower()`, `"".istitle()`

?string.center(s=..., width=...)

?"".center(width)

在前后填充空格使长度达到'width'（不会截断超出长度的字符串）。>>> import string

>>> string.center(width=30,s="Mary had a little lamb")

' Mary had a little lamb '

>>> string.center("Mary had a little lamb", 5)

'Mary had a little lamb'

Python1.6+，直接使用字符串对象的方法快一些。可以这样用：>>> "Mary had a little lamb".center(25)

' Mary had a little lamb '

参考：`string.ljust()`, `string.rjust()`

?string.count(s, sub [,start [,end]])

?"".count(sub [,start [,end]])

统计匹配的子串个数。后两个参数用来限定比较的起止位置。

>>> import string

>>> string.count("mary had a little lamb", "a")

4

>>> string.count("mary had a little lamb", "a", 3, 10)

2

Python1.6+，直接使用字符串对象的方法快一些。可以这样用：

>>> 'mary had a little lamb'.count("a")

4

?"".endswith(suffix [,start [,end]])

[string]模块里没有这个字符串对象方法。用来检查最后几个字符是否和参数'suffix'一样。后两个参数用来限定比较的起止位置。

参考：`"".startswith()`, `string.find()`

?string.expandtabs(s=... [,tabsize=8])

?"".expandtabs([,tabsize=8])

将tab换成空格。参数指定一个tab对应的空格长度。默认长度为8。

>>> import string

>>> s = 'mary\011had a little lamb'

>>> print s

mary had a little lamb

>>> string.expandtabs(s, 16)

'mary had a little lamb'

>>> string.expandtabs(tabsize=1, s=s)

'mary had a little lamb'

Python1.6+，直接使用字符串对象的方法快一些。可以这样用：

>>> 'mary\011had a little lamb'.expandtabs(25)

'mary had a little lamb'

?string.find(s, sub [,start [,end]])

?"".find(sub [,start [,end]])

查找子串第一次出现的位置。后两个参数用来限定比较的起止位置。如果未找到返回-1。>>> import string

>>> string.find("mary had a little lamb", "a")

1

>>> string.find("mary had a little lamb", "a", 3, 10)

6

>>> string.find("mary had a little lamb", "b")

21

>>> string.find("mary had a little lamb", "b", 3, 10)

-1

Python1.6+，直接使用字符串对象的方法快一些。可以这样用：

>>> 'mary had a little lamb'.find("ad")

6

参考：`string.index()`, `string.rfind()`

?string.index(s, sub [,start [,end]])

?"".index(sub [,start [,end]])

和`string.find()`差不多，只是如果未找到会抛出'ValueError'而不是返回-1。>>> import string

>>> string.index("mary had a little lamb", "b")

21

>>> string.index("mary had a little lamb", "b", 3, 10)

Traceback (most recent call last):

File "", line 1, in ?

File "d:/py20sl/lib/string.py", line 139, in index

return s.index(*args)

ValueError: substring not found in string.index

Python1.6+，直接使用字符串对象的方法快一些。可以这样用：

>>> 'mary had a little lamb'.index("ad")

6

参考：`string.find()`, `string.rindex()`

'.is*()'函数用来检查字符串是否是由相应的字符组成的，[string]模块里没有相应的函数：

?"".isalpha()

是否都是字母。

?"".isalnum()

是否都是字母加数字。

?"".isdigit()

是否都是数字字符。

?"".islower()

所含字母是否都是小写字母：

>>> "ab123".islower(), '123'.islower(), 'Ab123'.islower()

(1, 0, 0)

参考：`"".lower()`

?"".isspace()

是否都是空白字符。

?"".istitle()

每个单词是否第一个字符都是大写其他小写。

参考：`"".title()`

?"".isupper()

所含字母是否都是大写字母：

参考：`"".upper()`

?string.join(words=... [,sep=" "])

?"".join(words)

连接列表里各个子字符串组成一个新字符串，参数'sep'是间隔使用的字符串。

值得注意的是，`string.join()`和`string.split()`函数是互逆的。换句话说

'string.join(string.split(s,sep),sep)==s'肯定是真。

通常情况下，`string.join()`中使用都是自然生成的字符串列表。举例来说，这个小程序里的列表就是按输入顺序构成的：

#---------- list_capwords.py ----------#

import string,sys

capwords = []

for line in sys.stdin.readlines():

for word in line.split():

if word == word.upper() and word.isalpha():

capwords.append(word)

print string.join(capwords, '\n')

在'list_capwords.py'里利用连接使用字符串的效率还不错。如果使用Python2.0里增加的加法操作则会降低执行速度：

>>> import string

>>> s = "Mary had a little lamb"

>>> t = "its fleece was white as snow"

>>> s = s +" "+ t # 效率一般，如果是长字符串会较低

>>> s += " " + t # 效率低

>>> lst = [s]

>>> lst.append(t) # 效率更低

>>> s = string.join(lst)

>>> s = string.join((s," ",t)) # 效率高

Python1.6+，使用`"".join()`的效率是最高的。

参考：`string.split()`

?string.joinfields(...)

和`string.join()`一样。

?string.ljust(s=..., width=...)

?"".ljust(width)

后补空格。（不会截断字符串）

>>> import string

>>> string.ljust(width=30,s="Mary had a little lamb")

'Mary had a little lamb '

>>> string.ljust("Mary had a little lamb", 5)

'Mary had a little lamb'

Python1.6+，直接使用字符串对象的方法快一些。可以这样用：

>>> "Mary had a little lamb".ljust(25)

'Mary had a little lamb '

参考：`string.rjust()`, `string.center()`

?string.lower(s=...)

?"".lower()

转换大写字母为小写。

>>> import string

>>> string.lower("mary HAD a little lamb!")

'mary had a little lamb!'

>>> string.lower("Mary had a Little Lamb!")

'mary had a little lamb!'

Python1.6+，直接使用字符串对象的方法快一些。可以这样用：

>>> "Mary had a Little Lamb!".lower()

'mary had a little lamb!'

参考：`string.upper()`

?string.lstrip(s=...)

?"".lstrip([chars=string.whitespace])

删除左边的空白字符。Python1.6+，直接使用字符串对象的方法快一些。可以这样用：>>> import string

>>> s = """

... Mary had a little lamb \011"""

>>> string.lstrip(s)

'Mary had a little lamb \011'

>>> s.lstrip()

'Mary had a little lamb \011'

Python2.3+可以指定需要删除的字符。

参考：`string.rstrip(), `string.strip()`

?string.maketrans(from, to)

制作字符转换表，用于`string.translate()`。参数'from'和'to'必须是相同的长度。转换表是一个长度为256的字符串，每个字符对应相应的字节值。

>>> import string

>>> ord('A')

65

>>> ord('z')

122

>>> string.maketrans('ABC','abc')[65:123]

'abcDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz'

>>> string.maketrans('ABCxyz','abcXYZ')[65:123]

'abcDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwXYZ'

参考：`string.translate()`

?string.replace(s=..., old=..., new=... [,maxsplit=...])

?"".replace(old, new [,maxsplit])

替换操作。最后一个参数限定最大替换次数。

>>> import string

>>> string.replace("Mary had a little lamb", "a little", "some")

'Mary had some lamb'

Python1.6+，直接使用字符串对象的方法快一些。可以这样用：

>>> "Mary had a little lamb".replace("a little", "some")

'Mary had some lamb'

使用`string.replace()`的多次替换时需要注意是否把不期望替换的也替换了。有时可以使用保留字符串来解决这个问题。当然使用正则表达式也可以达到同样的目的，但是使用`string.replace()`会更快一些：

>>> import string

>>> line = 'variable = val # see comments #3 and #4'

>>> # 现在想把'#3'和'#4'中的'#'替换为'number'

>>> string.replace(line,'#','number ') # 没成功

'variable = val number see comments number 3 and number 4'

>>> place_holder=string.replace(line,' # ',' !!! ') # 保留不替换的

>>> place_holder

'variable = val !!! see comments #3 and #4'

>>> place_holder=place_holder.replace('#','number ') # 替换完了

>>> place_holder

'variable = val !!! see comments number 3 and number 4'

>>> line = string.replace(place_holder,'!!!','#') # 再换回原来的

>>> line

'variable = val # see comments number 3 and number 4'

显然，对于这样的工作，需要仔细处理。特别是要注意作为保留替换的字符串是否是子串。

参考：`string.translate()`, `mx.TextTools.replace()`

?string.rfind(s, sub [,start [,end]])

?"".rfind(sub [,start [,end]])

从右边开始查找子串第一次出现的位置。后两个参数用来限定比较的起止位置。如果未找到返回-1。

>>> import string

>>> string.rfind("mary had a little lamb", "a")

19

>>> string.rfind("mary had a little lamb", "a", 3, 10)

9

>>> string.rfind("mary had a little lamb", "b")

21

>>> string.rfind("mary had a little lamb", "b", 3, 10)

-1

Python1.6+，直接使用字符串对象的方法快一些。可以这样用：

>>> 'mary had a little lamb'.rfind("ad")

6

参考：`string.rindex()`, `string.find()`

?string.rindex(s, sub [,start [,end]])

?"".rindex(sub [,start [,end]])