python 基础知识四： dict 和 set 类型

写在前面：python系列基础知识采录整理于慕课网，在慕课网跟着教程敲一遍后发现无法记全，转换为自己的笔记更容易复习，故边学边复制了一份，原教程链接地址：https://www.imooc.com/code/3328，共勉

一，dict定义和使用

1，定义：花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。

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

d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59,
    'Paul': 75,
}

len(d)
#输出长度4

2，使用：

   ①，可以简单地使用 d[key] 的形式来查找对应的 value

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

   ③，为防止报错，方法一：先判断一下 key 是否存在，用 in 操作符

   ④，get访问后面是括号，不是方括号

if 'Paul' in d:
    print d['Paul']

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

d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}
print 'Adam:' , d.get('Adam')
print 'Lisa:' , d.get('Lisa')
print 'Bart:' , d.get('Bart')

3，特点

①，查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。缺点：快的代价就是占用内存；由于dict是按 key 查找，所以，在一个dict中，key不能重复。

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

③，dict的第三个特点是作为 key 的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。但是list是可变的，就不能作为 key。

4，更新dict

#追加元素
d = {
    95: 'Adam',
    85: 'Lisa',
    59: 'Bart'
}
d[72] = 'Paul'
print d
#直接赋值的方式，如果key重复，则value会被覆盖

5，遍历dict

#循环输出name: score
d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}
for key in d:
    print key, ':', d[key]

二，python 中的set

set 持有一系列元素，但是set的元素没有重复，而且是无序的。

创建 set 的方式是调用 set() 并传入一个 list，list的元素将作为set的元素：如：

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

set 的访问： in 语法

s = set(['Adam', 'Lisa', 'Bart', 'Paul'])
print 'Adam' in s #True
print 'Bart' in s #True

set的遍历：

#用 for 循环遍历如下的set，打印出 name: score 来
s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
for x in s:
    name = x[0]
    score = x[1]
    print name ,':',score

set的操作：新增：add，移除：remove

#对list中的每一个元素，如果在set中，就将其删除，如果不在set中，就添加进去
s = set(['Adam', 'Lisa', 'Paul'])
L = ['Adam', 'Lisa', 'Bart', 'Paul']
for name in L:
    if (name in s):
        s.remove(name)
    else:
        s.add(name)
print s

set用法补充：来源：https://www.cnblogs.com/crazylover/p/9672833.html

三、集合的其他常用的方法

　　2.1 集合的增　

 

set1=set({'jim','jordan','Spider Man'})
#第一种方式，通过add()添加元素
set1.add('Kong Fu Panda')
print(set1)  #{'Spider Man', 'Kong Fu Panda', 'jordan', 'jim'}
#第二种方式，通过update()添加元素,如果添加的元素里面时可以迭代的元素，那么它就会将其迭代添加
set1.update('James')
print(set1)  #{'J', 'jim', 'Spider Man', 'e', 'jordan', 'm', 's', 'a', 'Kong Fu Panda'}

 

　　2.2 集合的删　

 

set2=set({'jim','jordan','Spider Man','James','Jack'})
# 删除指定的元素,如果删除的元素不存在，则会报错
set2.remove('jordan')
print(set2)   #{'James', 'jim', 'Jack', 'Spider Man'}
#随机删除集合的某一个元素
set2.pop()
print(set2)  #{'jim', 'Jack', 'Spider Man'}
#删除集合
# del  set2
print(set2)  #NameError: name 'set2' is not defined  报错
#清空集合
set2.clear()

 　　2.3集合的查

set3=set({'jim','jordan','Spider Man','James','Jack'})
for i in set3:
    print(i)  #jordan James Spider Man jim  Jack

3.集合的其它操作

　　3.1 交集。（&  或者 intersection）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2)  # {4, 5}
print(set1.intersection(set2))  # {4, 5}

　　3.2 并集。（| 或者 union）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7,8}
print(set2.union(set1))  # {1, 2, 3, 4, 5, 6, 7,8}

　　3.3 差集。（- 或者 difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2)  # {1, 2, 3}
print(set2 - set1) #{8, 6, 7}
print(set1.difference(set2))  # {1, 2, 3}
print(set2.difference(set1)) #{8, 6, 7}

 　　3.4反交集。 （^ 或者 symmetric_difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2)  # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}

　　3.5子集与超集

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set1 < set2) # True
print(set1.issubset(set2))  # True 这两个相同，都是说明set1是set2子集。

print(set2 > set1) # True
print(set2.issuperset(set1))  # True 这两个相同，都是说明set2是set1超集。

      4，frozenset不可变集合，让集合变成不可变类型。

s = frozenset('James')
print(s,type(s))  # frozenset({'e', 's', 'J', 'a', 'm'}) 

 四、深浅copy

　　1、赋值运算

　　对于赋值运算来说，list1与list2指向的是同一个内存地址，所以他们是完全一样的。

list1=['Jordan','James','Paul','Jeorage','Curry']
list2=list1
list1.append('Irving')
print(list1) #['Jordan', 'James', 'Paul', 'Jeorage', 'Curry', 'Irving']
print(list2) # #['Jordan', 'James', 'Paul', 'Jeorage', 'Curry', 'Irving']

　　2、浅拷贝copy

　　对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。

l1 = [1,2,3,['hello','world']]

l2 = l1.copy()
print(l1,id(l1))  # [1, 2, 3, ['hello', 'world']] 1920725366664
print(l2,id(l2))  # [1, 2, 3, ['hello', 'world']] 1920726234696
l1[1] = 222
print(l1,id(l1))  #[1, 222, 3, ['hello', 'world']] 1920725366664
print(l2,id(l2))  # [1, 2, 3, ['hello', 'world']] 1920726234696

l1[3][0] = 'everybody'
print(l1,id(l1[3]))  # [1, 222, 3, ['everybody', 'world']] 1920726234824
print(l2,id(l2[3]))  # [1, 2, 3, ['everybody', 'world']] 1920726234824

     3、深拷贝deepcopy

　　对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变。

import copy

l1 = [1,2,3,['hello','world']]
l2=copy.deepcopy(l1)
print(l1,id(l1))  # [1, 2, 3, ['hello', 'world']] 2200548595592
print(l2,id(l2))  # [1, 2, 3, ['hello', 'world']] 2200548596424
l1[1] = 222
print(l1,id(l1))  #[1, 222, 3, ['hello', 'world']] 2200548595592
print(l2,id(l2))  # [1, 2, 3, ['hello', 'world']] 2200548596424

l1[3][0] = 'everybody'
print(l1,id(l1[3]))  # [1, 222, 3, ['everybody', 'world']] 2200548595400
print(l2,id(l2[3]))  # [1, 2, 3, ['hello', 'world']] 2200548596360