5:列表，元组，字典，集合

一：列表的增删改查列表

a=['a',4,'c',5,'d']
1:查询
#取单个(开头0  结尾-1)
print(a[2])
print(a[-2])

c
5

#切片
取到最后
print(a[1:])
倒序
print(a[::-1])
步进-正数
print(a[1::2])
步进-负数反方向---3先确定启始位置，步进正负确定方向。
print(a[3::-2])
全部
print(a[:])

[4, 'c', 5, 'd']
['d', 5, 'c', 4, 'a']
[4, 5]
[5, 4]
['a',4,'c',5,'d']

2:添加
#追加
a.append('lijia')
print(a)
#插入任意角标后
a.insert(1,'lijiajia')
print(a)
a=[1,2,3,4,5]
#放在4的后面-插入数据-先确定放入位置(哪个元素的后面)--在数确定下标---也就是最新生成列表的下标数
a.insert(4,'4')
print(a)
#添加多个--列表整合在一起
b=['1','2']
b.extend(['3',4])
print(b)

['a', 4, 'c', 5, 'd', 'lijia']
['a', 'lijiajia', 4, 'c', 5, 'd', 'lijia']
[1, 2, 3, 4, '4', 5]
['1', '2', '3', 4]

3：修改
#修改单个
a[1]=6
print(a)

#修改多个
a[3:]={'c','t'}
print(a)

['a', 6, 'c', 5, 'd']
['a', 6, 'c', 't', 'c']

4：删除
#删除值remove只能删除第一个
a.remove(4)
print(a)
['a', 'c', 5, 'd']
#删除角标--返回删除的值，默认是删除最后一位pop()
print(a.pop(0))
print(a)

a
['c', 5, 'd']

#del
a=[1,'a','b','c']
del a[2:]
print(a)
del a
print(a)

[1, 'a']
NameError: name 'a' is not defined(会报错a列表已经不存在了)


#循环遍历删除列表的元素（先把要删除的元素添加到一个临时列表，删除时遍历后指定的列表删除）

a=[11,12,13,14,15]
b=[]
for i in a:
    if i==13 or i==14:
        b.append(i)

for i in b:
    a.remove(i)
print(a)

5：clear：清空
a=[1,'a','b','c']
a.clear()
print(a)

[]

6:判断是否是列表
a=[1,'a','b','c']
print(type(a) is list)

True

列表的内置方法
1:count:计算元素出现的次数
a=['a',4,'c',5,'d',5]
print(a.count(5))
print(a.count(6))

2
0

2:extend:列表扩大
a=['a',4,'c',5]
b=['b',0]
a.extend(b)
print(a)
print(b)

['a', 4, 'c', 5, 'b', 0]
['b', 0]

3:index:取第一个指定元素的角标
a=['a',4,'b',5,'a','b']
#取第一个'b'的角标
frist=a.index('b')
print(frist)
#取第一个'b'元素后面的列表
c=a[frist+1:]
second=c.index('b')
print(second)
#第二个'b'的角标位置frist+second+1
print(a[frist+second+1])

2
2
b

4:reverse:倒序
a=['a',4,'b',5,'a','b']
a.reverse()
print(a)

['b', 'a', 5, 'b', 4, 'a']

5:sort：默认是升，参数reverse=True变成降
b=[1,6,9,7,4]
b.sort(reverse=True)
print(b)
b.sort()
print(b)

[9, 7, 6, 4, 1]
[1, 4, 6, 7, 9]

6:in:判断是否存在,存在True 不存在False
a=['a',4,'b',5,'a','b']
print('a' in a)
print(6 in a)

True
False

元祖和字典和集合

元祖--不能修改只能查询 和列表一样元素无限制但里面嵌套的列表可以修改
a=(1,2,3,[1,2],5)
a[3][0]=2
print(a)

(1, 2, 3, [2, 2], 5)

注意元祖只有一个元素加逗号-----不然表示本元素类型
a=('hello')
print(type(a))
b=('hello',)
print(type(b))

<class 'str'>
<class 'tuple'>

字典两大特点：1无序  2键唯一

字典
dic={'ss':True,'DD':[1,2],1:'dfs'}

#新增
dic['aa']=123
print(dic)
#键存在，不改动，返回字典中对应的键的值
a=dic.setdefault('ss',False)
print(a)
#键不存在，改动，返回字典中对应的键的值
b=dic.setdefault('bb','xx')
print(b)

