一、列表类型
======================================基本使用======================================
1.用途：记录多个值（同种属性）
2.定义方式：在[ ]内用逗号分隔开多个任意类型的值
l=['a','b','c'] #l=list(['a','b','c'])类型转换
l=list('hello') # ['h', 'e', 'l', 'l', 'o']
print(l)
l=list({'x':1,'y':2}) # ['x', 'y']
print(l)3.常用操作+内置的方法
优先掌握的操作：
l=['a','b','c','d','e']1、按索引存取值(正向存取+反向存取)：即可存也可以取 l [ ]
l=['a','b','c','d','e']
print(l[0]) # 'a'
print(l[-1]) # 'e'
print(id(l)) # 2869921460808
l[0]='A'
print(id(l)) #2869921460808
l[4]='EEEEEE' # ['A', 'b', 'c', 'd', 'EEEEEE']
print(l)
l[5]='dddddd' # 这种方式无法添加2、切片 (顾头不顾尾，步长) l [ : : : ]
l=['a','b','c','d','e']
print(l[1:4]) # ['b', 'c', 'd']
print(l) # ['a', 'b', 'c', 'd', 'e']3、长度 len(l)
l=['a','b','c','d','e']
print(len(l)) # 54、成员运算 ' ' in l 、' ' not in l
l=['a','b','c','d','e']
print('a' in l) #True
print('ssssss' not in l) #False5、追加&插入 l.append（' '）、l.insert(' ')
l=['a','b','c','d','e']
l.append(3333333) # 在列表末尾添加 '3333333'
l.append(44444) # 在列表末尾添加 '3333333'
print(l) # ['a', 'b', 'c', 'd', 'e', 3333333, 44444]
l.insert(0,11111111111) # 在 0 处插入 '11111111111'
print(l) # [11111111111, 'a', 'b', 'c', 'd', 'e', 3333333, 44444]6、删除 del l [ ] 、l.remove( ' ' ) 、res=l.pop( ' ' )
l=['a','b','c','d','e']
del l[0] # 删除 l列表的 0 位值，del 适用于各种场合
res=l.remove('b') # l列表中，将'b'移走，不返回值
print(l) # ['c', 'd', 'e']
print(res) # None
res=l.pop(0) # 类似于剪切，将 l 列表中 0 位的值拿出来，返回给 res, 此时的 l=['c', 'd', 'e']
print(l) # ['d', 'e']
print(res) # c7、循环 for
l=['a','b','c','d','e']
for item in l:
print(item) # a b c d e 需要掌握的操作 l.count( ' ' ) 、l.extend( items ) 、l.index( ' ' , , )
l=['a','b','a','c','d','e']
print(l.count('a')) #'a'在列表 l 中出现的次数 2l=['a','b','a','c','d','e']
items=[1,2,3,4,5]
l.extend(items)
print(l) #将 items列表元素添加进 l列表 ['a', 'b', 'a', 'c', 'd', 'e', 1, 2, 3, 4, 5]l=['a','b','a','c','d','e']
print(l.index('a',2,5)) #在 l列表范围内的 2位到 5位中查找 'a' 2
l.index(123123123123123123123123)
if 123123123123123123123123 in l:
print(l.index(123123123123123123123123))l=['a','b','a','c','d','e']
l.reverse() #将 l列表里的值反转
print(l) #['e', 'd', 'c', 'a', 'b', 'a']
l=[10,-1,3,11,9]
l.sort(reverse=True) # 将 l列表的值从小到大排序 reverse=True 就反过来
print(l) # [11, 10, 9, 3, -1]======================================该类型总结====================================
存多个值
有序
可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
练习题
1.队列：先进先出 l.pop(0)
入队
l=[] #创建一个空列表
l.append('first')
l.append('second')
l.append('third')
print(l) #['first', 'second', 'third']出队
l=['first', 'second', 'third']
print(l.pop(0)) # first
print(l.pop(0)) # second
print(l.pop(0)) # third堆栈：后进先出 l.pop()
入栈l=[] l.append('first') l.append('second') l.append('third') print(l) #['first', 'second', 'third']出栈
l=['first', 'second', 'third'] print(l.pop()) #third print(l.pop()) #second print(l.pop()) #first
二、元组tuple：
======================================基本使用======================================
1、用途：元组就是一个不可变的列表
2、定义方式：在 ( ) 内用逗号分隔开多个任意类型的元素
t=(1,2.2,'aa',('b','c'),['a','b','c']) # t=tuple(...)
print(type(t))强调：
l=['a']
print(type(l),l[0])
t=('a',)
print(type(t))
print(t)类型转换
t1=tuple('hello')
t2=tuple([1,2,3])
print(t1) #('h', 'e', 'l', 'l', 'o')
print(t2) #(1, 2, 3)3、常用操作+内置的方法
优先掌握的操作：
t=(1,2.2,'aa',('b','c'),['a','b','c'])1、按索引取值(正向取+反向取)：只能取 t [ ]
print(t[0]) # 1
print(t[-1]) #['a', 'b', 'c']
t[0]=1111111111 #不能改值，报错2、切片(顾头不顾尾，步长) t[ : : : ]
t=('a','b','c','e','f')
print(t[1:4]) #('b', 'c', 'e')3、长度 len(t)
print(len(t)) # 54、成员运算 in 和 not in
print('a' in t) #False5、循环 for
for item in t:
print(item) # 1 2.2 aa ('b','c') ['a','b','c']需要掌握的操作 t.index( ' ' , , ) 、t.count( ' ' )
t=('a','b','c','e','a','f')
print(t.index('a',1,5)) # 4
print(t.count('a')) # 2======================================该类型总结====================================
存多个值
有序
不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
t=('a','b','c')
print(id(t))
t=('A','B','C')
print(id(t))
t=('a',111,['b','c'])
print(id(t[0]),id(t[1]),id(t[2]))
t[2][0]='B'
print(t)
print(id(t[0]),id(t[1]),id(t[2])) #将 [] 看做一个值
t[0]='A'
t[2]=[1,2,3]
l=['a','b','c']
l[0]='A'
三、字典类型dict
======================================基本使用======================================
1、用途:记录多个值,列表是索引对应值,而字典是key对应值,其中key对value有描述性的功能
2、定义方式:在{}用逗号分隔开多个元素,每个元素都是key:value的形式,其中key可以是不可变类型,通常是字符串类型，而value可以是任意类型
d={1:'aaa',2.2:'bbb','xxx':'ccc',(1,2,3):'dddd'} #d=dict(...)
print(d[(1,2,3)])类型转换
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] # item代表items中的元素（元组），这个表达式为： key=value
d=dict(items)
print(d)了解
keys=['name','age','gender','height','weight']
d={}
for key in keys:
d[key]=None
d={}.fromkeys(keys,None)
print(d,type(d))3、常用操作+内置的方法
优先掌握的操作：
1、按key存取值：可存可取
dic={'name':'egon','age':18}
dic['xxxx']
print(dic.get('name'))
print(dic.get('xxx'))
print(dic['name'])
dic['name']='EGON'
dic['gender']='male'
print(dic)
l=['a','b','c']
l[0]='A'
l[4]='AAA'2、长度 len
dic={'name':'egon','age':18}
print(dic)
print(len(dic))3、成员运算in和not in :是以字典的key为准的
dic={'name':'egon','age':18}
print('name' in dic)
print('egon' in dic)4、删除
dic={'name':'egon','age':18}
del dic['name']
print(dic)
res=dic.pop('name')
print(dic)
print(res)
res=dic.popitem()
print(res)5、键keys()，值values()，键值对items()
在python2
>>> dic={'name':'egon','age':18}
>>>
>>>
>>> dic.keys()
['age', 'name']
>>>
>>>
>>> dic.values()
[18, 'egon']
>>>
>>>
>>> dic.items()
[('age', 18), ('name', 'egon')]在python3
>>> dic={'name':'egon','age':18}
>>>
>>> dic.keys()
dict_keys(['name', 'age'])
>>> dic.values()
dict_values(['egon', 18])
>>> dic.items()
dict_items([('name', 'egon'), ('age', 18)])6、循环 for
for k in dic.keys():
print(k)
for v in dic.values():
print(v)
for k,v in dic.items(): #k,v=('name', 'egon')
print(k,v)需要掌握的操作
dic={'name':'egon','age':18}
dic={'name':'egon','age':18}
dic.update({'age':19,'gender':'male'})
print(dic)
dic={'name':'egon','age':18}当key存在时,不改原值,返回原值
res=dic.setdefault('name','EGON')
print(dic)
print(res)当key不存在时,增加新值
res=dic.setdefault('gender','male')
print(dic)
print(res)======================================该类型总结====================================
存多个值
无序
可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
四、集合类型set
======================================基本使用======================================
1、用途: I: 关系运算 II:去重
2、定义方式:在{}内用逗号分隔开多个元素,但是元素的特点是
I: 集合内的元素必须是不可变类型
II: 集合内元素无序
III: 集合内元素不能重复
s={1,'aaa',2,} #s=set(...)
print(s,type(s))
s=set()
print(s,type(s))
s={1,1,1,1,1,1,1,1,1,1,1,1,'a','a','a'}
print(s)pythons=['张铁蛋','李铜淡','王金蛋','赵银胆','alex','kevin']
linuxs=['oldboy','张铁蛋','赵银胆','alex','wxx']
res=[]
for stu in pythons:
if stu in linuxs:
res.append(stu)
print(res)数据类型转换
res=set('hello')
print(res)
res=set([1,'a','b'])
print(res)3、常用操作+内置的方法
优先掌握的操作：
1、长度len
2、成员运算in和not in
pythons={'张铁蛋','李铜淡','王金蛋','赵银胆','alex','kevin'}
linuxs={'oldboy','张铁蛋','赵银胆','alex','wxx'}3、| 合集:求所有报名的学生
print(pythons | linuxs)
print(pythons.union(linuxs))4、& 交集:求同时报名两门课程的学生
print(pythons & linuxs)5、- 差集: 求只报名python课程的学员
print(pythons - linuxs)
print(linuxs - pythons) #求只报名linux课程的学员6、^ 对称差集:求没有同时报名两门课程的学生
res=(pythons - linuxs) | (linuxs - pythons)
res=pythons ^ linuxs
print(res)7、==
s1={1,2,3}
s2={3,2,1}
print(s1 == s2)注意:父子集描述的是一种包含与被包含的关系
8、父集：>=
9、子集：<=
s1={1,2,3}
s2={1,2,3,4}
print(s2 >= s1)
print(s1 <= s2)需要掌握的
s1={1,2,3}
s1.update({3,4,5,6})
print(s1)
s1={1,'aa','bb',3}
print(s1.pop())
res=s1.remove('bbbbbb')
print(s1)
print(res)
s1.discard('bbb')
s1.add(4)
print(s1)======================================该类型总结====================================
存多个值
无序
可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
集合的去重
局限性
1.只能针对不可变类型
2.不能保证原来的顺序
names=['egon','egon','egon','alex','alex','kevin']
new_names=list(set(names))
print(new_names)
l=[
{'name':'egon','age':18,'sex':'male'},
{'name':'alex','age':73,'sex':'male'},
{'name':'kevin','age':20,'sex':'female'},
{'name':'egon','age':18,'sex':'male'},
{'name':'egon','age':18,'sex':'male'},
]
new_l=[]
for dic in l:
if dic not in new_l:
new_l.append(dic)
print(new_l)