Python核心编程(第二版)第6章序列：字符串，列表和元组

文章由Byrx.net分享于2019-03-22 12:03:57评论（58）

Python核心编程(第二版)第6章序列：字符串，列表和元组

6.1 序列

6.12 序列类型操作符

1. 成员关系操作符(in、not in)

成员关系操作符是用来判断一个元素是否属于一个序列的。

>>> arr = (1, 2, 3, 4, "11", "2", "3")

>>> 1 in arr

True

>>> "11" in arr

True

>>> 5 in arr

False

>>>

2. 连接操作符(+)

+允许我们把一个序列和另一个相同类型的序列做连接。

3.重复操作符(*)

*可以将序列多份拷贝

4.切片操作符([], [:], [::])

>>> for item in range(-1, -len(m)-1, -1):

... print m[item]

...

>>> m[:None]

('a', 'b', 'c', 'd', 'e')

>>> m[:0]

()

>>>

6.1.3内建函数(BIF)

1. 类型转换

内建函数list(),str(),tuple()被用作在各种序列类型之间转换。这些转换实际上是工厂函数将对象作为参数，并将其内容前拷贝到新生成的对象中。

str()在需要将一个对象的可打印信息输出时特别有用。

unicode()是str()函数的unicode版本。

list()和tuple()函数在列表类型和元组类型互换时特别有用。

>>> list((1,2,3))

[1, 2, 3]

>>> str((1,2,3))

'(1, 2, 3)'

>>> tuple([1,2,3])

(1, 2, 3)

>>> unicode("123")

u'123'

2. 可操作

len()、reversed()和sum()函数只能接受序列类型对象作为参数，enumerate()、sorted()、zip()、max()、min()则还可以接受可迭代对象作为参数。

max()、min()函数也接受一个参数列表。

6.2 字符串

Python里面单引号和双引号的作用是相同的。

字符串是不可变类型。

字符串是由独立的字符组成的，并且这些字符可以通过切片操作顺序地访问。

6.3 字符串和操作符

6.3.1标准类型操作符

字符串在做比较操作的时候是按照ASCII值的大小来比较的。

6.3.2序列操作符切片

正向索引时，索引值开始于0，结束于总长度减1.

反向索引操作时，是从-1开始，向字符串的开始方向计数，到字符串长度的负数为索引的结束。

1. 成员操作符(in, not in)

成员操作符用于判断一个字符或者一个子串的字符是否出现在另一个字符串中。成员操作符不是用来判断一个字符串是否包含另一个字符串的，这样的功能由find()或者index()函数完成。

string 模块预定义的字符串：

PythonWin 2.7.1 (r271:86832, Nov 27 2010, 18:30:46) [MSC v.1500 32 bit (Intel)] on win32.

>>> import string

>>> string.uppercase

'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

>>> string.ascii_letters

'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

>>> string.lowercase

'abcdefghijklmnopqrstuvwxyz'

>>> string.digits

'0123456789'

>>>

for循环的else语句是一个可选项，它只在for循环完整的结束，没有遇到break时执行。

>>> x = [1,2,3,4,5]

>>> for item in range(0, len(x)):

... print x[item]

... else:

... print "The last value of item is ", item

...

The last value of item is 4

>>>

2. 连接符(+)

字符串的join():

>>> ''.join(('1','2','3','4'))

'1234'

>>>

3. 编译时字符串连接

Python的语法允许你在源码中把几个字符串连在一起写，以此来构建新的字符串。通过这种方法可以把长的字符串分成几部分写，而不用加反斜杠。这种写法的好处是可以把注释加进来。

>>> foo = "Hello" " " "World" "!"

>>> foo

'Hello World!'

>>>

4. 普通字符串转化为Unicode字符串。

如果把一个普通字符串和一个Unicode字符串做连接处理，Python会在连接操作前先把普通字符串转化为Unicode字符串。

重复操作符包含了原有字符串的多个拷贝的新串。

>>> "Anders!!!" * 3

'Anders!!!Anders!!!Anders!!!'

6.4 只适用于字符串的操作符

6.4.1格式化操作符(%)

Python支持两种格式的输入参数：第一种是元组，第二种是字典形式。

>>> "%s %s" % ("Anders", "Fan")

'Anders Fan'

>>> "%(Anders)s %(Fan)s" % {"Anders":"Anders", "Fan":"Fan"}

'Anders Fan'

>>>

6.4.2字符串模版：更简单的替代品

新式的字符串模版的优势是不用去记住所有相关细节的，Template对象有个方法substitute()。

>>> from string import Template

>>> s = Template("There are ${HowMany} ${Lang}!")

>>> print s.substitute(HowMany = "100M", Lang = "Money")

There are 100M Money!

