5月31日 基本数据类型（列表类型 字典类型 元组）及其内置方法

# 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))