python学习笔记(6)——字典(Dictionary)

dict= {key1 : value1, key2 : value2 ...}

关键词：字典中元素成对出现- key:value

　　　　格式- 两端{ } ，键:值，每对键值间用 ，隔开。

　　　　键key-唯一，且不可变（一般使用str、tuple（元组）、数字）。

　　　　值value-不唯一，可变，多次给key赋值，key只存储最近的一个value。

创建字典：

方法一：传统的文字表达式

>>> dict={'aaa':123,78.9:444,1/3:'ccc'}
>>> dict
{0.3333333333333333: 'ccc', 'aaa': 123, 78.9: 444}

方法二：动态分配键值

>>> d={}
>>> d['name']='python'
>>> d['age']=21
>>> d['gender']='male'
>>> d  #与方法一同，放入顺序与内部存储顺序无关（内部根本没顺序！）
{'name': 'python', 'gender': 'male', 'age': 21}

注：dict内部是无序架构，不能像list那样通过偏移量进行读取或修改，只能通过键来读取或赋值↓

>>> d[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 0
#类似list哪种用list[index]定位的方法，对dict不存在

访问key，获取value的方法有2种

方法1：直接读取key
>>> d={'name':'apple','age':21,'gender':'male'}
>>> d['name']
'apple'

>>> d['bmi'] #不存在的键值，会报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'bmi'


方法2：使用语法d.get(key) 同样可获取键值，且不报错
>>> d.get('name')
'apple'
>>> d.get('bmi')
(对不存在的键值返回none不显示任何值,为了获得反馈，可以加自定义符号以识别)
>>> d.get('bmi',0)
0
>>> d.get('bmi','啥也没有')
'啥也没有'

方法三：用内置函数dict()，内部传入参数格式有几种

1、入参为类似 name='python',age=21 的键值对（注意格式：此处key没有'',且type必须为str，value无任何影响）

>>> d=dict(name='python',age=21,gender='male')
>>> d
{'age': 21, 'gender': 'male', 'name': 'python'}

2、入参为一个元组  （#当入参为元组时，不论内部包含一些列tuple还是list，其数量必须≥2，否则报错；入参为 '键值对'&list时无限制）

　　　      └——元组内部是一系列包含两个值的元组tuple，例如(('name', 'python'), ('age', 21), ...)

>>> d=dict((('name','python'),('age',21),('gender','male')))
>>> d
{'name': 'python', 'gender': 'male', 'age': 21}

#注意，此处有3层(),最外层是dict格式//第二层表示对dict的入参是一个元组//第三层是各自键值对的括号

　　

    　     └——元组内部是一系列包含两个值的list，例如(['name', 'python'], ['age', 21],['gender','male'], ...)

>>> d=dict((['name','python'],['age',21],['gender','male']))
>>> d
{'name': 'python', 'gender': 'male', 'age': 21}

 

3、入参为一个list

　　　　　　└——list内部是一系列包含两个值的元组，例如[('name', 'python'), ('age', 21), ...]

>>> d=dict([('name','python'),('age',21),('gender','male')])
>>> d
{'name': 'python', 'gender': 'male', 'age': 21}

 

　　　　　　 └——list内部是一系列包含两个值的list，例如[['name', 'python'], ['age', 21], ...]

>>> d=dict([['name','python'],['age',21],['gender','male']])
>>> d
{'name': 'python', 'gender': 'male', 'age': 21}

 

方法四：用fromkeys创建字典(第一个值指定一个list/tuple，把其中的元素作为字典的key,第二个值作为所有key的value,生成一个字典)

>>> d=dict.fromkeys(['apple','orange','peach'],500)
>>> d
{'peach': 500, 'apple': 500, 'orange': 500}


>>> d=dict.fromkeys(('apple','orange','peach'),500)
>>> d
{'peach': 500, 'apple': 500, 'orange': 500}

>>> d=dict.fromkeys(['apple','orange',77.8],'hello,world')
>>> d
{'apple': 'hello,world', 'orange': 'hello,world', 77.8: 'hello,world'}
#list &tuple内部元素可以是 数字&str

 方法五：结合zip()方法创建字典

>>> a=['a','b','c','d']
>>> b=[1,2,3,4]
>>> d=dict(zip(a,b))
>>> d
{'c': 3, 'a': 1, 'b': 2, 'd': 4}

zip() 函数

 ①函数功能是聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器。

zip函数：以前理解为聚合多个list，组成以tuple为元素的list。查阅py官方文档才知道:zip是聚合传入的（任何个）迭代器，然后返回以tuple为元素的新迭代器。也就是说：zip入参不仅限list，str、tuple均可（甚至dict也可以做入参，但由于dict本身内部无序，得到的list不可预知）
>>> a=['a','b','c','d']
>>> b=[1,2,3,4]
>>> c=[1,2,3,4,5,6]
>>> zip(a,b)  #py3.0后zip()不返回list形式
<zip object at 0x0000000003B652C8>
>>> list(zip(a,b)) #在python 3.0中zip()是可迭代对象，要显示出所有结果可以用list、tuple等。
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> list(zip(a,c))  #不同元素个数的各入参，以最短为标准
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

# zip函数入参可以是任意类型iterable（list、tuple、str、dict、set...）
>>> a='abcd'
>>> b=(1,2,3,4)
>>> c={'c1':11,'c2':22,'c3':33} 　　#dict做聚合入参，只抓取它的key
>>> list(zip(a,b,c))   #str、typle、dict杂烩聚合，由于dict的无序性，本以为list结果无预知，谁想dict老老实实按自然序列提供key。
[('a', 1, 'c1'), ('b', 2, 'c2'), ('c', 3, 'c3')]

>>> a='abcd'　　# zip函数入参可以是任意数量、任何元素个数的iterable
>>> b=[1,2,3]
>>> c=('你','好','啊','妹','子')
>>> d={'约','吗'}
>>> list(zip(a,b,c,d))
[('a', 1, '你', '吗'), ('b', 2, '好', '约')]

>>> l1,l2,l3=[1,2,3],(4,5,6),'789'  　　#熟悉下这种写法
>>> list(zip(l1,l2,l3))
[(1, 4, '7'), (2, 5, '8'), (3, 6, '9')]

>>> a=[1,2,3]  
>>> list(zip(a))  #zip内只有一个参数
[(1,), (2,), (3,)]  #还记得tuple的陷阱吗？只有一个元素的tuple必须写成(1,)

>>> a=[]　　#无参数
>>> list(zip(a))
[]

#zip(*[iter(s)]*n)等效于调用zip(iter(s),iter(s),...,iter(s))
>>> x=[1,2,3]
>>> list(zip(*[x]*3))
[(1, 1, 1), (2, 2, 2), (3, 3, 3)]

#zip()方法用在for循环中，就会支持并行迭代：
l1=[1,2,3]
l2=[4,5,6]
for (x,y) in zip(l1,l2):
　　print(x,y,'________',x*y)

1 4 ________ 4
2 5 ________ 10
3 6 ________ 18

 关于字典的一些操作：

1、clear(清空字典内容，保留字典)

>>> d={'num1':'java','num2':'python','num3':'c'}
>>> d.clear()   #clear没有返回，需要自己验证
>>> d
{}

>>> d=dict(name='python',age=21,gender='male')
>>> f=d
>>> d.clear()
>>> d
{}
>>> f 　　#d.clear()除了删除本身字典内容，还会删除引用字典的内容。
{}

## “del” 函数是python通用，不是dict/list内置
#del dict 删除整个字典（内容和框架）
>>> d={'num1':'java','num2':'python','num3':'c'}
>>> del d
>>> d
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'd' is not defined

#关于del与引用的猜测
>>> d={'num1':'java','num2':'python','num3':'c'}
>>> id(d)
62278600
>>> f=d
>>> f
{'num1': 'java', 'num2': 'python', 'num3': 'c'}
>>> id(f)
62278600
>>> del d
>>> d
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'd' is not defined
>>> id(d)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'd' is not defined
>>> f
{'num1': 'java', 'num2': 'python', 'num3': 'c'}
>>> id(f)
62278600

2、copy（拷贝字典）

>>> d={'num1':'java','num2':'python','num3':'c'}
>>> d1=d.copy()
>>> d1
{'num1': 'java', 'num3': 'c', 'num2': 'python'}

3、items(返回由“键值对组成元素“的列表)

>>> d={'num1':'java','num2':'python','num3':'c'}
>>> d.items()
dict_items([('num1', 'java'), ('num3', 'c'), ('num2', 'python')])

4、keys(获取字典所有的key)，values同

>>> d={'num1':'java','num2':'python','num3':'c'}
>>> d.keys()
dict_keys(['num1', 'num3', 'num2'])
>>> d.values()
dict_values(['python', 'c', 'java'])

5、pop(获取指定key的value，并在字典中删除)

>>> d={'num1':'java','num2':'python','num3':'c'}
>>> d.pop('num1')  #此函数操作后首先返回待删除key的value,然后一并删除键值对
'java'
>>> d
{'num3': 'c', 'num2': 'python'}

## “del” 函数是python通用，不是dict/list内置
#del dict[]：通过key，删除某键值对（也可以通过索引删除list内元素）
>>> d={'num1':'java','num2':'python','num3':'c'}
>>> del d['num2']
>>> d
{'num3': 'c', 'num1': 'java'}

>>> d={'num1':'java','num2':'python','num3':'c'}
>>> del d['num1'],d['num2']　　#一次删除多个键值对
>>> d
{'num3': 'c'}

6、popitem(随机获取某个键值对，并在字典中删除)

>>> d={'num1':'java','num2':'python','num3':'c'}
>>> d.popitem()
('num1', 'java')
>>> d
{'num3': 'c', 'num2': 'python'}

7、setdefault(获取指定key的value，如果key不存在，则创建)

d={'num1':'java','num2':'python','num3':'c'}
>>> d.setdefault('num1') #获取num1的value
'java'
>>> d.setdefault('num5') #获取num5的value，但不存在key=num5,于是创建之，且value=none
>>> d
{'num1': 'java', 'num3': 'c', 'num2': 'python', 'num5': None}  #如何一并创建key:value呢，看下面

8、update(添加 键:值对到字典)

>>> d={'num1':'java','num2':'python','num3':'c'}
>>> d.update({'num4':'javascript'})
>>> d
{'num4': 'javascript', 'num1': 'java', 'num3': 'c', 'num2': 'python'}

#一次添加多个key:value
>>> d.update({'num5':'css','num6':'html5'})
>>> d
{'num4': 'javascript', 'num1': 'java', 'num5': 'css', 'num2': 'python', 'num6': 'html5', 'num3': 'c'}

 9、遍历字典的key、value、项

d={'num1':'java','num2':'python','num3':'c'}
for k in d.keys():  #遍历字典的key  #实质利用d.keys()函数将key输出为一个list
    print(k)
num1
num2
num3

for v in d.values():  #遍历字典的values
    print(v)
java
python
c

for i in d.items():  #遍历字典的项 (函数iteritems()在py3.0取消) ,将 键值对组成一个元组输出
    print(i)
('num1', 'java')
('num2', 'python')
('num3', 'c')

for （k,v） in d.items(): #遍历字典的key-value  #（k,v）=k,v
 print(k,v)
num1 java
num3 c
num2 python

10、dict(dict1, **dict2)合并两个字典

>>> d1={'a':1,'b':2,'c':3}
>>> d2={'c':4,'d':5,'e':6}
>>> dict(d1,**d2)
{'b': 2, 'a': 1, 'c': 4, 'd': 5, 'e': 6}

11、判断元素是否属于dict

> d={'a':1,'b':2,'c':3}
>>> 'a' in d
True
>>> 'e' in d
False
#in是一个布尔操作符，他测试左边的操作数是否包含于列表或字符串或...  # x in x也不是list/dict内置函数，py通用，多见于if语句
name=['water','life','peoper']
if 'water' in name:
 print('yes')
else:
 print('no')