python中的容器：列表，字典，元组，集合。（超详细，有代码有注释）

一、列表

1、列表的作用：

（1）变量可以存储一个元素，而列表是一个“大容器”可以存储N个元素，程序可以方便地对这些数据进行整体操作。

（2）列表相当于其他语言中的数组。

（3）列表示意图：

变量存储的是一个对象的引用；列表中存储的是n个对象的引用。

代码：

a=10   #变量存储的是一个对象的引用
lst=['hello','world',66]   #列表中存储的是n个对象的引用
print(id(lst))  #打印列表对象的id
print(type(lst))
print(lst)

2、列表对象的创建

（1）列表需要使用中括号[]，元素之间使用英文的逗号进行分隔。

（2）列表的创建方式：使用中括号；调用内置函数list[]。

# 创建列表的第一种方式，使用[]
lst=['hello','world',18]
print(lst)
#创建列表的第二种方式，使用内置函数list()
lst1=list(['hello','world','haha'])
print(lst1)

3、列表的特点：

（1）列表元素按顺序有序排序。

（2）索引映射唯一个数据。

列表中有两个索引，正索引和逆索引，可以映射唯一个数据：

 代码：

lst=['hello','world',99]
print(lst)
print(lst[0])  #获取索引为0的内容
print(lst[0],lst[-3])  #获取索引为0和索引为-3的内容

结果：

（3）列表可以存储重复数据。

lst=['hello','world',99,'hello']
print(lst)
print(lst[0])  #获取索引为0的内容
print(lst[0],lst[-3])  #获取索引为0和索引为-3的内容

（4）任意数据类型可以混存。

（5）根据需要动态分配和回收内存。

根据元素的多少动态分配内存空间，不用担心不够用。

4、获取指定元素的索引

（ 通过index()方法获取 ）

（1）如果查找列表中存在的N个相同的元素，只返回相同元素中的第一个元素的索引。

lst=['hello','world',99,'hello']
print(lst.index('hello'))
print(lst.index(99)) 

（2）如果查询的元素在列表中不存在，则会抛出ValueError

（3）还可以在指定的start和stop之间进行查找

lst=['hello','world',99,'hello']
print(lst.index('hello'))
print(lst.index('hello',1,4))   #在指定的范围内查找hello的索引

5、获取列表中的单个元素

（1）正向索引从0到n-1         举例：lst[0]

（2）逆向索引从-n到-1          举例：lst[-3]

（3）如果指定的索引不存在，则抛出indexError

lst=['hello','world',99,'hello','world',11]
#获取索引为2的元素
print(lst[2])
#获取索引为-3的元素  
print(lst[-3]) 

结果：

6、获取列表中的多个元素（切片）

语法格式： 列表名[start:stop:step]

（1）切片的结果：原列表片段的拷贝（生成一个新的列表）

（2）切片的范围：[start:stop]

（3）step默认值为1：简写为[start:stop]

lst=[10,20,30,40,50,60,70,80]
# start=1,stop=6,step=1
print(lst[1:6:1])
print('原列表id:',id(lst))
lst2=lst[1:6:1]
print('切的片段id：',id(lst2))
print(lst[1:6])  #默认步长为1
# start=1,stop=6,step=2
print(lst[1:6:2])  #步长为2

（4）step为正数：从start开始往后计算切片。

        [：stop：step]    切片的第一个元素默认是列表的第一个元素

        [start：：step]   切片的最后一个元素默认是列表的最后一个元素

lst=[10,20,30,40,50,60,70,80]
#stop=6,step=2,start采用默认
print(lst[:6:2])
#start=1,step=2,stop采用默认
print(lst[1::2])

（5）step为负数：从start开始往前计算切片。

         [：stop：step]    切片的第一个元素默认是列表的最后一个元素

         [start：：step]   切片的最后一个元素默认是列表的第一个元素

