列表 字典 元组 集合

一、列表
变量可以存储一个元素，列表可以存储N多个元素，相当于其他语言中的数组

a=10#变量存储的是一个对象的引用
lst=['hello','world',98]
print(id(lst))#列表对象的id  显示：2195817058824
print(type(lst))#列表对象的类型  显示：<class 'list'>
print(lst)#列表对象的值  显示：['hello', 'world', 98]

1.列表的创建与删除
(1)列表需要使用中括号[],有时还用内置函数list(),元素之间使用英文的逗号进行分隔

lst=['hello','world',98]
lst2=list(['hello','world',98])

(2)列表的特点
列表元素按顺序有序排序
索引映射为一个数据(有两种索引，一是从第一个数往右，索引由0递增，另一种是从最后一个数往左，索引由-1递减)
列表可以存储重复数据
任意数据类型混存
根据需要动态分配和回收内存

lst=['hello','world',98,'hello']
print(lst)#显示：['hello', 'world', 98,'hello']
print(lst[0])#显示：hello
print(lst[-4])#显示：hello
lst2=list(['hello','world',98])
print(lst2)

2.列表的查询操作
(1)获取列表中指定元素的索引
index()：
如查列表中存在N个相同元素，只返回相同元素中第一个元素的索引
如果查询的元素不在列表中，则会抛出ValueError
还可以在指定的start和stop之间进行查找

lst=['hello','world',98,'hello']
print(lst.index('hello'))#显示：0
#print(lst.index('Python'))#显示：ValueError: 'Python' is not in list
print(lst.index('hello',1,4))#显示：3

(2)获取列表中的单个元素
正向索引从0到N-1 如lst[0]
逆向索引从-N到-1 如lst[-N]
指定索引不存，抛出IndexError

lst=['hello','world',98,'hello','world',234]
print(lst[2])#显示：98
print(lst[-3])#显示：hello
#print(lst[10])#显示：IndexError: list index out of range

(3)获取列表中的多个元素(切片操作)
列表名[start:stop:step]
切片操作：
切片的结果为原列表片段的拷贝
切片的范围为[start,stop)
step默认为1，简写为[start:stop]
step为正数 （ 一种是[:stop:step]，切片的第一个元素默认是列表的第一个元素，从start开始往后计算切片
另一种是[start::step],切片的最后一个元素默认是列表的最后一个元素，从start开始往后计算切片）
step为负数 （ 一种是[:stop:step]，切片的第一个元素默认是列表的最后一个元素，从start开始往前计算切片
另一种是[start::step],切片的最后一个元素默认是列表的第一个元素，从start开始往前计算切片）

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

#start=1,stop=6,step=2
print(lst[1:6:2])#显示：[20, 40, 60]
#start默认,stop=6,step=2
print(lst[:6:2])#显示：[10, 30, 50]
#start=1,stop默认,step=2
print(lst[1::2])#显示：[20, 40, 60，80]

#start默认,stop默认,step=-1
print(lst[::-1])#显示：[80, 70, 60, 50, 40, 30, 20, 10]
#start=7,stop默认,step=-1
print(lst[7::-1])#显示：[80, 70, 60, 50, 40, 30, 20, 10]
#start=6,stop=0,step=-2
print(lst[6:0:-2])#显示：[70, 50,30]

(4)列表元素的查询操作
判断指定元素在列表中是否存在
元素 in 列表名
元素 not in 列表名

列表元素的遍历
for 迭代变量 in 列表名
操作

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

for item in lst:
    print(item)
#10 20 python hello

3.列表元素的增、删、改操作
(1)列表元素的增加操作
append()在列表末尾增加一个元素
extend()在列表的末尾至少添加一个元素
insert()在列表的任意位置添加一个元素
切片 在列表的任意位置添加至少一个元素

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

lst.insert(1,90)#向列表的末尾一次性添加多个元素
print(lst)#[10,90, 20, 30, 100, 'hello', 'world']

lst3=[True,False,'hello']
lst[1:]=lst3
print(lst)#[10, True, False, 'hello']

(2)列表元素的删除操作
remove()一次删除一个元素，重复元素只删除第一个，元素不存在抛出ValueError
pop()删除一个指定索引位置上的元素，指定索引不存在抛出IndexError，不指定索引时删除列表中最后一个元素
切片 一次至少删除一个元素
clear()清空列表
del 删除列表

lst=[10,20,30,40,50,60,30]
lst.remove(30)
print(lst)#[10, 20, 40, 50, 60, 30]
#lst.remove(100)#ValueError: list.remove(x): x not in list

