概念：可以存放多个元素的一种数据类型
###容器的种类
1.列表（list）
特点：基于线性表----双向链表的连续内存实现，元素有特定的顺序
列表的定义：

#方法1
ls = [1, 2, 3, 4]
#方法2
ls1 = list([1, 2, 3, "帅哥张"])

访问列表元素
列表中的元素是有序的集合，需要按照下表序号访问，默认序号从0开始。若访问下表序号不在列表范围内，则会抛出异常报错

ls[2]
ls1[0]

返回列表元素数量：通过全局函数实现

len(ls)
len(ls1)

遍历容器：

# 方法一
 for i in ls:
  print(i)
# 方法二
 index = 0
 while index < len(ls1)
  print(ls1([index]))
  index += 1

列表元素的赋值：通过下标访问赋予对应元素的值,但只能赋予目前存在的与元素

ls[2] = 200

列表的方法属性：

#向列表尾部追加元素
ls.append(20)
#向列表固定位置插入元素
ls.insert(2,200)
#按列表内元素的大小，从小到大排序（只能是同种类型的数据）
ls.sort()
#查找元素第一次出现在列表的位置，如果列表中没有这个元素，则抛出异常报错
ls.index(2)
#将列表中的元素顺序反转
ls.reverse()
#移除列表中的元素，通过匹配元素本身移除,如果元素不存在，则抛出异常报错
ls.remove(200)
#统计列表中指定元素的个数
ls.count()
#清楚列表中的元素
ls1.clear()
#浅拷贝,拷贝ls中的元素到ls1，是在堆内存中对存储的数据拷贝
ls2 = ls.copy()
#合并列表,将ls列表中的元素合并到ls1
ls1 = extend(ls)
#删除列表最后一个元素，并返回这个元素
ls.pop()

2.集合（set）
特点：底层基于哈希结构实现，元素是无序的，不能重复的
集合的创建：

a = set()
s = set({1, 2, 3, 4})
x = {1, 2,3 }     必须要有元素，否则就创建了一个字典

集合的常见方法

#增加元素，不能增加已有的元素，且元素是无序的 
s.add(10)  
#求差集，a相对于s的差集
a.difference(s)
#求交集，a先对于s的并集
a.intersection(s)
#求并集。合并集合，但不会改变a的集合
a.union(s)
#更新集合，合并集合，但会改变a的集合
a.update(s) 
#移除元素，但元素不存在，则不做任何操作
a.discard(s)

3.元组：
特点：元素是有序的、可重复的、类型不可变的，元素一旦定义下来，则无法改变
元组的创建：

t = (1, 2, 3, 4)
tt = tuple()
uu = tuple((1, 2, 3))

虽然元组不可变，如果元组内部元素是可变的，那么该元组就可变

z = (1, 2, [1,2 3],4)
f[2].append(100)

常见方法

#index     同上
#count     同上
  1. 字典（dict）
    特点：以键值对形式存储
    存储：
aa = {}
z = dict()
z = dict({"a":100,"b":200})
d = {"name":"shuai_ge_zhang","age":18,"gender":"boy"}

通过key访问对应的值：
若不存在，抛出异常报错

d["name"]
d["age"]
d["gender"]

赋值：

d["age"] = 17      #改变原有的值
d["address"] = "shaanxi_xi'an"    增加新的键值对

常见方法：

#获取key对应的值
d["age"]     #若不存在，则会抛出异常报错
d.get("age")  #若不存在，则会返回None
#返回所有的key
d.key()
#返回所有的值
d.values()
#设置一个默认值，当没有值返回时，就返回这个默认值
d.setdefault()
#返回键值对
d.items()
#通过key删除键值对，当没有该键值对是，则抛出异常报错
d.pop("address")
#移除键值对，移除的规则是LIFO（后进先出）
d.popitem()

字典的遍历：

# 方法一
for k in d.keys():
  print(k,d.get(k))
# 方法二
for k in d: 
  print(k,d[k])
# 方法三
for k,v in d.items():
  print(k,v)