Python_set集合&dict字典

时间：2019-08-10 18:25:30 收藏：0 阅读：74

-------------------集合set------------------

概念

set是可变的、无序的、不重复的元素集合（约定：set为集合，collection为集合类型或容器）

set操作

set初始化

>>> s1 = set()
>>> s2 = {}
>>> s3 = {1, 2, 3}    # {}内元素非k-v格式并且不为空时，类型为set
>>> type(s2), type(s3)
(dict, set)

set元素

必须可hash：可hash的都为不可变类型，称为hash类型， hashable（不可hash的类型：list、set、bytearray）
- 数值型：int、float、complex
- 布尔型：True、False
- 字符串: string、bytes
- tuple
- None
不可以是索引
可迭代

# hash语法：hash(object)
# object ->对象
# 返回对象的哈希值

# 示例：
>>> hash(11), hash(11.11)     # 数值
 (11, 253642731013505035)

>>> hash(True), hash(False)   # 布尔
 (1, 0)

>>> hash('summer'), hash(b'a')    # 字符串
 (1892576216179648960, -6180982495755337473)

>>> hash(None)    # None
 -9223372036575868911

>>> hash((1,))    # tuple
 3430019387558

>>> hash([1, 2, 3])   # list不可直接进行hash
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-17-84d65be9aa35> in <module>
----> 1 hash([1, 2, 3])

TypeError: unhashable type: 'list'

set增加

# add() 增加元素到set中，若元素存在，则不做操作
>>> s1 = set()
>>> s1.add('summer')
>>> s1
{'summer'}

# update() 合并其他元素到set中，参数必须为可迭代对象，就地修改
>>> s1.update([18, 'qingdao'])
>>> s1
{18, 'qingdao', 'summer'}

set删除

# remove() 从set中移除一个元素，若元素不存在，抛出KeyError异常
>>> s1 = {1, 2, 3, 'ab',  66, 'ff'}
>>> s1.remove('ab')       # 移除元素'ab'
>>> s1
 {1, 2, 3, 66, 'ff'}
>>> s1.remove('ss')       # 若移除元素不存在，则抛出异常
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-33-63061d263830> in <module>
----> 1 s1.remove('ss')

KeyError: 'ss'

# discard() 从set中移除一个元素，若元素不存在，则不做操作
>>> s1.discard(1) # 移除元素1
>>> s1
 {1, 2, 3, 66, 'ff'}
>>> s1.discard('mm')  # 移除元素不存在，则不做任何操作
>>> s1
 {1, 2, 3, 66, 'ff'}

# pop()   移除并返回任意元素，空集返回KeyError异常
>>> s1
 {2, 3, 66, 'ff'}
>>> s1.pop()
 66
>>> s1.pop()
 2
>>> s1.pop()
 3
>>> s1.pop()  
 'ff'
>>> s1.pop()  # 当移除元素的集合为空时，抛出异常
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-51-095118de218b> in <module>
----> 1 s1.pop()