>>> print s.substitute(HowMany = '2', Lang = 'brothers')

There are 2 brothers!

>>>

6.4.3原始字符串操作符(r/R)

在原始字符串里，所有字符都是直接按照字面意思来使用，没有转义字符或不能打印的字符。

>>> '\n'

'\n'

>>> print '\n'

>>> r'\n'

'\\n'

>>> print r'\n'

>>>

6.4.4Unicode字符串操作符(u/U)

u/U用来把标准字符串或者包含Unicode字符的字符串转换成完全的Unicode字符串对象。

Unicode操作符必须出现在原始字符串操作符的前面。

>>> u'abc'

u'abc'

>>> u'\u1234'

u'\u1234'

>>> u'abc\u1234\n'

u'abc\u1234\n'

>>> print u'abc'

abc

>>> ur'Hello \n World!'

u'Hello \\n World!'

>>>

6.5 内建函数

6.5.1标准类型函数

cmp()：根据字符串的ASCII码值进行比较。

>>> cmp("abc", "lmn")

-1

>>> cmp("xyz", 'abc')

>>> cmp('lmn', 'lmn')

>>>

6.5.2序列类型函数

len() 返回字符串的字符数

>>> len(string.letters)

max() and min()

返回最大或者最小字符

>>> max(string.digits)

'9'

>>> min(string.digits)

'0'

>>>

enumerate()

>>> s = "Anders Fan"

>>> for item, value in enumerate(s):

... print item, ' ', value

...

0 A

1 n

2 d

3 e

4 r

5 s

7 F

8 a

9 n

>>>

zip()

>>> first, second = "Anders", "Fan "

>>> zip(first, second)

[('A', 'F'), ('n', 'a'), ('d', 'n'), ('e', ' '), ('r', ' '), ('s', ' ')]

>>>

6.5.3字符串类型函数

raw_input()：提示用户输入并将这个输入返回。

str() and unicode()函数都是工厂函数，产生相对应的类型的对象。

isinstance()函数判断一个对象的类型。

chr()函数用一个range(256)范围内的整数做参数，返回一个对应的字符。

unichr()函数跟chr()一样，返回的Unicode字符。

ord()函数是chr()函数或unichr()函数的配对函数，它以一个字符作为参数，返回对应的ASCII数值，或者Unicode数值。

>>> chr(123)

'{'

>>> unichr(123)

u'{'

>>> ord('A')

>>> ord(u'\u1234')

4660

>>>

6.6 字符串内建函数

>>> quest = 'what is your favorite color?'

>>> quest.capitalize()

'What is your favorite color?'

>>> quest.center(40)

' what is your favorite color? '

>>> quest.count('or')

>>> quest.endswith('blue')

False

>>> quest.find('or', 30)

-1

>>> quest.find('or', 10)

>>> quest.index('or', 10)

>>> ':'.join(quest.split())

'what:is:your:favorite:color?'

>>> quest.replace(' ', ':')

'what:is:your:favorite:color?'

>>> quest.upper()

'WHAT IS YOUR FAVORITE COLOR?'

>>>

6.7 字符串的独特特性

6.7.1特殊字符串和控制字符

Python区别于C语言，并不是以NUL(\000)作为结束符的。

6.7.2三引号

Python的三引号允许一个字符串跨多行，字符串可以包含换行符、制表符以及其他特殊字符。

>>> strPython = """<xml>

... 111</xml>

... <item>

... 222

... </item>

... """

>>> strPython

'<xml>\n111</xml>\n<item>\n222\n</item>\n'

>>>

6.7.3字符串不变性

字符串是一种不可变数据类型。

6.8 Unicode

6.8.2什么是Unicode

Unicode是计算机可以支持这个星球上多种语言的秘密武器。Unicode通过使用一个或多个字节来表示一个字符的方法突破了ASCII的限制。在这样的机制下，Unicode可以表示超过90000个字符。

6.8.3怎样使用Unicode

新的内建函数unicode()和unichar()可以看成Unicode版本的str()和chr()。

Codec是什么

Unicode用的是多字节。codec支持的4种耳熟能详的编码方式：ASCII，ISO 8859-1/Latin-1，UTF-8和UTF-16。

UTF-8编码，用一个字节来编码ASCII字符，ASCII字符的UTF-8编码跟ASCII编码完全相同。

UTF-16容易读写，因为它把所有的字符都是用单独的一个16位字，两个字节来存储的。实际上实现它的程序很少，因为大家需要对ASCII进行支持。

6.8.5编码解码

Python通过Unicode字符串的encode转换编码格式。

>>> unicode1 = u"范旭阳"

>>> print unicode1

范旭阳

>>> utf8_unicode1 = unicode1.encode('utf-8')

