Python序列:字符串、数组、元组

作者:最西瓜
来源:《Core Python Programming》CH6. Sequences: Strings, Lists, and tuples

通用操作符

Python中的序列支持一些通用的操作符可以作用于字符串、列表和与元组。这些操作符包括:

  • 成员关系(in,not in):用于判断一个元素是否在序列中,如一个字符串是否在另一个字符串中,元素是否在列表或者元组中;
  • 连接符(+)用于将两个类型相同的序列连接起来,注意这会生成一个新的序列而不改变原有的序列。并且这并不是最有效的方式,对于字符串推荐用 join() 方法,对于List推荐用 extend() 方法;
  • 重复(*)用于将序列重复多次并返回一个新的序列,用法如下:sequence * copies_int;
  • 切片([],[ : ],[ : : ])[index] 将访问一个元素,[start_index:end_index] 将访问一段元素,end_index 是不包含的,[start_index:end_index:stride] 以步进的方式访问列表中的元素;

切片是Python序列非常重要的特性,值得多说几句。首先单值索引不能超出范围,否则会抛出IndexError异常。其次切片索引允许负值,范围是 -len(sequence) <= index <= -1 表示从尾部开始计算,-1表示最末尾的元素,-len(sequence) 表示第一个元素。

sequence[start_index:end_index]中 start_index 和 end_index 都是可选的,如果不提供就分别表示从头开始或者到末尾结束。并且索引是可以超出范围的,超出部分就计算到两个端点。使用None作为索引和不同索引的结果是一样的。

s = 'abcde'
for i in [None] + range(-1, -len(s), -1):
    print s[:i]

内建函数

Python为序列提供不少的内建函数,除了构建函数还是一些操作函数,所有接受 iter 参数的函数可以接受迭代器而不仅仅是序列,参数为 seq 的就只能接受序列。所谓迭代器是一种比序列更通用的概念,表示能够依次访问得到顺序值。

  • list(iter) 和 tuple(iter) 很多时候用来进行相互转换;
  • str() 常用来获取别的对象的字符串表示,也常用来转换数字;
  • len(seq) 获取序列的长度;
  • enumerate(iter) 返回迭代的枚举对象,每次访问枚举对象都会返回一个(index,item)的元组;
  • max(iter, key=None) 或 max(arg0, arg1…, key=None) 返回迭代器或者参数列表的最大值;
  • min(iter, key=None) 或 min(arg0, arg1…, key=None) 返回最小值;
  • reversed(seq) 返回反向序列;
  • sorted(iter, func=None, key=None, reverse=False) 从迭代器中返回一个排好序的List;
  • sum(seq, init=0) 将序列的所有值叠加起来并加上初始值;
  • zip([it0, it1,… itN]) 把这N个迭代器对应位置的值组成一个元组,直到最短的迭代器没有值为止;

字符串

Python中的字符串实际上由三个类构成:str unicode 和基类 basestring 。Python不支持字符类型,因而单个字符也是字符串。在此再重复一次,Python中的字符串是不可变的,因而不能将切片用于赋值操作符的左边,即不能改变字符串的子串。如:s[2] = ‘a’

Python预定义了如下字符串:string.uppercase string.lowercase string.letters string.digits

Python的连接操作是比较慢的,推荐使用 % 形式的字符串格式化或者把字符串放在 List 中,然后调用 join()方法。如下:

'%s %s' % ('Spanish', 'Inquisition')
s = ' '.join(('Spanish', 'Inquisition', 'Made Easy'))

笔记中不打算详细讲解 % 格式化字符串的详细用法,它跟 C 的 printf 函数很像,具体参考相关书籍。

Python支持类似于 C 中的源码字符串拼接,相邻的两个字符串字面量自动合并成一个长的字符串 foo = “hello” ‘world!’

当正常字符串和 Unicode 字符串一起使用时,正常字符串被转为 Unicode 字符串,如:’Hello’ + u’ ‘ + ‘World’ + u’!’

Python除了可以使用传统的元组形式的格式化,还可以使用字典形式的格式化:

'There are %(howmany)d %(lang)s Quotation Symbols' % \
    {'lang':'Python', 'howmany':3}

string 模块中有一个类叫 Template 专门用来处理类似于 PHP 中的变量替换,$形式的变量会被其值替换。substitute()是严格模式,safe_substitute()则在缺少变量时不抛出错误。示例代码如下:

from string import Template
s = Template('There are ${howmany} ${lang} Quotation Symbols')
print s.substitute(lang='Python', howmany=3) #缺少其中之一会抛出错误
print s.safe_substitue(lang='Python')

字符串中还有一个原始字符串操作符(r/R),此操作符放在引号的前面,对于字符串中的特殊字符不进行转义。这个特性主要是为了减轻正则表达式字符串的负担。

f = open(r'C:\windows\temp\readme.txt', 'r')
f.readline()
f.close()

Python 字符串还支持 Unicode 字符串,就是在引号前防止 u 或者 U ,而且 ur 可以一起使用。如:

u'abc'
u'\u1234'
u'abc\u1234\n'
ur'Hello\nWorld!'

字符串对象方法

