e）列表，列表用[]表示
在Python中，最基本的数据结构是序列（sequence）。序列中的每个元素被分配一个序号——即元素的位置，也称为索引。第一个索引是 0，第二个则是 1，以此类推。序列中的最后一个元素标记为 -1，倒数第二个元素为 -2，依次类推。 列表是由序列特定顺序排列的元素组成的，可以是字符串、数字、字典等，它们的元素可以有很多个。
Python包含 6 中内建的序列，包括列表、元组、字符串、Unicode字符串、buffer对象和xrange对象。列表和元组的主要区别在于，列表可以修改，元组则不能。
所有序列类型都可以进行某些特定的操作。这些操作包括：索引（indexing）、分片（sliceing）、加（adding）、乘（multiplying）以及检查某个元素是否属于序列的成员（成员资格）。除此之外，Python还有计算序列长度、找出最大元素和最小元素的内建函数。
str1 = 'dsfjasdfalsdf'
print(list(str1)) #每个元素都是字符
print(type(str1))
a = ['a','b','c',123]
print(a)
print (type(a)) #查看类型为list类型
print(dir(a)) #查看a属性的方法
返回结果为：
方法：['append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
append：用于在列表list的末尾追加新的元素(对象)。
语法：""" L.append(object) -- append object to end """
print(a)
a.append('hello')
print(a)
返回结果为：
index：检测字符串中是否包含子字符串 str ，如果指定 start（开始） 和 stop（结束） 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常，查找字符所在的下标位置。
语法：L.index(value, [start, [stop]]) -> integer -- return first index of value.
参数：str -- 指定检索的字符串
start -- 开始索引，默认为0。
stop -- 结束索引，默认为字符串的长度。
print(a)
print(a.index('abc'))
返回结果为：
insert：用于将指定对象插入列表的指定位置。
语法：L.insert(index, object) -- insert object before index
a.insert(0,'yjb') #在0下标的位置插入yjb
print(a)
a.insert(3,'adasdfdasf')
print(a)
返回结果为：
pop：用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
语法：L.pop([index]) -> item -- remove and return item at index (default last).
print(a)
print(a.pop()) #删除末位list元素
print(a)
返回结果为：
remove：用于移除列表list中某个值的第一个匹配项。
语法：L.remove(value) -- remove first occurrence of value.
print(a)
a.remove('abc')
print(a)
返回结果为：
print(a)
a.remove('abc')
print(a)
a.append('abc')
a.append('abc')
print(a)
a.remove('abc')
a.remove('abc') #如果要删除多个一样的元素，需要写多个删除
print(a)
返回结果为：
sort：用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数(可以定义自己的比较函数)。
语法：L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
print(a)
a.sort() #正序排序
print(a)
返回结果为：
reverse：用于反向列表中元素。list反序(降序)
语法：L.reverse() -- reverse *IN PLACE*
print(a)
a.reverse() #反序排序
print(a)
返回结果为：
列表切片：
字符串、列表、元组在Python中都符合“序列”这一特征，只要符合这一特征的变量我们都可以用切片（slice）去存取它们的任意部分。我们可以把序列想像成一个队列，我们可能需要前面三位、后面三位、或从第三位后的四位、或隔一个取一个等，我们用切片操作符来实现上述要求
切片操作符在Python中的原型是：
[start:stop:step]
即：[开始索引:结束索引:步长值]
开始索引：同其它语言一样，从0开始，序列从左向右方向中，第一值的索引为0，最后一个为-1
结束索引：切片操作符将取到该索引为止，不包含该索引的值
步长值：默认是一个接着一个切取，如果为2，则表示进行隔一取一操作，步长值为正时表示从左向右取，如果为负，则表示从右向左取，步长值不能为0
print(a)
print(a[3:])
print(a[1:5])
#下标从1打印到5，注意，切片的时候，取的最后一位数字-1
print(a)
print(a[1:5:2]) #隔几个取，默认隔1个
返回结果为：
e）元组
tuple(元组)就是不可变的list，但是tuple还是和list有些差别
1.Tuple的定义形式
tuple唯一和list定义的区别就是[]变成了()，其他没有什么变化，tuple不能增加和减少里面的元素(不可增加或删除里面的元素)，它本身自己的方法很少，只有count和index两个方法，其他的list方法都不可用
str1='abcdefg'
print(tuple(str1))
print(type(tuple(str1)))
返回结果为：
2.Tuple单个元素需要注意：
Tuple在表示单个元素的时候，元素后面要加逗号，否则Python解析器不会识别为tuple类型
m=('abcd')
print(type(m))
n=('abc',)
x=(123,)
print(type(n))
print(type(x))
打印结果为：
3.Tuple的方法：
x=(123,)
#tuple的方法
print(dir(x))
count：统计某个元素的个数
tu1=('a','b','c','a','d','a','c')
print(tu1.count('a'))
返回结果为：
indext：返回某个元素的下标
tu1=('a','b','c','a','d','a','c')
print(tu1.index('d'))
打印结果为：
print(tu1.index('h'))
如果某个元素不存在，则直接报错
e）字典
字典是以key:value的形式，字典是另一种可变容器模型，且可存储任意类型对象
字典的每个键值(key=>value)对 用冒号(:)分割，每个对 之间用逗号(,)分割，整个字典包括在花括号{}中，字典赋值有三种方式：
1.字典赋值方式一：
k = {'name':'YJB','age':20,'sex':'man'}
print(k)
print(type(k))
返回结果为：
2.字典赋值方式二：
#list('abcdefg') 这是列表， tuple('hijkml') 这是元组形式,字典也可以直接用dict表示
k1 = dict(a=1,b=2,c=3)
print(k1)
print(type(k1))
打印结果为：
3.字典赋值方式三(这种方法不常用)：列表里面是元组的方式
d = dict([('name','YJB'),('age',28)]) #这里面是一个列表，先外面是一个dict函数，里面是一个列表 ，列表里面是两个元组，
print(d)
打印结果为：
字典常用的方法：
print(dir(d))
clear：清除字典里面的元素，不常用
print(k1)
k1.clear()
print(k1)
打印结果为：
get：获取Key值的Vlue
print(k.get('name'))
print(k.get('age'))
print(k.get('ab'))#如果里面没有的话会返回一个空值
打印结果为：
setdefault：跟get一样也是为了获取键值，当去获取值时，如果有值则会去获取本身的值，如果key没有值则可以设置(增加)一个默认值
print(k.setdefault('name'))
print(k.setdefault('age'))
print(k.setdefault('ab'))
print(k.setdefault('ab','@@@'))
print(k.setdefault('abc','123'))
打印结果为：
keys：列出所有的key值
print(k)
print(k.keys())
打印结果为：
iterkeys：跟keys相关，这是一个对象，后面会讲
print(k.iterkeys())
打印结果为：
values：只把key的值给打印出来
print(k.values())
打印结果为：
iteritems：得到的也是一个对象，然后怎么取得或者获得这个对象呢？当你用到的时候一一取出来的时候才会显示，不取会搞成对象，取一次用一次，会用到for循环。如果光打印出k.iteritems()的话，
print(k.iteritems())
for k,v in k.iteritems():
print(k,v)
打印结果为：
print(k.iteritems()) #这是一个对象，推荐用这个，取一次用一次，如果要得到所有的键值，如果把所有的键值都给取出来后都是放到内存中去的，所以取一次用一次
print(k.items()) #搞出来之后这是一个列表,列表里面每个小元素是元组
for x, y in k.iteritems():
print(x, y)
打印结果为：
pop：删除指定的key值(不能放value值，否则会报错,只能写Key)
print(k)
k.pop('name')
print(k)
打印结果为：
fromkeys：从一个列表中获得Key
#有一个需要，把l的值当成m的字典
l = ['a','b','c','d']
m = {}
#n=m.fromkeys(l,123) #赋值所有的一个默认值为123
n=dict.fromkeys(l,124)#上面也可以这么写也是成立的
print(n)
打印结果为：
zip：zip是一个涵数，把两个列表进行叠加合并成一个字典(偶然会用)，
#如果有两个字典的话,把l1当成key,把l2当成value
h1 = ['a','b','c','d']
g2 = [1,2,3,4]
dict_test = zip(h1,g2)
print(dict_test)
打印结果为：
update：合并字典
#如果有两个字典的话,把l1当成key,把l2当成value
h1 = ['a','b','c','d']
g2 = [1,2,3,4]
k = {'name':'YJB','age':20,'sex':'man'}
dict_test = dict(zip(h1,g2))
print(dict_test)
print(k)
#把上面第一个字典增加到第二个字典里面去,进行合并，把两个字典进行叠加
dict_test.update(k)
print(dict_test)
打印结果为：
soft：对字典进行排序
按Ctrl键单击可以查看这个涵数是怎么写的#对字典进行排序soft,下例是按照value进行排序的
mm = dict(a=1,b=10,c=3,d=9)
print(mm)
print sorted(mm.iteritems(),key = lambda d:d[1],reverse = True) #lambda是一个匿名涵数,d是一个参数
print sorted(mm.iteritems(),key = lambda d:d[1],reverse = False)
打印结果为：