lst.pop(1)
print(lst)#[10, 40, 50, 60, 30]
#lst.pop(5)#IndexError: pop index out of range
lst.pop()
print(lst)#[10, 40, 50, 60]

#切片生成新的列表对象，原列表不变
new_lst=lst[1:3]
print('原列表',lst)#原列表 [10, 40, 50, 60]
print('切片后的列表',new_lst)#切片后的列表 [40, 50]

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

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

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

(3)列表元素的修改操作
为指定索引的元素赋予一个新值；为指定的切片赋予一个新值

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

4.列表元素的排序
一种方法是调用sort()方法，列表中所有元素默认按从小到大的顺序进行排序，可以指定reverse=True,进行降序排序
另一种方法是调用内置函数sorted(),可以指定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)

#使用内置函数sorted()对列表进行排序,将产生一个新的列表对象  可以指定reverse=True,进行降序排序,原列表不发生改变
lst=[20,40,10,98,54]
print('排序前的列表',lst,id(lst))
new_list=sorted(lst)
print(new_list)

#通过指定关键字参数，将列表中的元素降序排序
desc_list=sorted(lst,reverse=True)
print(desc_list)

5.列表推导式
列表生成式简称生成列表的公式
[ii for i in range(1,10)]
ii 为列表元素的表达式，其中常包含自定义变量 ，i为自定义变量 range(1,10)为可迭代对象

lst=[i for i in range(1,10)]
print(lst)#[1, 2, 3, 4, 5, 6, 7, 8, 9]
lst2=[i*i for i in range(1,10)]
print(lst2)#[1, 4, 9, 16, 25, 36, 49, 64, 81]
lst3=[i*2 for i in range(1,6)]
print(lst3)#[2, 4, 6, 8, 10]

二、字典
1.什么是字典
字典是python内置的数据结构之一，与列表一样是一个可变序列，以键值对的方式存储数据，字典是一个无序的序列
scores={‘张三’:100,‘李四’:98,‘王五’:45}
scores是字典名，'张三’是键key，100是值value
字典中键的存储位置不是由输入的先后决定的，而是经过哈希函数的计算得到的，所以放在字典中的键必须是不可变序列，即不可进行增删改操作，例如字符串str和整数序列。可变序列有列表和字典。
2.字典的原理
根据key查找value所在的位置
3.字典的创建与删除
(1)字典的创建
一是使用花括号，scores={‘张三’:100,‘李四’:98,‘王五’:45}
二是使用内置函数dict()，dict(name=‘jack’,age=20)

scores={'张三':100,'李四':98,'王五':45}
print(scores,type(scores))#{'张三': 100, '李四': 98, '王五': 45} <class 'dict'>

student=dict(name='jack',age=20)
print(student)#{'name': 'jack', 'age': 20}

#空字典
d={}
print(d)#{}

4.字典的查询操作
(1)[],例如scores=[‘张三’]，如果字典中不存在指定的key，抛出keyError异常
(2)get(),例如scores.get=(‘张三’),如果字典中不存在指定的key，则返回None,可以通过参数设置默认的value,以便指定的key不存在时返回

scores={'张三':100,'李四':98,'王五':45}
print(scores['张三'])#100
#print(scores['陈六'])#KeyError: '陈六'
print(scores.get('张三'))#100
print(scores.get('陈六'))#None
print(scores.get('陈六',99))#99,是在查找‘陈六’所对的value不存在时，提供的一个默认值

5.字典元素的增、删、改操作
(1)key的判断
in 指定的key在字典中存在返回True,‘张三’ in scores
not in 指定的key在字典中不存在返回True,‘陈六’ not in scores
(2)字典元素的删除
del scores[‘张三’]
(3)字典元素的新增
scores[‘陈六’]=90

scores={'张三':100,'李四':98,'王五':45}
print('张三'in scores)#True
print('张三'not in scores)#False
del scores['张三']
print(scores)#{'李四': 98, '王五': 45}
scores.clear()
print(scores)#{}
scores['陈六']=98
print(scores)#{'陈六': 98}

6.获取字典视图
三个方法：
keys(),获取字典中所有key
values(),获取字典中所有value
items(),获取字典中所有key,value对

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

values=scores.values()
print(values,type(values))#dict_values([100, 98, 45]) <class 'dict_values'>
print(list(values))#[100, 98, 45]

items=scores.items()
print(items,type(items))#dict_items([('张三', 100), ('李四', 98), ('王五', 45)]) <class 'dict_items'>
print(list(items))#[('张三', 100), ('李四', 98), ('王五', 45)]  转换之后的列表元素是由元组组成的

