数据结构是通过某种方式（例如对元素进行编码）组织在一起的数据元素的集合
这些数据元素可以是数字或者字符，甚至可以是其他的数据结构。在python中，最基本的数据结构是序列（sequence）。序列中的每个元素被分配一个序号--即元素的位置，也称为索引。
元组除了不能更改之外，其他的性质和列表都很类似。
序列概览
python包含6中内建的序列:列表，元组，字符串，Unicode字符串，buffer对象和xrange对象
列表和元组的主要区别在于：列表可以修改，元组则不能。
需要根据要求来添加元素，使用列表。
出于某些原因，序列不能修改的时候，使用元组则更为合适。---技术性，他与python内部的运作方式有关。这也是内建函数可能返回元组的原因。
一般来说，在几乎所有的情况下列表都可以替代元组（元组作为字典的键是，键不可修改，所以不能使用列表）
>>> edwar=['edward gumby',42]
>>> john=['john smith',50]
>>> database=[edwar,john]
>>> database
[['edward gumby', 42], ['john smith', 50]]
python之中还有一种名为容器（container）的数据结构。容器基本上是包含其他对象的任意对象。序列（列表和元组）和映射（字典）是两类主要的容器。
集合不是序列也不是映射的容器类型
通用序列操作
所有序列类型都可以进行某些特定的操作：索引，分片，加，乘以及检查某个元素是否属于序列的成员（成员资格）。计算序列长度，找出最大元素和最小元素的内建函数。
1.索引---从0开始递增
>>> greeting='hello'
>>> greeting[0]
'h'
>>> greeting[-1]
'o'
字符串就是一个由字符组成的序列。
字符串字面值（其他序列字面量亦可）能够直接使用索引，而不需一个变量引用他们
>>> "Hello"[1]
'e'
>>> forth=raw_input('Year: ')[3]
Year: 2005
>>> forth
'5'
eg：
month.py
months=['January','February','March','April','May','June','July','August','September','October','November','December']
endings=['st','nd','rd']+17*['th']\
+['st','nd','rd']+7*['th']+['st']
year=raw_input('Year: ')
month=raw_input('Month(1-12): ')
day=raw_input('Day(1-31): ')
month_number=int(month)
day_number=int(day)
month_name=months[month_number-1]
ordinal=day+endings[day_number-1]
print month_name+' '+ordinal+','+year
run:
>>>
====================== RESTART: E:/pythonlearn/month.py ======================
Year: 2017
Month(1-12): 4
Day(1-31): 12
April 12th,2017
>>>
2.分片
索引访问单个元素，使用分片操作来访问一定范围内的元素
>>> tag='<a href="http;//www.python.org">Python web site</a>'
>>> tag[9:30]
'http;//www.python.org'
>>> tag[9:40]
'http;//www.python.org">Python w'
>>> tag[32:-4]
'Python web site'
>>>
分片操作的实现需要提供两个索引作为边界，第一个索引的元素是包含在分片内的，第二个则不包括在分片内。
>>> numbers=[1,2,3,4,5,6,7,8,9,10]
>>> numbers[7:10]
[8, 9, 10]
>>> numbers[-3:-1]
[8, 9]
>>>
>>> numbers[-3:0]
[]
>>> numbers[-3:]
[8, 9, 10]
>>> numbers[:3]
[1, 2, 3]
分片中最左边的索引比他右边的晚出现在序列中
eg:
sliceing.py
url=raw_input('Please enter the URL: ')
domain=url[11:-4]
print 'Domain name:'+domain
>>>
==================== RESTART: E:/pythonlearn/sliceing.py ====================
Please enter the URL: http://www.python.org
Domain name:python
>>>
步长 步长2的分片包括开始到结束每隔一个的元素，步长不能为0，但是步长可以是负数，从右往左提取元素：
>>> numbers=[1,2,3,4,5,6,7,8,9,10]
>>> numbers[0:10:1]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[0:10:2]
[1, 3, 5, 7, 9]
>>> numbers[3:6:3]
[4]
>>> numbers[::3]
[1, 4, 7, 10]
>>> numbers[8:3:-1]
[9, 8, 7, 6, 5]
>>> numbers[10:0:-2]
[10, 8, 6, 4, 2]
>>> numbers[0:10:-2]
[]
>>> numbers[::-2]
[10, 8, 6, 4, 2]
>>> numbers[5::-2]
[6, 4, 2]
>>> numbers[:5:-2]
[10, 8]
负数作为步长时，必须让开始点大于结束点。在没有明确指定开始点和结束点的时候，正负数的使用可能会带来一些混淆
对于整数步长，python会从序列的头部开始向右提取元素，知道最后一个元素，而对于负数不成，则是从序列的尾部开始向左提取元素，直到第一元素。
3.序列相加
>>> [1,2,3]+[4,5,6]
[1, 2, 3, 4, 5, 6]
>>> "hello,"+"world!"
'hello,world!'
>>> [1,2,3]+'world'
Traceback (most recent call last):
File "<pyshell#34>", line 1, in <module>
[1,2,3]+'world'
TypeError: can only concatenate list (not "str") to list
>>>
两种相同类型的序列才能进行连接操作。
4.乘法
用数字x乘以一个序列会生成新的序列。
>>> "python"*5
'pythonpythonpythonpythonpython'
>>> [42]*10
[42, 42, 42, 42, 42, 42, 42, 42, 42, 42]
None 空列表和初始化
None使用一个python的内建值
eg：
multiplus.py
sentence=raw_input('Sentence: ')
sceen_width=80
text_width=len(sentence)
box_width=text_width+4
left_margin=(sceen_width-box_width)//2
print ' '*left_margin+'+'+'-'*(box_width-2)+'+'
print ' '*left_margin+'| '+' '*text_width +' |'
print ' '*left_margin+'| '+sentence +' |'
print ' '*left_margin+'| '+' '*text_width +' |'
print ' '*left_margin+'+'+'-'*(box_width-2)+'+'
run
==================== RESTART: E:/pythonlearn/multiplus.py ====================
Sentence: He's a very naughty boy!
+--------------------------+
| |
| He's a very naughty boy! |
| |
+--------------------------+
>>>
5.成员资格
>>> permissions='rw'
>>> 'w' in permissions
True
>>>
6长度，最小值和最大值
>>> numbers=[100,34,678]
>>> len(numbers)
3
>>> max(numbers)
678
>>> min(numbers)
34
>>>
>>> max(3,2)
3
>>> min(3,2)
2
列表
列表是可变的，可以该表列表的内容，并且列表有很多有用的，专门的方法
list函数
实际上是一种类型而不是函数
>>> list('hello')
['h', 'e', 'l', 'l', 'o']
list函数适用于所有类型的序列，而不只是字符串。
基本的列表操作
列表可以使用所有适用于序列的标准操作，例如索引，分片，连接和乘法。列表是可以i修改的。
改变列表的方法：元素赋值，元素删除，分片赋值以及列表方法（并不是所有的列表方法都真正地改变列表）
1.改变列表：元素赋值
改变列表是很容易的。赋值语句即可。
>>> x=[1,2,43,33]
>>> x[2]=3
>>> x
[1, 2, 3, 33]
不能为一个位置不存在的元素进行赋值。
2.删除元素
>>> del x[2]
>>> x
[1, 2, 33]
3.分片赋值
分片是一个非常强大的特性，分片赋值操作则更加显示他的强大。
>>> name=list("Pera")
>>> name
['P', 'e', 'r', 'a']
>>> name[2:]=list('ar')
>>> name
['P', 'e', 'a', 'r']
程序可以i一次性为多个元素赋值。可以使用与原序列不等长的序列将分片替换。
>>> name[1:]=list('python')
>>> name
['P', 'p', 'y', 't', 'h', 'o', 'n']
分片赋值可以在不需要替换任何原有元素的情况下插入新的元素
>>> numbers=[1,5]
>>> numbers[1:1]=[2,3,4]
>>> numbers
[1, 2, 3, 4, 5]
通过分片赋值删除元素也可
>>> numbers
[1, 2, 3, 4, 5]
>>> numbers[1:4]=[]
>>> numbers
[1, 5]
>>> numbers[1:4:2]
[1, 3]
>>> numbers[1:4:2]=[8,9]
>>> numbers
[1, 8, 2, 9, 4, 5]
列表方法
方法调用：对象.方法（参数）
1.append
append直接修改原来的列表
>>> numbers.append(10)
>>> numbers
[1, 8, 2, 9, 4, 5, 10]
2.count
count方法统计某个元素在列表中出现的次数：
>>> ['to','be','number','one','be'].count('be')
2
>>> x=[[1,2,3],3,2,[1,2],[3]]
>>> x.count(3)
1
>>>
3.extent
extend方法修改了被扩展的序列，而原始的连接操作则不然，他会返回一个全新的列表：
>>> a=[1,2,3]
>>> b=[4,5,6]
>>> a.extendp(b)
>>> a.extend(b)
>>> b.append(4)
>>> a
[1, 2, 3, 4, 5, 6]
>>>
>>> a.append(b)
>>> a
[1, 2, 3, 4, 5, 6, [4, 5, 6, 4]]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6, [4, 5, 6, 4], 4, 5, 6, 4]
>>> a=[1,2,3]
>>> b=[4,5,6]
>>> a+b
[1, 2, 3, 4, 5, 6]
>>> a
[1, 2, 3]
原始连接操作中创建一个包含了a和b副本的新列表，a=a+b的操作的效率比extend方法低，不会修改原来的列表
4.index
>>> a
[1, 2, 3]
>>> a.index(2)
1
>>> a.index(4)
Traceback (most recent call last):
File "<pyshell#111>", line 1, in <module>
a.index(4)
ValueError: 4 is not in list
5.insert
>>> a.insert(4,5)
>>> a
[1, 2, 3, 5]
>>> a.insert(7,4)
>>> a
[1, 2, 3, 5, 4]
>>> a.insert(0,0)
>>> a
[0, 1, 2, 3, 5, 4]
6.pop
pop方法会移除列表中的一个元素（默认是最后一个），并且返回该元素的值
>>> a.pop()
4
>>> a
[0, 1, 2, 3, 5]
>>> a.pop(0)
0
>>> a
[1, 2, 3, 5]
pop方法是唯一一个既能修改列表又返回元素值（除了None）的列表方法
使用pop方法可以实现一种常见的数据结构--栈，后进先出（LIFO）
>>> x=[1,3,5]
>>> x.append(x.pop())
>>> x
[1, 3, 5]
实现先进先出（FIFO）的队列（queue），
>>> x.insert(0,x.pop(0))
>>> x
[1, 3, 5]
7.remove
remove方法用于移除列表中的某个值的第一个匹配项：
>>> x=['to','be','or','not','to','be']
>>> x.remove("be")
>>> x
['to', 'or', 'not', 'to', 'be']
>>> x.remove('bee')
Traceback (most recent call last):
File "<pyshell#132>", line 1, in <module>
x.remove('bee')
ValueError: list.remove(x): x not in list
remove是一个没有返回值的原位置改变方法。他修改了列表却没有返回值，与pop方法相反。
8.reverse
>>> x=[1,2,3]
>>> x.reverse()
>>> x
[3, 2, 1]
>>> list(reversed(x))
[1, 2, 3]
改变列表但不返回值
reverse函数返回一个迭代器对象，而不是列表
9.sort
sort方法用于在原位置对列表进行排序，改变原来的列表
>>> x=[4,6,3,2,1,9,7]
>>> x.sort() #返回None不能对x.sort()进行赋值
>>> x
[1, 2, 3, 4, 6, 7, 9]
x[:]得到包含了x所有元素的分片，x=y 使x和y指向同一个列表。
>>> x=[4,6,3,2,1,9,7]
>>> y=x[:]
>>> y.sort()
>>> x
[4, 6, 3, 2, 1, 9, 7]
>>> y
[1, 2, 3, 4, 6, 7, 9]
>>> y=x
>>> x=[4,6,3,2,1,9,7]
>>> y=x
>>> y.sort()
>>> y
[1, 2, 3, 4, 6, 7, 9]
>>> x
[1, 2, 3, 4, 6, 7, 9]
sorted函数获取已排序的列表副本的方法
>>> x=[4,6,3,2,1,9,7]
>>> y=sorted(x)
>>> x
[4, 6, 3, 2, 1, 9, 7]
>>> y
[1, 2, 3, 4, 6, 7, 9]
>>> sorted('python')
['h', 'n', 'o', 'p', 't', 'y']
高级排序
cmp内建函数 x>y 1 x<y -1 x==y 0
>>> cmp(42,32)
1
>>> cmp(32,42)
-1
>>> cmp(10,10)
0
>>> numbers=[5,2,9,6]
>>> numbers.sort(cmp)
>>> numbers
[2, 5, 6, 9]
sort 方法有两个可选的参数--key和reverse，关键字参数
>>> x=["sd","34e21","232","232dssa","23ssa"]
>>> x.sort(key=len)
>>> x
['sd', '232', '34e21', '23ssa', '232dssa']
>>> x=[9,3,45,2,1,6]
>>> x.sort(reverse=True)
>>> x
[45, 9, 6, 3, 2, 1]
元组：不可变序列
元组没有像列表一样的方法
>>> 1,2,3
(1, 2, 3)
>>> (1,3,4)
(1, 3, 4)
>>> ()
()
>>> 42
42
>>> 43,
(43,)
>>> (43,)
(43,)
>>> 3*(40+2,)
(42, 42, 42)
>>> a=(1,2,3)
>>> a[2]
3
tuple函数 跟list一样的功能，如果参数是元组则原样返回
tuple并不是真正的函数---而是一种类型
>>> tuple([1,2,3])
(1, 2, 3)
>>> tuple('aaf')
('a', 'a', 'f')
>>> tuple((1,2,2))
(1, 2, 2)
基本元组操作
创建元组和访问元组元素
使用元组的场景：
元组可以在映射（和集合的成员）中当做键使用-而列表则不行
元组作为很多内建函数和方法的返回值存在，也就是说你必须对元组进行处理。
序列是一种数据结构，它包含的元素都进行了编号（从0开始）。典型的序列包括列表，字符串和元组。列表是可变的，元组和字符串是不可变的。
成员资格。in操作符可以检查一个值是否存在于序列（或者其他的容器中）。对字符串使用in操作符是一个特例--他可以查找子字符串。
一些内建的类型（例如列表和字符串，元组则不再其中）具有很多有用的方法。