lst=[10,20,30,40,50,60,70,80]
print('原列表：',lst)
print('--------------step步长为-1-------------------------')
#step步长为-1
print(lst[::-1])
print('-------------start=7，stop省略，step=-1------------')
#start=7，stop省略，step=-1
print(lst[7::-1])
print('-------------start=6,stop=0,step=-2----------------')
#start=6,stop=0,step=-2
print(lst[6:0:-2])

 7、列表元素的判断及遍历

（1）判断指定元素在列表中是否存在

元素   in   列表名

元素   not in  列表名

print('p' in 'python')  #True
print('w' not in 'python')  #True

lst=[10,20,'python','hello','world']
print(20 in lst) #True
print(100 in lst) #Flase
print(10 not in lst) #Flase
print(100 not in lst) #Ture

（2）列表元素的遍历

for   迭代变量   in   列表名

lst=[10,20,'python','hello','world']
for item in lst:
	print(item)

8、列表元素的增加操作

（1）append() ：在列表的末尾添加一个元素

lst=[10,20,30]
print('添加元素之前：',lst,id(lst))
lst.append(100)
print('添加元素之后：',lst,id(lst))
lst2=['hello','world']
lst.append(lst2)  #在lst末尾添加lst2
print('添加一个列表后：',lst)

（2）extend() ：在列表的末尾至少添加一个元素

lst=[10,20,30]
lst2=['hello','world']
#用extend在列表末尾添加多个元素
lst.extend(lst2)  #在lst末尾添加lst2
print('添加一个列表后：',lst)

（3）insert() ：在列表的任意位置添加一个元素

lst=[10,20,30]
print('原列表：',lst)
lst.insert(1,90)  #在列表中索引为1的地方添加90
print(lst)

（4）切片 ：在列表的任意位置添加至少一个元素

lst=[10,20,30]
print('原列表：',lst)
lst2=[True,False,'haha']
#在任意位置上添加n多个元素
lst[1:]=lst2
print('添加后的列表：',lst)

9、列表元素的删除操作

（1）remove() 方法：

                一次只删除一个元素，重复元素只删除第一个，元素不存在抛出ValueError。

lst=[10,20,30,40,50,60,70,30]
print('原列表：',lst)
lst.remove(30)  #从列表中移除一个元素，如果有重复元素只移除第一个元素。
print(lst)

（2）pop() 方法：

                删除一个指定索引位置上的元素，指定索引不存在就抛出IndexError，不指定索引就删除列表中最后一个元素。

lst=[10,20,30,40,50,60,70,30]
print('原列表：',lst)
lst.pop(1)
print(lst)
lst.pop()
print(lst)

（3）切片：

                一次至少删除一个元素，将会产生一个新的列表对象。

lst=[10,20,30,40,50,60,70,30]
print('原列表：',lst)
new_lst=lst[1:3]
print('切片后的列表：',new_lst)

print('--------不产生新的列表对象，而是删除原列表中的内容-------')
#令切片的部分为空，就可以删除原列表中的内容且不产生新的列表对象
lst[1:3]=[]
print(lst)

（4）clear() 方法：

                清空列表，使列表为空。

lst=[10,20,30,40,50,60,70,30]
print('原列表：',lst)
lst.clear()
print(lst)

（5）del 方法：

                删除列表，直接将列表对象删除。

lst=[10,20,30,40,50,60,70,30]
print('原列表：',lst)
del lst
print(lst)

10、列表元素的修改操作

（1）为指定索引的元素赋予一个新的值。

lst=[10,20,30,40,50,60,70,30]
print('原列表：',lst)
#一次修改一个值,令30变为100
lst[2]=100
print(lst)

（2）为指定的切片赋予一个新的值。

lst=[10,20,30,40,50,60,70,30]
print('原列表：',lst)
#一次修改多个值,令索引为1、2的元素变为300，400，500，600
lst[1:3]=[300,400,500,600]   #切片前闭后开
print(lst)

 11、列表的排序操作

（1）调用  srot()  方法，列表中所有的元素默认按照从小到大的顺序进行排序，可以指定  reverse=True  进行降序排序。不会产生新的列表对象。

