Python基础：序列（字符串）

一、概述

字符串 类似于C中的字符数组（功能上更像C++中的string），它是由一个个 字符 组成的序列。与C/C++不同的是，Python中没有 字符 这个类型，而是用 长度为1的字符串 来表示字符的概念。

二、分类

Python中的字符串共有2种：ASCII字符串（str）和 Unicode字符串（unicode）。每一种字符串又可以进一步划分：根据对转义字符处理方式的不同，分为 常规字符串 和 原始字符串；根据字符串是否跨行，分为 单行字符串 和 跨行字符串。每一个字符串的字面值既可以包含在 单引号（'）中，又可以包含在 双引号（"）中。

以单引号为例（双引号的情况把 ' 换成 " 即可），字符串的 字面值表示 与上述分类之间的关系如下：

字面值表示	ASCII字符串	Unicode字符串	常规字符串	原始字符串	单行字符串	跨行字符串
'Hello, Python'	√		√		√
'''Hello Python'''	√		√			√
r'Hello, Python'	√			√	√
r'''Hello Python'''	√			√		√
u'Hello, Python'		√	√		√
u'''Hello Python'''		√	√			√
ur'Hello, Python'		√		√	√
ur'''Hello Python'''		√		√		√

以上各种字符串（字面值表示）的应用场景：

• 单引号 和 双引号 基本等价，除了字符串中含有引号字符的情况（如"it's ok"、'it "seems" ok'等）
• 单行字符串 主要用于表示简短的字符文本，日常使用较多
• 跨行字符串 允许字符文本跨越多行，从而更直观、易读，主要用于表示 代码注释、数据库SQL语句 或 HTML文本 等
• 常规字符串 能够理解 转义字符，会对转义字符进行特殊处理，常用于表示 文件内容 或 打印文本 中
• 原始字符串 中没有转义字符，所有字符都按照字面意思使用，多用于表示 路径名 或 正则表达式 等
• ASCII字符串 是英文字符串的同义词，在英文语言环境中可以满足所有字符串处理的需要
• Unicode字符串 可以支持全球的所有语言，一个国际化的软件应该使用Unicode字符串

三、操作

除了 Python基础：序列 中给出的 通用序列操作 以外，字符串还支持以下 字符串操作：

操作	说明
str.capitalize()	将str的第一个字符大写，其余字符小写（非字母字符不受影响）
str.center(width[, fillchar])	居中str（返回长度为width的字符串：str居中、以fillchar填充两侧）
str.count(sub[, start[, end]])	返回sub子串在str[start:end]中出现的次数（非重叠）
str.decode([encoding[, errors]])	以编码格式encoding解码str
str.encode([encoding[, errors]])	以编码格式encoding编码str
str.endswith(suffix[, start[, end]])	如果str[start:end]以suffix子串结尾，返回True；否则，返回False
str.expandtabs([tabsize])	将str中的所有'\t'用空格替换并补齐，使得每一个'\t'后的子串位于第tabsize*n列（n=0,1,2,...）
str.find(sub[, start[, end]])	返回sub子串在str[start:end]中的最小下标，不存在则返回-1
str.format(args, *kwargs)	字符串格式化（推荐使用最新的format，而不是传统的 % ）
str.index(sub[, start[, end]])	返回sub子串在str[start:end]中的最小下标，不存在则抛出ValueError异常
str.isalnum()	如果str不为空且其中仅含有字母或数字，返回True；否则，返回False
str.isalpha()	如果str不为空且其中仅含有字母，返回True；否则，返回False
str.isdigit()	如果str不为空且其中仅含有数字，返回True；否则，返回False
str.islower()	如果str至少包含一个字母，且这些字母全部为小写，返回True；否则，返回False
str.isspace()	如果str不为空且其中仅含有空白符，返回True；否则，返回False
str.istitle()	如果str不为空且是标题化的（见title()），返回True；否则，返回False
str.isupper()	如果str至少包含一个字母，且这些字母全部为大写，返回True；否则，返回False
str.join(iterable)	串联迭代对象iterable生成的字符串序列，并以str分隔
str.ljust(width[, fillchar])	类似center()，但左对齐str，以fillchar填充右侧
str.lower()	将str中的字母全部小写
str.lstrip([chars])	删除str开始处、位于chars中的字符（默认为空白符）
str.partition(sep)	如果str中存在sep，以第一个sep的下标为分界，返回元组 (sep之前的子串, sep, sep之后的子串)；否则，返回元组 (str, '', '')
str.replace(old, new[, count])	将str中的old子串替换为new子串，只执行count次替换（省略count则全部替换）
str.rfind(sub[, start[, end]])	逆序版find()：返回最大下标
str.rindex(sub[, start[, end]])	逆序版index()：返回最大下标
str.rjust(width[, fillchar])	类似center()，但右对齐str，以fillchar填充左侧
str.rpartition(sep)	逆序版partition()：存在则以最后一个sep的下标为分界，返回元组（sep之前的子串, sep, sep之后的子串)；否则返回 ('', '', str)
str.rsplit([sep[, maxsplit]])	从右向左分割str，以sep为分割符（省略时，sep默认为空白符），只执行maxsplit次分割（省略则全部分割）
str.rstrip([chars])	删除str结尾处、位于chars中的字符（默认为空白符）
str.split([sep[, maxsplit]])	逆序版rsplit()：从左向右分割str
str.splitlines([keepends])	以换行符（universal newlines）为分割符，分割str；如果指定keepends且为True，则分割后保留换行符
str.startswith(prefix[, start[, end]])	逆序版endswith()：判断str[start:end]是否以prefix子串开始
str.strip([chars])	综合lstrip()和rstrip()的功能：同时删除str开始和结尾处的空白符（或指定字符）
str.swapcase()	将str中的所有字母的大小写翻转：大写变小写，小写变大写
str.title()	标题化str：使得str中非字母字符之后的字母（或首字母）大写，字母字符之后的字母小写
str.translate(table[, deletechars])	从str中删除由deletechars指定的字符（如果table不为None，再根据table中的转换关系对剩余字符进行转换）
str.upper()	将str中的所有小写字母变为大写
str.zfill(width)	返回长度为width的字符串：在str左侧补'0'

