python之字典的基本概念（Python字典的定义）

发布时间：2022-11-16

本文目录一览：

  1. Python初学（十九）
  2. python字典的特点和用处
  3. python字典操作函数
  4. python里面的字典有什么用？

Python初学（十九）

“键值对”是组织数据的一种重要方式，广泛应用在Web系统中。键值对的基本思想是将“值”信息关联一个“键”信息，进而通过键信息查找对应值信息，这个过程叫映射。Python语言中通过字典类型实现映射。 Python语言中的字典使用大括号{}建立，每个元素是一个键值对，使用方式如下:

{键1:值1, 键2:值2, ... , 键n:值n}

其中，键和值通过冒号连接，不同键值对通过逗号隔开。字典类型也具有和集合类似的性质，即键值对之间没有顺序且不能重复。 列表类型采用元素顺序的位置进行索引。由于字典元素“键值对”中键是值的索引，因此，可以直接利用键值对关系索引元素。 字典中键值对的索引模式如下，采用中括号格式:

值 = 字典变量[键]

print(d['201801'])

输出的也就是: 小明 使用大括号可以创建字典。通过索引和赋值配合，可以向字典中增加元素。 字典是存储可变数量键值对的数据结构，键和值可以是任意数据类型，通过键索引值，并可以通过键修改值。 字典类型有一些通用的操作函数

  • dict()函数用于生成一个空字典，作用和{}一致 字典类型存在一些操作方法，使用语法形式是:
字典变量.方法名称(方法参数)
  • d.keys()返回字典中的所有键信息，返回结果是Python的一种内部数据类型dict_keys，专用于表示字典的键。如果希望更好的使用返回结果，可以将其转换为列表类型。
  • d.values()返回字典中的所有值信息，返回结果是Python的一种内部数据类型dict_values。如果希望更好的使用返回结果，可以将其转换为列表类型。
  • d.items()返回字典中的所有键值对信息，返回结果是Python的一种内部数据类型dict_items。当然也可以转成列表类型，即: list(d.items())
  • d.get(key, default)根据键信息查找并返回值信息，如果key存在则返回相应值，否则返回默认值，第二个元素default可以省略，如果省略则默认值为空。例如: 就拿上边的数组d 来说 d.get('201801',“不存在”) 相当于一个if语句，如果key 201801 存在，就返回201801 values，不存在就返回默认值“不存在”
  • d.pop(key, default)根据键信息查找并取出值信息，如果key存在则返回相应值，否则返回默认值，第二个元素default可以省略，如果省略则默认值为空。相比d.get()方法，d.pop()在取出相应值后，将从字典中删除对应的键值对。和d.get方法类似
  • d.popitem()随机从字典中取出一个键值对，以元组(key,value)形式返回。取出后从字典中删除这个键值对。
  • d.clear()删除字典中所有键值对。
  • 此外，如果希望删除字典中某一个元素，可以使用Python保留字del。即: del d[key]
  • 字典类型也支持保留字in，用来判断一个键是否在字典中。如果在则返回True，否则返回False。
  • 与其他组合类型一样，字典可以遍历循环对其元素进行遍历，基本语法结构如下:
for 变量名 in 字典名
    语句块

for循环返回的变量名是字典的索引值。如果需要获得键对应的值，可以在语句块中通过get()方法获得。 以上就是本章的所有内容,感谢大家. Python 学习的基础（持续更新中......）

python字典的特点和用处

字典的特点：

  • 字典的每个健值的展现方式是：key:value用冒号分割；键值之间为逗号分割；整个字典用大括号{}将键值括起来；
  • 键值可以是任意类型的对象；
  • 键必须是唯一的；
  • 键是不可变的；

字典的作用:

字典（日常生活中的字典和Python字典）旨在让你能够轻松地找到特定的单词（键），以获悉其定义（值）。 在很多情况下，使用字典都比使用列表更合适。下面是Python字典的一些用途：

  • 表示棋盘的状态，其中每个键都是由坐标组成的元组；
  • 存储文件修改时间，其中的键为文件名；
  • 数字电话/地址簿。

python字典操作函数

