列表，简单说就是用[]括起来的一大堆数据，这些数据我们叫做元素，元素与元素之间用","隔开，这些元素可以是数字，布尔值，字符串，列表等等，基本所有的数据类型都可以放在列表里边，同时这些元素是可以修改的。
例如：
#假如我们有这么一个列表
l = ["jasonhy",[12,False],45,True]
#删除索引1的元素
del l[1] print(l)
#再次输出列表l的结果为：
['jasonhy', 45, True]
#将一个字符串变成一个列表
print(list("jasonhy"))
输出结果是：
['j', 'a', 's', 'o', 'n', 'h', 'y']
功能一：将列表转换成字符串
#假如有一个列表既有字符串又有数字，那么这个时候想将列表转换成字符串就只能依次的遍历了
l = ["jasonhy","123",45] s = ""
for item in l:
s = s + str(item)
print(s)
输出结果是：
jasonhy12345
#如果列表里都是字符串，那么我们就可以直接调用join（）方法
l = ["jasonhy","123","45"] s = "".join(l)
print(s)
输出结果是：
jasonhy12345
功能二：向列表中添加指定的元素
def append(self, p_object):
""" L.append(object) -> None -- append object to end """ #添加一个元素到列表的末尾
pass
def extend(self, iterable):
""" L.extend(iterable) -> None -- extend list by appending elements from the iterable """ #以迭代的方式遍历每一个元素添加到列表中
pass
def insert(self, index, p_object):
""" L.insert(index, object) -- insert object before index """ #在指定的位置插入元素
pass
案例：
#以追加的形式添加
l = ["jasonhy","123",45] l.append([67,"89"])
print(l)
输出结果是：
['jasonhy', '123', 45, [67, '89']]
#以迭代的形式进行添加
l = ["jasonhy","123",45] l.extend([67,"89"])
print(l)
输出结果是：
['jasonhy', '123', 45, 67, '89']
注：append（）和 extend（）的区别就是，append（）在添加元素的时候，以一个整体的形式将元素追加在原列表的末尾，而extend（）则遍历每个元素，将遍历到元素添加到原列表中
#在指定位置进行添加
l = ["jasonhy","123",45] l.insert(2,"67")
print(l)
输出结果是：
['jasonhy', '123', '67', 45]
功能三：删除元素
def clear(self):
""" L.clear() -> None -- remove all items from L """ #移除列表里面的所有的元素
pass
def pop(self, index=None):
"""
L.pop([index]) -> item -- remove and return item at index (default last). #根据索引删除列表里的元素，默认删除列表的最后一个元素，并可以获取被删除的元素
Raises IndexError if list is empty or index is out of range.
"""
pass
def remove(self, value):
"""
L.remove(value) -> None -- remove first occurrence of value. #删除被选中的元素
Raises ValueError if the value is not present.
"""
pass
案例：
#全部删除
l = ["jasonhy","123",45] l.clear()
print(l)
输出结果是：
[]
#删除指定位置的元素，并获取这个元素
l = ["jasonhy","123",45] s = l.pop(1)
print(s,l)
输出结果是：
123 ['jasonhy', 45]
#删除指定的元素
l = ["jasonhy","123",45] l.remove(45)
print(l)
输出结果是：
['jasonhy', '123']
功能四：计算列表里元素出现的次数
def count(self, value):
""" L.count(value) -> integer -- return number of occurrences of value """ 返回元素value出现的次数
return 0
案例：
l = ["jasonhy","123",45]
print(l.count("123"))
输出结果是：
1
功能五：反转
def reverse(self):
""" L.reverse() -- reverse *IN PLACE* """ 将元素位置反转
pass
案例：
l = ["jasonhy","123",45]
l.reverse()
print(l)
输出结果是：
[45, '123', 'jasonhy']
功能六：排序
def sort(self, key=None, reverse=False):
""" L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* """ #key接收的是一个函数的返回值，这个返回值就是一个权值，可根据权值进行大小排序，reverse接收的是False或者True表示是否逆序
pass
案例：
l = ["67","123","45"]
l.sort()
print(l)
输出结果是：
['123', '45', '67']
l = ["67",[1,5,6,7],"123","jasonhy"]
def rule(x):
'''
定义一个rule函数
:param x:
:return: 按照长度返回
'''
return len(x)
l.sort(key=rule)
print(l)
输出结果是：
['67', '123', [1, 5, 6, 7], 'jasonhy']
注：如果加上reverse=True就按照降序进行排序
元组（tuple），有点类似列表，但是它的元素不可以修改，在这里，我们说的元素不可以修改指的是一级元素不可以修改，不能增加元素，也不能删除元素，元组长得像我们定义的函数，所以我们为了区别，可读性，往往在元组的最后一个元素后面加上一个逗号，比如：t = ("jasonhy",18,)，元组就两个方法，一个是count(self, value)，是用来统计元素value出现的次数的；另一个是index(self, value, start=None, stop=None)，是用来查找元素value出现的位置索引，start和stop分别用来设置查找的起始位置和终止位置。
字典（dict），它的元素是在一个大括号里面，比如：d={"name":"jasonhy","age":18}，这就是字典的表现形式，从这个表现形式，我们也可以看出，字典里面的元素是一种键值对的关系，也就是key-value之间的一种关系，value可以是任何值，但是key必须是不可修改的，比如列表，由于列表里的元素是可修改的，那就不能作为key值了，在这里我们可以这样理解，小张可以拥有一支钢笔和一个笔记本，如果把小张改成小王，小张和小王还是同一个人吗？这样答案就显然了。
字典还有一个特点就是无序。
功能一：元素删除
#定义了一个字典t
t = {"name":"jasonhy","age":18}
#直接调用del，根据key来删除
del t["age"] print(t)
输出结果是：
{'name': 'jasonhy'}
#调用内置函数pop(k, d=None)，也是根据key进行删除，并将被删除的元素返回
s = t.pop("age")
print(s,t)
输出结果是：
18 {'name': 'jasonhy'}
#调用内置函数popitem（），随机删除，删除的是一个键值对，以元组的形式将被删除的键值对返回
s = t.popitem() print(s,t)
输出结果是：
('age', 18) {'name': 'jasonhy'}
注：这个结果是随机的
#我们现在有一个需求就是要变量字典t里面的元素
for item in t:
print(item)
输出结果是：
age
name
我们发现直接遍历的是，实际遍历的是key值，那么我们想要value值呢？
#现在需求是要变量字典t里面的元素的value
for item in t.values():
print(item)
输出结果是：
jasonhy
18
我们希望的是key和value都能遍历出来
#现在需求是要变量字典t里面的元素的value
for item in t.values():
print(item)
输出结果是：
('name', 'jasonhy')
('age', 18)
功能二：生成一个字典
@staticmethod
def fromkeys(*args, **kwargs):
""" Returns a new dict with keys from iterable and values equal to value. """ #根据×args迭代之后生成key值，每个key对应的value值都是一样的
pass
案例：
l = (12,45)
d = ("ab","cd")
print(dict.fromkeys(l,d))
输出结果是：
{12: ('ab', 'cd'), 45: ('ab', 'cd')}
功能三：获取value值
def get(self, k, d=None):
""" D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """ #根据k来获取value值，如果k不在字典里边，返回就是d指定的值，d默认是None
pass
案例：
t = {"name":"jasonhy","age":18}
print(t.get("12","has not key"))
输出结果是：
has not key
功能四：更新元素
def setdefault(self, k, d=None):
""" D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """ #将一个key值设置到字典里边，如果这个key以及存在字典里，那就不设置进去了
pass
def update(self, E=None, **F):
"""
D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k] #以字典的形式进行更新，如果这个字典里面的key已经在原字典存在了，就将原字典里的value值进行更新，如果不存在，就添加到原字典里面
"""
pass
案例：
t = {"name":"jasonhy","age":18}
t.setdefault("age",20)
print(t)
输出结果是：
{'name': 'jasonhy', 'age': 18}
t.update({"loc":"广州","age":20})
print(t)
输出结果是：
{'loc': '广州', 'name': 'jasonhy', 'age': 20}