字符串、列表、字典、元组、集合都是序列结构sequence，有下标、具备切片功能、可以存放任何类型数据。

列表list

定义： list = []

　　       list=[1,2,'a',"hello",(3,4),[3,5,'f'],{'a':'tom'}]

　　　　1> 增：

　　　　　　a> list.append() #默认尾部增加

　　　　　　　　list.append(100)    list.append([1,2])#默认尾部增加

　　　　　　b> list.insert(插入下标，插入值) #某个位置插入

　　　　　　　　list.insert(0,120)

　　　　　　c> 子列表插入

　　　　　 　　 list[-2].insert(1,"edf")

　　　　2> 删:

　　　　　　a> del 下标寻找值删除

　　　　　　　　del  list[1]

　　　　　　　　del  list[0:2]

　　　　　　b> list.pop() : 有返回值，返回删除的那个元素的值

　　　　　　　　list.pop(2)

　　　　　　c> list.remove() #：对值删除，删除速度最慢，因为要遍历寻找到这个值

　　　　　　　　list.remove(2)

　　　　3> 改

　　　　　　list[0] = 20 #下标修改

　　　　4> 查

　　　　　　list[3] #下标查找

合并列表：+ ,extend()

　 　a = [1,2]      b = [3,4]

　　 a> 临时合并+,相当于另存为

　　　　print (a + b)  - -   [1,2,3,4]

　　 b> 永久合并--扩充列表

　　　　print (a.extend(b))    - --  - - a结果为 ：  [1,2,3,4]

内置函数：

　　len(list) ：计算元素个数

max(list)：返回列表中元素最大值

　　min(list) ：返回列表中元素最小值

　　list.reverse() ：反向列表中元素

　　list.remove(obj) ：移除列表中某个值的第一个匹配项

　　list.sort() : 排序，正序，有参数，sort(reverse=True/False) True正序，False倒序

　　list.clear() :删除列表中所有元素，并不是删除列表对象

　　list.copy() : 浅拷贝，返回列表对象的浅拷贝

首元素和最后一个元素：

　　str[0],str[len(str)-1]

　　str[-1],str[-len(str)]

元组tuple ：不能修改，元素值也不能修改，个数也不能修改，相当于固定的

　　1> 也是序列的一种sequence

　　2> 可以存储任何类型的数据

　　3> 也具有切片功能

　　4> 元组和列表不同：元组不能该表其组成元素

　　5> 只能查询，不能增删改

元组和列表区别：

字典dict

1> 定义

　　键值对dic = {'键'：'值'，'键'：值}

　　　　键 ：可以是：字符串（常用）、int、float、tuple、bool

　　　　　　 不可以：list、dict

　　　　值： 任意类型

　　dict1 = {}

　　dict2 = {'name'：mike，'age'：28}

　2> 特性

　　序列sequence，特性称为map，字典是无序的，查找清晰，扩展性好，通过key找values

　3> 常用方法

　　a> 增：

　　　　字典的键是唯一的;

　　　　字典是无序的；　　　

　　　　python3：尾部增加　　　python2：随机增加

　　　　如果键名存在 -- 修改操作；

　　　　如果键名不存在 --- 新增；

　　　　dict['weight'] = 170

　　b> 删：

　　　　 del :   del  dict['name']

　　　　pop :   dict.pop('age')

　　c> 改：

　　　　通过键进行修改;

　　　　dict ['name'] = 'mike'; (如果键存在，则修改值；如果键不存在，则新增键值对)

　　d> 查：

　　　　通过键去找值;

　　　　如果键不存在-报错-keyerror;

　　　　print (dict['name']);

4> 常用操作

　　 a> 判断键是否在字典中，in

　　　　print ('name' in dict)      - -- -   True

　　 b> 清空字典内容clear()

　　　　清空 :  dict.clear()

　　　　重新复制 : dict = {}

　　  c> 长度len(dict)

　　　　len(dict)

　　　　len(dict['name'])   #len(dict['键名'])

　　  d> 返回所有的键keys()

　　　　dict.keys() - - 类列表，不能使用下标，但可以遍历

　　　　如果一定要使用下标，则需要将其转换为列表list

　　　　　　list(dict.keys())[0]         tuple(dict.keys())[0]

　　　e>返回所有的值values()

　　　　dict.values()

　　　f> 返回所有的键值对items()

　　　　dict.items()  - -  [(’键’，‘值‘),(’键’，‘值‘)]

　　　　print(dict.items())   --    [('name','Jack'),('age',21)]

　　   g> 字典合并update()

　　　　d={1:'1',2:'2'}

　　　　print(d.update({4:'4',5:'5'}))

　　　　结果： {1：’1‘，2：’2‘，3：’3‘，4：’4‘，5：‘5’}

　　  h> 字典的遍历操作　　

　　　　　1)　for one in dict: # one取得是键

　　　　　　　　　print (one)

　　　　　　    -- name

　　　　　　　    age

　　　　　2)  for one in dict:#获取键值

　　　　　　　　print(one,dict[one])

　　　　　　  --  name tom

　　　　　　      age 21

　　　　    3)  for a,b in dict.items():

　　　　　　　　print(a,b)

　　　　         -- name tom

　　　　　　      age 21

5> 使用场景

　　　　 有序场景不能用;

　　        鉴定函的存储可以使用列表;

　　　　 可以作为扩展内容;