python基础之字典、集合

renyz

一、字典（dictionary）

　　作用：存多个值,key-value存取，取值速度快

　　定义：key必须是不可变类型，value可以是任意类型

　　字典是一个无序的，可以修改的，元素呈键值对的形式，以逗号分割的，以大括号包围的序列；

　　典是python基础数据类型当中唯一一个映射关系的数据类型；

说明：

　　字典和列表一样，也能够存储多个数据，字典中的值并没有特殊顺序。

　　列表中找某个元素时，是根据下标进行的，如果下标很多，查找数据不方便。

　　当索引不好用时，使用字典，字典中找某个元素时字典的每个元素由2部分组成，键:值。例如 \'name\':\'班长\' ,\'name\'为键，\'班长\'为值，字典由键值组成。

字典的特点：

　　因为字典是无序的，所以字典没有索引值；

　　因为字典没有索引值，所以字典以键取值，(字典的键相当于列表的索引)；

　　因为字典以键取值，所以字典的键唯一且不可修改；所以字典天生去重；

　　因为字典的键不可修改，所以列表和字典等可变类型的数据不可以给字典做键。

和list比较，dict有以下几个特点：

  1. 查找和插入的速度极快，不会随着key的增加而变慢；
  2. 需要占用大量的内存，内存浪费多。

而list相反：

  1. 查找和插入的时间随着元素的增加而增加；
  2. 占用空间小，浪费内存很少。

所以，dict是用空间来换取时间的一种方法。

dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。

 

 

 

字典的取值

keys

返回一个包含字典所有key的列表

values

返回一个包含字典所有vaule的列表

get

以键取值，如果指定键不存在，默认返回None,可以指定返回内容

update

以字典格式更新指定键的内容，如果键不存在，创建键和值

items

返回字典键值呈元组形式的格式

 

len

测量字典，键值对的个数（整体）

 

字典的删除

pop

弹出，返回并删除指定键对应的值

popitem

随机弹出一个键值元组，这里随机的原因是因为字典无序

clear

清空字典

字典的判断

in

判断指定的键是否在字典当中，即将被废除，之后我们python3用in

字典的遍历

通过for ...in ...

通过for ... in ...:的语法结构，我们可以遍历字符串、列表、元组、字典等数据结构。

 

1、定义

nfo = {"name":"ryz","age":18,"qq":1249773850}
print(type(info))
---------------------------------------------------------------
<class \'dict\'>

2、增加

