Python笔记(五）——Dict（字典）和set（集合）

我会带着你远行 2022-04-02 05:13 523阅读 0赞

目录

字典集合的常见用法

一、字典（dict）

二、集合（set）

具体介绍：

一、Dict（字典）

1.1 字典的定义“{ }”

1.2 Python之访问dict

1.3 Python之遍历dict

1.4 Python添加字典元素

1.5 删除字典元素

1.6 Python中dict的特点

二、set（集合）

2.1 set的创建

2.2 Python之访问set

2.3 Python之 set的特点

2.4 Python之 遍历set

2.5 Python之 更新set

字典集合的常见用法

一、字典（dict）

dict的作用是建立一组 key 和一组 value 的映射关系，dict的key是不能重复的。注：dict中的元素要是key：value两个值对应的形式

a.函数创建：

  1. d = { 
  2.      'Adam': 95,
  3.      'Lisa': 85,
  4.      'Bart': 59
  5.     }

b.访问数据： d[key] 的形式来查找对应的 value

法一：

print d['Paul']

法二;

  1.  print d.get('Bart')

c.更新dict：用赋值语句或者用赋值做替换

d['Pa= 72

d.遍历dict：用for循环

  1. >>> d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 } 
  2. >>> for key in d: #通过key来找到对应的value
  3. ...     print key

二、集合（set）

集合（set）是一个无序的不重复元素序列。

a.创建set：调用 set() 并传入一个 list，list的元素将作为set的元素：

  1. >>> s = set(['A', 'B', 'C'])

b.添加元素

  1. >>> s.add( x ) #将元素x加到集合s中
  2. 或者是
  3. >>> s.update(x) #括号处x可以是列表，元组，字典等

c.移除元素

  1. >>> s.remove( x ) #若移除元素不存在会出错
  2. #另一种方法
  3. >>> s.discard( x ) #若移除元素不存在，不会发生错误
  4. #随机删除集合中某元素
  5. >>> s.pop( ) #随机删除集合中某元素，或者在（）中加序号后删除该元素

d.计算集合元素个数

  1. >>> len(s)

e.清空集合

  1. >>> s.clear()

f.判断元素是否在集合中存在

  1. >>> x in s #返回true或者false

具体介绍：

一、Dict（字典）

1.1 字典的定义“{ }”

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

  1.                                       ![20190630145752841.png][]
  3. d = {key1 : value1, key2 : value2 }

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

  1.                                       ![20190630145835365.png][]
  3.                                                      ![20190630145945723.png][]

一个简单的字典实例：

  1. dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}

也可如此创建字典：

  1. dict1 = { 'abc': 456 }; 
  2. dict2 = { 'abc': 123, 98.6: 37 };
  • 字典的作用：给定一个名字，就可以直接查到分数。

由于dict也是集合，len() 函数可以计算任意集合的大小：

  1. >>> len(d)
  2. 3

注意: 一个 key-value 算一个，因此，dict大小为3。

任务

新来的Paul同学成绩是 75 分，请编写一个dict，把Paul同学的成绩也加进去。

  1. d = {
  2.     'Adam': 95,
  3.     'Lisa': 85,
  4.     'Bart': 59
  5. }
  1. d = {
  2. 'Adam': 95,
  3. 'Lisa': 85,
  4. 'Bart': 59,
  5. 'Paul': 75
  6. }
  7. print(d)

20181225150208389.png

1.2 Python之访问dict

  • 把相应的键放入到括号中

我们已经能创建一个dict，用于表示名字和成绩的对应关系：

  1. d = { 
  2.     'Adam': 95, 
  3.     'Lisa': 85, 
  4.     'Bart': 59 
  5.     }

那么，如何根据名字来查找对应的成绩呢？

可以简单地使用 d[key] 的形式来查找对应的 value，这和 list 很像，不同之处是，list 必须使用索引返回对应的元素，而dict使用key：

  1. >>> print d['Adam'] 
  2. 95 
  3. >>> print d['Paul'] 
  4. Traceback (most recent call last): 
  5.   File "index.py", line 11, in <module> 
  6.     print d['Paul'] 
  7. KeyError: 'Paul'

注意: 通过 key 访问 dict 的value，只要 key 存在，dict就返回对应的value。如果key不存在，会直接报错：KeyError。

要避免 KeyError 发生，有两个办法：

一是先判断一下 key 是否存在，用 in 操作符：

  1. if 'Paul' in d:
  2.     print d['Paul']

如果 ‘Paul’ 不存在，if语句判断为False，自然不会执行 print d[‘Paul’] ，从而避免了错误。

二是使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None：

  1. >>> print d.get('Bart') 
  2. 59 
  3. >>> print d.get('Paul') 
  4. None

1.3 Python之遍历dict

由于dict也是一个集合，所以，遍历dict和遍历list类似，都可以通过 for 循环实现。