# clear() 移除所有元素
>>> s1 = set(range(10))
>>> s1
 {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
>>> s1.clear()
>>> s1
 set()

set修改、查询
- set修改只能增加或删除元素
- set为非线形结构，无法索引
- 可进行遍历（迭代所有元素）
```
>>> s1 = set(range(5, 9))
>>> for i in s1: print(i)
8
5
6
7
```
set成员运算的比较
- list和set成员运算效率比较（set遍历的速率远高于list）

set和线性结构

线性结构的查询时间复杂度是O(n), 耗时随数据规模的增大而增加

set、dict等结构，内部使用hash值作为key，时间复杂度可做到O(1),且查询时间和规模无关

集合

概念
- 全集：所有元素的集合
- 子集subset和superset：A集合所有元素都在集合B中，A是B的子集，B是A的超集
- 真子集和真超集：A是B的子集，且A不等于B， A是B的真子集，B是A的真超集
- 并集：多个集合合并的结果
- 交集：多个集合共同的部分
- 差集：集合中除去其他集合共同的部分

集合运算

并集

# union(*others) 返回多个集合合并后的新的集合
>>> s1, s2
 ({0, 1, 2, 3, 4}, {3, 4, 5, 6, 7, 8, 9})=
>>> s1.union(s2)
 {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

# 等同于union()
>>> s1 | s2
 {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

# update(*.others) 和多个集合合并，就地修改
>>> s1.update(s2)
>>> s1
 {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

 # |= 等同于update()
>>> s3 = {'a', 'b', 'c'}
>>> s2 |= s3
>>> s2
 {3, 4, 5, 6, 7, 8, 9, 'a', 'b', 'c'}

交集

>>> a = set(range(6))
>>> b = set(range(3, 10))

# intersection(*others) 返回多个集合的交集
>>> a.intersection(b)     # 返回同时属于a集合和b集合的元素,a集合和b集合不变
 {3, 4, 5}
>>> a, b
 ({0, 1, 2, 3, 4, 5}, {3, 4, 5, 6, 7, 8, 9})

# & 等同intersection()
>>> a & b
 {3, 4, 5}
>>> a, b
 ({0, 1, 2, 3, 4, 5}, {3, 4, 5, 6, 7, 8, 9})

# intersection_update(*others) 获取和多个集合的交集，并且就地修改
>>> a.intersection_update(b)  # 就地修改a集合的元素为a和b的交集，b集合不变
>>> a, b  
 ({3, 4, 5}, {3, 4, 5, 6, 7, 8, 9})

# &= 等同于intersection_update()

>>> a, c
 ({3, 4, 5}, {4, 5, 6, 7})
>>> a &= c
>>> a, c
 ({4, 5}, {4, 5, 6, 7})

差集

>>> s1, s2
({100, 101, 102, 103, 104, 105, 106, 107, 108, 109},
 {105, 106, 107, 108, 109, 110, 111, 112, 113, 114})

# difference(*others) 返回多个集合的差集
>>> s1.difference(s2)     # 返回所有属于s1集合且不属于s2集合的元素所组成的新集合
 {100, 101, 102, 103, 104}
>>> s1, s2        # 原s1和s2集合不变
({100, 101, 102, 103, 104, 105, 106, 107, 108, 109},
 {105, 106, 107, 108, 109, 110, 111, 112, 113, 114})

# - 等同于difference
>>> s1 - s2
 {100, 101, 102, 103, 104}
>>> s1, s2
({100, 101, 102, 103, 104, 105, 106, 107, 108, 109},
 {105, 106, 107, 108, 109, 110, 111, 112, 113, 114})


# difference_update(*others) 获取多个集合的差集并就地修改
>>> s1.difference_update(s2)  # 获取s1和s2集合的差集，并就地修改s1，s2不变
>>> s1, s2
 ({100, 101, 102, 103, 104}, {105, 106, 107, 108, 109, 110, 111, 112, 113, 114})

# -= 等同于difference_update()
>>> s3 = set(range(110, 120))
>>> s2 -= s3s
>>> s2, s3
 ({105, 106, 107, 108, 109}, {110, 111, 112, 113, 114, 115, 116, 117, 118, 119})

对称差集：集合A和集合B，由不属于A和B的交集元素组成的组合，即：(A - B) U (B - A)

# symmetric_difference(other) 返回和另一个集合的对称差集
>>> A, B
 ({'a', 'b', 'c', 'd', 'e'}, {'a', 'b', 'c', 'f', 'h', 'zz'})
>>> A.symmetric_difference(B)     # 返回A和B的对称差集
 {'d', 'e', 'f', 'h', 'zz'}
>>> A, B
 ({'a', 'b', 'c', 'd', 'e'}, {'a', 'b', 'c', 'f', 'h', 'zz'})

# ^ 等同于symmetric_difference()
>>> A ^ B
 {'d', 'e', 'f', 'h', 'zz'}
>>> A, B
 ({'a', 'b', 'c', 'd', 'e'}, {'a', 'b', 'c', 'f', 'h', 'zz'})

# symmetric_difference_update(other) 获取和另一个集合的对称差集并就地修改
>>> A, B
 ({'a', 'b', 'c', 'd', 'e'}, {'a', 'b', 'c', 'f', 'h', 'zz'})
>>> A.symmetric_difference_update(B)  # A集合修改为A和B集合的对称差集元素
>>> A, B
 ({'d', 'e', 'f', 'h', 'zz'}, {'a', 'b', 'c', 'f', 'h', 'zz'})

# ^= 等同于 symmetric_difference_update()
>>> C = {'f', 'h', 'zz'}
>>> A ^= C
>>> A, C
 ({'d', 'e'}, {'f', 'h', 'zz'})

其他集合运算

>>> a, b
({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, {0, 1, 2, 3, 4})

# issubset(other) 等同于<= 判断当前集合是否是另一个集合的子集
>>> a.issubset(b), b.issubset(a), a <= b, b <= a
(False, True, False, True)

# set1 < set2 判断set1是否是set2的真子集
>>> a < b, b < a
(False, True)

# set1 》 set2 判断set1是否是set2的真超集
>>> a > b, b > a
(True, False)

# isdisjoint(other) 判断当前集合和另一个集合没有交集，没有交集则返回True
>>> a.isdisjoint(b), b.isdisjoint(a)
(False, False)
>>> c = set(range(20, 25))
>>> a.isdisjoint(c), b.isdisjoint(c)
(True, True)

集合练习

随机产生2组各10个数字的列表，要求如下：
- 每个数字取值范围[10, 20]
- 统计20个数字中，一共有多少个不同的数字
- 2组比较，打印不同的数字及个数
- 2组比较，打印重复的数字及个数

import random
lst1 = []
lst2 = []
for i in range(10):
    lst1.append(random.randint(1, 20))
    lst2.append(random.randint(1, 20))
print(lst1,'\n',lst2)

s1 = set(lst1)
s2 = set(lst2)

print(s1, s2)
print('Total: {} nums: {}'.format(len(s1 | s2), s1 | s2))
print('Total: {} The same nums: {}'.format(len(s1 & s2), s1 & s2))
print('Total: {} The diff num: {}'.format(len(s1 ^ s2), s1 ^ s2))

------------------字典dict------------------

概念

dict是key-value键值对的数据的集合
dict是可变的、无序的、key不可重复
dict的key和set集合的元素要求一致，必须可hash

字典dict操作

dict定义（初始化）

# dict(**kwargs)  使用key=value对初始化一个字典，或直接使用{key:values,}
>>> d1 = dict(a=1, b=2, c=3)
>>> d2 = {'name': 'summer', 'age': 18}
>>> d1, d2
({'a': 1, 'b': 2, 'c': 3}, {'name': 'summer', 'age': 18})

# dict(iterable, **kwarg)使用可迭代对象构造字典，可迭代对象必须是一个二元结构
>>> d3 = dict(((1, 'a'), (2, 'b')))
>>> d4 = dict(([5, 'zz'], [6, 'ss']), c=100)
>>> d3, d4
({1: 'a', 2: 'b'}, {5: 'zz', 6: 'ss', 'c': 100})

# dict.fromkeys(iterable, value) 类方法，默认value=None
>>> d6 = dict.fromkeys(range(5))
>>> d7 = dict.fromkeys(range(5), 0)
>>> d6, d7
({0: None, 1: None, 2: None, 3: None, 4: None}, {0: 0, 1: 0, 2: 0, 3: 0, 4: 0})

dict元素访问

# d[key] 返回key对应的value值，key不存在抛出KeyError异常
In [4]: d
Out[4]: {5: 'zz', 6: 'ww', 7: 'qq', 8: 'aa', 9: 'ss'}

In [5]: d[5], d[9]        # 返回key对应的value值
Out[5]: ('zz', 'ss')

In [6]: d[10]     # key不存在抛异常
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-6-76a0c2738598> in <module>
----> 1 d[10]

KeyError: 10

# get(key[, default]) 返回key对应的value值，key不存在返回缺省值，若无缺省值返回None
In [10]: d.get(7), d.get(5)  # 返回key对应的value值
Out[10]: ('qq', 'zz')

In [12]: d.get(11), d.get(20, 'haha')   # key值不存在返回None，设置缺省值则返回缺省值
Out[12]: (None, 'haha')


# setdefault(key[, default]) 返回key对应的value值，key不存在，添加kv对，value默认为缺省值，若未设置缺省值则为None

Out[13]: {5: 'zz', 6: 'ww', 7: 'qq', 8: 'aa', 9: 'ss'}

In [14]: d.setdefault(9)       # 返回key对应的value值
Out[14]: 'ss'

In [15]: d.setdefault(11, 'hh')       # key不存在，添加kv对，value默认为缺省值
Out[15]: 'hh'

In [16]: d
Out[16]: {5: 'zz', 6: 'ww', 7: 'qq', 8: 'aa', 9: 'ss', 11: 'hh'}

dict增加和修改

# d[key] = value 将key对应的值修改为value， key值不存在则添加新的kv对
In [17]: d
Out[17]: {5: 'zz', 6: 'ww', 7: 'qq', 8: 'aa', 9: 'ss', 11: 'hh'}

In [18]: d[11] = 'haha'       # 修改key对应的value值

In [19]: d
Out[19]: {5: 'zz', 6: 'ww', 7: 'qq', 8: 'aa', 9: 'ss', 11: 'haha'}

In [20]: d[100] = 'world'     # key值不存在则添加新kv对

In [21]: d
Out[21]: {5: 'zz', 6: 'ww', 7: 'qq', 8: 'aa', 9: 'ss', 11: 'haha', 100: 'world'}

# update([other]) 使用另一个字典的kv更新本字典，key不存在则创建，key存在则覆盖key对应的value值，就地修改

In [27]: d2
Out[27]: {111: 'boom', 6: 'mm', 7: 'wow'}

In [28]: d.update(d2)     # 使用字典d2更新字典d,key不存在则创建，存在则使用d2对应的value值覆盖d的value值

In [29]: d
Out[29]:
{5: 'zz',
 6: 'mm',
 7: 'wow',
 8: 'aa',
 9: 'ss',
 11: 'haha',
 100: 'world',
 111: 'boom'}

dict删除

# pop(key[, default]) key存在，移除并返回对应value值；key不存在返回给定的defaule，default未设置，key不存在则抛出异常
In [31]: d.pop(5)     # key存在，返回对应的value值
Out[31]: 'zz'

In [32]: d.pop(22, 0) # key不存在，返回给定的值
Out[32]: 0

In [34]: d.pop(33)        # key不存在且default为设置，则抛出异常
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-34-f427c8d8b6e4> in <module>
----> 1 d.pop(33)

KeyError: 33

# popitem() 移除并返回任意一个键值对，字典为empty，抛出KeyError异常
In [40]: d2
Out[40]: {111: 'boom', 6: 'mm', 7: 'wow'}

In [41]: d2.popitem()
Out[41]: (7, 'wow')

In [42]: d2.popitem()
Out[42]: (6, 'mm')

In [43]: d2.popitem()
Out[43]: (111, 'boom')

In [45]: d2
Out[45]: {}

In [44]: d2.popitem()     # 字典为空后，抛出异常
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-44-2d6551896b5f> in <module>
----> 1 d2.popitem()

KeyError: 'popitem(): dictionary is empty'

# clear() 清空字典
In [46]: d
Out[46]: {6: 'mm', 7: 'wow', 8: 'aa', 9: 'ss', 11: 'haha'}

In [47]: d.clear()

In [48]: d
Out[48]: {}

dict遍历

# 遍历values
# 1 -----------------
for k in d:
    print(d[k])
# 2 -----------------
for k in d.keys():
    print(d.get(k))
# 3 -----------------
for v in d.values():
    print(v)
# 4 -----------------
for _,v in d.items():
      print(v)

# 遍历item，即kv对
# 1 -----------------
for item in d.items():
      print(item)
# 2 -----------------
for k,v in d.items():
    print(k, v)

有序字典（collections.OrderedDict）
- 需要使用collections模块
- 使用OrderedDict记录元素插入顺序，并按照该顺序输出打印

原文：https://www.cnblogs.com/summer-dhy/p/11332207.html

Python_set集合&amp;dict字典

-------------------集合set------------------

概念

set操作

set和线性结构

集合

集合练习

------------------字典dict------------------

概念

字典dict操作

Python_set集合&dict字典