以上操作的示例如下：

# capitalize()

>>> 'hello'.capitalize(), '-*-HELLO'.capitalize()

('Hello', '-*-hello')



# ljust()、center()和rjust()

>>> s = 'hello'

>>> s.ljust(2), s.ljust(10), s.ljust(10, '=')

('hello', 'hello     ', 'hello=====')

>>> s.center(2), s.center(10), s.center(10, '=')

('hello', '  hello   ', '==hello===')

>>> s.rjust(2), s.rjust(10), s.rjust(10, '=')

('hello', '     hello', '=====hello')



# count()

>>> 'abababababa'.count('a'), 'abababababa'.count('aba')

(6, 3)



# encode()和decode()

>>> s = u'你好'

>>> e = s.encode('utf-8')

>>> d = e.decode('utf-8')

>>> s, e, d

(u'\u4f60\u597d', '\xe4\xbd\xa0\xe5\xa5\xbd', u'\u4f60\u597d')



# startswith()和endswith()

>>> s = 'hello, python'

>>> s.startswith('lo'), s.startswith('lo', 3)

(False, True)

>>> s.startswith('he'), s.startswith('he', 3)

(True, False)

>>> s.endswith('py'), s.endswith('py', 0, -4)

(False, True)

>>> s.endswith('python'), s.endswith('python', 0, -4)

(True, False)



# expandtabs()

>>> '01\t012\t0123\t01234'.expandtabs() # tabsize默认为8

'01      012     0123    01234'

>>> '01\t012\t0123\t01234'.expandtabs(4)

'01  012 0123    01234'



# find()、rfind()、index()和rindex()

>>> s = 'goooogle'

>>> s.find('o'), s.rfind('o')

(1, 4)

>>> s.index('o'), s.rindex('o')

(1, 4)

>>> s.find('w')

-1

>>> s.index('w')

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

ValueError: substring not found



# format()和%

>>> "I'm %s, there're %d 'l's in my name." % ('RussellLuo', 3)

"I'm RussellLuo, there're 3 'l's in my name."

>>> "I'm {0}, there're {1} 'l's in my name.".format('RussellLuo', 3)

"I'm RussellLuo, there're 3 'l's in my name."

>>> "I'm {name}, there're {count} 'l's in my name.".format(name='RussellLuo', count=3)

"I'm RussellLuo, there're 3 'l's in my name."



# isalnum()、isalpha()、isdigit()和isspace()

>>> 'abc'.isalnum(), 'abc'.isalpha()

(True, True)

>>> '123'.isalnum(), '123'.isdigit()

(True, True)

>>> 'abc123'.isalnum(), 'abc123'.isalpha(), 'abc123'.isdigit()

(True, False, False)

>>> ''.isspace(), '  \t\r\n'.isspace()

(False, True)



# isupper()、islower()、upper()、lower()和swapcase()

>>> s = 'RussellLuo'

>>> s.isupper(), s.upper()

(False, 'RUSSELLLUO')

>>> s.islower(), s.lower()

(False, 'russellluo')

>>> s.swapcase()

'rUSSELLlUO'



# istitle()和title()

>>> s.istitle(), s.title()

(False, "I'M Russellluo, There'Re 3 'L'S In My Name.")



# join()

>>> l = ['how', 'are', 'you']

>>> ''.join(l)

'howareyou'

>>> ' '.join(l)

'how are you'

>>> '...'.join(l)

'how...are...you'



# lstrip()、rstrip()和strip()

>>> s = u'人人为我，我为人人'

>>> print s.lstrip(u'人')

为我，我为人人

>>> print s.rstrip(u'人')

人人为我，我为

>>> print s.strip(u'人')

为我，我为



# partition()和rpartition()

>>> s = 'where are you, here you are'

>>> s.partition('you')

('where are ', 'you', ', here you are')

>>> s.rpartition('you')

('where are you, here ', 'you', ' are')

>>> s.partition('him')

('where are you, here you are', '', '')

