1.列表
变量可以存储一个元素，而列表是一个大容器，可以存储多个元素，程序可以方便的对这些数据进行整体操作.
#第一种创建方式,使用“[]"
lst1 = ['hello','world',98]
#第二种创建方式，使用内置函数list()
lst2 = list(['hello','world',98])
一些性质：列表可以存储重复数据
列表可以存储不同类型的数据
根据需要动态分配和回收内存
1).index()获取列表中指定数据的索引，如果列表中有相同元素，只返回列表中相同元素的第一个的索引.
lst1 = ['hello','world',98,'hello']
print(lst1.index('hello'))
结果为：0
index()可以在指定范围内查找元素的索引.
lst1 = ['hello','world',98,'hello']
print(lst1.index('hello',1,4))
结果为：3
2).获取列表中的单个元素：
lst1 = ['hello','world',98,'hello','world',234]
print(lst1[2])
print(lst1[-3])
结果：
3).列表的切片：获取列表中的多个元素.
lst = [10,20,30,40,50,60,70,80]
lst1 = lst[1:6:1]
lst2 = lst[1:6:2]
lst3 = lst[::2]
print("原列表lst",id(lst))
print("列表lst1",id(lst1))
print("列表lst2",id(lst2))
print(lst1)
print(lst2)
print(lst3)
结果：
通过结果知道，切片后得到的列表是一个新的列表，因为id变化了.
列表切片负索引时：
lst = [10,20,30,40,50,60,70,80]
lst1 = lst[::-1]
lst2 = lst[6::-2]
print(lst1)
print(lst2)
结果：
4).判断指定元素是否在列表中
lst = [10,20,30,40,50,60,70,80]
print(10 in lst)
print(15 not in lst)
结果：
5).列表元素的遍历
lst = [10,20,30,40,50,60,70,80]
for item in lst:
print(item)
结果：
6).列表元素的增加操作
四种方法.
lst = [10,20,30]
#向列表末尾增加一个元素
print("添加元素前的id",id(lst))
lst.append(100)
print(lst)
print("添加元素后的id",id(lst))
#在列表末尾添加一个或者多个元素
lst1 = ["hello","world"]
lst.extend(lst1)
print(lst)
#在列表的任意位置插入一个元素
lst.insert(1,50)
print(lst)
#在列表的任意位置添加至少一个元素
lst2 = [True,False,"Hello"]
lst[1:]=lst2 #相当于后面的砍掉不要了，用lst2接上
print(lst)
结果：
注：增加元素，列表id不变.
7).列表元素的删除操作
lst = [10,20,30,40,50,60,30]
#remove方法
lst.remove(30) #若移除的元素有相同元素，则移除前面的一个
print(lst)
#pop方法
lst.pop(1)
print(lst)
lst.pop() #不指定索引位置，则移除最后一个元素
print(lst)
#切片删除方法，删除至少一个元素，将产生一个新的列表对象
new_list = lst[1:3]
print(new_list)
#clear,可以清楚列表中的所有元素
lst.clear()
print(lst)
#del语句可以将整个列表对象删除
del lst
结果：
8).列表元素的修改
lst = [10,20,30,40,50,60,30]
lst[2] = 100
print(lst)
print(id(lst[1]))
print(id(lst[2]))
lst[1:3] = [300,400,500,600]
print(lst)
结果：
9).列表的排序
列表方法：.sort()
lst = [10,20,30,40,50,60,30]
print("排序前的列表",lst,id(lst))
lst.sort()
print("排序后的列表：",lst,id(lst))
lst.sort(reverse=True) #降序排序.reverse的值默认为False
print(lst)
结果：
注：不产生新的列表对象.
内置函数：sorted()
lst = [10,20,30,40,50,60,30]
print("排序前的列表",lst)
new_list = sorted(lst)
print("排序后的列表：",new_list)
desc_list = sorted(lst,reverse=True)
print("排序后的列表：",desc_list)
结果：
注：产生新的列表对象.
10).列表生成式
lst = [i*i for i in range(1,10)]
print(lst)
结果：
练习：列表中的元素的值为2,4,6,8,10.
lst = [i*2 for i in range(1,6)]
print(lst)
总结一下关于列表的知识点：
2.字典
python内置数据结构之一，与列表一样是一个可变序列.以键值对的方式存储数据，字典是一个无序的序列.
注：python中的字典是根据key查找value所在的位置.
1).字典的创建
# 使用{}创建
scores = {'张三':100,'李四':98,'王五':99}
print(scores)
print(type(scores))
#第二种，使用dict()创建
student = dict(name = 'jack',age = 20)
print(student)
student1 = dict(nme = 250,age = 20)
print(student1)
#创建空字典
d = {}
print(d)
结果：
2).从字典中获取元素
scores = {'张三':100,'李四':98,'王五':99}
#第一种方式，使用[]
print(scores["张三"])
#第二种方式，使用get()方法
print(scores.get("张三"))
print(scores.get("张五"))
print(scores.get("张五",999)) #字典中不存在该元素时，返回999.
结果：
3).字典的一些操作
key的判断：
scores = {'张三':100,'李四':98,'王五':99}
print("张三" in scores)
结过为：True
增加，删除，修改：
scores = {'张三':100,'李四':98,'王五':99}
#删除指定的键值对
del scores["张三"]
print(scores)
#新增元素
scores['陈六'] = 88
print(scores)
#修改元素
scores['陈六'] = 86
print(scores)
结果：
4).获取字典视图操作
scores = {'张三':100,'李四':98,'王五':99}
#获取所有的键
keys = scores.keys()
print(keys)
print(type(keys))
print(list(keys)) #可转为列表
#获取所有的值
values = scores.values()
print(values)
print(type(values))
print(list(values)) #可转为列表
#获取素有的键值对
items = scores.items()
print(items)
print(list(items)) #可转为列表
结果：
5).字典元素的遍历
scores = {'张三':100,'李四':98,'王五':99}
for item in scores:
#获取键值
print(item,scores[item],scores.get(item))
结果：
字典的一些特点：
6).字典生成式
内置函数zip():用于将可迭代对象作为参数，将对象中对应的元素打包成一个元组.然后返回由这些元组组成的序列.
items = ["Fruits",'BOOKs',"Others"]
prices = [93,78,80,96,100]
lst = zip(items,prices)
print(list(lst))
d = {item.upper():price for item,price in zip(items,prices)}
print(d)
结果：
关于字典的知识点的总结：
3.元组
python内置的数据结构，不可变序列.不可以对其中元素进行增、删、改.
注：列表和字典是可变序列.
1).元组的创建方式
#第一种方式，使用()
t1 = ("Python","hello",98)
print(t1)
print(type(t1))
t11 = "Python","hello",98,"world"
print(t11)
#第二种方式，使用功内置函数tuple()
t2 = tuple(("Python","hello",98))
print(t2)
结果：
注：元组的创建不能没有逗号.
t1 = "python",
print(t1)
t2 = ("python",)
print(t2)
t3 = ("Python")
print(type(t3))
#空元组
t4 = tuple()
print(t4)
t5 = ()
print(t5)
print(type(t5))
结果：
一些关于元组的其他内容：
t = (10,[20,30],40)
print(t)
print(id(t[1]))
t[1].append(100)
print(t)
print(id(t[1]))
结果：
2).元组的遍历
t = ("python","world",98)
for item in t:
print(item)
结果：
4.集合
可变类型的序列.
1).集合的创建
#第一种方式，使用{}
set1 = {2,3,4,6,7,7} #集合中的元素不可重复
print(set1)
#第二种方式，使用内置函数set()
set2 = set(range(6))
print(set2)
print(set([1,2,3,5]))
print(set((1,2,6,5))) #集合元素无序
print(set("Pytohn"))
print(set({4,5,"py"}))
#空集合
print(set())
print(type({})) #不可以用{}定义空集合
结果：
2).集合的相关操作
增加元素：
set1 = {10,20,30,40,60}
# 判断元素是否在集合中
print(10 in set1)
#使用add添加元素
set1.add(80)
print(set1)
#使用update一次性添加多个元素
set1.update({100,200,300})
print(set1)
set1.update([100,200,300])
print(set1)
结果：
删除元素：
set1 = {10,20,30,40,60}
#remove方法,没有该元素则报错
set1.remove(20)
print(set1)
#discard方法，指定元素不存在不会报错
set1.discard(100)
print(set1)
#pop方法
set1.pop() #pop没有参数
print(set1)
#clear方法，清空集合
set1.clear()
print(set1)
结果：
3).集合之间的关系
set1 = {10,20,30,40,60}
#两个集合是否相等
set2 = {20,10,30,60,40}
print(set1==set2)
#一个集合是否是另一个集合的子集
set3 = {10,30}
print(set3.issubset(set1))
#一个集合是否是另一个集合的超集
print(set1.issuperset(set3)) #若集合A是集合B的子集，则集合B是集合A的超集
print(set2.issuperset(set3))
#两个集合是否有交集
print(set3.isdisjoint(set1)) #有交集为False
set4 = {50,99.5}
print(set4.isdisjoint(set1)) #没有交集为True
结果：
4).集合的运算
set1 = {10,20,30,40,60}
set2 = {10,20,100}
#求交集
print(set1.intersection(set2))
print(set1 & set2)
#求并集
print(set2.union(set1))
print(set1 | set2)
#求差集
print(set1.difference(set2))
print(set1 - set2)
#求对称差集
print(set1.symmetric_difference(set2))
print(set1 ^ set2)
#集合的运算不影响原集合
print(set1)
print(set2)
结果：
5).集合生成式
注：元组没有生成式.
set1 = {i*i for i in range(6)}
print(set1)
结果：
元组合集合的总结：
python数据结构的总结：
注：元组的创建不能少逗号，而不是括号.
