1.字典

1.1.认识字典

1.2.访问字典中的值

1.3.字典的增删改查

1.3.1.增加

1.3.2.删除

1.3.3.修改

1.3.4.查找

1.4.由类似对象组成的字典

1.5.遍历字典

1.5.1.遍历所有的键-值对

1.5.2.遍历字典中的所有键

1.5.3.按顺序遍历字典中所有的键

1.5.4.遍历字典中所有的值

1.6.字典的嵌套使用

1.6.1.列表中存储字典

1.6.2.字典中存储列表

1.6.3.在字典中存储字典

2.集合

2.1.集合的概念

2.2 集合的性质

2.3 集合的创建

2.4 集合的基本操作

1.字典

1.1.认识字典

字典在python中，是可以让数据更加清晰的数据容器，用“{}”表示，里面的元素以键值对的方式存储，例如：

#创建一个外星人游戏，这些外星人的颜色和点数各不相同
#这是一个简单的字典，存储了有关特定外星人的信息
alien_0={'color':'green','points':5}
print(alien_0)
#使用两条print语句来访问并打印这些信息
print(alien_0['color'])
print(alien_0['points'])>>>{'color': 'green', 'points': 5}
green
5

在字典中，字典的键有两个要求：

①字典的键必须是不可变数据类型
不可变数据类型包括：数字、字符串、元组、布尔值。
可变数据类型：字典，列表

例如以下方式，都可以创建字典：

dict1={1:'小明'}
dict2={'name':'小明'}
dict3={(1,2):'小明'}
dict4={False:'小明'}
print(dict1,dict2,dict3,dict4)>>>{1: '小明'} {'name': '小明'} {(1, 2): '小明'} {False: '小明'}

②字典的键不允许重复
如果字典里面的键重复了，后面键的值会覆盖前面键的值：

dict1 = {'name':'小蓝','name':'小绿'}
print(dict1)>>>{'name': '小绿'}

字典里面的值可以是任意数据类型，可以是数字、字符串、元组、布尔值，也可以是列表，甚至字典。

dict1 = {'age':1}  #数字
dict2 = {'name':'小明'} #字符串
dict3 = {'data':(1,2)}  #元组
dict4 = {'result':False} #布尔值
dict5 = {'name':['小明','小红']} #列表
dict6 = {'小明':{'age':21,'sex':'男'}} #字典
print(dict1)
print(dict2)
print(dict3)
print(dict4)
print(dict5)
print(dict6)>>>{'age': 1}
{'name': '小明'}
{'data': (1, 2)}
{'result': False}
{'name': ['小明', '小红']}
{'小明': {'age': 21, 'sex': '男'}}

1.2.访问字典中的值

要获取与键相关的值，可依次指定字典名和放在方括号里的键：

dict1 = {'color':'green','piece':56,'size':'superbig'}
print(dict1['color'])   #这将返回dict1中与键'color'相关联的值
print(dict1['piece'])   #这将返回dict1中与键'piece'相关联的值
print(dict1['size'])   #这将返回dict1中与键'size'相关联的值>>>green
56
superbig

1.3.字典的增删改查

字典是一种可变的数据容器，所以具有增删改查的功能。

字典中元素是无顺序排列的
只能通过key来获取value

1.3.1.增加

字典是一种动态结构，在字典中，通过使用"[key]"的形式，并且给它赋值。如果这个key当前不包含在字典中，那么就会把这个key以及value同时加入到字典中。

alien_0={'color':'green','points':5}
print(alien_0)
#现在给外星人添加坐标
alien_0['x_position']=0
alien_0['y_position']=5
print(alien_0)>>>{'color': 'green', 'points': 5}
{'color': 'green', 'points': 5, 'x_position': 0, 'y_position': 5}
{'color': 'green', 'points': 5, 'y_position': 5, 'x_position': 0}
#Python不关心键值对的添加顺序，只关心键和值的关联关系。

先创建一个空字典，有时候我们为了方便，会先创建一个空字典，然后往里面添加元素：

alien_0={}
print(alien_0)
#现在给外星人添加坐标
alien_0['y_position']=5
alien_0['x_position']=0print(alien_0)>>>{}
{'y_position': 5, 'x_position': 0}

1.3.2.删除

a.在字典中，我们可以使用pop()从字典中移除某个元素

alien_0={}
print(alien_0)
#现在给外星人添加坐标
alien_0['y_position']=5
alien_0['x_position']=0
print(alien_0.pop('y_position'))
print(alien_0)>>>{}
5
{'x_position': 0}

b.也可以使用del删除字典里面的元素：

