序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。

为了更形象的认识序列，可以将它看做是一家旅店，那么店中的每个房间就如同序列存储数据的一个个内存空间，每个房间所特有的房间号就相当于索引值。也就是说，通过房间号（索引）我们可以找到这家旅店（序列）中的每个房间（内存空间）。

在 Python 中，序列类型包括字符串、列表、元组、集合和字典，这些序列支持以下几种通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。
字符串也是一种常见的序列，它也可以直接通过索引访问字符串内的字符。

列表（list）

列表是由[]括起，”,”分隔的序列

Python内置的数据类型：列表(list)
list是一种有序的集合，可以随时添加和删除其中的元素。
列表是可变的（mutable）——可以改变列表的内容。
列表是一种容器类型：

• 可以包含任意对象的有序集合，通过索引进行访问其中的元素，是一种可变对象，其长度可变
• 支持异构和任意嵌套
• 支持在原处修改

定义

list1 = ['Google','Huawei',1997,2000]
list2 = [1,2,3,4,5]
list3 = ['a','b','c','d']
#type获取类型为:<class 'list'>
同样可以用len()函数可以获得list元素的个数：
print(len(list1))
4

索引

序列的索引与之前的字符串索引相似，都是从0开始

list1 = ['Google','Huawei',1997,2000]
list2 = [1,2,3,4,5]
list3 = ['a','b','c','d']
#嵌套
list4 = ["all of them",list1,list2,list3]
print(list4)
['all of them', ['Google', 'Huawei', 1997, 2000], [1, 2, 3, 4, 5], ['a', 'b', 'c', 'd']]
#序列的索引都是从0开始，-1代表最后一个
print(list1[0])
print(list1[-1])
print(list1[1:4])
Google
2000
['Huawei', 1997, 2000]

增

使用append()或insert()方法
append方法用于在列表末尾追加新的对象
insert 方法用于将对象插入到列表中

list1 = ['Google','Huawei',1997,2000]
#append追加新元素2010
list1.append(2010)
print(list1)
print(list1[-1])
['Google', 'Huawei', 1997, 2000, 2010]
2010
#insert在第三个位置插入'w'
list2 = [1,2,3,4,5]
list2.insert(2,'W')
print(list2)
[1, 2, 'W', 3, 4, 5]

删

pop方法
要删除list末尾的元素，用pop()方法
要删除指定位置的元素，用pop(i)方法，其中i是索引位置
pop是有返回值的，返回值为该元素的值

#pop()删除末尾的元素
list3 = ['a','b','c','d']
list3.pop()
print(list3)
['a', 'b', 'c']
#pop(i)删除指定位置的元素
list3 = ['a','b','c','d']
list3.pop(1)
print(list3)
['a', 'c', 'd']

remove方法

list3 = ['a','b','c','d']
list3.remove('b')
print(list3)
['a', 'c', 'd']

del方法

list3 = ['a','b','c','d']
del list3[0]
print(list3)
['b', 'c', 'd']
#整个删除
del list3

改

list1 = ['Google','Huawei',1997,2000]
list1[1] = 'Apple'
print(list1)
['Google', 'Apple', 1997, 2000]
list1 = ['Google','Huawei',1997,2000]
list1[1:2] = ['Apple',2333]
print(list1)
['Google', 'Apple', 2333, 1997, 2000]

其他操作

列表还有一些其他操作，如 + 和 ，操作和字符串相似，+组合，重复
示例：

>>> [1,2,3]+[4,5,6]
[1, 2, 3, 4, 5, 6]
>>> ['oh! ']*10
['oh! ', 'oh! ', 'oh! ', 'oh! ', 'oh! ', 'oh! ', 'oh! ', 'oh! ', 'oh! ', 'oh! ']
>>> 2 in [1,2,3]
True
>>> max([1,2,3])
3
>>> min([3,2,1])
1

list.的一些方法

例子：

#排序后反向存放
list1=[3,2,1,5,4,6]
list1.sort(reverse=True)
print(list1)
[6, 5, 4, 3, 2, 1]

元组（tuple）

tuple
元组和列表类似，用（）括起来，”,”分隔的序列。不同列表的是，元组是只读的，无法修改，在定义的时候元素必须被确定下来，也可以像列表一样，用索引访问
所以元组可以理解为只读的列表

元组的应用

>>> t = ('Google','Huawei',1997,2000)
>>> t[0]
'Google'
>>> t[-1]
2000
#修改元组的值会抛出异
>>> t[0] = 'baidu'
Traceback (most recent call last):
  File "<pyshell#60>", line 1, in <module>
    t[0] = 'baidu'
TypeError: 'tuple' object does not support item assignment
#定义一个空元组
>>> t = ()
>>> t
()
>>> type(t)
<class 'tuple'>
#当元组只有一个元素时，元素后面带上逗号，","是元组的特征
>>> t = (1)
>>> type(t)
<class 'int'>
>>> 
>>> t = (1,)
>>> type(t)
<class 'tuple'>