lst=[15,10,50,30,25,40]
print('原列表：',lst,id(lst))
#开始排序，调用列表对象的sort方法，升序排序
#id不会变，所以没有产生新的列表对象
lst.sort()
print("排序后的列表：",lst,id(lst))

#通过指定关键字，将列表中的元素进行降序排序,reverse=True是降序排序，reverse=True是升序排序。
lst.sort(reverse=True)
print("降序后的列表：",lst)
lst.sort(reverse=False)
print("升序后的列表：",lst)

（2）调用内置函数  sorted()  ，可以指定  reverse=Ture ， 进行降序排序，原列表不发生改变。会产生新的列表对象。

lst=[15,10,50,30,25,40]
print('原列表：',lst,id(lst))
#开始排序
new_lst=sorted(lst)
print(new_lst)
#指定关键字参数，实现列表元素的降序排序
desc_lst=sorted(lst,reverse=True)
print(desc_lst)

12、列表生成式

生成列表的公式

语法格式：[ i*i  for  i  in  range(1,10) ]

注意事项：“表示列表元素的表达式”中通常包含自定义变量。

lst=[i*i for i in range(1,10)]
print(lst)
'''列表中的元素为2，4，6，8，10'''
lst2=[i*2 for i in range(1,6)]
print(lst2)
#利用切片的方法实现
lst3=[i for i in range(2,11,2)]
print(lst3)

 

总结图：

 二、字典

1、什么是字典

python内置的数据结构之一，与列表一样是一个可变序列。

以键值对的方式存储数据，字典是一个无序的序列。

scores = { ‘张三’ ：100，‘李四’：90，‘王五’：80 }

字典的实现原理：

字典的实现原理与字典类似，查字典是先根据部首或拼音查找汉字对应的页码，python中的字典是根据key查找value所在的位置。

2、字典的创建

（1）最常用的方式：使用花括号

（2）使用内置函数dict()

'''字典的创建方式'''
scores={'张三':100,'李四':88,'王五':77}
print(scores)
print(type(scores))

student=dict(name='jack',age=18)
print(student)
print(type(student))

'''空字典'''
print("打印空字典：")
d={}
print(d)

 

3、字典中元素的获取

（1）使用中括号  []   ：[]如果字典中不存在指定的key，则抛出keyError异常

举例：scores [  '张三'  ]

（2）get()  方法取值，如果字典中不存在指定的key值，并不会抛出KeyError而是返回None，可以通过参数设置默认的value，以便指定的key不存在时返回。

举例：scores.get (  '张三'  )

scores={'张三':100,'李四':88,'王五':77}
'''第一种方式,使用[]'''
print(scores['张三'])
# print(scores['王麻子'])

'''第二种方式，使用get()方法'''
print(scores.get('张三'))
print(scores.get('王麻子'))  #None
print(scores.get('哈哈怪','没有这个键')) 
 #'没有这个键'就是在查找'哈哈怪'所对的value不存在时，所对应的一个默认值

 

4、字典的常用操作

（1）key的判断：

in：指定key在字典中存在返回Ture

not  in ：指定key在字典中不存在返回Ture

'''键的判断'''
scores={'张三':100,'李四':88,'王五':77}
print('张三' in scores)
print('张三' not in scores)

 

（2）字典元素的删除：

del  scores [ '张三' ]

（3）字典元素的新增：

scores [ 'jack' ] = 80

scores={'张三':100,'李四':88,'王五':77}
print(scores)

del scores['张三']   # 删除指定的键值对
print(scores)

scores.clear()  #清空字典的元素
print(scores)

scores['陈六']=99  #新增元素
print(scores)

scores['陈六']=66  #修改元素
print(scores)

 

（4）字典元素的遍历：

