0.    序列包括字符串、列表和元组三种类型

1.    序列

1.0  序列的每一个元素可以通过指定一个偏移量的方式得到，多个元素可以通过切片操作的方式一次得到。偏移量从0开始，到总元素数-1结束

1.1  标准类型操作符

标准类型操作符一般适用于所有的序列类型

1.2  序列类型操作符

1.2.1  成员关系操作符—in和not in

成员关系操作符用来判断一个元素是否属于一个序列，返回True/False：满足成员关系就返回True，否则返回False。

>>> "12" in "123456"
True
>>> "12" not in "13456"
True

1.2.2  连接操作符

连接操作符可以连接一个序列和另一个类型相同的序列。

>>> "123" + "456"
'123456'

需要注意：①连接、合并字符串，更有效的办法是把所有子字符串放到一个列表或可迭代对象中，再调用join方法；类似的，合并列表，更有效的办法是调用列表的extend()方法。

>>> str1 = 'abc'
>>> str2 = 'def'
>>> ' '.join((str1, str2))
'abc def'
abc def
>>> list1 = list(str1)
>>> list2 = list(str2)
>>> list1.extend(list2)
>>> list1
['a', 'b', 'c', 'd', 'e', 'f']

②当仅需要简单的合并两个对象的内容，或者连接那些没有返回值（返回None）的时候，连接操作符较为简便

1.2.3  重复操作符

重复操作符返回一个新的、包含多份原对象拷贝的对象，用于需要一个序列的多份拷贝时，如例：

>>> "12" * 3
"121212"
>>> [12,13] * 3
[12,13,12,13,12,13]

重复操作符连接的非列表对象必须是整型，不能是长整型

1.2.4  切片操作符

①用方括号[]加下标可以访问序列的每一个元素；方括号[]中用冒号:把开始下标和结束下标分开可以访问序列的一组元素，这种访问序列的方式就叫做切片

②访问单个元素

语法：sequence[index]

index可以是正数也可以是负数，区别在于正数从序列的开始为起点，负数从序列的结束为起点，故index为正数时范围是0<=index<=len(sequence)-1;负数范围是-len(sequence)<=index<=-1

且

sequence[len(sequence)-1] = sequence[-1]    sequence[0] = sequence[-len(sequence)]

③访问一组元素

当给出用冒号分割的开始和结束索引值时，可以访问一组元素。

语法：sequence[start_index:end_index]

起始索引和结束索引都是可选的，如果没有提供或者用None作为参数，则从序列的开始处开始，或者到序列的最后结束

1.2.5  切片扩展

序列切片的第三个可选操作是选择步长

语法  sequence[start_index:end_index:step]

如：

>>> a = [1,2,3,4,5,6]
>>> a[::-1]
[6,5,4,3,2,1]    #翻转操作
>>> a[::2]
[1,3,5]      #隔一个取一个

1.2.6  切片索引

切片索引语法灵活，即使开始和结束的索引值超过字符串的长度也没关系。

例子①  对一个字符串，通过循环每次把位于最后的一个字符砍掉，下面是一种实现方法

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

②若需在第一次迭代时显示整个字符串，则可如下修改

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

1.3  内建函数

1.3.1  类型转换

list()  把可迭代类型转换为列表：

>>> list("123456")
['1','2','3','4','5','6']

str()  把对象转换成字符串

>>> str(123)
'123'
>>> str([1,2,3])
'[1,2,3]'

str()在输出对象的可打印信息时很有用；

list()和tuple()函数在用于列表和元组的互换时很有用

转换类型函数说明：

1.3.2  可操作

Python为序列类型提供的内建可操作函数包括以下各种，其中len();  reversed();  sum()函数只能接受序列类型作为参数。剩下的可以作为可迭代对象作为参数。max()、min()函数还可以接受一个参数列表

2.字符串和操作符

2.1  标准类型操作符

字符串做比较操作时，字符串是按照ASCII码值比较的

2.2  序列操作符切片

①正向索引范围从0到len()-1;反向索引范围从-1到-len()

2.3  成员操作符 in / not in

①成员操作符用于判断一个字符和字符串是否出现在另一个字符串中，出现返回True，否则返回False

>>> 'ab' in 'abc'
True
>>> 'ab' in 'bcde'
False
>>> 'ab' not in 'abc'
False
>>> 'ab' not in 'bcde'
True