alien_0={}
print(alien_0)
#现在给外星人添加坐标
alien_0['y_position']=5
alien_0['x_position']=0
del alien_0['x_position']
print(alien_0)>>>{}
{'y_position': 5}

c.也可以使用clear清除字典里面所有的元素：

alien_0={}
print(alien_0)
#现在给外星人添加坐标
alien_0['y_position']=5
alien_0['x_position']=0
print(alien_0)
alien_0.clear() #删除全部元素
print(alien_0)>>>{}
{'y_position': 5, 'x_position': 0}
{}

1.3.3.修改

在字典中，通过对字典中的键重新赋值，可以修改元素

alien_0={'y_position': 5, 'x_position': 0}
print(alien_0)
alien_0['y_position']=35 #修改y_position的值
print(alien_0)>>>{'y_position': 5, 'x_position': 0}
{'y_position': 35, 'x_position': 0}

1.3.4.查找

a.在字典中，可以通过[key]的方式查询字典中的元素：

alien_0={'x_position': 5, 'y_position': 0}
result=alien_0['x_position']
print(result)>>>5

b.使用get方法也能查找

alien_0={'x_position': 5, 'y_position': 0}
print(alien_0.get('x_position')) #使用get方法
print(alien_0['x_position']) #直接获取
#那么这两种方法的区别在哪儿
#当查找的键值不存在时
print(alien_0.get('color')) #返回值是None
print(alien_0['color'])   #会报错>>>5
5
None
KeyError: 'color'

1.4.由类似对象组成的字典

在前面的示例中，字典存储的都是一个对象的多种信息，但我们可以用字典来存储众多对象的同一种信息。

例如，你要调查很多人，询问他们最喜欢的编程语言：

这是示例还演示了如何将较长的print语句分成多行，以及字典分行定义，看起来格式更好

favorite_language={'jen':'C','sarah':'Python','edward':'Ruby','phil':'Python'
}
print(favorite_language)
#获取sarah最喜欢的语言
print('sarah最喜欢的语言是：'+favorite_language.get('sarah').lower())>>>{'jen': 'C', 'sarah': 'Python', 'edward': 'Ruby', 'phil': 'Python'}
sarah最喜欢的语言是：python

1.5.遍历字典

1.5.1.遍历所有的键-值对

字典本身提供了一个items()帮助我们遍历字典中的键值对：

items()返回一个键值对列表，接着使用for循环依次将每个键值对存储到指定的两个变量中：

(无序的字典，遍历返回顺序和存储顺序可能是不一样的)

user_0={'username':'username','age':25,'sex':'男'
}
print(user_0.items())
print(user_0.keys())
print(user_0.values())
#使用for循环遍历所有键值对
for key,value in user_0.items():print(key,value)>>>dict_items([('username', 'username'), ('age', 25), ('sex', '男')])
dict_keys(['username', 'age', 'sex'])
dict_values(['username', 25, '男'])
username username
age 25
sex 男

favorite_language={'jen':'C','sarah':'Python','edward':'Ruby','phil':'Python'
}
#使用for循环遍历所有键值对
#打印出每个人喜欢的语言
for key,value in favorite_language.items():print(key.title()+'最喜欢的语言是：'+value)>>>Jen最喜欢的语言是：C
Sarah最喜欢的语言是：Python
Edward最喜欢的语言是：Ruby
Phil最喜欢的语言是：Python

user_0={'username':'UZI','age':23,'job':'loler'
}
for key in user_0:print(key)#print(user_0[key])print(user_0.get(key))>>>username
UZI
age
23
job
loler

1.5.2.遍历字典中的所有键

字典本身提供了一个keys()帮助我们遍历字典中的键：

favorite_language={'jen':'C','sarah':'Python','edward':'Ruby','phil':'Python'
}
#使用for循环遍历所有键值对
#打印出每个人喜欢的语言
for key in favorite_language.keys():print('被调查者的名字是'+key.title())>>>被调查者的名字是Jen
被调查者的名字是Sarah
被调查者的名字是Edward
被调查者的名字是Phil

遍历字典时，会默认遍历所有的键，因此将上述代码中 for key in favorite_language.keys() 改成 for name in favorite_language，输出将不变，但使用keys()方法更容易理解一些，你可以选择这样做，也可以选择不这样做。

favorite_language={'jen':'C','sarah':'Python','edward':'Ruby','phil':'Python'
}
#使用for循环遍历所有键值对
#打印出每个人喜欢的语言
for key in favorite_language:print('被调查者的名字是'+key.title())>>>被调查者的名字是Jen
被调查者的名字是Sarah
被调查者的名字是Edward
被调查者的名字是Phil