>>> s.rpartition('him')

('', '', 'where are you, here you are')



# replace()

>>> s = 'goooooooooogle'

>>> s.replace('o', 'u'), s.replace('o', 'u', 5)

('guuuuuuuuuugle', 'guuuuuooooogle')



# split()和rsplit()

>>> s = 'how are you'

>>> s.split()

['how', 'are', 'you']

>>> s.rsplit()

['how', 'are', 'you']

>>> s.split('o')

['h', 'w are y', 'u']

>>> s.rsplit('o')

['h', 'w are y', 'u']

>>> s.split('o', 1)

['h', 'w are you']

>>> s.rsplit('o', 1)

['how are y', 'u']



# splitlines()

>>> s = 'ab c\n\nde fg\rkl\r\n'

>>> s.splitlines()

['ab c', '', 'de fg', 'kl']

>>> s.splitlines(True)

['ab c\n', '\n', 'de fg\r', 'kl\r\n']



# translate()

>>> s = 'look at this'

>>> s.translate(None, 'lost')

'k a hi'

>>> import string

>>> t = string.maketrans(' ahik', 'egndl')

>>> s.translate(t, 'lost')

'legend'



# zfill()

>>> '12'.zfill(10), '-12'.zfill(10)

('0000000012', '-000000012')

四、格式化

1、%

对于字符串的格式化，我们通常使用 % 操作符。在 % 操作符中，参数的类型和格式 由 转换限定符 （conversion specifier）来指定，而 参数的值 可以支持两种输入形式：元组 和 字典。

# 1. 元组输入

>>> print '0x%x' % 108

0x6c

>>> print 'hello, %s' % ('world')

hello, world

>>> print '%s has %03d quote types' % ('Python', 2)

Python has 002 quote types



# 2. 字典输入

>>> print '%(language)s has %(number)03d quote types.' % \

...       {'language': 'Python', 'number': 2}

Python has 002 quote types.

2、str.format()

从2.6版本开始，Python提供了全新的格式化方法 str.format() ，并且推荐使用str.format()代替传统的 % 进行格式化（实际上，str.format()在Python3中是字符串格式化的标准方法）。

相比于传统的 % 操作符，str.format()有以下几个特点：

• 不需要指定 参数的类型
• 通过 位置参数（positional argument）和 关键字参数（keyword argument）来指定 参数的值
• 在格式化字符串中，使用以 {} 包围的 替换域（replacement fields）为预期的参数占位
• 在替换域中，支持访问参数的属性或成员，并且可以对参数调用str()或repr()

一些使用str.format()的示例如下：

# 位置参数

>>> '{} has {} quote types.'.format('Python', 2)

'Python has 2 quote types.'

>>> '{0} has {1} quote types.'.format('Python', 2)

'Python has 2 quote types.'



# 关键字参数

>>> '{language} has {number} quote types.'.format(language='Python', number=2)

'Python has 2 quote types.'



# 访问参数的属性

>>> class N: pass

... 

>>> N.value = 2

>>> '{0} has {1.value} quote types.'.format('Python', N)

'Python has 2 quote types.'



# 访问参数的成员

>>> '{data[0]} has {data[1]} quote types.'.format(data=['Python', 2])

'Python has 2 quote types.'



# !s对参数调用str()，!r对参数调用repr()

>>> '{0!s} has {1!r} quote types.'.format('Python', str(2))

"Python has '2' quote types."

五、Unicode

现代的软件和应用都应该支持国际化（Internationalization，简写为I18N），因此都应该使用Unicode。

软件的国际化是一个系统性工程，以下是使用Unicode的金科玉律：

• 为所有字符串都加上前缀 u
• 使用unicode()函数（而不是str()）
• 只在输出（写数据到文件或数据库或网络）时使用encode()进行编码，只在输入（从文件或数据库或网络读数据）时使用decode()进行解码
• 确保第三方依赖（如模块、数据库、Web框架等）支持Unicode

正确使用Unicode的简单示例如下：

#!/usr/bin/env python

# -*- coding: utf-8 -*-



''' 使用Unicode处理文件的输入输出（编码格式为utf-8） '''



CODEC = u'utf-8'

FILE = ur'/home/russellluo/python/unicode.txt'



text = u'English中文'



# 输出

text_cod = text.encode(CODEC)

f = open(FILE, 'w')

f.write(text_cod)

f.close()



# 输入

f = open(FILE, 'r')

text_cod = f.read()

f.close()

text_dec = text_cod.decode(CODEC)

print text_dec

运行结果：

$ python unicode_example.py

English中文

六、相关模块

Python标准库中与字符串相关的核心模块有（更多细节参考 String Services）：

模块	说明
string	字符串操作的相关函数和工具
re	正则表达式：强大的字符串模式匹配模块
struct	字符串与二进制之间的转换
difflib	比较序列之间的差异
StringIO / cStringIO	字符串缓冲对象，操作方法类似于file对象
textwrap	文本包装和填充
codecs	解码器注册和基类
unicodedata	Unicode数据库
stringprep	提供用于互联网协议的Unicode字符串