7.字典元素的遍历
for item in scores:
print(item)

scores={'张三':100,'李四':98,'王五':45}
for item in scores:
    print(item,scores[item],scores.get(item))#张三 100 100   李四 98 98  王五 45 45

8.字典的特点
字典中的所有元素都是一个key-value对，key不允许重复，value可以重复
字典中的元素都是无序的
字典中的key必须是不可变对象
字典也可以根据需要动态地伸缩
字典会浪费较大的内存，是一种使用空间换时间的数据结构

d={'name':'张三','name':'李四'}
print(d)#{'name': '李四'}  所以key不允许重复，一旦重复会出现覆盖的情况
d={'name':'张三','nikename':'张三'}
print(d)#{'name': '张三', 'nikename': '张三'}  所以value可以重复

lst=[10,20,30]
lst.insert(1,100)
print(lst)
d={lst:100}
print(d)#TypeError: unhashable type: 'list'  列表是可变值，不允许进行哈希计算

9.字典推导式
items=[‘fruits’,‘books’,‘others’]
prices=[98,78,85]
——>{‘fruits’:98,‘books’:78,‘others’:85}
内置函数zip()用于将可迭代对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表
items=[‘fruits’,‘books’,‘others’]
prices=[98,78,85]
lst=zip(items,prices)
print(list(lst))
字典生成式：{item.upper():price for item,price in zip(items,prices)}

items=['fruits','books','others']
prices=[98,78,85]
d={item.upper():price for item,price in zip(items,prices)}
print(d)#{'FRUITS': 98, 'BOOKS': 78, 'OTHERS': 85}
prices=[98,78,85,100,120]
d2={item.upper():price for item,price in zip(items,prices)}
print(d)#{'FRUITS': 98, 'BOOKS': 78, 'OTHERS': 85}

三、元组
1.什么是元组
元组是Python内置的数据结构之一，是一个不可变序列
不可变序列(没有增删改操作)：字符串、元组
可变序列(可以对序列执行增删改操作，对象地址不发生更改)：列表，字典
元组：t=(‘python’,‘hello’,90)

#可变序列
lst=[10,20,45]
print(id(lst))
lst.append(300)
print(id(lst))#内存地址不发生变化

#不可变序列
s='hello'
print(id(s))
s=s+'world'
print(id(s))#内存地址发生变化

2.元组的创建方式
直接小括号：t=(‘python’,‘hello’,90)
使用内置函数tuple()： t=tuple((‘python’,‘hello’,90))
只包含一个元组的元素需要使用逗号和小括号：t=(10,)

t=('python','hello',90)
print(t,type(t))#('python', 'hello', 90) <class 'tuple'>
t1='python','hello',90#省略了小括号
print(t1,type(t1))#('python', 'hello', 90) <class 'tuple'>

t2=tuple(('python','hello',90))
print(t2,type(t2))#('python', 'hello', 90) <class 'tuple'>

t3=('python')
print(t3,type(t3))#python <class 'str'>
t4=('python',)#一定要加逗号
print(t4,type(t4))#('python',) <class 'tuple'>

#创建空列表
lst=[]
lst1=list()
print('空列表',lst,lst1)#空列表 [] []
#创建空元组
d={}
d2=dict()
print('空列表',d,d2)#空列表 {} {}
#创建空元组
t4=()
t5=tuple()
print('空元组',t4,t5)#空元组 () ()

因为在多任务环境中，同时操作对象时不需要加锁，因此，在程序中尽量使用不可变序列
注意：元组中存储的是对象的引用
如果元组中对象本身是不可变对象，则不能再引用其他对象
如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变

t=(10,[20,30],9)
print(t,type(t))#(10, [20, 30], 9) <class 'tuple'>
print(t[0],type(t[0]),id(t[0]))#10 <class 'int'>
print(t[1],type(t[1]),id(t[1]))#[20, 30] <class 'list'>
print(t[2],type(t[2]),id(t[2]))#9 <class 'int'>
print(id(100))
#t[1]=100#TypeError: 'tuple' object does not support item assignment  所以元组是不允许修改元素的，但由于[20,30]是列表，列表是可变序列，所以可以向列表中添加元素，而列表的内存地址不变
t[1].append(100)
print(t,id(t[1]))#(10, [20, 30, 100], 9) 1667609125376 向列表中添加元素，元素id不变

3.元组的遍历
元组是可迭代对象，所以可以用for……in进行遍历
t=tuple((‘python’,‘hello’,90))
for item in t:
print(item)

