Python集合：列表list，字典dict，元组tuple，集合set

一、列表list及其基本操作

1.1、为什么需要列表

1、变量可以存储一个元素，而列表是一个“大容器”可以存储N多个元素，程序可以方便地对这些数据进行整体操作
2、列表相当于其它语言中的数组
3、列表示意图

lst=['hello','world',98]
print(id(lst))
print(type(lst))
print(lst)

 1.2、列表的创建和删除

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

2、列表的创建方式：使用中括号；调用内置函数list()

'''创建列表的第一种方式，使用[]'''
lst=['大圣','娟子姐']
'''创建列表的第二种方式，使用内置函数list()'''
lst2=list(['大圣','娟子姐'])

3、列表的删除

del list

1.3、列表的特点

1、列表的特点

 2、示例

lst=['hello','world',98,'hello']
print(lst.index('hello')) #0
#如果列表中有相同元素只返回列表中相同元素的第一个元素的索引
print(lst.index('hello',1,4)) #3
#print(lst.index('Python')) 
#ValueError: 'Python' is not in list
#print(lst.index('hello',1,3)) 
#ValueError: 'hello' is not in list   'world',98

 1.4、列表的查询操作

1.4.1、获取列表中指定元素的索引

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

 1.4.3、示例

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

#获取索引为10的元素
#print(lst[10]) 
#IndexError: list index out of range

1.5、列表元素的查询

1.5.1、获取列表中的多个元素（切片操作）

列表名[start:stop:step]

lst=[10,20,30,40,50,60,70,80]
#start=1,stop=6,step1
#print(lst[1:6:1])
print('原列表',id(lst))
lst2=lst[1:6:1]
print('切的片段:',id(lst2))
print(lst[1:6]) #默认步长为1
print(lst[1:6:])
#start=1,stop=6,step=2
print(lst[1:6:2])
#stop=6,step=2,start采用默认
print(lst[:6:2])
#start=1，step=2，stop采用默认
print(lst[1::2])
print('------------step步长为负数的情况-----------------')
print('原列表:',lst)
print(lst[::-1])
#start=7,stop 省略 step=-1
print(lst[7::-1])
#start=6,stop=0,step=-2
print(lst[6:0:-2])

 1.5.2、判断指定元素在列表中是否存在

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

lst=[10,20,'python','hello']
print(10 in lst) #True
print(100 in lst) #False
print(10 not in lst) #False
print(100 not in lst) #True
print('--------------------------')

1.5.3、列表元素的遍历

for item in lst:
    print(item)

1.6、列表元素的增、删、改操作

1.6.1、列表的增加操作

lst=[10,20,30]
print('添加元素之前',lst,id(lst))
lst.append(100)
print('添加元素之后',lst,id(lst))
lst2=['hello','world']
#lst.append(lst2) #将lst2做为一个元素添加到列表的末尾
#向列表的末尾一次性添加多个元素
lst.extend(lst2)
print(lst)

#在任意位置上添加一个元素
lst.insert(1,90)
print(lst)

lst3=[True,False,'hello']
#在任意的位置上添加N多个元素
lst[1:]=lst3
print(lst)

1.6.2、列表元素的删除操作

lst=[10,20,30,40,50,60,30]
lst.remove(30) #从列表中移除一个元素，如果有重复元素只移第一个元素
print(lst)
#lst.remove(100) 
#ValueError: list.remove(x): x not in list

#pop()根据索引移除元素
lst.pop(1)
print(lst)
#lst.pop(5) 
#IndexError: pop index out of range  如果指定的索引位置不存在，将抛出异常
lst.pop()  #如果不指定参数（索引），将删除列表中的最后一个元素
print(lst)

print('----------切片操作-删除至少一个元素 ，将产生一个新的列表对象-------------------')
new_list=lst[1:3]
print('原列表',lst)
print('切片后的列表',new_list)

'''不产生新的列表对象，而是删除原列表中的内容'''
lst[1:3]=[]
print(lst)

'''清除列表中的所有元素'''
lst.clear()
print(lst)

'''del语句将列表对象删除'''
del lst
#print(lst) 
#NameError: name 'lst' is not defined

1.6.3、列表元素的修改操作

1、为指定索引的元素赋予一个新值

2、为指定的切片赋予一个新值

lst=[10,20,30,40]
#一次修改一个值
lst[2]=100
print(lst)
#一次修改多个值
lst[1:3]=[300,400,500,600]
print(lst)

1.7、列表元素的排序操作

1.7.1、调用sort()方法

列有中的所有元素默认按照从小到大的顺序进行排序，可以指定 reverse=True，进行降序排序

lst=[20,40,10,98,54]
print('排序前的列表',lst,id(lst))
#开始排序 ,调用列表对象的sort方法,升序排序
lst.sort()
print('排序后的列表',lst,id(lst))

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