favorite_language={'jen':'C','sarah':'Python','edward':'Ruby','phil':'Python'
}
friends=['jen','sarah']
#使用for循环遍历所有键值对
#打印出每个人喜欢的语言
for key in favorite_language.keys():print(key.title())#在这种循环方式里，可以使用当前键来访问与之相关联的值if key in friends:print(key+'是我的朋友')>>>Jen
jen是我的朋友
Sarah
sarah是我的朋友
Edward
Phil

你还可以使用keys()确认某人是否接受了调查

favorite_language={'jen':'C','sarah':'Python','edward':'Ruby','phil':'Python'
}
if 'erin' not in favorite_language.keys():print('erin没有接受调查')
else:print('erin接受了调查')>>>erin没有接受调查

所以，方法keys()并非只能用于遍历，实际上，它返回一个列表，其中包含字典的所有键

1.5.3.按顺序遍历字典中所有的键

字典总是明确的记录键与值之间的关联关系，但获取字典的元素时，获取顺序是不可预测的，我们可以使用sortde()来获得特定顺序排列的键。

favorite_language={'jen':'C','sarah':'Python','edward':'Ruby','phil':'Python'
}
for key in sorted(favorite_language.keys()):print(key)>>>edward
jen
phil
sarah

1.5.4.遍历字典中所有的值

字典本身提供了一个values()帮助我们遍历字典中的值：（它返回一个值列表，而不包含任何键）

favorite_language={'jen':'C','sarah':'Python','edward':'Ruby','phil':'Python'
}
#获取所有最喜欢的语言
for value in sorted(favorite_language.values()):print(value)>>>C
Python
Python
Ruby

这种方法提取字典中所有的值，而没有考虑是否重复，涉及的值很少时，这也许不是问题，但是如果被调查者很多，最终的列表可能包含大量的重复项，为剔除重复项，可使用集合set()，集合类似于列表，但每个元素必须是独一无二的：

favorite_language={'jen':'C','sarah':'Python','edward':'Ruby','phil':'Python'
}
#调用set()
#可以让Python找出列表中独一无二的元素，并使用这些元素来创建一个集合
for value in sorted(set(favorite_language.values())):print(value)>>>C
Python
Ruby

1.6.字典的嵌套使用

1.6.1.列表中存储字典

将字典放入列表中：

alien_0={'color':'green','points':5}
alien_1={'color':'yellow','points':10}
alien_2={'color':'red','points':15}
#我们将三个字典都放到一个名为alien的列表中
aliens=[alien_0,alien_1,alien_2]
for alien in aliens:print(alien)>>>{'color': 'green', 'points': 5}
{'color': 'yellow', 'points': 10}
{'color': 'red', 'points': 15}

我们使用range()代码自动生成30个外星人

#创建一个空列表用于存储外星人
aliens=[]
#创建30个绿色外星人
for i in range(30):aliensi={'color':'green','points':5,'speed':'slow'}aliens.append(aliensi)
#显示前五个外星人
for alien in aliens[0:5]:print(alien)
print('...')
#显示创建了多少个外星人
print(len(aliens))>>>{'color': 'green', 'points': 5, 'speed': 'slow'}
{'color': 'green', 'points': 5, 'speed': 'slow'}
{'color': 'green', 'points': 5, 'speed': 'slow'}
{'color': 'green', 'points': 5, 'speed': 'slow'}
{'color': 'green', 'points': 5, 'speed': 'slow'}
...
30

我们可以发现，当我们使用列表存储字典时，可以进行统计，每个外星人都时独立的，让我们可以独立的修改每个外星人，而且很方便的创建了30个字典。

经常需要在列表中包含大量的字典，例如你可能需要为网站的每个用户创建一个字典，并将这些字典储存在一个名为users的列表中。

user_1={'name':'小明','age':18,'sex':'男'
}
user_2={'name':'小红','age':16,'sex':'女'
}
users=[user_1,user_2]
#打印用户数量
print(len(users))
#打印每个用户的详细信息
for user in users:print(user['name'])for key,value in user.items():if key != 'name':print(key,value)>>>2
小明
age 18
sex 男
小红
age 16
sex 女

1.6.2.字典中存储列表

有时候，需要将列表存储在字典中。

例如，询问每个人最喜欢的两种编程语言：

favorite_languages={'jen':['c','python'],'able':['ruby','java'],'july':['python','php'],'tom':['.net','c#']
}
languages=[]
#遍历每个人最喜欢的语言
for key,value in favorite_languages.items():print(key.title())for v in value:print(v.upper())
#使用format()方法格式化打印分割线
#30是格式化之后的宽度，{:}是固定格式，=用于设置填充字符，<^>设置格式是左对齐、居中、右对齐
print('{:=^30}'.format('这是一条分割线'))
#去重打印出所有被喜欢的语言
for value in favorite_languages.values():languages.extend(value)
for language in set(languages):print(language)>>>Jen
C
PYTHON
Able
RUBY
JAVA
July
PYTHON
PHP
Tom
.NET
C#
===========这是一条分割线============
.net
ruby
python
java
c#
c
php

1.6.3.在字典中存储字典

有时候我们需要在字典中嵌套字典，例如，网站用户，每个都有姓名和独特的用户名、密码：

users={'小明':{'username':'xiaoming','passward':'123456',},'小红':{'username':'xiaohong','passward':'456789'}
}#遍历
for key,value in users.items():print(key)for key1,value1 in value.items():print(key1+':'+value1)
print('{:=^30}'.format(''))
#查询小红的用户名
print(users['小红']['username'])
#使用这种方法有时候会更清晰
stu1={}
stu2={}
users1={'小绿':stu1,'小蓝':stu2}
stu1={'username':'xiaolv','passward':'123345'}
stu2={'username':'xiaolan','passward':'123345'}>>>小明
username:xiaoming
passward:123456
小红
username:xiaohong
passward:456789
==============================
xiaohong

2.集合

2.1.集合的概念

集合是python中的一种容器。既然我们有万能的列表了，为什么还要其他容器呢？这其实是由于集合的一个最重要的特点：集合具有最高的查询速度。

当我们运行下面代码时：

#l={'c','c++','c#','.net','java','ruby','python'}
l=['c','c++','c#','.net','java','ruby','python']
if 'python' in l:print('yes')
else:print('no')>>>yes

python会在列表l中从前向后查找元素python，如果列表元素非常多，查询速度会非常慢。但集合不同，即使元素非常多，查询速度也不改变，而且是最高的。那么，集合是如何做到的呢？

举个例子：如果成绩单下来，我们要看看自己考了多少，按照列表的做法，就是从前向后一个个扫；但集合不同，它会首先把每个人的名字变成不同的数字存放到固定的位置，查询的时候，也会首先把名字变成数字，只需要找到这个数字的位置，然后看看它对应的分数就行了。而电脑最擅长的就是找固定的位置了。所以使得查询速度非常高。

看了上面的过程，你是否想起了前面的字典。没错，字典和集合的原理一样的。如果我们有一个字典：

d={'alex':92,'tom':74}

现在我们对分数部分不感兴趣，把它去掉，变成：

d={'alex','tom'}

这就是一个集合。

实际上，python内部就是这么处理的，把字典的所有值都变成 None，然后隐藏起来，就是一个集合。

2.2 集合的性质

集合与字典类似，都是把一个元素变成一个固定的数字，那么问题来了，如果再来一个相同的元素呢？根据查询的过程我们可以看出，相同的元素得到的数字是一样的。所以当一个已经存在的元素进入集合，它就会被忽略。这就意味着集合中的元素始终只存在一个，它导致集合的一个重要特征：元素的唯一性。

集合中元素的唯一性让我们想起字典中键的唯一性，现在看来，这两种唯一性的原理是完全一样的，这也从侧面说明了集合与字典的相似性。

所以，根据集合元素不重复的特性，我们可以使用集合set()来进行去重：

l=['python','c','c++','c#','python','.net','java','ruby','python']
print(l)
l=set(l)
print(l)>>>['python', 'c', 'c++', 'c#', 'python', '.net', 'java', 'ruby', 'python']
{'python', 'java', 'c++', 'c#', 'ruby', '.net', 'c'}

2.3 集合的创建

集合与字典的相似性也可以从它们的符号看出来，两者都用大括号表示。

所以创建一个集合，只要把元素放入大括号中，{}只能创建一个非空集合：

s={1,'ab',1.23}
for i in s:print(i,type(i))>>>1.23 <class 'float'>
1 <class 'int'>
ab <class 'str'>

如果大括号中什么都没有，难道就是一个空的集合？

s={}

不是，因为这种方式已经被字典抢先占用了，它表示一个空字典。那么，该如何创建一个空集合呢？

就像可以用字典的英文缩写的函数dict()来创建一个空字典一样，也可以用集合的英文表示的函数set()来创建一个空集合：

s = set(

但如果是非空集合，就不能像下面这样直接放在括号中了：

s = set('a', 'b', 3)  #错误的方式
>>>TypeError: set expected at most 1 arguments, got 3
#而是要放入列表或者元组中
s = set( ['a', 'b', 3] )
print(s)
s = set( ('a', 'b', 3) )
print(s)

2.4 集合的基本操作

集合的增删操作

poets={'李白','杜甫','苏轼'}
print(poets)
#给集合添加元素 add()
poets.add('李清照') #集合中没有的元素会被添加到集合中
poets.add('苏轼')  #如果元素已存在，则不进行任何操作
print(poets)
#移除元素 remove()
poets.remove('李白')
print(poets)
#如果元素不存在，则会发生错误
'''
poets.remove('王维')
>>>KeyError: '王维'
print(poets)
'''>>>{'李白', '杜甫', '苏轼'}
{'李白', '杜甫', '李清照', '苏轼'}
{'杜甫', '李清照', '苏轼'}

因为集合是无序的，所以也不存在索引和切片，只能进行判断是否在集合内，无法进行查找操作

poets={'李白','杜甫','苏轼'}
if '李白' in poets:print('yes')>>>yes

判断集合的长度：

poets={'李白','杜甫','苏轼'}
print(len(poets))>>>3

【Python9】字典与集合相关推荐

python 字典排序最大键_Python中的列表、元祖、字典、集合操作大全
来源:http://suo.im/5HPGNT 在Python中有4种内建的数据结构:列表.元组.字典.集合.今天我们将会学习如何使用它们,以及它们如何使编程变得简单. 一.列表list 是处理一组有 ...
dmol3给定关键字不在字典中_python中的数据结构与算法（2）：字典与集合
1. 字典是什么字典是便于信息检索的一种数据结构,鉴于信息检索在程序中无处不在,字典的使用场景也非常广泛,包括许多 python 内部机制的实现,也依赖字典结构,比如命名空间的管理等. 检索一般是根 ...
OC基础第四讲--字符串、数组、字典、集合的常用方法
OC基础第四讲--字符串.数组.字典.集合的常用方法字符串.数组.字典.集合有可变和不可变之分.以字符串为例,不可变字符串本身值不能改变,必须要用相应类型来接收返回值:而可变字符串调用相应地方法后, ...
刻意练习：Python基础 -- Task06. 字典与集合
背景我们准备利用17天时间,将 "Python基础的刻意练习" 分为如下任务: Task01:变量.运算符与数据类型(1day) Task02:条件与循环(1day) Task0 ...
Python基础学习！容器：列表，元组，字典与集合！（2）
本文是元组字典与集合的学习笔记! 真滴好多! 在许多地方都可以用元组代替列表,但是元组的方法函数与列表相比要少. 像,append(),insert()这些函数,元组都没有.因为,创建元组就无法修改 ...
iOS 开发 OC编程字典和集合排序方法
// // main.m // oc- 05 字典和集合 // // Created by dllo on 15/10/29. // Copyright (c) 2015年 dllo. All ...
python内置函数可以返回列表元组_Python内置函数()可以返回列表、元组、字典、集合、字符串以及range对象中元素个数....
Python内置函数()可以返回列表.元组.字典.集合.字符串以及range对象中元素个数. 青岛远洋运输有限公司冷聚吉船长被评为全国十佳海员.()A:错B:对有源逆变是将直流电逆变成其它频率的交流 ...
python3 列表倒叙_python的列表、元组、字典、集合
本文首发于我的博客徐小晋的博客 | Xu Xiao Jinjiayouxujin.github.io python的列表.元组.字典.集合jiayouxujin.github.io 前言本文对 ...
散列表的设计与实现_python基础之字典与集合实现
更多内容,欢迎关注微信公众号: tmac_lover 上一篇介绍python中字典和集中时,提到,字典和集合的优势在于增删改查非常高效,而高效的原因就在于,python中字典和集合这两个数据结构是基于 ...

【Python9】字典与集合

1.字典

1.1.认识字典

1.2.访问字典中的值

1.3.字典的增删改查

1.3.1.增加

1.3.2.删除

1.3.3.修改

1.3.4.查找

1.4.由类似对象组成的字典

1.5.遍历字典

1.5.1.遍历所有的键-值对

1.5.2.遍历字典中的所有键

1.5.3.按顺序遍历字典中所有的键

1.5.4.遍历字典中所有的值

1.6.字典的嵌套使用

1.6.1.列表中存储字典

1.6.2.字典中存储列表

1.6.3.在字典中存储字典

2.集合

2.1.集合的概念

2.2 集合的性质

2.3 集合的创建

2.4 集合的基本操作

【Python9】字典与集合相关推荐

最新文章

热门文章