直接使用for循环可以遍历 dict 的 key：

  1. >>> d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 } 
  2. >>> for key in d: 
  3. ...     print(key + ':', d[key]) 
  4. ... 
  5. Lisa : 95
  6. Adam : 85
  7. Bart : 59

20181227113256912.png

由于通过 key 可以获取对应的 value，因此，在循环体内，可以获取到value的值。

1.4 Python添加字典元素

dict是可变的，也就是说，我们可以随时往dict中添加新的 key-value。比如已有dict：

  1. d = {
  2.     'Adam': 95,
  3.     'Lisa': 85,
  4.     'Bart': 59
  5. }

要把新同学’Paul’的成绩 72 加进去，用赋值语句：

  1. >>> d['Paul'] = 72

再看看dict的内容：

  1. >>> print d
  2. {'Lisa': 85, 'Paul': 72, 'Adam': 95, 'Bart': 59}

如果 key 已经存在，则赋值会用新的 value 替换掉原来的 value：

  1. >>> d['Bart'] = 60
  2. >>> print d
  3. {'Lisa': 85, 'Paul': 72, 'Adam': 95, 'Bart': 60}

1.5 删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。

显示删除一个字典用del命令，如下实例：

  1. dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} 
  3. del dict['Name'] # 删除键 'Name' 
  4. dict.clear() # 清空字典 
  5. del dict # 删除字典 
  7. print ("dict['Age']: ", dict['Age']) 
  8. print ("dict['School']: ", dict['School'])

但这会引发一个异常，因为用执行 del 操作后字典不再存在：

  1. Traceback (most recent call last):
  2.   File "test.py", line 9, in <module>
  3.     print ("dict['Age']: ", dict['Age'])
  4. TypeError: 'type' object is not subscr

注：del() 方法后面也会讨论。

1.6 Python中dict的特点

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。

以下重要的点需要记住：

  • 1）dict查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。

不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。

  • 2）由于dict是按 key 查找，所以，在一个dict中，不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

    dict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Name’: ‘小菜鸟’}
    print (“dict[‘Name’]: “, dict[‘Name’])

以上实例输出结果：

  1. dict['Name']: 小菜鸟

  • 3）键必须不可变，Python的基本类型如字符串、整数、浮点数或元组都是不可变的，所以可以作为key（键），而列表就不行，如下实例：

    dict = {[‘Name’]: ‘Runoob’, ‘Age’: 7}
    print (“dict[‘Name’]: “, dict[‘Name’])

以上实例输出结果：

  1. Traceback (most recent call last):
  2.   File "test.py", line 3, in <module>
  3.     dict = {['Name']: 'Runoob', 'Age': 7}
  4. TypeError: unhashable type: 'list'

不可变这个限制仅作用于key，value是否可变无所谓：

  1. {
  2.     '123': [1, 2, 3],  # key 是 str，value是list
  3.     123: '123',  # key 是 int，value 是 str
  4.     ('a', 'b'): True  # key 是 tuple，并且tuple的每个元素都是不可变对象，value是 boolean
  5. }

最常用的key还是字符串，因为用起来最方便。

  • 4）dict存储的key-value序对是没有顺序的！这和list不一样：

    d = {

    1. 'Adam': 95,
    2. 'Lisa': 85,
    3. 'Bart': 59

    }

当我们试图打印这个dict时：

  1. >>> print d
  2. {'Lisa': 85, 'Adam': 95, 'Bart': 59}

打印的顺序不一定是我们创建时的顺序，而且，不同的机器打印的顺序都可能不同，这说明dict内部是无序的，不能用dict存储有序的集合。

二、set（集合）

dict的作用是建立一组 key 和一组 value 的映射关系，dict的key是不能重复的。

有的时候，我们只想要 dict 的 key，不关心 key 对应的 value，目的就是保证这个集合的元素不会重复，这时，set就派上用场了。

set 持有一系列元素，这一点和 list 很像，集合（set）是一个无序的不重复元素序列。这点和 dict 的 key很像。

集合（set）是一个无序的不重复元素序列。

2.1 set的创建

可以使用大括号 { }或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

  1. parame = {value01,value02,...}
  2. 或者
  3. set(value)
  5. 调用 set() 并传入一个 list，list的元素将作为set的元素：
  7. >>> s = set(['A', 'B', 'C'])

可以查看 set 的内容：

  1. >>> print s
  2. {'A', 'C', 'B'}

请注意，上述打印的形式类似 list， 但它不是 list，仔细看还可以发现，打印的顺序和原始 list 的顺序有可能是不同的，因为set内部存储的元素是无序的。

因为set不能包含重复的元素，所以，当我们传入包含重复元素的 list 会怎么样呢？

  1. >>> s = set(['A', 'B', 'C', 'C'])
  2. >>> print s
  3. set(['A', 'C', 'B'])
  4. >>> len(s)
  5. 3

结果显示，set会自动去掉重复的元素，原来的list有4个元素，但set只有3个元素。