1.7.2、调用内置函数sorted()

可以指定reverse=True，进行降序排序，原列表不发生改变

lst=[20,40,10,98,54]
print('原列表',lst)
#开始排序
new_list=sorted(lst)
print(lst)
print(new_list)
#指定关键字参数，实现列表元素的降序排序
desc_list=sorted(lst,reverse=True)
print(desc_list)

1.8、列表的生成式

1、列表生成式简称“生成列表的公式”
2、语法格式:

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

4、示例

一、字典dict及其基本操作

1.1、什么是字典

1.1.1、字典

Python内置的数据结构之一，与列表一样是一个可变序列
以键值对的方式存储数据，字典是一个无序的序列

1.1.2、字典示意图

1.2、字典的原理

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

1.3、字典的创建与删除

1.3.1、使用花括号  

scores={'张三':100,'李四':98,'王五':45}

1.3.2、使用内置函数dict()

student=dict(name='jack',age=20)

1.3.3、空字典

d={}
print(d)

1.4、字典的常用操作

1.4.1、字典中元素的获取

1.4.2、[]取值与使用get()取值的区别

'''获取字典的元素'''
scores={'张三':100,'李四':98,'王五':45}
'''第一种方式，使用[]'''
print(scores['张三'])
#print(scores['陈六']) 
#KeyError: '陈六'

'''第二种方式，使用get()方法'''
print(scores.get('张三'))
print(scores.get('陈六')) 
#None
print(scores.get('麻七',99)) 
#99是在查找'麻七'所对的value不存在时，提供的一个默认值

1）[]如果字典中不存在指定的key，抛出keyError异常

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

1.4.3、key的判断

scores={'张三':100,'李四':98,'王五':45}
print('张三' in scores)
print('张三' not in scores)

1.4.4、字典元素的增、删、改操作

del scores['张三']  #删除指定的key-value对
#scores.clear()  #清空字典的元素
print(scores)

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

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

1.4.5、获取字典视图的三个方法

scores={'张三':100,'李四':98,'王五':45}
#获取所有的key
keys=scores.keys()
print(keys)
print(type(keys))
print(list(keys))  #将所有的key组成的视图转成列表

#获取所有的value
values=scores.values()
print(values)
print(type(values))
print(list(values))

#获取所有的key-value对
items=scores.items()
print(items)
print(list(items))  #转换之后的列表元素是由元组组成 （元组将在下个章节讲解）

1.4.6、字典元素的遍历

scores={'张三':100,'李四':98,'王五':45}
#字典元素的遍历
for  item  in scores:
    print(item,scores[item],scores.get(item))

1.5、字典的特点

1、字典中的所有元素都是一个 key-value对，key不允许重复， value可以重复

d={'name':'张三','name':'李四'}  #key不允许重复
print(d) #{'name': '李四'}

d={'name':'张三','nikename':'张三'} #value可以重复的
print(d) #{'name': '张三', 'nikename': '张三'}

lst=[10,20,30]
lst.insert(1,100)
print(lst)
#d={lst:100} 
#TypeError: unhashable type: 'list'
#print(d)

2、字典中的元素是无序的
3、字典中的key必须是不可变对象 
4、字典也可以根据需要动态地伸缩
5、字典会浪费较大的内存，是一种使用空间换时间的数据结构

1.6、字典生成式

1.6.1、内置函数zip()

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

1.6.2、字典生成式

items = ['Fruits', 'Books', 'Others']
prices = [96, 78, 85, 100, 120]

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

 二、元组tuple及其基本操作

2.1、什么是元组

2.1.1、元组

Python内置的数据结构之一，是一个不可变序列

2.1.2、不可变序列与可变序列

1、不变可变序:字符串、元组
不变可变序列：没有增、删，改的操作
2、可变序列:列表、字典
可变序列：可以对序列执行增、删、改操作，对象地址不发生更改

'''不可变序列，可变序列'''
'''可变序列  列表，字典'''
lst=[10,20,45]
print(id(lst))
lst.append(300)
print(id(lst))#不变
'''不可变序列，字符串,元组'''
s='hello'
print(id(s))
s=s+'world'
print(id(s))#变化
print(s)

2.2、元组的创建方式

2.2.1、直接小括号

t=('Python','world',98)
t2='Python','world',98  #省略了小括号
t3=('Python',)  #如果元组中只有一个元素，  逗号不能省

注意：只包含一个元组的元素需要使用逗号和小括号

2.2.2、使用内置函数tuple()

t1=tuple(('Python','world',98))

2.2.3、空元组

lst=[]
lst1=list()

d={}
d2=dict()

#空元组
t4=()
t5=tuple()

