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.0zip()是可迭代对象,要显示出所有结果可以用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) >>> f=d
>>> f
{'num1': 'java', 'num2': 'python', 'num3': 'c'}
>>> id(f) >>> 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)

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

  

python学习笔记(6)——字典(Dictionary)的更多相关文章

  1. python学习笔记整理——字典

    python学习笔记整理 数据结构--字典 无序的 {键:值} 对集合 用于查询的方法 len(d) Return the number of items in the dictionary d. 返 ...

  2. python学习笔记七——字典

    4.3 字典结构 字典是Python中重要的数据类型,字典的由“键-值”对组成的集合,字典中的“值”通过“键”来引用. 4.3.1 字典的创建 字典由一系列的“键-值”(key-value)对组成,“ ...

  3. Python学习笔记之字典

    一.创建和使用字典 1.创建字典 phonebook={'Alice':'2341','Beth':'9102','Cecil':'3258'} 2.dict,通过映射创建字典 >>> ...

  4. 【Python学习笔记】字典操作

    字典dict是Python中唯一内置的映射类型,由键值对组成,字典是无序的.字典的键必须是不变对象,如字符串.数字.元组等,而包含可变对象的列表.字典和元组则不能作为键.这里可变和不可变的意思是指这个 ...

  5. Python学习笔记四--字典与集合

    字典是Python中唯一的映射类型.所谓映射即指该数据类型包含哈希值(key)和与之对应的值(value)的序列.字典是可变类型.字典中的数据是无序排列的. 4.1.1字典的创建及赋值 dict1={ ...

  6. python学习笔记八——字典的方法

    4.3.3 字典的方法 字典的常用方法可以极大地提高编程效率.keys()和values()分别返回字典的key列表和value列表.例: dict={"a":"appl ...

  7. python学习笔记(字典乱码)

    博主总结下 python中字典中包含中文时,使用过程中出现乱码 json.dumps(params, encoding="UTF-8", ensure_ascii=False) p ...

  8. Python学习笔记3(字典)

    创建字典 dict函数 字典的格式化字符串 字典方法 clear copy fromkeys 序列是一个按照一定顺序将值进行组织的数据结构形式,可以通过索引对其进行征引.另外还有一种数据结构是通过名字 ...

  9. python学习笔记(三)---字典

    字典 在Python中,字典 字典 是一系列键 键-值对 值对 .每个键 键 都与一个值相关联,你可以使用键来访问与之相关联的值.与键相关联的值可以是数字.字符串.列表乃至字典.事实上,可将 任何Py ...

随机推荐

  1. day4-hdfs的核心工作原理\写数据流程 \读数据流程

    namenode元数据管理要点 1.什么是元数据? hdfs的目录结构及每一个文件的块信息(块的id,块的副本数量,块的存放位置<datanode>) 2.元数据由谁负责管理? namen ...

  2. Unity3D 玻璃 Shader

     Shader "Custom/Glass" { // Upgrade NOTE: replaced 'SeperateSpecular' with 'SeparateSpec ...

  3. 解决fragmentTransaction.replace不能全屏

    今天遇到个问题,使用fragmentTransaction.replace替换后的内容不能全屏.. FragmentManager fragmentManager = getSupportFragme ...

  4. yarn-cli 添加

    添加依赖包 当你想使用另一个包时,你要先把它添加到依赖列表中.也就是执行 yarn add [package-name] 命令将它安装到你的项目中. 这也将同时更新你的 package.json 和  ...

  5. Tomcat 隐藏Server Name

    隐藏Http请求中的Header ServerName 方法一 在tomcat/lib/tomcat-coyote.jar中 下面两个文件 org/apache/coyote/http11/Const ...

  6. web 开发之js---js 实现文本高亮

    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html> <head ...

  7. POJ 1625 Censored! (AC自己主动机 + 高精度 + DP)

    题目链接:Censored! 解析:AC自己主动机 + 高精度 + 简单DP. 字符有可能会超过128.用map映射一下就可以. 中间的数太大.得上高精度. 用矩阵高速幂会超时,简单的DP就能解决时间 ...

  8. 关于clojurescript+phantomjs+react的一些探索

    这两天需要使用phantomjs+react生成些图片 React->Clojurescript: 最开始发现clojurescript中包裹react的还挺多: https://github. ...

  9. 上百例Silverlight网站及演示汇总,供友参考

    毁灭2012 博客园 首页 新闻 新随笔 联系 管理 订阅 随笔- 125  文章- 0  评论- 446  上百例Silverlight网站及演示汇总,供友参考   今天我将发现的Silverlig ...

  10. [Codeforces Round511C] Enlarge GCD

    [题目链接] https://codeforces.com/contest/1047/problem/C [算法] 首先求出n个数的最大公约数g , 将每个数除以g , 那么 , 问题就转化为在n个数 ...