t=('python','hello',90)
#获取元组元素的方式，使用索引
print(t[0])
print(t[1])
print(t[2])
#print(t[3])#IndexError: tuple index out of range
#获取元组元素的方式，遍历元组
for item in t:
    print(item)

四、集合
1.什么是集合
集合是python提供的内置数据结构，与列表、字典一样都属于可变类型的序列，集合是没有value的字典，集合中元素的存储数据也不是依照录入先后决定的，而是经过哈希计算键key得到的
2.集合的创建
一是直接{}，s={‘python’,‘hello’,90}
二是使用内置函数set()，s=set(range(6))
print(s)

s={2,3,4,5,5,6,7,7}
print(s)#{2, 3, 4, 5, 6, 7}  集合中的元素不允许重复
s=set(range(6))
print(s)#{0, 1, 2, 3, 4, 5}
print(set([3,4,53,56]))#{56, 3, 4, 53} 集合中的元素是无序的
print(set((3,4,43,453)))#{43, 3, 4, 453}
print(set('Python'))#{'P', 'y', 't', 'h', 'n', 'o'}
print(set({124,3,4,4,5}))#{5, 3, 124, 4}
print(set())#set()  定义一个空集合

3.集合的增删改查操作
(1)判断操作
in 或not in
(2)新增操作
add(),一次添加一个元素
update(),至少添加一个元素
(3)删除操作
remove(),一次删除一个指定元素，如果指定元素不存在抛出KeyError
discard(),一次删除一个指定元素，如果指定元素不存在不抛出异常
pop(),一次只删除一个任意元素
clear(),清空集合

s={10,20,30,405,60}
print(10 in s)#True
print(10 not in s)#False
print(100 in s)#False
print(100 not in s)#True

s.add(80)#一次只能添加一个元素
print(s)#10, 80, 20, 405, 60, 30}
s.update({200,400,300})#一次至少添加一个元素
print(s)#{200, 10, 300, 80, 400, 20, 405, 60, 30}
s.update([100,99,8])
print(s)#{99, 100, 200, 8, 10, 300, 80, 400, 20, 405, 60, 30}
s.update((78,64,56))
print(s)#{64, 99, 100, 200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}
s.remove(100)
print(s)#{64, 99, 200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}
#s.remove(500)#KeyError: 500
s.discard(500)
print(s)#不抛异常
s.pop()
print(s)#{99, 200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}  删除了第一个元素
#s.pop(400)#ypeError: pop() takes no arguments (1 given)  不能删除指定元素
s.clear()
print(s)#set()

4.集合间的关系
(1)两个集合是否相等
可以用==或!=进行判断
(2)一个集合是否是另一个集合的子集
可以调用方法issubset进行判断
B是A的子集
(3)一个集合是否是另一个集合的超集
可以调用方法issuperset进行判断
A是B的超集
(4)两个集合是否没有交集
可以调用方法isdisjoint进行判断

s={10,20,30,40}
s1={10,20,30,40,50,60}
s2={30,40,20,10}
s3={10,20,90}
s4={100,200,300}
print(s==s2)#True
print(s!=s2)#False

print(s.issubset(s1))#True
print(s3.issubset(s1))#False

print(s1.issuperset(s))#True
print(s1.issuperset(s3))#False

print(s.isdisjoint(s3))#False 有交集
print(s.isdisjoint(s4))#True 没有交集

5.集合的数据操作

s1={10,20,30,40}
s2={20,30,40,50,60}

#交集
print(s1.intersection(s2))#{40, 20, 30}
print(s1 & s2)#{40, 20, 30}

#并集
print(s1.union(s2))#{40, 10, 50, 20, 60, 30}
print(s1|s2)#{40, 10, 50, 20, 60, 30}

#差集
print(s1.difference(s2))#{10}
print(s1-s2)#{10}

#对称差集
print(s1.symmetric_difference(s2))#{50, 10, 60}

6.集合生成式
就是用于生成集合的公式
{i*i for i in range(1,10)}
将{}修改为[]就是列表生成式
没有元组生成式

lst=[i*i for i in range(10)]
print(lst)#[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

s={i*i for i in range(10)}
print(s)#{0, 1, 64, 4, 36, 9, 16, 49, 81, 25}

总结：

数据结构	是否可变	是否重复	是否有序	定义符号
列表(list)	可变	可重复	有序	[]
元组(tuple)	不可变	可重复	有序	()
字典(dict)	可变	key不可重复	无序	{key:value}
字典(dict)	可变	value可重复	无序	{key:value}
集合(set)	可变	不可重复	无序	{}