# 1、作用：按位置存放多个值
# 2、定义：
# l=[1,1.2,'aa']#l=ist([1,1.2,'aa'])
# print(type(l))
# 3、类型转换:但凡能夠被for循环遍历的类型都可以当做参数传给list（）转换
# res=list('hello')
# print(res)
# res=list({'k1:':111,'k2':222,'k3':333})
# print(res)
# 4、内置方法
# 4.1 优先掌握
# 4.1.1、按索引取值（正向取+反向取）：只能取
# l=[1,1.2,'aa']
# 正向取
# print(l[0])
# print(l[1])
# 反向取
# print(l[-1]) #4
# 只能取 可以能改
# l[0]='222' #索引存在则修改对应的值
# print(l)
# 无论是取值操作还是赋值操作：索引不存在则报错
# l[3]=333
# .往列表里添加值
# 1. 追加
# l=[1,1.2,'aa']
# l.append(333)
# l.append(444)
# print(l)
# 2. 插入值
# l=[1,1.2,'aa']
# l.insert(0,'yyy')
# l.insert(1,'xxx')
# print(l)
# 3. extend实现将一个列表里的值，分别取出来，再添加到另一个列表
# newy = [1, 2, 3]
# l = [1, 1.2, 'aa']
# l.extend(newy)
# print(l)
# l.extend('yui')
# print(l)
# 删除
# 方式一
# l=[1,1.2,'aa']
# del l[1] #不支持赋值语法
# print(l) #
# 方式二：l.pop() 根据索引删除,会返回值
# l=[1,1.2,'aa']
# l.pop() #不指定索引默认删除最后一个
# print(l)
# res=l.pop(1)
# print(res)
# 方式三：l.remove() 根据元素删除，返回None
# l=[1,1.2,'aa',['r','q','w']]
# l.remove(['r','q','w'])
# print(l)
# res=l.remove(['r','q','w'])
# print(res) #返回None
# 、切片：索引的拓展应用（顾头不顾尾，步长）
# p= [1, 1.2, 'aa',5,8,9,7,'w','r']
# print(p[0:5])
# print(p[0:5:2]) # 0 2 4 [1, 'aa', 8]
# print(p[0:len(p)])
# print(p[:]) #切片等同于拷贝行为，而且相当于浅拷贝
# print(p[::-1]) # 相当于把列表倒过来
# 长度
# print(len([1,2,3]))
# 成员运算in和notin
# 循环
# for x in [1,'aaa','bbb']:
# print(x)
# 需要掌握的操作
# p = [1, 'aaa', 'bbb']
# 1、p.count()
# print(p.count('aaa'))
# 2、p.index()
# print(p.index('aaa'))
# print(p.index('aaaaaaa')) # 找不到报错
# 3、p.clear()
# p.clear()
# print(p)
# 4、p.reverse() :不是排序，就是将列表倒过来
# p=[1,'aaa','bbb']
# p.reverse()
# print(p)
# 5、p.sort() :列表内元素必须是同种类型才可以排序
# p=[1,2,5,99,24,63,'5.2']
# p.sort() #默认从小到大排，称之为升序
# p.sort(reverse=True) #从大到小排，设置为降序
# print(p)
# p=['c','e','a']
# p.sort()
# print(p) #['a', 'c', 'e']
# 了解 字符串可以比大小，按照对应的位置的字符依次PK
# 按照ASCI码表的先后顺序区别字符的大小，表中排在后面的字符大于前面的
# print('a'>'b') #False
# print('abz'>'abcdef') # True
#
# print('A'>'a') #False
# 了解：列表之间也可以比大小,原理同字符串，但是对应元素必须是同种类型
# p1=[1,'abc','zaa']
# p2=[10,]
#
# print(p1>p2)
# 补充
# 队列：first in first out 一般写成 FIFO ，先进先出
# p = []
# 入队操作
# p.append('first')
# p.append('second')
# p.append('third')
# print(p)
# 出队操作
# print(p.pop(0))
# print(p.pop(0))
# print(p.pop(0))
# print(p)
# 堆栈： LIFO ，后进先出
p = []
# 入栈操作
p.append('first')
p.append('second')
p.append('third')
print(p)
# 出栈操作
print(p.pop(0))
print(p.pop(0))
print(p.pop(0))
print(p)
字典类型
# 1.作用：
# 2.定义:{}内用逗号分隔开多喝key：vaule,其中vaule可以是任意类型，但key必须是不可变类型.且不能重复。
# d={'k1':111,'k2':(1,2,3),'k3':222} # d=dict(......)
#
# print(type(d))
# d={} #默认定义出来的是空字典
# print(type(d))
# d=dict(x=1,y=2,z=3)
# print(type(d))
# print(d) #{'x': 1, 'y': 2, 'z': 3}
# 3.类型转换：
# info=[
# ['name','egon'],
# ('age',18),
# ['gender','male']
# ]
# d={}
# for item in info:
# d[item[0]]=item[1]
# print(d)
# res=dict(info) # 一行代码搞定上述for循环的工作
# print(res)
# 造字典的方式:快速初始化一个字典
# keys=['name','age','gander']
# d={}
# for k in keys:
# d[k]=None
# print(d)
# d={}.fromkeys(keys,None)
# print(d)
# 内置方法：
# 1.按key存取值：可存可取
# d={'k1':111}
# 针对赋值操作：key存在，则修改
# d['k1']=222
# print(d)
# 针对赋值操作：key不存在，则创建新值
# d['k2']=333
# print(d)
# 2.、长度len
# d={'k1':111,'k2':(1,2,3),'k1':222}
# print(d)#{'k1': 222, 'k2': (1, 2, 3)}
# print(len(d)) # 2
# 3.、成员运算in和noting
# d={'k1':111,'k2':(1,2,3),'k3':222}
# print('k1'in d) #True
# print(111 in d)# False
# 4、删除
# 4.1 通用删除
# d = {'k1': 111, 'k2': (1, 2, 3), 'k3': 222}
# del d['k1']
# print(d)
# 4.2 pop 删除: 根据key删除元素, 返回删除key的对应值
# res=d.pop('k1')
# print(d)
# print(res)
# 4.3 d.popitem 删除:随机删除，返回元组（删除的key,value)
# res = d.popitem()
# print(res)
# 5、键keys（），值values（），键值对items（）=>在Python3中都是老母鸡
# d={'k1': 111, 'k2': 222}
# 在Python2中
"""
>>> d={'k1': 111, 'k2': 222}
>>>
>>> d.keys()
['k2', 'k1']
>>> d.items()
[('k2', 222), ('k1', 111)]
>>> dict(d.items())
{'k2': 222, 'k1': 111}
>>>exit()
"""
# 6.for循环
# for k in d :
# print(k)
# for v in d.values():
# print(v)
# for k,v in d.items():
# print(k,v)
# print(list(d.keys()))
# print(list(d.values()))
# print(list(d.items()))
#需要掌握的内置方法
# d={'k1': 111, 'k2': 222}
# 1、 d.clear() #清空字典
# 2. d.update()
# d.update({'k2':444,'k1':111})
# print(d)
# 3. d.get() :容错性好
# print(d['k3']) #key不存在则报错
# print(d.get('k1')) # 111
# print(d.get('k3')) # key不存在不报错，返回None
#4. d.setdefault()
info={}
# if "name" in info :
# ... #等同于pass
# else:
# info['name']='egon'
# print(info)
# 4.1 如果k1有则不添加，返回字典中key對應的值（执行完毕之后的key对应的value返回出来）
# d={'k1': 111}
# d.setdefault('k1',222)
# print(d)
# 4.2 如果k1没有则添加，返回字典中key對應的值（执行完毕之后的key对应的value返回出来）
# info={}
# info.setdefault('name','egon')
# print(info)
元组
# 元组就是“一个不可变的列表”
# 1.作用：按照索引/位置存放多个值，只用于读不用于改
# 2.定义:()内用逗号分隔开多个任意类型的元素
# t = (1, 1.3, 'aa') # t=tuple((1, 1.3, 'aa'))
# print(t, type(t))
# x=(10)# 单独一个括号代表包含的意思
# print(x,type(x)) #int
# t=(10,)# 如果元组中只有一个元素，必须加逗号
# print(t,type(t))
# t=(1, 1.3, 'aa') #t=(0->值1的内存地址，1->值1.3的内存地址，2->"aaa"的内存地址)
# t[0]=111
# t=(1, [11,22], 'aa') #t=(0->值1的内存地址，1->值[1,2]的内存地址，2->"aaa"的内存地址)
# print(id(t[0]),id(t[1]))
# t[0]=11111111111 #不能改
# t[1]=22222222222 #不能改
# t[1][0]=1111111111111111111
# print(t)
# print(id(t[0]),id(t[1]))
# 3.类型转换
# print(tuple('1'))
# print(tuple[1,2,3])
# print(tuple({'a1':111,'a2':222}))
#4.内置方法
#优先掌握操作
# 4.1 优先掌握
# 4.1.1、按索引取值（正向取+反向取）：只能取
# t=(1,1.2,'aa'）
# 正向取
# print(t[0])
# print(t[1])
# 反向取
# print(t[-1]) #4
# 只能取 可以能改
# t[0]='222' #索引存在则修改对应的值
# print(t)
# 长度
# print(len(t))
# 成员运算in和notin
# 循环
# for x in t:
# print(x)
# 内置方法
# t=(2,3,111,111,111)
# print(t.index(111))
# print(t.index(111111))# 报错
# print(t.count(111))
