Python学习札记(九) Basic6 dict and set

参考：dict and set

Note：

A.dict

Hint：注意最后三点。

1.Python内置字典dict，全称directory，在别的语言如C++中称为map，使用键值-value存储，查找速度极快。

2.给定一个键值key，dict在内部根据键值计算出存储的内存地址，从而迅速的得到value。

3.dict初始化时，必须是key-value的形式。eg. 'Chen' : 90;

4.dict支持根据key赋值，即dict['key'] = value。

5.可以通过dict.get('key_name'[, value])函数来判断'key_name'这个key是否在dict中，如果不在，则返回none或者自定义的值value。也可以通过 'key_name' in dict 的形式，在 => 返回True，不在 => 返回False。

6.删除一个key，使用的是dict.pop('key_name')方法。

eg.

#!/usr/bin/env python3

score = {'Chen' : 90, 'Michael' : 89, 'Li' : 78, 'Wang' : 0}

score['Wang'] = 69      # dict['string'] = value

score['Wang'] = 79
    
print(score)

name = input()

print(score[name])

score.pop('Wang')           # dict.pop('string')

print(score.get('Wang', -1))

print(score)

Output：

sh-3.2# ./dict1.py 
{'Michael': 89, 'Chen': 90, 'Li': 78, 'Wang': 79}
Wang
79
-1
{'Michael': 89, 'Chen': 90, 'Li': 78}

7.dict内部存放的顺序和key放入的顺序是没有关系的，原因是内部使用hash散列决定key-value的存储位置。

8.dict的key，必须是不可变对象，即整数、字符串等，不能是list。要保证hash的正确性，作为key的对象就不能变。

9.dict与list的比较：

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

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

而list相反：

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

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

B.set

Hint：注意第5点。

1.set即集合，元素互异、无序、确定。

2.创建set时，需要传入一个list，list中的重复元素自动被过滤。 set_name = set([v1, v2, ..., vn])

3.add(key)方法传入元素，remove(key)方法删除元素。注意，add(key)如果之前key值已经存在与set中，则不会有效果。

4.两个集合之间可以通过 & 和 | 进行与和并的运算。

eg.

#!/usr/bin/env python3

s = set([1, 2, 3])

print(s)

s = set([1, 2, 3, 3, 4, 4, 4])

print(s)

s.add(5)

print(s)

s.add(5)

print(s)

s.remove(4)

print(s)

s1 = set([1, 2, 3])

s2 = set([2, 3, 4])

print(s1 & s2)

print(s1 | s2)

output：

sh-3.2# ./set1.py 
{1, 2, 3}
{1, 2, 3, 4}
{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5}
{1, 2, 3, 5}
{2, 3}
{1, 2, 3, 4}

5.set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。

再议不可变对象

1.对于可变对象list，进行相关操作list是会变化的。

eg.

sh-3.2# python3
Python 3.5.2 (v3.5.2:4def2a2901a5, Jun 26 2016, 10:47:25) 
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> list = [3, 2, 1]
>>> list.sort()
>>> print(list)
[1, 2, 3]
>>> 

2.对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。

调用自身的方法 => new 对象 and 返回 => 自身不变。

eg.

>>> str = 'abc'
>>> str.replace('a', 'A')
'Abc'
>>> print(str)
abc

上述代码中调用replace()方法，新建了一个str对象并返回，原有str对象不变。

可以写为：

>>> str = 'abc'
>>> b = str.replace('a', 'A')
>>> print(b)
Abc
>>> print(str)
abc

在内存单元中存储如图：

实验：Tuple 放入 dict

1.Tuple中不含list：

dict0 = {(1, 2, 3) : 90}

print(dict0[(1, 2, 3)])

正常输出90。表明不含dist的Tuple是不可变对象，可被hash。

2.Tuple中含list：

dict0 = {(1, 2, [3, 4]) : 90}

print(dict0[(1, 2, [3, 4])])

报错：

Traceback (most recent call last):
  File "./dict1.py", line 25, in <module>
    dict0 = {(1, 2, [3, 4]) : 90}
TypeError: unhashable type: 'list'

表明含list的Tuple为可变对象，不能作为dict和set的元素。

2017/1/28