简单列举常用的几个字符串对象方法。

  • string.count(str, beg=0, end=len(string)) 返回 str 在 string 中出现的次数,beg 和 end 限定出现的范围;
  • string.decode(encoding=’UTF-8′, errors=’strict’) 以指定编码对 string 进行解码;
  • string.encode(encoding=’UTF-8′, errors=’strict’) 以指定编码对 string 进行编码;
  • string.endswith(obj, beg=0, end=len(string)) string 中由 beg 和 end 限定的子串是否以 obj 结尾;
  • string.find(str, beg=0, end=len(string)) 在 string 的子串中查找字符串 str ,返回索引,没找到返回 -1 ;
  • string.index(str, beg=0, end=len(string)) 类似于 find 但是在没有找到时抛出异常;
  • string.isalnum() string.isalpha() string.isdecimal() string.isdigit() string.islower() string.isnumeric()
  • string.join(seq) 将序列 seq 中每个元素连接起来,中间用 string 拼接;
  • string.lower() string.upper()
  • string.replace(str1, str2, num=string.count(str1)) 替换 string 中的子串 st1 为 str2 直到达到 num 次;
  • string.rfind(str, beg=0, end=len(string)) 类似于 find ,执行反向搜索;
  • string.rindex(str, beg=0, end=len(string)) 类似于 index ,执行反向搜索;
  • string.lstrip() string.rstrip() string.strip() 消除左右两边的空白;
  • string.split(str=””, num=string.count(str)) 将 str 当做分隔符对字符串 string 进行分割直到达到 num 次;
  • string.startswith(obj, beg=0, end=len(string)) 判断 string 的子串是否以 obj 起始;

Python 字符串与 C 字符串的不同之处在于,Python 字符串中可以包含任意数量的 NUL(\0)值,使得它很适合用来
存储二进制数据。

三引号字符串能够原原本本保留字符串中的换行符,特别适合与 HTML 和 SQL 语句。

此笔记不打算讲解 Unicode 字符串,因为涉及到编码和大小端,记住我们目前最常用的编码是 UTF-8 就行了。

列表

列表的最大特点就是可变,并且可以包含任意类型的元素。列表可以用 [] 或者 list() 来创建,可以通过切片操作符来访问列表中的元素。列表有一个重要的特性就是列表解析(List Comprehensions)。可以将列表当做多维数组来使用:

mixup_list = [4.0, [1, 'x'], 'beef', -1.9+6j]
mixup_list[1][1] = -64.875
num_list = [43, -1.23, -2, 6.19e5]
num_list[2:4] = [16.0, -49]  #这样不会改变列表的维度

连接操作(+)只能作用于列表而不能是元组或别的类型,连接操作符要求两边的类型一致。

列表的比较执行如下逻辑:对列表中的元素进行比较,如果类型相同则执行值比较,否则认为数字比任何其它类型值小,除此之外别的类型用类型的名字进行比较,最后如果都相等就按照列表的长度进行比较,长的较大,否则长度也相等就是一样大。

List() 和 Tuple() 方法经常用来进行相互之间的转换。它们都能够接受一个迭代器作为参数来生成对应的值。

列表对象方法

  • list.append(obj) 将 obj 添加到列表的末尾;
  • list.count(obj) 返回 obj 在列表中出现的次数;
  • list.extend(seq) 将序列 seq 中的元素添加到列表中;
  • list.index(obj, i=0, j=len(list)) 返回 obj 在列表中的位置,范围必须在 i<=k<j 如果找不到将抛出 ValueError 异常;
  • list.insert(index, obj) 将 obj 插入到列表的 index 位置;
  • list.pop(index=-1) 从列表中移除元素,元素在索引 index 位置或者缺省在最末尾;
  • list.remove(obj) 从列表中一处元素 obj ;
  • list.reverse() 将列表反转此操作将改变列表 list;
  • list.sort(func=None, key=None, reverse=False) 对列表进行排序;

元组

元组跟列表很类似,唯一的区别就是元组是不可变的,而列表是可变的。元组可以用 () 或 tuple() 来创建新对象。如果是空对象,则为 (,) 形式,单元素元组是 (obj,)。由于元组具有不可变性,所以不能改变元组的内容。以下是一些示例代码:

t = (['xyz', 123], 23, -103.4)
t * 2
t = t + ('free', 'easy')
23 in t
123 in t
t[0][1]
t[1:]
str(t)
len(t)
maxt(t)
min(t)
cmpy(t, (['xyz', 123], 23, -103.4, 'free', 'easy'))
list(t)

请牢记:元组的切片值不能放到等号的左边,这是由不变性造成的,如果需要一个可变序列,用 list() 方法。另外一点就是元组中可以包含可变对象,如下:

t = (['xyz', 123], 23, -103.4)
t[0][1] = ['abc', 'def']

不带括号的逗号分隔的多个对象是元组,通常用于函数返回多个值,同时返回值可以用多个变量来接收。

def foo():
    return 1, 2, 3
a, b, c = foo()

相关模块包括:collections, array, copy 。要对序列进行深度拷贝要使用 copy.deepcopy() ,值得注意的是深度拷贝只会对可变容器对象进行递归拷贝,对于不可变对象依然是只拷贝引用。

Leave a Reply

Your email address will not be published. Required fields are marked *