元组中含列表

注意，元组的元素不变是指每个元素的指向永远不变，如果元组的某个元素是一个列表，那么这个列表的元素是可以改变的，但元组指向这个列表永远不变。
例子：元组的元素是列表

>>> a=['a','b']        #定义一个列表a
>>> b=['c','d']        #定义一个列表b
>>> t=('e','f',a)    #定义一个元组t，第三个元素指向列表a
>>> t
('e', 'f', ['a', 'b'])
#t[2]相当于a,t[2][0]相当于a[0]
>>> t[2][0]
'a'
>>> t[2][1]
'b'
#相当于修改a[0]=x
>>> t[2][0]='x'
>>> t[2][1]='y'
>>> a
['x', 'y']
>>> t
['e', 'f', ['x', 'y']]
#在元组中t[2]指向的是a，之这个指向无法更改
>>> t[2]=b
Traceback (most recent call last):
  File "<pyshell#178>", line 1, in <module>
    t[2]=b
TypeError: 'tuple' object does not support item assignment

如果希望元组中的每个元素无法修改，就必须保证元组中的内一个元素本身也不能改变，如数字、字符串、元组等不可变数据类型。

• 元组不允许被被修改，但能进行连接组合
• 元组中的元素不允许删除，但可以用del删除整个元组

字典（dict）

Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。
字典是Python中唯一的映射类型，采用键值对（key-value）的形式存储数据。
“映射”是数学中的术语，简单理解，它指的是元素之间相互对应的关系，即通过一个元素，可以唯一找到另一个元素。

Python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。
可哈希表示key必须是不可变类型，如：数字、字符串、元组。
字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

定义

字典的定义非常简单：使用一堆花括号{}括起，键值对之间使用”,”分隔，例如

>>> dict = {'hello':'你好','world':'世界'}    #定义字典
>>> dict
{'hello': '你好', 'world': '世界'}
>>> len(dict)        #计算字典元素个数，即键的总数
2
>>> str(dict)        #输出字典。可以打印的字符串表示
"{'hello': '你好', 'world': '世界'}"

字典值可以是任何python对象，既可以是标准对象，也可以是用户自定义对象，但键不行，有两点要注意：
(1)不允许同一个键出现两次

>>> dict = {'hello':'你好','world':'世界','hello':'hello'} #hello的键值被更新了
>>> str(dict)
"{'hello': 'hello', 'world': '世界'}"

(2)因为键值不可变，所以可以用数字、字符串或元组充当，用列表则不行，即键必须为不可变数据类型

#键是列表，会报错
>>> dict = {'a':1,'b':2,['a']:'abc'}
Traceback (most recent call last):
  File "<pyshell#216>", line 1, in <module>
    dict = {'a':1,'b':2,['a']:'abc'}
TypeError: unhashable type: 'list'

遍历字典

>>> d = { 'a':1,'b':2,'c':3,'d':4,'e':5,'f':6 }        #定义一个字典
>>> for key,value in d.items():            #d.items()方法返回一个可遍历的键值对的元组
    print(key,value)
a 1
b 2
c 3
d 4
e 5
f 6
>>> for key in d:
    print(key,d[key])
a 1
b 2
c 3
d 4
e 5
f 6

字典的常用方法

集合（set）

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。也无法存储列表、字典、集合这些可变的数据类型
集合是一个无序的，不重复的数据组合，它的主要作用如下：

• 去重，把一个列表变成集合，就自动去重了
• 关系测试，测试两组数据之前的交集、差集、并集等关系

可以用”x in set”来判断x是否在集合中，使用”len(set)”来获取集合元素个数，使用”for x in set”来遍历集合中的元素。集合不记录位置元素，所以也不能获取元素位置和切片等操作。

对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。

定义和常见用法

>>> x=set('abcd')        #创建集合x由单个字符组成
>>> y=set(['a','bc','d',10])        #创建集合y有列表元素组成
>>> x,y                #打印x,y
({'a', 'b', 'd', 'c'}, {'a', 10, 'bc', 'd'})
>>> x&y                #取交集
{'a', 'd'}
>>> x|y                #取并集
{'bc', 'a', 'd', 10, 'b', 'c'}
>>> x-y                #取差集（x有，y没有的）
{'b', 'c'}
>>> x^y                #对称差集（在x中有或在y中有，不会同时出现在二者中）
{'bc', 10, 'b', 'c'}

使用集合去重

>>> a = [11,22,33,44,11,22]
>>> b = set(a)
>>> b
{33, 11, 44, 22}

集合的基本操作

union()、intersection()、difference()、symmetric_difference()的非运算符（non-operator就是形如s.union这样的）版本将会接受任何可迭代对象（iterable）作为参数。相反，它们的运算符版本（&^+-|）要求参数必须是集合对象