>>> print utf8_unicode1

范旭阳

>>> utf16_unicode1 = unicode1.encode('utf-16')

>>> print utf16_unicode1

��������֊>>> print utf8_unicode1.decode('utf-8')Firing event 'ProcessEnter' failed.

>>> print utf8_unicode1.decode('utf-8')

范旭阳

>>> print utf16_unicode1.decode('utf-16')

范旭阳

>>>

6.8.6把Unicode应用到实际应用中

程序中出现字符串时一定要加个前缀u。

不要用str()函数，用unicode()代替。

不要用过时的string模块——如果传给它的是非ASCII字符，它就会把一切搞砸

不到必须时不要在你的程序中编解码Unicode字符。只在你要写入文件或者数据库或者网络时，才调用encode()函数；相应的，只要你需要把数据读回来的时候才调用decode()函数。

Python标准库里面的绝大部分模块都是兼容Unicode的，除了pickle模块!pickle模块只支持ASCII字符串。

6.8.8 Python的Unicode支持

1. 内建的unicode()函数

unicode的工厂方法，它接受一个string做参数，返回一个Unicode字符串。

2. 内建的decode()/encode()方法

decode()和encode()内建函数接受一个字符串做参数返回该字符串对应的解码后/编码后的字符串。decode()和encode()都可以应用在常规字符串和Unicode字符串。

3. Unicode类型

Unicode字符串对象是basestring的子类、用Unicode()工厂方法或直接在字符串前面加一个u或者U来创建实例。

4. Unicode序数

内建的unichr()函数返回一个对应的Unicode字符。

5. 强制类型转换

混合类型字符串操作需要把普通字符串转换成Unicode对象。

6. 异常

UnicodeError异常是在exceptions模块中定义的，ValueError的子类。

7. 标准编码

utf-8、utf-16

8. RE引擎对Unicode的支持

正则表达式引擎需要Unicode的支持。

9.字符串格式化操作符

如果格式化字符串是Unicode对象，所有参数都将首先强制转换成Unicode然后根据对应的格式串一起进行格式转换。数字首先被转换成普通字符串，然后在转换成Unicode。Python字符串通过默认编码格式转化成Unicode。

>>> u"12345%s78%d0"%("6", 9)

u'1234567890'

>>>

6.10 字符串关键点总结

1. 一些引号分隔的字符

可以用两种引号来创建字符串，好处是当你的字符串中包含单引号时，如果用单引号创建字符串，那么字符串就不需要转义，反之亦然。

2. 不可分字符类型

字符串是唯一的字面上的字符序列类型，字符本身并不是一种类型，字符串是字符存储操作的最基本单位。字符应该被视为长度为1的字符串。

3. 字符串格式化操作符(%)提供类似printf()的功能。

4. 三引号

在三引号字符串中可以包含诸如回车或者tab键这样的特殊字符。

5. 原始字符串对每个特殊字符串都使用它的原意(r/R)

6. Python字符串不是用过NUL或者‘\0’来结束的。

Python为你自动管理内存。

6.11 列表

列表与元组的区别：元组是不可变的，或者说是只读的。

1. 如何创建列表类型数据并给它赋值。

>>> [1,2,3,"45",[6,'7'],8]

[1, 2, 3, '45', [6, '7'], 8]

>>> list("123")

['1', '2', '3']

>>> list()

[]

>>> []

[]

>>>

2. 如何访问列表中的值。

列表的切片操作就像字符串中的一样。

>>> aList=[1,2,3,'45', [6,"7"],9]

>>> aList[1]

>>> aList[:4]

[1, 2, 3, '45']

>>> aList[4:5]

[[6, '7']]

>>> aList[4][1]

'7'

>>>

3. 如何更新列表

可以通过在等号的左边指定一个索引或者索引范围的方式来更新一个或几个元素，也可以用append()方法追加元素到列表中去。

>>> aList=[1,2,3,'45', [6,"7"],9]

>>> aList.append((1,2,3))

>>> aList

[1, 2, 3, '45', [6, '7'], 9, (1, 2, 3)]

>>> aList[2]=[]

>>> aList

[1, 2, [], '45', [6, '7'], 9, (1, 2, 3)]

>>>

4. 如何删除列表中的元素或者列表(本身)

要删除列表中的元素，如果确切知道要删除元素的索引可以用del语句，否则可以用remove()方法。

如果想明确删除一整个列表，可以用del语句。

>>> aList

[1, 2, [], '45', [6, '7'], 9, (1, 2, 3)]

>>> del aList[1]

>>> aList

[1, [], '45', [6, '7'], 9, (1, 2, 3)]

>>> aList.remove("45")

>>> aList

[1, [], [6, '7'], 9, (1, 2, 3)]

