列表型別：
用途：記錄多個值（同種屬性）
定義方式：在[]內用逗號分隔開多個任意型別的值
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())