2.2 Python之访问set

由于set存储的是无序集合，所以我们没法通过索引来访问。

访问 set中的某个元素实际上就是判断一个元素是否在set中。

例如，存储了班里同学名字的set：

  1. >>> s = set(['Adam', 'Lisa', 'Bart', 'Paul'])

我们可以用 in 操作符判断：

Bart是该班的同学吗？

  1. >>> 'Bart' in s
  2. True

Bill是该班的同学吗？

  1. >>> 'Bill' in s
  2. False

bart是该班的同学吗？

  1. >>> 'bart' in s
  2. False

看来大小写很重要，’Bart’ 和 ‘bart’被认为是两个不同的元素。

任务

由于上述set不能识别小写的名字，请改进set，使得 ‘adam’ 和 ‘bart’都能返回True。

  1. s = set(['Adam', 'adam', 'Lisa', 'lisa', 'Bart', 'bart', 'Paul', 'paul'])
  2. print ('adam' in s)
  3. print ('bart' in s)

2.3 Python之 set的特点

set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快。

set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象是不能放入set中的。

最后，set存储的元素也是没有顺序的。

set的这些特点，可以应用在哪些地方呢？

星期一到星期日可以用字符串’MON’, ‘TUE’, … ‘SUN’表示。

假设我们让用户输入星期一至星期日的某天，如何判断用户的输入是否是一个有效的星期呢？

可以用 if 语句判断，但这样做非常繁琐：

  1. x = '???' # 用户输入的字符串 
  2. if x!= 'MON' and x!= 'TUE' and x!= 'WED' ... and x!= 'SUN': 
  3.     print 'input error' 
  4. else: 
  5.     print 'input ok'

注意：if 语句中的…表示没有列出的其它星期名称，测试时，请输入完整。

如果事先创建好一个set，包含’MON’ ~ ‘SUN’：

  1. weekdays = set(['MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT', 'SUN'])

再判断输入是否有效，只需要判断该字符串是否在set中：

  1. x = '???' # 用户输入的字符串 
  2. if x in weekdays: 
  3.     print 'input ok' 
  4. else: 
  5.     print 'input error'

这样一来，代码就简单多了。

任务

月份也可以用set表示，请设计一个set并判断用户输入的月份是否有效。

月份可以用字符串’Jan’, ‘Feb’, …表示。

  1. months = set(['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'])
  2. x1 = 'Feb'
  3. x2 = 'Sun'
  5. if x1 in months:
  6.     print ('x1: ok')
  7. else:
  8.     print ('x1: error')
  10. if x2 in months:
  11.     print ('x2: ok')
  12. else:
  13.     print ('x2: error')

2.4 Python之 遍历set

由于 set 也是一个集合，所以，遍历 set 和遍历 list 类似，都可以通过 for 循环实现。

直接使用 for 循环可以遍历 set 的元素：

  1. >>> s = set(['Adam', 'Lisa', 'Bart']) 
  2. >>> for name in s: 
  3. ...     print name 
  4. ... 
  5. Lisa 
  6. Adam 
  7. Bart

注意: 观察 for 循环在遍历set时，元素的顺序和list的顺序很可能是不同的，而且不同的机器上运行的结果也可能不同。

任务

请用 for 循环遍历如下的set，打印出 name: score 来。

  1. s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
  1. s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
  2. for x in s:
  3.     print x[0] + ':', x[1]

2.5 Python之 更新set

由于set存储的是一组不重复的无序元素，因此，更新set主要做两件事：

一是把新的元素添加到set中，二是把已有元素从set中删除。

添加元素时，用set的add()方法：

  1. >>> s = set([1, 2, 3])
  2. >>> s.add(4)
  3. >>> print s
  4. set([1, 2, 3, 4])

如果添加的元素已经存在于set中，add()不会报错，但是不会加进去了：

  1. >>> s = set([1, 2, 3])
  2. >>> s.add(3)
  3. >>> print s
  4. set([1, 2, 3])

删除set中的元素时，用set的remove()方法：

  1. >>> s = set([1, 2, 3, 4])
  2. >>> s.remove(4)
  3. >>> print s
  4. set([1, 2, 3])

如果删除的元素不存在set中，remove()会报错：

  1. >>> s = set([1, 2, 3])
  2. >>> s.remove(4)
  3. Traceback (most recent call last):
  4.   File "<stdin>", line 1, in <module>
  5. KeyError: 4

注：用add()可以直接添加，而remove()前需要判断。

任务

针对下面的set，给定一个list，对list中的每一个元素，如果在set中，就将其删除，如果不在set中，就添加进去。

  1. s = set(['Adam', 'Lisa', 'Paul'])
  2. L = ['Adam', 'Lisa', 'Bart', 'Paul']

参考文献

http://www.runoob.com/python3/python3-set.html

发表评论

表情：
评论列表 （有 0 条评论，523人围观）

还没有评论，来说两句吧...

相关阅读