Python 05

字符串，列表，元祖，这些类型是由一些成员共同组成的一个序列整体，统称为序列

序列

序列有着相同的访问模式：它的每一个元素可以通过指定一个偏移量的方式得到，而且多个元素可以通过切片操作的方式一次得到。

成员关系操作符（in，not in）

成员关系操作符使用来判断一个元素是否属于一个序列，比如对字符串类型来说就是判断一个字符是否属于这个字符串，对元祖来说就代表一个对象是否属于该对象序列。in/not in操作符的返回值一般来讲就是True/False，满足成员关系就返回True，否则返回False：

obj [not] in sequence

序列操作符	作用
seq[ind]	获取下标为ind的元素
seq[ind1:ind2]	获得下标从ind1到ind2之间的元素集合
seq*expr	序列重复expr次
seq1+seq2	连接序列seq1和seq2
obj in seq	判断obj元素是否包含在seq中
obj not in swq	判断obj元素是否不包含在seq中

连接操作符(+)：允许把一个序列和另一个相同类型的序列做连接

sequence1+sequence2

该表达式的结果是一个包含sequence1和sequence2的内容的新序列，这种方式看起来似乎实现了把两个序列内容合并的概念，但是这个操作不是最快或者最有效的，对字符串来说这个擦偶走不如把所有的子字符串放到一个列表或可迭代对象中，然后调用一个join方法来把所有的内容连接在一起节约内存，类似的对列表来说，可以使用extend()方法来把两个或者多个列表对象合并，当需要简单地把两个对象的内容合并或者说不能依赖于可变对象的那些没有返回值（实际上返回一个None）的内建方法来完成的时候时连接操作符还是一个方便的选择。

重复操作符(*)：当需要一个序列的多份拷贝时，重复操作非常有用

sequence*copies_int

copies_int必须是一个整数，像连接操作符一样，该操作符返回一个新的包含多份员对象拷贝的对象

切片操作符([],[:],[::])：序列类型是其元素被顺序放置的一种数据结构类型，这种方式允许通过指定下标的方式来获得某一个数据元素，或者通过指定下标范围来获取一组序列的元素，这种访问序列的方式称作切片，通过切片操作符可以实现上面说道的操作，访问某个数据元素的语法如下：

sequence[index]

sequence是序列的名字，index是想要访问的元素对应的偏移量，偏移量可以是正直，范围是从0到偏移最大值，用len()函数可以得到序列长度，此外也可以使用负索引，范围是-1到序列的负长度，正负索引的区别在于正索引以序列的开始为起点，负索引以序列的结束为起点，试图访问一个越界的索引会引发异常：

>>> names=('Tom1','Tom2','Tom3')
>>> print(names[4])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: tuple index out of range
>>> names[1]
'Tom2'
>>> names[0:2]
('Tom1', 'Tom2')
>>> names
('Tom1', 'Tom2', 'Tom3')
>>> names[0:1]
('Tom1',)
>>> names[-1]
'Tom3'
>>> names[::-1]
('Tom3', 'Tom2', 'Tom1')
>>> names[::2]       #隔一个取一个数据
('Tom1', 'Tom3')
>>> names[::1]
('Tom1', 'Tom2', 'Tom3')

内建函数(BIFs)

类型转换

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

函数	含义
list(iter)	把可迭代对象转换为列表
str(obj)	把obj对象转换成字符串（对象的字符串表示法）
unicode(obj)	把对象转换成Unicode字符串(使用默认编码)
basestring()	抽象工厂函数，其作用仅仅是为str和unicode函数提供父类，所以不能被实例化，也不能被调用
tuple(iter)	把一个可迭代对象转换成一个元祖对象

所谓浅拷贝就是只拷贝了对对象的索引，而不是重新建立了一个对象，如果想完全的拷贝一个对象(包括递归，如果对象是一个包含在容器中的容器)，需要用到深拷贝，str()函数在需要把一个对象的可打印信息输出时特别有用，不仅是对序列类型，对其他类型的对象同样如此，Unicode()是str()函数的unicode版本，跟str()函数基本一样，list()和tuple()函数在列表类型和元祖类型的互换是非常有用，不过这些函数也适用于string类型(因为string类型也是序列的一种)，但是在string类型上应用tuple()和list()函数却得不到通常希望的结果。

Operational

Python为序列类型提供以下可操作BIFs，len(),reversed()和sum()函数只能接收序列类型对象作为参数，而剩下的则还可以接收可迭代作为参数，另外，max()和min()函数也可以接受一个参数列表：

函数名	功能
enumerate(iter)	接受一个可迭代对象作为参数，返回一个enumerate对象(同时也是一个迭代器)，该对象生成由iter每个元素的index值和item值组成的元祖
len(seq)	返回seq的长度
max(iter,key=None) or max(arg0,arg1…,key=None)	返回iter或(arg0,arg1,…)中的最大值，如果指定了key，这个key必须是一个可以传给sort()方法的，用于比较的回调函数
min(iter,key=None) or min(arg0,arg1…,key=None)	返回iter里面的最小值，或者返回(arg0,arg2,…)里面的最小值，如果指定了key，这个key必须是一个可以传给sort()方法的，用于比较的回调函数
reversed(seq)	接受一个序列作为参数，返回一个以逆序访问的迭代器
sorted(iter,func=None,key=None,reverse=False)	接受一个可迭代对象作为参数，返回一个有序的列表；可选参数func,key和reverse的函数以list.sort()内建函数的参数含义一样
sum(seq,init=0)	返回seq和可选参数init的综合，其效果等同域reduce(operator.add,seq,init)
zip([it0,it1,… itN])	返回一个列表，其第一个元素是it0,it1,…这些元素的第一个元素组成的一个元祖，第二个…,类推

字符串

Python中可以通过在引号间包含字符的方式创建它，Python里单引号和双引号的作用是相同的，字符串是不可变类型，当改变一个字符串的元素需要新建一个新的字符串，字符串是由独立的字符组成的，并且这些字符可以通过切片操作顺序访问：

>>> tmp='abcdefg' #创建字符串
>>> tmp
'abcdefg'
>>> print(tmp)
abcdefg
>>> s=str([0,1,2,4])
>>> s
'[0, 1, 2, 4]'
>>> tmp[0]  # 访问字符串
'a'
>>> tmp[1:3]
'bc'
>>> tmp[4:]
'efg'
>>> tmp[4::]
'efg'
>>> tmp[3::]
'defg'
>>> tmp=tmp[:3]+' python'  #改变字符串
>>> tmp
'abc python'
>>> del tmp  #删除一个字符串
>>> tmp
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'tmp' is not defined

字符串和操作符

string模块预定义字符串：

>>> import string
>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'
>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.digits
'0123456789'

连接符(+)：

>>> '%s %s' % ("Hello","World")
'Hello World'
>>> s = '%s %s' % ("Hello", "World")
>>> s
'Hello World'
>>> q=''.join(('Hello','World'))
>>> q
'HelloWorld'
>>> ('%s%s' % (s[:3],s[10])).upper()
'HELD'
>>> f=('http://' #protocol   字符串连接
...   'localhost' #hostname
...   ':8080' #port
...   'string.py') #file
>>> f
'http://localhost:8080string.py'
>>> 'Hello'+u' '+'World'+u'!' #普通字符转换为Unicode字符串
'Hello World!'
>>> "Hi "*8  #重复字符（*）
'Hi Hi Hi Hi Hi Hi Hi Hi '

只适用与字符串的操作符

字符串模版

新式字符串Template对象的引进使得string模块重新活了过来，Template对象有两个方法，substitule()和safe_substitute(),前者更为严谨，在key缺少的情况下会报一个KeyError的异常，后者在缺少key时，直接原封不动的把字符串显示出来：

>>> from string import Template
>>> s=Template('Now have ${Number} ${Type} problems')
>>> s
<string.Template object at 0x0048DDF0>
SyntaxError: invalid syntax
>>> print(s.substitute(Type='Life',Number=10))
Now have 10 Life problems
>>> print(s.substitute(Type='Life'))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "C:\Users\Administrator\AppData\Local\Programs\Python\Python35-32\lib\str
ing.py", line 129, in substitute
    return self.pattern.sub(convert, self.template)
  File "C:\Users\Administrator\AppData\Local\Programs\Python\Python35-32\lib\str
ing.py", line 119, in convert
    val = mapping[named]
KeyError: 'Number'
>>> print(s.safe_substitute(Type='Life'))
Now have ${Number} Life problems
>>>

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

在原始字符串里，所有的字符都是直接按照字面的意思来使用，没有转义字符或不能打印的字符，除了原始字符串符号(引号前面的字幕“r”)意外，原始字符串跟普通字符串有着几乎完全相同的语法，‘r’可以小写也可以大写，唯一的要求是必须紧靠在第一个引号前。

>>> '\n'
'\n'
>>> '\\n'
'\\n'
>>> '\n'
'\n'
>>> print('\n')


>>> r'\n'
'\\n'
>>> print(r'\n')
\n