元祖&字典

Posted 2020-11-16 liugangjiayou

#什么是元祖：元祖是一个不可变的列表（没有改的需求）

#======================================基本使用======================================
#1、用途：用于存放多个值，当存放的多个值只有读的需求 没有改的需求时用元祖最合适

#2、定义方式：在()内用，分割开多个任意类型的值
t=(1,3.1,‘aaa‘,(1,2,3),[‘a‘,‘b‘])
t=tuple(...)
res=tuple(‘hello‘)
res=tuple([‘x‘:1,‘y‘:2])
print(res)

#3、常用操作+内置的方法
#优先掌握的操作：
#1、按索引取值(正向取+反向取)：只能取
t=(‘a‘,‘b‘,1)
t[0]=111

#2、切片(顾头不顾尾，步长)
t=(‘h‘,‘e‘,‘l‘,‘l‘,‘o‘)
res=[1:3] el
print(res)
print(t) 不可变 切边不会改变原值
#3、长度
t=(‘h‘,‘e‘,‘l‘,‘l‘,‘o‘)
print(len(t))
#4、成员运算in和not in
t=(‘h‘,‘e‘,‘l‘,‘l‘,‘o‘)
print(‘h‘ in t) True

#5、循环
t=(‘h‘,‘e‘,‘l‘,‘l‘,‘o‘)
for item in t:
print(item)

 

#======================================该类型总结====================================
#存多个值

#有序

#不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
元组的元素不可变 列表可变 指的是内存地址可以变
t=(1,‘a‘,[‘x‘,‘y‘,‘z‘])
print(id(t))
t[2][0]=‘X‘
print(t)
print(id(t))

#掌握方法
t=(‘a‘,‘b‘,‘a‘)
print(t.index(‘a‘)) 下标是0
t.index(‘xxx‘)
print(t.count(a)) 一共两个

字典类型
#======================================基本使用======================================
#1、用途：用来存放多个(不同种类的)值

#2、定义方式：在{}内用逗号分开多个key:value的元素，其中value可以是热议数据类型，而key的功能通常是用来描述value的所以key通常是字符串类型，但其实key必须是不可变类型(intfloatstr uple)
d={0:‘x‘,1.3:‘y‘,‘k1‘:‘z‘,(1,2,3):‘aaa‘}
print(d[(1,2,3)])#输出字典中key为(1,2,3)的value
d=dict(...)
print(d[(1,2,3)])
d1={[1,2,3]:‘aaa‘}不可以这样定义

d=dict([(‘k1‘,1),(‘k2‘,2),(‘k3‘,3)]) #将这种数据类型转换成字典
print(d) 输出整个字典

d=dict(((‘k1‘,1),(‘k2‘,2),(‘k3‘,3)))
print(d) 换成元祖也可以 第一个值相当于key第二个值相当于value

l=[(‘k1‘,1),(‘k2‘,2),(‘k3‘,3)]
d={}
for t in l:
print(t) #取出三个小元祖
d[t[0]]

l=[(‘k1‘,1),(‘k2‘,2),(‘k3‘,3)]
d={}
for t in l:
k,v=t
d[k]=v
print(d)
d=dict(l)
print(d)

d=dict(x=1,y=2,z=3)
print(d)

#3、常用操作+内置的方法
#优先掌握的操作：
#1、按key存取值：可存可取
d={‘x‘:1}
print(d[‘x‘]) #1
print(id(d))
d[‘x‘]=1111
print(d)
print(id(d))
key存在的情况下 id不变 说明字典是可变类型

key不存在情况下
d[‘y‘]=2222
print(d)
也可以在里面加值
l=[‘a‘,‘b‘]
l[2]=‘c‘#报错 不能做赋值操作

索引不存在 列表不能往里面加值
字典可以在不存在的key里面加值

#2、长度len
d={‘x‘:1,‘y‘:2,‘z‘:3}
print(len(d))
长度是3
#3、成员运算in和not in
d={‘x‘:1,‘y‘:2,‘z‘:3}
print(1 in d) false
print(‘x‘ in d) true
字典的成员运算按照key来的

#4、删除
d={‘x‘:1,‘y‘:2,‘z‘:3}
del d[‘y‘]
print(d)

d={‘x‘:1,‘y‘:2,‘z‘:3}
res=d.pop(‘y‘) #返回y对应的那个值
print(res) #res为2
print(d) #y被删除

res=d.popitem()
print(res) #返回删除的那个key:value
print(d) #输出删除后d的值

字典是无序的popitem是随机删除
#5、键keys()，值values()，键值对items()
d={‘x‘:1,‘y‘:2,‘z‘:3}
d.keys()输出key
print(list(d.keys()))
d.values()输出value
print(list(d.values()))
d.item()输出字典
print(list(d.items()))

 

#6、循环

for k in d.keys():
print(k)

for k in d:
print(k)#默认循环是直接输出key

print(list(d.keys()))
for v in d.values():
print(v)
print(list(d.values()))
for k,v in d.items():
print(k,v)
print(list(d.items()))

#======================================该类型总结====================================
#存一个值or存多个值

#有序or无序

#可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

#需要掌握的操作
d={‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘,‘hobblies‘:[1,2,3]}
v=d.get(‘namexxxx‘)#不存在key返回值为None不会报错
print(v)

v1=d.get(‘name‘)#返回值为value
print(v1)

update放法
d={‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘,‘hobblies‘:[1,2,3]}
d.update({‘x‘:1,‘name‘:"EGON"})
print(d) #更新d 没有key的添加 有key的修改（更新）

#fromkeys:需求是快速新造出一个字典，value的初始值全都为None，而key是来自于一个列表
keys=[‘name‘,‘age‘,‘sex‘]
d={}.fromkeys(keys,None) #keys是d中的key value都为None
print(d)
相当于下面代码：
keys=[‘name‘,‘age‘,‘sex‘]
d={}
for k in keys:
d[k]=None
print(d)

#setdefault

按照默认的操作形式
d={"x":1,"y":3}
d[‘x‘]=1111
d[‘z‘]=12345
存在就改值 不存在就加值

按照setdefault的形势
d={"x":1,"y":3}
res=d.setdefault(‘x‘:11111)#在key存在的情况下不修改值 会返回原值
print(d)
print(res)

res=d.setdefault(‘z‘,11111)#在key不存在的情况下增加一个新的值 会返回新增的值
print(d)
print(res)

#练习
s=‘hello alex alex say hello sb sb‘
#d={‘hello‘:2,‘alex‘:2,‘say‘:1,‘sb‘:2}

d={}
words=s.split()
print(words)
for word in words:
#d[word]=words.count(word)#d[‘hello‘]=word.count(‘hello‘)#每次重复添加 优化操作 如下代码
d.setdefault(word,words.count(word))


print(d)
#[‘hello‘, ‘alex‘, ‘alex‘, ‘say‘, ‘hello‘, ‘sb‘, ‘sb‘]
#{‘hello‘: 2, ‘alex‘: 2, ‘say‘: 1, ‘sb‘: 2}

 

for word in words:
d[word]=words.count(word)
print(d)

print(words)
d[‘hello‘]=words.count(‘hello‘)
d[‘alex‘]=words.count(‘alex‘)
print(d)

补充元祖符号
t=(1,)
print(t,type(t))
对于元祖 只有一个元素后面必须加上逗号 不加逗号这个()就是包含的意思

name=input(‘>>:‘).strip()
res=‘my name is %s‘ %name
print(res.center(50,‘*‘))

两步并做一步
()的一个用法 他有这包含的 意思
name=input(‘>>:‘).strip()
print((‘my name is %s‘ %name).center(50,‘*‘))