列表类型，元祖类型，字典类型，集合类型

列表类型：
用途：记录多个值（同种属性）
定义方式：在[]内用逗号分隔开多个任意类型的值
l=['a','b','c']
类型转换
l=list('hello')
print(l)
l=list({'x':1,'y':2})
优先掌握：
l=['a','b','a','d','e']
print(l[0])
print(l[-1])
l[0]='A'

切片
l[1:4]

长度
len(l)

追加，插入
l.append(3333)#末尾添加
l.insert(0,1111)#在之前添加


删除
del l[0]
l.remove('a')
l.pop()


循环
for item in l:
    print(item)

l.extend(items)#添加列表

l.index('a',2,5)

l.reverse() #反转
l.sort(reverse=True)#从大到小
l.sort()#从小到大

存多个值
有序
可变

队列：先进先出
l=[]
# 入队
l.append('1')
l.append('2')
l.append('3')
print(l)
# 出队
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))
# 堆栈：后进先出
# 入栈
l.append('1')
l.append('2')
l.append('3')
print(l)
# 出栈
print(l.pop())
print(l.pop())
print(l.pop())


元祖类型：tuple
用途：元祖就是一个不可变的列表
定义：在（）内用逗号分隔开多个任意类型的元素
t=(1,2.2,'aa',('b','c'),['a','b','c'])
类型转换
t1=tuple('hello')

按索引取值，只能取
print(t[0])
切片
print(t[1:4])
长度
len(t)
成员运算
print('a' in t)


需要掌握的
print(t.index('a',1,5))
print(t.count('a'))
存多个值
有序
不可变


字典类型：dict
用途：记录多个值，列表是索引对应值，而字典是key对应值，其中key对value有描述性的功能
定义：在｛｝用逗号分隔开多个元素，每个元素都是key：value的形式，其中key不可变类型，通常是字符串类型
而value可以是任意类型
类型转换
d=dict(x=1,y=2,z=3)
print(d)

items=[('name','egon'),('age,18'),('gender','male')]
d={}
for item in items:
    d[item[0]]=item[1]

d=dict(items)
print(d)

keys=['name','age','gender','height','weight']
d={}.fromkeys(keys,None)
print(d,type(d))

d={}
for key in keys:
    d[key]=None

按key存取值：可存可取
dic={'name':'egon','age':18}
dic['gender']='male'
print(dic)

del dic['name']
dic.pop()
dic.popitem()

集合类型set
pythons=['张铁蛋','李蛋','王蛋','赵蛋','egon','Alex']
linuxs=['张铁蛋','egon','Alex']

res=[]
for stu in pythons :
    if stu in linuxs:
        res.append(stu)
print(res)

用途：关系运算，去重
定义：在｛｝内用逗号分隔开多个元素，但是元素的特点是
集合内的元素必须是不可变类型
集合内元素无序
集合内元素不能重复
s=set()
print(s,type(s))

s={1,2,3,4,5,1,2,3,6,2}
print(s)

res=set('hello')
print(res)

pythons={'张铁蛋','李蛋','王蛋','赵蛋','egon','Alex'}
linuxs={'张铁蛋','egon','Alex','sb'}
# 合集
print(pythons | linuxs)
# 交集
print(pythons & linuxs)
# 差集
print(pythons - linuxs)
# 对称差集,除公共以外的部分
res=pythons ^ linuxs
print(res)

==
s1={1,2,3}
s2={3,2,1}
print(s1 == s2)


父子集描述的是一种包含与被包含的关系
# 父集：>=
# 子集：<=
print(s1.pop())