②string模块中预定义的方法

>>> import string
>>> string.uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.lowercase
'abcdefghijklmnopqrstuvwxyz'
>>> string.letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.digits
'0123456789'

标识符检查例子（idcheck.py）

import stringalphas = string.letters + '_'
nums = string.digitsprint "Welcome to the Identifier Checker v1.0"
print "Testees must be at least 2 chars long."
myInput = raw_input("Identifier to test? ")if len(myInput) < 2:print "Testees must be at least 2 chars long!"elif len(myInput) >= 2:if myInput[0] not in alphas:print '''invalid: first symbol must bealphabetic'''else:for otherChar in myInput[1:]:if otherChar not in alphas + nums:print '''invalid: remainingsymbol must be alphabetic'''breakelse:print "Okay as an identifier"

注①：这里用到了for-else结构。for遍历循环可以有可选的一个else分支语句，在循环迭代正常完成后执行，即除非以正常方式结束循环，否则其他任意方式（如break）退出循环时，else分支不会被执行。看下面的例子

>>> for i in range(5)：
...     print i
... else:
...     print "This will print."
...
0
1
2
3
4
This will print
>>>
>>> for i in range(5):
...     if i >= 3:
...         break
...     print i
... else:
...     print "This will not print."
...
0
1
2
>>>

注②一般来说，从性能的角度来考虑，重复操作作为参数在循环体里面是很低效的 所以我们可以对例子里的某段代码做出修改

# 原代码
# for otherChar in myInput[1:]:
#     if otherChar not in alphas + nums:
#         pass# 修改后代码
alphasnums = alphas + numsfor otherChar in myInput[1:]:if otherChar not in alphasnums"pass

2.4  连接符 "+"

字符串的upper() lower() 方法

>>> Upp = 'ABC'
>>> Low = 'abc'
>>> Upp.lower()
'abc'
>>> Low.upper()
'ABC'

3.  只适用于字符串的操作符

3.1  格式化操作符（%）  格式化字符串

3.1.1  字符串格式化符号

A.字符串格式化的符号

B.格式化操作符辅助指令

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

元组形式的例子：

>>> "%x" % 108
'6c'
>>> "%X" % 108
'6C'
>>> "%#X" % 108    # 八进制数前显示'0'，十六进制前面显示'0x'或'0X'
'0X6C'
>>> "%#x" % 108    # x输出小写，X输出大写
'0x6c'
>>> '%f' % 1234.567890
'1234.567890'
>>> '%.2f' % 1234.567890    # 小数点后保留两位
'1234.57'
>>> '%08.2f' % 1234.567890  # 小数点后保留2位，且最小显示宽度为8，小数点算一位，不足8位用0补充
'01234.57'
>>> '%8.2f' % 1234.567890   # 小树点后保留2为，且最小宽度为8，小数点算一位，不足8位空格补充
' 1234.57'
>>> '%g' % 1234.567890
'1234.57'    # %g会根据值得大小选择%e或%f控制输出，且输出最多保留6位有效数字
>>> '%g' % 1.234567890
'1.23457'
>>> '%g' % 12345678.9
'1.23457e+07'
>>> '%e' % (111111111111L)
'1.111111e+11'

字典形式的例子：

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

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

新式的字符串Template对象可以替代字典形式的字符串格式化，有两个方法：substitute()和safe_substitute()。前者更加严谨，缺少key时报错；后者缺少对应的key则会原封不动的显示出来。

>>> from string import Template
>>> s = Template('There are ${howmany} ${long} Quotation Symbols')
>>>
>>> print s.substitute(lang='Python', howmany=3)
There are 3 Python Quotation Symbols
>>> print s.safe_substitute(lang='Python')
There are ${howmany} Python Quotation Symbols

3.3  原始字符串操作符

在字符串引号前加r或R，则对字符串中的转义字符默认不处理

>>> print '\n'>>> print r'\n'
\n

3.4  内建函数

3.4.1  序列类型函数

len()  max()  min()  enumerate()    zip()函数均适用于字符串

>>> str1 = 'abc'
>>> len(str1)
3
>>> str2 = 'lmn'
>>> str3 = 'xyz'
>>> max(str2)
'n'
>>> min(str3)
'x'
>>> s = 'Python'
>>> for i, t in enumerate(s):
...     print i, t
...
0 P
1 y
2 t
3 h
4 o
5 n
>>> s, t = 'Pyt', 'hon'
>>> zip(s,t)
[('P', 'h'), ('y', 'o'), ('t', 'n')]