print('空列表',lst,lst1)
print('空字典',d,d2)
print('空元组',t4,t5)

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

2.3.1、在多任务环境下，同时操作对象时不需要加锁。因此，在程序中尽量使用不可变序列 

2.3.2、注意事项：

元组中存储的是对象的引用

a)如果元组中对象本身不可对象，则不能再引用其它对象
b)如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变

t=(10,[20,30],9)
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]))
'''尝试将t[1]修改为100'''
print(id(100))
#t[1]=100   
#元组是不允许修改元素的
'''由于[20,30]列表，而列表是可变序列，所以可以向列中添加元素，而列表的内存地址不变'''
t[1].append(100)  #向列表中添加元素
print(t,id(t[1]))

2.4、元组的遍历

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

t=('Python','world',98)
'''第一种获取元组元组的方式，使用索引'''
print(t[0])
print(t[1])
print(t[2])
#print(t[3]) #IndexError: tuple index out of range
'''遍历元组'''
for item in t:
    print(item)

三、集合set及其基本操作

3.1、什么是集合

1、Python语言提供的内置数据结构
2、与列表、字典一样都属于可变类型的序列
3、集合是没有value的字典

3.2、集合的创建方式

3.2.1、直接{}

s={2,3,4,5,5,6,7,7} 
#集合中的元素不允许重复
print(s)#{2, 3, 4, 5, 6, 7}

3.2.2、使用内置函数set()

s1=set(range(6))
print(s1,type(s1))

s2=set([1,2,4,5,5,5,6,6])
print(s2,type(s2))

s3=set((1,2,4,4,5,65))  #集合中的元素是无序的
print(s3,type(s3))

s4=set('python')
print(s4,type(s4))

s5=set({12,4,34,55,66,44,4})
print(s5,type(s5))

3.2.3、空集合

#定义一个空集合
s6={}   #dict字典类型
print(type(s6))

s7=set()
print(type(s7))

3.3、集合的判断、新增、删除操作

s={10,20,30,405,60}

3.3.1、集合元素的判断操作（in或not in）

print(10 in s)  #True
print(100 in s) # False
print(10 not in s) #False
print(100 not in s) #True

3.3.2、集合元素的新增操作

1、调用add()方法，一次添中一个元素
2、调用update()方法至少添中一个元素

s.add(80)  #add一次添加一个元素
print(s)
s.update({200,400,300})  #一次至少添加一个元素
print(s)
s.update([100,99,8])
s.update((78,64,56))
print(s)

3.3.3、集合元素的删除操作 

1、调用remove()方法，一次删除一个指定元素，如果指定的元素不存在抛出KeyError
2、调用discard()方法，一次删除一个指定元素，如果指定的元素不存在不抛异常
3、调用pop()方法，一次只删除一个任意元素
4、调用clear()方法，清空集合

s.remove(100)
print(s)
#s.remove(500) #KeyError: 500
s.discard(500)
s.discard(300)
print(s)
s.pop()
s.pop()

#s.pop(400) #TypeError: pop() takes no arguments (1 given)
print(s)
s.clear()
print(s)

3.4、集合间的关系

3.4.1、两个集合是否相等

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

3.4.2、一个集合是否是另一个集合的子集

可以调用方法issubset进行判断

3.4.3、一个集合是否是另一个集合的超集

可以调用方法issuperset进行判断

3.4.4、两个集合是否没有交集 

可以调用方法isdisjoint进行判断

3.4.5、示例 

'''两个集合是否相等（元素相同，就相等）'''
s={10,20,30,40}
s2={30,40,20,10}
print(s==s2)   #True
print(s!=s2)   #False

'''一个集合是否是另一个集合的子集'''
s1={10,20,30,40,50,60}
s2={10,20,30,40}
s3={10,20,90}
print(s2.issubset(s1))  #True
print(s3.issubset(s1))  #False

'''一个集合是否是另一个集合的超集'''
print(s1.issuperset(s2))  #True
print(s1.issuperset(s3))  #False

'''两个集合是否含有交集'''
print(s2.isdisjoint(s3))  #False   有交集为False
s4={100,200,300}

print(s2.isdisjoint(s4))  #True    没有交集为True

3.5、集合的数学操作 （交集、并集、差集、对称差集）

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

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

#(3)差集操作
print(s1.difference(s2))
print(s1-s2)

print(s1)
print(s2)

#（4）对称差集
print(s1.symmetric_difference(s2))
print(s1^ s2)

3.6、集合生成式

用于生成集合的公式

#列表生成式
lst=[ i*i for i in range(10)]
print(lst)


#集合生成式
s={ i*i for i in range(10)}
print(s)

注：

将{}修改为[]就是列表生成式^_^
没有元组生成式

四、列表、字典、元组、集合总结