for  item  in  scores  :

        print ( item ）

scores={'张三':100,'李四':88,'王五':77}
for item in scores:
	print(item)

for item in scores:
	print(item,scores[item])

（5）获取字典视图的三个方法

keys（） ：获取字典中所有的key。

values（）：获取字典中所有的value。

items（）：获取字典中所有的key，value对。

scores={'张三':100,'李四':88,'王五':77}
keys=scores.keys()  #获取字典中所有的key
print(keys)
print(type(keys))  #可以看到是keys类型
print(list(keys))  #将所有keys组成的视图，转换为列表

print('---------------------------------')
values=scores.values()  
print(values)
print(type(values))
print(list(values))  #将所有values组成的视图，转换为列表

print('---------------------------------')
items=scores.items() #获取字典中所有的键值对
print(items)
print(type(items))  
print(list(items))  #转换之后的列表元素是由元组构成。

 

5、字典的特点

（1）字典中所有元素都是一个 key—value 对，key不允许重复，value可以重复。

（2）字典中的元素是无序的。

（3）字典中的key必须是不可变对象。

（4）字典也可以根据需要动态地收缩。

（5）字典会浪费较大的内存，是一种使用空间交换时间的数据结构。

6、字典生成式

内置函数zip（）

        用于将可迭代的对象作为参数，将列表对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表。

items=['Fruits','Books','Others']
prices=[20,35,50]

d={item:price  for item,price in zip(items,prices) }
print(d)

 

总结图：

三、元组 

元组是python内置的数据结构之一，是一个不可变序列。

1、不可变序列与可变序列：

（1）不可变序列：字符串、元组

                没有增、删、改的操作。

s='hello'
print(id(s))
s=s+'world'
print(s)
print(id(s))
'''我们发现修改后，内存地址发生了改变'''

（2）可变序列：列表、字典

                可以对序列执行增、删、改操作，对象地址不发生改变

lst=[10,20,45]
print(id(lst))
lst.append(300)
print(id(lst))
'''我们会发现列表修改后的内存地址是相同的，这种叫做可变序列'''

2、元组的创建方式

（1）直接小括号

（2）使用内置函数tuple（）

（3）只包含一个元组的元素需要使用逗号和小括号

'''元组的创建方式'''
'''第一种,使用()'''
t1=('Python','world','haha',666)  #其实括号也可以省略
print(t1)
print(type(t1))

'''第二种,使用内置函数tuple()'''
t2=tuple(('python','hello',100))
print(t2)
print(type(t2))

'''如果只有一个元素，需要使用逗号和小括号'''
t3=(10,)
print(t3)
print(type(t3))

 创建空列表，空字典，空元组：

'''空列表，空字典，空元组的方式'''
lst=[]
lst1=list()

d={}
d1=dict()

t=()
t1=tuple()

print('空列表',lst,lst1)
print('空字典',d,d1)
print('空元组',t,t1)

3、为什么要将元组设计成不可变序列

（1）在多任务环境下，同时操作对象时不需要加锁

（2）因此，在程序中尽量使用不可变序列

注意事项：元组中存储的对象的引用：

（a）如果元组中对象本身是不可变对象，则不能再引用其他对象。

（b）如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变。

t=(10,[20,30],66)  #元组中含有一个列表[20,30]
print(t)
print(type(t))
print(t[0],type(t[0]),id(t[0]))
print(t[1],type(t[1]),id(t[1]))
print(t[2],type(t[2]),id(t[2]))

'''由于[20,30]是列表，而列表是可变序列，所以可以向列表中添加元素，而列表的内存地址不发生改变'''
t[1].append(100)  #向列表中添加元素
print(t,id(t[1]))
'''我们发现t[1]的内存地址没有发生改变'''

4、元组的遍历

元组是可迭代对象，所以可以使用for ...... in 进行遍历

'''元组的遍历'''
t=('python','world',99)
'''第一种方式，使用索引'''
print(t[0])
print(t[1])
print(t[2])
# print(t[3]) 会报错，因为索引超出了范围

print('---------------------')

'''第二种，遍历元素'''
for item in t:
	print(item)

四、集合

1、什么是集合

（1）python语言提供的内置数据结构

（2）与列表、字典一样都属于可变类型的序列

（3）集合是没有 value 的字典。（也是使用花括号定义）

2、集合的创建方式

（1）直接 {} 

（2）使用内置函数 set ()

'''集合的创建方式'''
'''第一种，使用{}'''
s={2,3,4,5,5,6,6,7,7} 
print(s)
 #我们可以发现，重复的元素没有了。因为集合中的元素不能重复

'''第二种，使用内置函数set()'''
s1 = set(range(6))  #range(6)是产生一个0到5的整数序列。
print(s1,type(s1))

s2=set([1,2,4,5,6,6,6,7])
print(s2,type(s2))
#我们可以发现，通过内置函数set()可以将列表中的元素转换为集合并且去掉了重复元素。

s0=set()    #直接使用小括号定义空集合
print(type(s0))

 

3、集合的相关操作

（1）集合元素的判断操作

in 或 not in 

（2）集合元素的新增操作

        调用add（）方法，异常添加一个元素

        调用update（）方法，一次至少添加一个元素

'''集合的相关操作'''
#集合元素的判断操作
s={10,20,30,40,50,60}
print(10 in s)  #True
print(100 in s) #False
print(20  not in s)  #Flase
print(100 not in s) #True

#集合元素的添加操作
s.add(2022)   #添加一个元素
print(s)
s.update({2018,2019,2020})  #添加多个元素。我们也可以发现集合是无序的。
print(s)

 

（3）集合元素的删除操作

调用remove（）方法，一次删除一个指定元素，如果指定的元素不存在抛出KeyError

调用discard（）方法，一次删除一个指定元素，如果指定元素不存在也不会抛出异常

调用pop（）方法，一次删除任意一个元素

调用clear（）方法，清空集合

'''集合元素的删除操作'''
s={10,20,30,40,50,60}
s.remove(10)
print(s)
s.discard(500)
print(s)
s.pop()   #pop()方法不能写入参数。删除任意一个元素
print(s)

s.clear()
print(s)

 

4、集合间的关系

（1）判断两个集合是否相等：

可以使用运算符 == 或者 ！= 进行判断

（2）一个集合是否是另一个集合的子集

可以调用方法 issubset 进行判断

（3）一个集合是否是另一个集合的超集

可以调用方法issuperset进行判断

（4）判断两个集合是否没有交集

可以调用方法isdisjoint进行判断

'''判断两个集合是否相等（元素相等，就相等'''
s1={10,20,30,40}
s2={30,40,20,10}
print(s1==s2)   #True
print(s1!=s2)   #Flase


'''判断一个集合是否是另一个集合的子集'''
s3={10,20,30,40,50,60}
s4={10,20,30}
s5={10,90}
print(s4.issubset(s3))  #True
print(s5.issubset(s3))  # Flase

'''判断一个集合是否是另一个集合的超集'''
print(s3.issuperset(s4))  #Ture
print(s3.issuperset(s5))  #Flase

'''判断两个集合是否含有交集'''
s6={2021,2022}
print(s5.isdisjoint(s3))  #Flase  有交集为False
print(s4.isdisjoint(s6))  #Ture  没有交集为True

5、集合生成式

{ I**  for  i  in  range（1，10）}

将 {} 修改为 [] 就是列表生成式

没有元组生成式

s = {i*i for i in range(10)}
print(s)

从结果可以看出，集合是无序的。 

6、集合的数据操作

交集，并集，差集，对称差集

'''交集操作'''
s1={10,20,30,40}
s2={20,30,40,50,60}
print(s1.intersection(s2))
print( s1 & s2)   #intersection()与 & 等价，交集操作。

print('----------------------------')
'''并集操作'''
print(s1.union(s2))
print(s1|s2)    # union() 与 | 等价，并集操作。

print('----------------------------')
'''差集操作'''
print(s1.difference(s2))  #s1中减去s2中相同的元素
print(s1-s2)  #difference() 与 - 等价，差集操作。
print(s2.difference(s1))  #s2中减去s1中相同的元素。


print('----------------------------')
'''对称差集操作'''
print(s1.symmetric_difference(s2))
print(s1^s2)  #symmetric_difference() 与 ^ 等价，对称差集操作。

总截图：