字典是一种通过名字或者关键字引用的数据结构，其键可以是数字、字符串、元组，这种结构类型也称之为映射。字典类型是Python中唯一内建的映射类型，基本的操作包括如下：

  1. len()：返回字典中键—值对的数量；
  2. d[k]:返回关键字对应的值；
  3. d[k]=v:将值关联到键值k上；
  4. del d[k]:删除键值为k的项；
  5. key in d:键值key是否在d中，是返回True，否则返回False。
  6. clear函数：清除字典中的所有项
  7. copy函数：返回一个具有相同键值的新字典；deepcopy()函数使用深复制，复制其包含所有的值，这个方法可以解决由于副本修改而使原始字典也变化的问题
  8. fromkeys函数：使用给定的键建立新的字典，键默认对应的值为None
  9. get函数：访问字典成员
  10. has_key函数：检查字典中是否含有给出的键
  11. items和iteritems函数: items将所有的字典项以列表方式返回，列表中项来自（键，值），iteritems与items作用相似，但是返回的是一个迭代器对象而不是列表
  12. keys和iterkeys：keys将字典中的键以列表形式返回，iterkeys返回键的迭代器
  13. pop函数：删除字典中对应的键
  14. popitem函数：移出字典中的项
  15. setdefault函数：类似于get方法，获取与给定键相关联的值，也可以在字典中不包含给定键的情况下设定相应的键值
  16. update函数：用一个字典更新另外一个字典
  17. values和itervalues函数：values以列表的形式返回字典中的值，itervalues返回值的迭代器，由于在字典中值不是唯一的，所以列表中可以包含重复的元素

一、字典的创建

1.1 直接创建字典

d={'one':1,'two':2,'three':3}
print(d)
print(d['two'])
print(d['three'])

运算结果：

{'three':3,'two':2,'one':1}

1.2 通过dict创建字典

items=[('one',1),('two',2),('three',3),('four',4)]
print('items中的内容:')
print(items)
print('利用dict创建字典，输出字典内容:')
d=dict(items)
print(d)
print('查询字典中的内容:')
print(d['one'])
print(d['three'])

运算结果：

items中的内容:
[('one',1), ('two',2), ('three',3), ('four',4)]
利用dict创建字典，输出字典内容:
{'four':4,'three':3,'two':2,'one':1}
查询字典中的内容:

或者通过关键字创建字典

d=dict(one=1,two=2,three=3)
print('输出字典内容:')
print(d)
print('查询字典中的内容:')
print(d['one'])
print(d['three'])

运算结果：

输出字典内容:
{'three':3,'two':2,'one':1}
查询字典中的内容:

二、字典的格式化字符串

d={'one':1,'two':2,'three':3,'four':4}
print(d)
print("three is %(three)s."%d)

运算结果：

{'four':4,'three':3,'two':2,'one':1}
three is 3.

三、字典方法

3.1 clear函数：清除字典中的所有项

d={'one':1,'two':2,'three':3,'four':4}
print(d)
d.clear()
print(d)

运算结果：

{'four':4,'three':3,'two':2,'one':1}
{}

请看下面两个例子

3.1.1
d={}
dd=d
d['one']=1
d['two']=2
print(dd)
d={}
print(d)
print(dd)

运算结果：

{'two':2,'one':1}
{}
{'two':2,'one':1}
3.1.2
d={}
dd=d
d['one']=1
d['two']=2
print(dd)
d.clear()
print(d)
print(dd)

运算结果：

{'two':2,'one':1}
{}
{}

3.1.2与3.1.1唯一不同的是在对字典d的清空处理上，3.1.1将d关联到一个新的空字典上，这种方式对字典dd是没有影响的，所以在字典d被置空后，字典dd里面的值仍旧没有变化。但是在3.1.2中clear方法清空字典d中的内容，clear是一个原地操作的方法，使得d中的内容全部被置空，这样dd所指向的空间也被置空。

3.2 copy函数：返回一个具有相同键值的新字典

x={'one':1,'two':2,'three':3,'test':['a','b','c']}
print('初始X字典：')
print(x)
print('X复制到Y：')
y=x.copy()
print('Y字典：')
print(y)
y['three']=33
print('修改Y中的值，观察输出：')
print(y)
print(x)
print('删除Y中的值，观察输出')
y['test'].remove('c')
print(y)
print(x)

运算结果：

初始X字典：
{'test': ['a','b','c'],'three':3,'two':2,'one':1}
X复制到Y：
Y字典：
{'test': ['a','b','c'],'one':1,'three':3,'two':2}
修改Y中的值，观察输出：
{'test': ['a','b','c'],'one':1,'three':33,'two':2}
{'test': ['a','b','c'],'three':3,'two':2,'one':1}
删除Y中的值，观察输出
{'test': ['a','b'],'one':1,'three':33,'two':2}
{'test': ['a','b'],'three':3,'two':2,'one':1}