info = {"name":"ryz","age":18,"qq":1249773850}
info["doing"] = "python"
print(info)
--------------------------------------------------------------
{\'name\': \'ryz\', \'age\': 18, \'qq\': 1249773850, \'doing\': \'python\'}

3、修改

info = {"name":"ryz","age":18,"qq":1249773850}
info["age"] = 3
print(info)
-------------------------------------------------------------
{\'name\': \'ryz\', \'age\': 3, \'qq\': 1249773850}

4、删除

info = {"name":"ryz","age":18,"qq":1249773850,"from":"shanxi","gradute":"zhongbei"}
info.pop("qq")　　#标准删除
print(info)
del info["gradute"]　　#注意是[]
print(info)
info.popitem()　　#随机删除
print(info)
-------------------------------------------------------------------
{\'name\': \'ryz\', \'age\': 18, \'from\': \'shanxi\', \'gradute\': \'zhongbei\'}
{\'name\': \'ryz\', \'age\': 18, \'from\': \'shanxi\'}
{\'name\': \'ryz\', \'age\': 18}
#setdefault设置默认值
info = {
    \'name\':\'ryz\',
    \'age\':18,
    \'qq\':1249773850
}
info.pop(\'name\')
info.setdefault(\'name\',\'ryz\')　　#不存在默认插入
print(info)
-----------------------------------------------------
{\'age\': 18, \'qq\': 1249773850, \'name\': \'ryz\'}　　

5、查找

info = {"name":"ryz","age":18,"qq":1249773850,"from":"shanxi","gradute":"zhongbei"}
print("age" in info)　　#检查字典是否存在该key，存在返回True，不存在返回False
print(info.get("qq"))　　#获取qq对应的value值
print(info["age"])　　#获取qq对应的value值
# print(info["love"])　　#如果一个键不存在，就报错，get不会报错，不存在只返回None
print(info.get("love"))
-------------------------------------------------------------
True
1249773850
18
None

6、多级字典嵌套及操作

dict1 = {
    "北京":{
        "朝阳区":["望京","国贸"],
        "海淀区":["央视塔"],
        "昌平区":["宏福"],
    },
    "山西":{
        "太原":["尖草坪","小店"],
        "晋中":["乔家大院","平遥古城"],
    },
    "河北":{
        "保定":[]
    },
}
print(dict1["北京"]["朝阳区"])
dict1["河北"]["保定"] = "狼牙山"
print(dict1["河北"]["保定"])
dict1["山西"]["太原"][0] += ",中北大学"
print(dict1["山西"]["太原"])
-------------------------------------------------------------
[\'望京\', \'国贸\']
狼牙山
[\'尖草坪,中北大学\', \'小店\']

7、其它

info = {"name":"ryz","age":18,"qq":1249773850,"from":"shanxi","gradute":"zhongbei"}
print(info.keys())　　#得到字典的键
print(info.values())　　#得到字典的值
print(info.get("name"))　　#以键取值，如果知道键不存在，默认返回None，可以指定返回内容
# print(info.clear())　　#清空字典
print(len(info))　　#测量字典长度
--------------------------------------------------------------
dict_keys([\'name\', \'age\', \'qq\', \'from\', \'gradute\'])
dict_values([\'ryz\', 18, 1249773850, \'shanxi\', \'zhongbei\'])
ryz
5
info = {"name":"ryz","age":18}
info2 = {"qq":1249773850}
info.update(info2)　　#字典updata（）函数把字典info2的键值对更新到dict里
print(info)
------------------------------------------
{\'name\': \'ryz\', \'age\': 18, \'qq\': 1249773850}
info = {"name":"ryz","age":18,}
print(info.items())　　#以元组形式返回dict键值对
-------------------------------------------------
dict_items([(\'name\', \'ryz\'), (\'age\', 18)])
print(dict.fromkeys([1,2,3]),"hello")
print(dict.fromkeys([1,2,3],"hello"))　　#通过一个列表生成默认dict，尽量少用
-----------------------------------------------------
{1: None, 2: None, 3: None} hello
{1: \'hello\', 2: \'hello\', 3: \'hello\'}

8、循环dict

info = {"name":"ryz","age":18,"qq":1249773850,"from":"shanxi","gradute":"zhongbei"}
for i in info.items():
    print(i)
for k,v in info.items():　　#会先把dict转成list，数据量大时莫用
    print(k,v)
-------------------------------------------------
(\'name\', \'ryz\')
(\'age\', 18)
(\'qq\', 1249773850)
(\'from\', \'shanxi\')
(\'gradute\', \'zhongbei\')
name ryz
age 18
qq 1249773850
from shanxi
gradute zhongbei

二、集合（set）

　定义集合：{  }内用逗号分割每个元素都必须是不可变类型,元素不能重复,无序

集合对象还支持交集(intersection),差集(difference)、并集和对称差集(sysmmetric_difference)

　　集合是一个无序的，不重复的数据组合，它的主要作用如下：

  • 去重，把一个列表变成集合，就自动去重了
  • 关系测试，测试两组数据之前的交集、差集、并集等关系
#作用：关系运算，去重
python = {"test","gavin","woniu"}
linux = {"boy","girl","test"}
# &交集:同时报名两门课程的学生
print(python&linux)
# |并集: 所有的学生
print(python|linux)
#^ 对称差集:没有同时报名两门课程
print(python^linux)
#  - 差集：只报名python课程的学生,去掉共同的部分
print(python-linux)
---------------------------------------------------------------
{\'test\'}
{\'girl\', \'woniu\', \'test\', \'boy\', \'gavin\'}
{\'girl\', \'gavin\', \'boy\', \'woniu\'}
{\'gavin\', \'woniu\'}
# s = set([3,5,9,10])      #创建一个数值集合
s = {3,5,9,10}
print(type(s))
t = set("Hello")         #创建一个唯一字符的集合
print(type(t))
print(s|t)          # t 和 s的并集
print(s&t)          # t 和 s的交集
print(s-t)          # 求差集（项在t中，但不在s中）
print(s^t)          # 对称差集（项在t或s中，但不会同时出现在二者中）
print(s.union(t))   #s | t
#返回一个新的 set 包含 s 和 t 中的每一个元素
print(s.intersection(t))    #s & t
#返回一个新的 set 包含 s 和 t 中的公共元素
print(s.difference(t))  #s - t
#返回一个新的 set 包含 s 中有但是 t 中没有的元素
print(s.symmetric_difference(t))    #s ^ t
#返回一个新的 set 包含 s 和 t 中不重复的元素

#基本操作：
t.add(\'x\')            # 添加一项
print(t)
s.update([10,37,42])  # 在s中添加多项
print(s)
#使用remove()可以删除一项：
t.remove(\'H\')
print(t)
print(len(s))   #set 的长度
print(\'x\' in s)
# #测试 x 是否是 s 的成员
print(\'x\' not in s)
#测试 x 是否不是 s 的成员
print(s.issubset(t))    #s <= t
#测试是否 s 中的每一个元素都在 t 中
print(s.issuperset(t))  #s >= t
#测试是否 t 中的每一个元素都在 s 中
print(s.copy())
#返回 set “s”的一个浅复制
----------------------------------------------------------------
1、<class \'set\'>
2、<class \'set\'>
3、{\'o\', 3, 5, 9, 10, \'H\', \'l\', \'e\'}
4、set()
5、{9, 10, 3, 5}
6、{\'o\', 3, 5, 9, 10, \'H\', \'l\', \'e\'}
7、{\'o\', 3, 5, 9, 10, \'H\', \'l\', \'e\'}
8、set()
9、{9, 10, 3, 5}
10、{\'o\', 3, 5, 9, 10, \'H\', \'l\', \'e\'}
11、{\'o\', \'x\', \'H\', \'l\', \'e\'}
12、{3, 37, 5, 9, 10, 42}
13、{\'o\', \'x\', \'l\', \'e\'}
14、6
15、False
16、True
17、False
18、False
19、{3, 42, 37, 5, 9, 10}

 

分类：

技术点：

相关文章：

猜你喜欢
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode