#列表类型
======================================基本使用======================================
1、用途：记录多个值（同种属性）
2、定义方式：在[]内用逗号分隔开多个任意类型的值
l=['a','b','c'] #l=list(['a','b','c'])
类型转换
l=list('hello')
l=list({'x':1,'y':2}) #将字典转换为列表
print(l)
3、常用操作+内置的方法
#优先掌握的操作：
l=['a','b','c','d','e']
1、按索引存取值(正向存取+反向存取)：即可存也可以取
print(l[0]) #读取列表内第一个元素
print(l[-1]) #读取列表内最后一个元素
print(id(l))
l[0]='A' #说明列表是可变的，元素改变，但是保存在内存中的ID号不变
print(id(l))
l[4]='EEEEEE' #改变列表中最后一个元素的值
print(l)
l[5]='dddddd' #列表中不能添加新的值
#2、切片(顾头不顾尾，步长)
l=['a','b','c','d','e']
print(l[1:4]) #列表切片，这里得到的值是b,c,d
print(l)
#
#3、长度
l=['a','b','c','d','e']
print(len(l)) #查看列表内有几个元素这里是5个
#4、成员运算in和not in
print('a' in l) #查看a这个字符是不是在列表内
print('ssssss' not in l) #ssss这个元素不在l内， not in 所以也是TrUE
#5、追加&插入
l=['a','b','c','d','e']
l.append(3333333) #append 是添加的意思，在最后的尾部添加
l.append(44444)
print(l) #所以这里打印的值为a,b,c,d,e,33333333333,444444
#
l.insert(0,11111111111) #inser是插入的意思，这里0就是首部插入字符为111111111111
print(l) #打印的结果为 [11111111111, 'a', 'b', 'c', 'd', 'e']
#
6、删除
l=['a','b','c','d','e']
del l[0] #del是删除的意思，这里删除的是a这个元素
res=l.remove('b') #remove是移除的意思，这里可以使用字符表示不需要根据索引来删除
print(l)
print(res)
res=l.pop(0) #pop默认是从 首部开始的 如果想尾部删除就使用-1
print(l)
print(res)
#
#7、循环
l=['a','b','c','d','e']
for item in l: #for循环打印列表内的元素
print(item)
#需要掌握的操作
l=['a','b','a','c','d','e']
print(l.count('a')) #count是统计列表内a这个元素在列表内有多少个
l=['a','b','a','c','d','e']
items=[1,2,3,4,5]
for item in items:
l.append(item) #for循环来依次吧items内的值添加到l内并打印出来
#
l.extend(items) #这里的话extend一条命令就能完成for循环的操作，extend是延申的意思
print(l)
l=['a','b','a','c','d','e']
print(l.index('a',2,5)) #index是查看a这个元素所在的列表内的位置! 2,5的意思就是从第二索引查到第五索引的位置
l.index(123123123123123123123123)
if 123123123123123123123123 in l:
print(l.index(123123123123123123123123))
l=['a','b','a','c','d','e']
l.reverse() #reverse的意思就是吧列表内的元素全部倒过来
print(l)
#
l=[10,-1,3,11,9]
l.sort(reverse=True) #sort是从小到大排序，但是()内添加了reverse=True时就是反转，从大到小排序
print(l)
print(l.extend(['a','b','c'])) #直接吧a,b,c添加到l的列表内
print(l.pop(0)) #删除第一个元素
print(l)
======================================该类型总结====================================
存多个值
有序
可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
练习题
#1. 队列：先进先出 #队列就是 吃了就啦 的意思，啦出来肯定是最先吃进去的
l=[] #定义一个空列表
入队
l.append('first') #添加第一个元素
l.append('second') #添加第二个元素
l.append('third')
print(l)
出队
print(l.pop(0)) #取出第一个元素 这个时候是first为第一个
print(l.pop(0))
print(l.pop(0))
2. 堆栈：后进先出 #堆栈就是吃了多了呕吐了，吐出来的肯定是最后吃进去的东西
l=[]
入栈
l.append('first')
l.append('second')
l.append('third')
print(l)
出栈
print(l.pop()) #去除最后一个元素，这个时候是third
print(l.pop())
print(l.pop())
元组tuple：
======================================基本使用======================================
1、用途：元组就是一个不可变的列表
2、定义方式：在()内用逗号分隔开多个任意类型的元素
t=(1,2.2,'aa',('b','c'),['a','b','c']) # t=tuple(...)
print(type(t)) #查看元祖类型为tuple
强调：
l=['a']
print(type(l),l[0]) #元祖也可以通过标识符来取值
#
t=('a',)
print(type(t)) #只要元祖内有个逗号，他就是元祖，没有逗号光一个值他就是字符串
print(t)
msg=('hello world') #这个就是字符串，一个不是元祖
类型转换
t1=tuple('hello') #将字符串转换为元祖
t2=tuple([1,2,3]) #将列表转化为元祖
print(t1)
print(t2)
3、常用操作+内置的方法
#优先掌握的操作：
t=(1,2.2,'aa',('b','c'),['a','b','c'])
1、按索引取值(正向取+反向取)：只能取
print(t[0]) #元祖正向取值根据索引去第一个为1
print(t[-1]) #元祖方向取值根据定位符取最后一个值 他是['a', 'b', 'c']
#
t[0]=1111111111
#2、切片(顾头不顾尾，步长)
t=('a','b','c','e','f')
print(t[1:4]) #元祖切片，切出来的是'b','c','e'
#3、长度
print(len(t)) #显示元祖内有几个元素
#4、成员运算in和not in
print('a' in t)
#5、循环
for item in t:
print(item)
需要掌握的操作
t=('a','b','c','e','a','f')
print(t.index('a',1,5)) #index是索引的意思，定义a 在这个元祖内的位置! 1,5是在第一位置到第五位置去查找
print(t.count('a')) #count是统计这个a元素在元祖内有多少个
======================================该类型总结====================================
存多个值
有序
不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
t=('a','b','c')
print(id(t))
t=('A','B','C')
print(id(t)) #这里表示的是元祖是不可变的
#字典类型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)]) #字典取值的方式，如果要取多个 print(d[1],d['xxx'])
类转换
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) #这dict是字典生成的方式
print(d)
了解
keys=['name','age','gender','height','weight']
d={}
for key in keys:
d[key]=None
#
d={}.fromkeys(keys,None) #fromkeys是生成value的关键词
print(d,type(d)) #生成的信息是{'name': None, 'age': None, 'gender': None, 'height': None, 'weight': None}
#
3、常用操作+内置的方法
#优先掌握的操作：
1、按key存取值：可存可取
dic={'name':'egon','age':18}
print(dic['name'])
dic['name']='EGON'
dic['gender']='male' #字典是可以改变vale 并可以添加新的key 和value进去
print(dic)
l=['a','b','c']
l[0]='A'
l[4]='AAA'
#2、长度len
dic={'name':'egon','age':18}
print(dic)
print(len(dic)) #字典统计长度是统计key有几个的
#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) #字典用pop删除字典key ，可以打印出来key对应的value的值
print(res)
res=dic.popitem() #popitem是删除key和value的值 并且可以打印出来，删除的内容
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、循环
dic={'name':'egon','age':18}
for k in dic: #默认是打印key
print(k)
for k in dic.keys(): #这个是后面指定打印key值
print(k)
for v in dic.values(): #这个是指定打印value的值
print(v)
for k,v in dic.items(): #k,v=('name', 'egon') #当使用.items时， 前面需要使用2个值来对应,这样可以同时打印出key，和value的值
print(k,v)
======================================该类型总结====================================
存一个值or存多个值
有序or无序
可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
pythons=['张铁蛋','李铜淡','王金蛋','赵银胆','alex','kevin']
linuxs=['oldboy','张铁蛋','赵银胆','alex','wxx']
#
res=[]
for stu in pythons:
if stu in linuxs:
res.append(stu)
#
print(res)
集合类型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'} #集合有去重复的意思，这里显示只有{1,'a'}
print(s)
数据类型转换
res=set('hello') #吧字符串变为集合显示的为{'l', 'h', 'e', 'o'} 因为集合是无序的，去重所以少了个l
print(res)
res=set([1,'a','b']) #吧列表转换为集合，显示为{1, 'b', 'a'}
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) # & 这个是显示交集 显示的是{'alex', '张铁蛋', '赵银胆'} 因为他们都报了2们课程
#5、-差集: 求只报名python课程的学员
print(pythons - linuxs) # - 这个是差集 是让2个元祖内的元素相减
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}) #update是更新的意思，就是添加元素到集合内{1, 2, 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)