>>> del aList

>>> aList

Traceback (most recent call last):

File "<interactive input>", line 1, in <module>

NameError: name 'aList' is not defined

>>>

6.12 操作符

6.12.1标准类型操作符

6.12.2序列类型操作符

1. 切片([]和[:])

2. 成员关系操作(in，not in)

3. 连接操作符(+)

连接操作符允许我们把多个列表对象合并在一起。注意，列表类型的连接操作也只能在同类型之间进行。extend()方法比连接操作的一个优点是它实际上是把新列表添加到了原有的列表里面，而不是像连接操作那样新建一个列表。

连接操作符并不能实现向列表中添加新元素的操作。

>>> list1 = [1, 2, '3' ]

>>> list2 = [4, 5, '6' ]

>>> list1 + list2

[1, 2, '3', 4, 5, '6']

>>>

4. 重复操作符(*)

重复操作符可能更多地应用在字符串类型中，不过，列表和元组跟字符串同属序列类型，所以需要的时候也可以使用这一操作。

>>> list1 * 3

[1, 2, '3', 1, 2, '3', 1, 2, '3']

>>>

6.12.3列表类型操作符和列表解析

列表解析结合了列表的方括弧和for循环，在逻辑上描述要创建的列表的内容。

>>> [j for j in range(10) if j%2==0]

[0, 2, 4, 6, 8]

>>>

6.13 内建函数

6.13.1标准类型函数

cmp()

6.13.2序列类型函数

len() max() min() sorted() reversed() enumerate() zip() sum() list() tuple()

>>> aList = ["a", 1, 3, 4]

>>> for(i, j) in enumerate(aList):

... print i, j

...

0 a

1 1

2 3

3 4

>>> for(i, j) in zip([0, 1, 2, 3], aList):

... print i, j

...

0 a

1 1

2 3

3 4

>>>

>>> import operator

>>> reduce(operator.add, [6, 4, 5])

>>> sum([6, 4, 5])

>>>

>>> tuple([0, 1, 2, 3])

(0, 1, 2, 3)

>>> list((5, 6, 7 ,80))

[5, 6, 7, 80]

>>>

6.13.3列表类型内建函数

range()

6.14 列表类型的内建函数

可以在一个对象应用dir()方法来得到它所有的属性和方法。

list.append() list.count() list.extend() list.index() list.insert() list.pop() list.remove() list.reverse() list.sort()

那些可以改变对象值的可变对象的方法都是没有返回值的

6.15 列表的特殊特性

用列表构建其他数据结构

1. 堆栈

堆栈是一个后进先出(LIFO)的数据结构。

stack = []

def pushit():

stack.append(raw_input(' Enter New String: ').strip())

def popit():

if len(stack)==0:

print 'Cannot pop from an empty stack!'

else:

print 'Removed [',`stack.pop()`,']'

def viewstack():

print stack #calls str() internally

pushit()

viewstack()

popit()

viewstack()

popit()

viewstack()

2. 队列

队列是一种先进先出(FIFO)的数据类型。

代码类似堆栈。

6.16 元组

元组的创建、访问、更新，移除与列表类似，只是在更新与移除时不能更改原元组本身。

6.17 元组操作符和内建函数

与列表完全一致

6.18 元组的特殊性

6.18.2元组也不是那么“不可变”

元组对象本身是不可变的。

6.18.3默认集合类型

所有函数返回的多对象都是元组类型。

>>> def fun():

... return 1, 2, 3

...

>>>

6.18.4单元素元组

无法创建单元素元组，一个变通的方法是在第一个元素后面添一个逗号来表明是一个元组而不是在做分组操作。

>>> ("111")

...

'111'

>>> type(("222"))

>>> ("111",)

('111',)

>>>

6.20 *拷贝Python对象、浅拷贝和深拷贝

序列类型对象的浅拷贝是默认类型拷贝，并可以以下几种方式实施(1)完全切片操作[:] (2)利用工厂函数(3)使用copy模块的copy函数。

深拷贝需要copy.deepcopy()函数

>>> person1 = ['name', ['money', 100]]

>>> person2 = person1

>>> import copy www.2cto.com

>>> person3 = copy.deepcopy(person1)

>>> person1[1][1] = 50

>>> print person1, person2, person3

['name', ['money', 50]] ['name', ['money', 50]] ['name', ['money', 100]]

>>>

几点需要注意:1)、非容器类型没有被拷贝一说，浅拷贝是用完全切片操作来完成的。2)、如果元组变量只包含原子类型对象，对它的深拷贝将不会进行。(注：因为元组是不可变的，深拷贝没有意义)摘自：xufei96的专栏

热门文章：

Python核心编程(第二版)第6章序列：字符串，列表和元组