{'ss': True, 'DD': [1, 2], 1: 'dfs', 'aa': 123}
True
xx

#查询
dic={'a':12,'b':13,'c':14}
print(dic['a'])
#列表形式获取所有键
print(list(dic.keys()))
#列表形式获取所有值
print(list(dic.values()))
#列表元组形式展示键值对
print(list(dic.items()))

['a', 'b', 'c']
[12, 13, 14]
[('a', 12), ('b', 13), ('c', 14)]

#修改
dic={'a':12,'b':13,'c':14}
dic['a']='ff'
print(dic)
dic1={'c':14,'d':16}
#update:重复的会覆盖
dic.update(dic1)
print(dic)


{'a': 'ff', 'b': 13, 'c': 14}
{'a': 'ff', 'b': 13, 'c': 14, 'd': 16}



#删除
#删除键值对
del dic['a']
print(dic)
#删除键值对 返回值
a=dic.pop('b')
print(a)
print(dic)
#随机返回并删除字典中的最后一对键和值。
b=dic.popitem()
print(b,dic)
#空字典
dic.clear()
print(dic)
#删除整个字典
del dic
#dic已删除了不存在
print(dic)

{'b': 13, 'c': 14, 'd': 15, 'f': 16, 'e': 17}
13
{'c': 14, 'd': 15, 'f': 16, 'e': 17}
('e', 17) {'c': 14, 'd': 15, 'f': 16}
{}

name 'dic' is not defined




a={'name':'li'}
#键存在输出，键不存在输出
print(a.get('name','jia'),a['name'])
print(a.get('sex','ll'),a['name'])


li li
ll li


集合set：无序（无法访问）没有下标，唯一（去重复）
a=set([3,3,4,5])
print(a)

集合--单一字符，列表，字典，元祖都可以，里面元素都是不可变类型(嵌套只能是元祖)-无序不重复
a=set('li jia jia')
print(a)
b=['li','jia','jia']
print(set(b),type(set(b)))


c=[[1,2],2,3]
d=[{'a':b},2,3]
e=[(1,2),2,2]
# print(set(c))
# print(set(d))
print(set(e))

#判断集合中是否存在
f=set(['li','jia','jia'])

print(f)
print('ji' not in f)

#直接添加字符元素
f.add('uu')
print(f)
f.add('kk')
print(f)
#添加字符-去重，取每个单一元素
f.update('ops')
print(f)
f.update('kk')
print(f)
#添加字符和数字-列表
f.update(['bb',12])
print(f)
#删除
f.remove(12)
f.remove('o')
print(f)
#随机删除
f.pop()
f.pop()
print(f)
#清空
f.clear()
print(f)

#判断等于
print(set('sex')==set('sexx'))
#判断包含-不能相等
print(set('sex')==set('sexxt'))
#联合
print(set('sex').union(set('sexxt')))
print(set('sex')|(set('sexxt')))
#交集
print(set('sex').intersection('sett'))
print(set('sex')&set('sett'))
#差集
#属于a不属于b
print(set('sex').difference(set('set')))
print(set('sex')-(set('set')))
#属于b不属于a
print(set('set').difference(set('sex')))
print(set('set')-(set('sex')))

#反向差集-取ab不相同的地方
print(set('set').symmetric_difference(set('sex')))
print(set('set')^set('sex'))


{'j', 'a', 'l', 'i', ' '}
{'jia', 'li'} <class 'set'>
{(1, 2), 2}
{'jia', 'li'}
True
{'uu', 'jia', 'li'}
{'uu', 'kk', 'jia', 'li'}
{'uu', 's', 'kk', 'jia', 'li', 'p', 'o'}
{'uu', 's', 'k', 'kk', 'jia', 'li', 'p', 'o'}
{'uu', 's', 12, 'k', 'bb', 'kk', 'jia', 'li', 'p', 'o'}
{'uu', 's', 'k', 'bb', 'kk', 'jia', 'li', 'p'}
{'k', 'bb', 'kk', 'jia', 'li', 'p'}
set()
True
False
{'e', 'x', 't', 's'}
{'e', 'x', 't', 's'}
{'s', 'e'}
{'s', 'e'}
{'x'}
{'x'}
{'t'}
{'t'}
{'t', 'x'}
{'t', 'x'}