3.5  字符串内建方法

字符串内建方法可参考下列表

下面是一些例子

>>> quest = 'what is your favorite color?'
>>> quest.capitalize()
'What is your favorite color?'
>>>
>>> quest.center(40)
'      What is your favorite color?      '
>>>
>>> quest.count('or')
2
>>>
>>> quest.endswith('or')
False
>>> quest.endswith('or?')
True
>>>
>>> quest.find('or')
16
>>> quest.find('ro')
-1
>>> quest.find('or',18)
25
>>>
>>> quest.index('or',0,18)
16
>>>
>>> alnum = 'abc123'
>>> notalnum = 'abc 123'
>>> alpha = 'abc'
>>> num = '123'
>>> num_hex = '017'
>>> num_oct = '0X17'
>>> alnum.isalnum()
True
>>> notalnum.isalnum()
False
>>> alpha.isalpha()
True
>>> alnum.isalpha()
False
>>> u'123'.isdecimal()
True
>>> u'0X17'.isdecimal()
False
>>> alpha.isdigit()
False
>>> num.isdigit()
True
>>> quest.islower()
True
>>> quest.capitalize().islower()
False
>>> quest.isspace()
False
>>> '  '.isspace()
True
>>> quest.istitle()
False
>>> quest.title().istitle()
True
>>> quest.isupper()
False
>>> quest.upper().isupper()
True
>>> ':'.join(quest.split())
'what:is:your:favorite:color?'
>>> quest.ljust(40)
'what is your favorite color?            '
>>> '   abc'.lstrip()
'abc'
>>> quest.partition('or')
('what is your fav', 'or', 'ite color?')
>>> quest.split('or')
['what is your fav', 'ite col', '?']
>>> quest.replace('or', 'OR')
'what is your favORite colOR?'
>>>
>>> quest.rjust(40)
'            what is your favorite color?'

3.6 字符串的独特特性

3.6.1  特殊字符串和控制字符

①一个反斜线"\"加一个单一字符可以表示一个特殊字符，通常是一个不可打印的字符，这就是转义的功能

②转义字符表

③单独的反斜线作为连字符，将本行和下一行的内容连接起来

>>> print "This a \
... sentence \
... and \
... this."
This is a sentence and this.

3.6.2  三引号

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

3.7  编码问题

3.7.1  raw_input在Windows系统的命令后模式下偶有中文提示语言乱码问题，原因在于Windows的CMD输出的编码问题，如下操作即可

>>> # -*- coding:utf-8 -*-
>>> print u'中文测试'
中文测试
>>> raw_input(u'中文测试'.encode('gbk'))
中文测试_

3.7.2  一个例子

'''
An example of reading and writing Unicode strings:Writes
a Unicode string to file in utf-8 and reads it back in.
'''
CODEC = 'utf-8'
FILE = 'Unicode.txt'hello_out = u"Hello world\n"
bytes_out = hello_out.encode(CODEC)
f = open(FILE, 'w')
f.write(bytes_out)
f.close()f = open(FILE, 'r')
bytes_in = f.read()
f.close()
hello_in = bytes_in.decode(CODEC)
print hello_in,

3.7.3  实际应用中的建议

①程序中出现字符串是在前面加前缀"u"

②用unicode()代替str()函数

③非必要时不要编解码Unicode字符。只有在写入文件/数据库/网络时才调用encode()函数；相应的，需要把数据读取回来时才使用decode()函数

④Python标准库里面大部分模块都支持Unicode,但pickle模块不支持，所以最好避免基于文本的pickle操作

⑤假设构建一个用数据库来读写Unicode数据的web应用，为了支持Unicode，必须确保以下方面对Unicode的支持：

A.数据库服务器（MySQL等）

B.数据库适配器

C.web开发框架

3.8  相关模块

下表列出了Python标准库里面与字符串有关的模块

3.9  列表

①更新列表可以通过在等号左边指定一个索引或一个索引范围，也可以通过append()方法