注：在复制的副本中对值进行替换后，对原来的字典不产生影响，但是如果修改了副本，原始的字典也会被修改。deepcopy函数使用深复制，复制其包含所有的值，这个方法可以解决由于副本修改而使原始字典也变化的问题。

from copy import deepcopy
x={}
x['test']=['a','b','c','d']
y=x.copy()
z=deepcopy(x)
print('输出：')
print(y)
print(z)
print('修改后输出：')
x['test'].append('e')
print(y)
print(z)

运算输出：

输出：
{'test': ['a','b','c','d']}
{'test': ['a','b','c','d']}
修改后输出：
{'test': ['a','b','c','d','e']}
{'test': ['a','b','c','d']}

3.3 fromkeys函数：使用给定的键建立新的字典，键默认对应的值为None

d=dict.fromkeys(['one','two','three'])
print(d)

运算输出：

{'three':None,'two':None,'one':None}

或者指定默认的对应值

d=dict.fromkeys(['one','two','three'],'unknow')
print(d)

运算结果：

{'three':'unknow','two':'unknow','one':'unknow'}

3.4 get函数：访问字典成员

d={'one':1,'two':2,'three':3}
print(d)
print(d.get('one'))
print(d.get('four'))

运算结果：

{'three':3,'two':2,'one':1}
1
None

注：get函数可以访问字典中不存在的键，当该键不存在时返回None

3.5 has_key函数：检查字典中是否含有给出的键

d={'one':1,'two':2,'three':3}
print(d)
print(d.has_key('one'))
print(d.has_key('four'))

运算结果：

{'three':3,'two':2,'one':1}
True
False

3.6 items和iteritems函数: items将所有的字典项以列表方式返回，列表中项来自（键，值），iteritems与items作用相似，但是返回的是一个迭代器对象而不是列表

d={'one':1,'two':2,'three':3}
print(d)
list=d.items()
for key, value in list:
    print(key,':',value)

运算结果：

{'three':3,'two':2,'one':1}
three :3
two :2
one :1

d={'one':1,'two':2,'three':3}
print(d)
it=d.iteritems()
for k, v in it:
    print("d[%s]="%k,v)

运算结果：

{'three':3,'two':2,'one':1}
d[three]=3
d[two]=2
d[one]=1

3.7 keys和iterkeys：keys将字典中的键以列表形式返回，iterkeys返回键的迭代器

d={'one':1,'two':2,'three':3}
print(d)
print('keys方法：')
list=d.keys()
print(list)
print('\niterkeys方法：')
it=d.iterkeys()
for x in it:
    print(x)

运算结果：

{'three':3,'two':2,'one':1}
keys方法：
['three','two','one']
iterkeys方法：
three
two
one

3.8 pop函数：删除字典中对应的键

d={'one':1,'two':2,'three':3}
print(d)
d.pop('one')
print(d)

运算结果：

{'three':3,'two':2,'one':1}
{'three':3,'two':2}

3.9 popitem函数：移出字典中的项

d={'one':1,'two':2,'three':3}
print(d)
d.popitem()
print(d)

运算结果：

{'three':3,'two':2,'one':1}
{'two':2,'one':1}

3.10 setdefault函数：类似于get方法，获取与给定键相关联的值，也可以在字典中不包含给定键的情况下设定相应的键值

d={'one':1,'two':2,'three':3}
print(d)
print(d.setdefault('one',1))
print(d.setdefault('four',4))
print(d)

运算结果：

{'three':3,'two':2,'one':1}
1
4
{'four':4,'three':3,'two':2,'one':1}

3.11 update函数：用一个字典更新另外一个字典

d={
    'one':123,
    'two':2,
    'three':3
}
print(d)
x={'one':1}
d.update(x)
print(d)

运算结果：

{'three':3,'two':2,'one':123}
{'three':3,'two':2,'one':1}

3.12 values和itervalues函数：values以列表的形式返回字典中的值，itervalues返回值的迭代器，由于在字典中值不是唯一的，所以列表中可以包含重复的元素

d={
    'one':123,
    'two':2,
    'three':3,
    'test':2
}
print(d.values())

运算结果：

[2,3,2,123]

python里面的字典有什么用？

字典是另一种可变容器模型，可存储任意类型对象。 字典的每个键值 key-value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中，格式如下所示：

d = {key1 : value1, key2 : value2 }

键一般是唯一的，必须是不可变的，如字符串，数字或元组。值不需要唯一，可以取任何数据类型。 在需要使用hash时，就需要用到字典。 比如在统计字符个数时，可以使用字典。

d = {}
for char in strs:
    d[char] = d.get(char, 0) + 1
推荐文章