>>> a_list = [123, 456, 789, 'abc', 'def']
>>> a_list[2] = 'hhh'
>>> a_list
[123, 456, 'hhh', 'abc', 'def']
>>> a_list.append('I am the new')
>>> a_list
[123, 456, 'hhh', 'abc', 'def', 'I am the new']

②删除列表中的元素，可以用del语句和remove方法及pop方法，通过例子来看不同

>>> a_list
[123, 456, 'hhh', 'abc', 'def', 'I am the new']
>>> del a_list[2]
>>> a_list
[123, 456, 'abc', 'def', 'I am the new']
>>> a_list.remove(123)
>>> a_list
[456, 'abc', 'def', 'I am the new']
>>> a_list.pop()
>>> a_list
[456, 'abc', 'def']
>>> a_list.pop(1)
[456, 'def']

3.10  操作符和内建函数

3.10.1  标准类型操作符

标准类型操作符比较两个列表时，两个列表的每个元素分别比较，直到有一方的元素胜出为止。

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

列表解析结合了列表的方括弧和for循环

>>> [i ** 3 for i in [8, -2, 5]]
[512, -8, 125]
>>> [i * 3 for i in 'abcde']
['aaa', 'bbb', 'ccc', 'ddd', 'eee']

3.10.3  cmp()函数比较

cmp()比较两个列表的算法如下：

①对两个列表的每个元素逐一进行比较

②如果比较的元素是同类型的，则比较其值并返回结果

③若不是同一类型，则检查他们是否是数字：

A。如果是数字，则进行必要的强制类型转换，然后比较

B。如果只有一方的元素是数字，则另一方的元素"大"（数字是"最小的"）

C。否则，通过类型名字的字母顺序进行比较

④如果有一个列表首先达到末尾，则另一个长一点的元素大

⑤如果两个列表都达到末尾且所有元素都相等，则返回0即判定两个列表相等

3.10.4  序列类型函数

①len()函数返回列表或元组元素个数，每个对象都作为一项来处理

②max()和min()返回列表或元组各元素中最大或最小的项

③函数reversed()对列表或词典进行翻转；sorted()对列表排序

>>> s = ['They', 'stamp', 'them', 'when', "They're", 'small']
>>> for t in reversed(s):
...     print t,
...
small They're when them stamp They
>>> sorted(s)
['They', "They're", 'small', 'stamp', 'them', 'when']

④enumerate()和zip()

>>> albums = ['tales', 'robot', 'pyramid']
>>> for i, album in enumerate(albums):
...     print i, album
...
0 tales
1 robot
2 pyramid
>>> fn = ['ian', 'stuart', 'david']
>>> ln = ['bairnson', 'elliott', 'paton']
>>>
>>> for i, j in zip(fn, ln):
...     print ('%s %s' % (i, j)).title()
...
Ian Bairnson
Stuart Elliott
David Paton

⑤sum()

>>> a = [12, 3, 4]
>>> sum(a)
19
>>> sum(a, 1)
20
>>> import operator
>>> reduce(operator.mul, a)
144

注：reduce()是内建函数，接收的第一个参数是一个二元操作函数，接受的第二个参数是一个列表或元组，先对列表或元组中的第1和第2个元素利用给定函数进行操作，得到的结果再与第3个元素利用给定函数计算，最终得到一个结果。

3.11  列表的内建方法

3.11.1  列表内建方法表

下面是使用这些方法的例子

>>> music_media = [45]
>>> music_media
[45]
>>> music_media.append('long playing record')
>>> music_media
[45, 'long playing record']
>>> music_media.count(45)
1
>>> music_media.count('Hello')
0
>>> music_media.extend(['Hello'])
>>> music_media
[45, 'long playing record', 'Hello']
>>> music_media.index(45)
0
>>> music_media.index('H')
Traceback (most recent call last):File "<stdin>", line 1, in <module>
ValueError: 'H' is not in list
>>> music_media.insert(1, 46)
>>> music_media
[45, 46, 'long playing record', 'Hello']
>>> music_media.pop(1)
46
>>> music_media
[45, 'long playing record', 'Hello']
>>> music_media.remove(45)
>>> music_media
['long playing record', 'Hello']
>>> music_media.reverse()
>>> music_media
['Hello', 'long playing record']
>>> music_media.extend('Hello')
>>> music_media.sort()
>>> music_media
['H', 'Hello', 'e', 'l', 'l', 'long playing record', 'o']