python核心编程（七）—字典和集合

心已赠人 2022-07-13 04:42 211阅读 0赞

## 字典 ##

### 比较：cmp ###

![cmp的执行流][cmp]

### 字典的键 ###

字典中的值没有任何限制。 他们可以是任意 Python 对象,即,从标准对象到用户自定义对象 皆可。但是字典中的键是有类型限制的。

1.  不允许一个键对应多个值
2.  键必须是可哈希的

<table> 
 <thead> 
  <tr> 
   <th>方法名字</th> 
   <th>操作</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>dict.clear()</td> 
   <td>删除字典中所有元素</td> 
  </tr> 
  <tr> 
   <td>dict.copy()</td> 
   <td>返回字典(浅复制)的一个副本</td> 
  </tr> 
  <tr> 
   <td>dict.fromkeysc(seq,val=None)</td> 
   <td>创建并返回一个新字典,以 seq 中的元素做该字典的键,val 做该字典中所有键对应的初始值(如果不提供此值,则默认为 None)</td> 
  </tr> 
  <tr> 
   <td>dict.get(key, default=None)</td> 
   <td>对字典 dict 中的键 key,返回它对应的值 value,如果字典中不存在此 键,则返回 default 的值(注意,参数 default 的默认值为 None)</td> 
  </tr> 
  <tr> 
   <td>dict.has_key(key)</td> 
   <td>如果键(key)在字典中存在,返回 True,否则返回 False. 在 Python2.2 版本引入 in 和 not in 后,此方法几乎已废弃不用了,但仍提供一个 可工作的接口。</td> 
  </tr> 
  <tr> 
   <td>dict.items()</td> 
   <td>返回一个包含字典中(键, 值)对元组的列表</td> 
  </tr> 
  <tr> 
   <td>dict.keys()</td> 
   <td>返回一个包含字典中键的列表</td> 
  </tr> 
  <tr> 
   <td>dict.iter()</td> 
   <td>方法 iteritems(), iterkeys(), itervalues()与它们对应的非迭代方法 一样,不同的是它们返回一个迭代子,而不是一个列表。</td> 
  </tr> 
  <tr> 
   <td>dict.pop(key [, default])</td> 
   <td>和方法 get()相似,如果字典中 key 键存在,删除并返回 dict[key], 如果 key 键不存在,且没有给出 default 的值,引发 KeyError 异常。</td> 
  </tr> 
  <tr> 
   <td>dict.setdefault(key,default=None)</td> 
   <td>和方法 set()相似,如果字典中不存在 key 键,由 dict[key]=default 为它赋值。</td> 
  </tr> 
  <tr> 
   <td>dict.update(dict2)</td> 
   <td>将字典 dict2 的键-值对添加到字典 dict</td> 
  </tr> 
  <tr> 
   <td>dict.values()</td> 
   <td>返回一个包含字典中所有值的列表</td> 
  </tr> 
 </tbody> 
</table>

### 集合类型 ###

数学上, 把 set 称做由不同的元素组成的集合,集合(set)的成员通常被称做集合元素(set elements)。Python 把这个概念引入到它的集合类型对象里。集合对象是一组无序排列的可哈希的值。

和其他容器类型一样,集合支持用 in 和 not in 操作符检查成员, 由 len() 内建函数得到集合的基数(大小), 用 for 循环迭代集合的成员。但是因为集合本身是无序的,你不可以为集合创建索引或执行切片(slice)操作,也没有键(keys)可用来获取集合中元素的值。

集合(sets)有两种不同的类型,可变集合(set) 和 不可变集合(frozenset)。

**集合操作符和关系符号**

1.  如何更新集合
    
    用各种集合内建的方法和操作符添加和删除集合的成员。
2.  如何删除集合中的成员和集合
    
    1.  用`-`实现删除成员。
    2.  如何删除集合本身,可以像删除任何 Python 对象一样, 令集合超出它的作用范围,或调用 del 将他们直接清除出当前的名字空间。如果它的引用计数为零, 也会被标记以便被垃圾回收。

#### 集合类型操作符 ####

1.  标准类型操作符(所有的集合类型)
    
    1.  成员关系 (in, not in)
    2.  集合等价/不等价（==、!=）
        
        等价/不等价被用于在相同或不同的集合之间做比较。两个集合相等是指,对每个集合而言,当 且仅当其中一个集合中的每个成员同时也是另一个集合中的成员。
    3.  子集/超集
        
        Sets用Python的比较操作符检查某集合是否是其他集合的超集或子集。“小于”符号( <,<=) 用来判断子集,“大于”符号( >, >= )用来判断超集。
2.  集合类型操作符(所有的集合类型)
    
    1.  联合( | )
        
        联合(union)操作和集合的 OR(又称可兼析取(inclusive disjunction))其实是等价的,两个集 合的联合是一个新集合,该集合中的每个元素都至少是其中一个集合的成员,即,属于两个集合其 中之一的成员。联合符号有一个等价的方法,union().
    2.  交集( & )
        
        两个集合的交集是一个新集合,该集合中的每 个元素同时是两个集合中的成员,即,属于两个集合的成员。交集符号有一个等价的方法, intersection().
    3.  差补/相对补集( – )
        
        两个集合(s 和 t)的差补或相对补集是指一个集合 C,该集合中的元素,只属于集合 s,而不属 于集合 t。差符号有一个等价的方法,difference().
    4.  对称差分( ^ )
        
        和其他的布尔集合操作相似,对称差分是集合的 XOR(又称”异或“ (exclusive disjunction)). 两个集合(s 和 t)的对称差分是指另外一个集合 C,该集合中的元素,只能是属于集合 s 或者集合 t 的成员,不能同时属于两个集合。对称差分有一个等价的方法,symmetric\_difference().
    5.  混合集合类型操作
        
        如果左右两个操作数的类型相同,既都是可变集合或不可变集合, 则所产生的结果类型是相同 的,但如果左右两个操作数的类型不相同(左操作数是 set,右操作数是frozenset,或相反情况)，则所产生的结果类型与左操作数的类型相同。

#### 集合类型操作符(仅适用于可变集合) ####

1.  (Union) Update ( |= )
    
    这个更新方法从已存在的集合中添加(可能多个)成员,此方法和 update()等价.
2.  保留/交集更新( &= )
    
    保留(或交集更新)操作保留与其他集合的共有成员。此方法和intersection\_update()等价.
3.  差更新 ( –= )
    
    对集合 s 和 t 进行差更新操作 s-=t,差更新操作会返回一个集合,该集合中的成员是集合 s 去 除掉集合 t 中元素后剩余的元素。此方法和 difference\_update()等价.
4.  对称差分更新( ^= )
    
    对集合 s 和 t 进行对称差分更新操作(s^=t),对称差分更新操作会返回一个集合,该集合中的成 员仅是原集合 s 或仅是另一集合 t 中的成员。此方法和 symmetric\_difference\_update()等价.

### 内建函数 ###

1.  标准类型函数
    
    len()
    
    把集合作为参数传递给内建函数 len(),返回集合的基数(或元素的个数)。
2.  集合类型工厂函数
    
    set() and frozenset()
    
    set()和 frozenset()工厂函数分别用来生成可变和不可变的集合。如果不提供任何参数,默认 会生成空集合。如果提供一个参数,则该参数必须是可迭代的,即,一个序列,或迭代器,或支持 迭代的一个对象,例如:一个文件或一个字典。

### 集合类型内建方法 ###

#### 方法(所有的集合方法) ####

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>操作</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>s.issubset(t)</td> 
   <td>如果s是t的子集，则返回True，否则返回False</td> 
  </tr> 
  <tr> 
   <td>s.issuperset(t)</td> 
   <td>如果s是t的超集，则返回True，否则返回False</td> 
  </tr> 
  <tr> 
   <td>s.union(t)</td> 
   <td>返回一个新集合，该集合是s和t的并集</td> 
  </tr> 
  <tr> 
   <td>s.intersection(t)</td> 
   <td>返回一个新集合,该集合是s和t的交集</td> 
  </tr> 
  <tr> 
   <td>s.difference(t)</td> 
   <td>返回一个新集合,该集合是 s 的成员,但不是 t 的成员</td> 
  </tr> 
  <tr> 
   <td>s.symmetric_difference(t)</td> 
   <td>返回一个新集合,该集合是 s 或 t 的成员,但不是 s 和 t 共有的成员</td> 
  </tr> 
  <tr> 
   <td>s.copy()</td> 
   <td>返回一个新集合,它是集合 s 的浅复制</td> 
  </tr> 
 </tbody> 
</table>

#### 方法(仅适用于可变集合) ####

新的方法有 add(), remove(), discard(), pop(), clear(). 这些接受对象的方法,参数必须是可哈希的。

#### 操作符和内建方法比较 ####

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>操作</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>s.update(t)</td> 
   <td>用 t 中的元素修改 s, 即,s 现在包含 s 或 t 的成员</td> 
  </tr> 
  <tr> 
   <td>s.intersection_update(t)</td> 
   <td>s中的成员是共同属于s和t的元素。</td> 
  </tr> 
  <tr> 
   <td>s.difference_update(t)</td> 
   <td>s 中的成员是属于 s 但不包含在 t 中的元素</td> 
  </tr> 
  <tr> 
   <td>s.symmetric_difference_update(t)</td> 
   <td>s 中的成员更新为那些包含在 s 或 t 中,但不是 s和 t 共有的元素</td> 
  </tr> 
  <tr> 
   <td>s.add(obj)</td> 
   <td>在集合 s 中添加对象 obj</td> 
  </tr> 
  <tr> 
   <td>s.remove(obj)</td> 
   <td>从集合 s 中删除对象 obj;如果 obj 不是集合 s 中的元素(obj not in s),将引发 KeyError 错误</td> 
  </tr> 
  <tr> 
   <td>s.discard(obj)</td> 
   <td>如果 obj 是集合 s 中的元素,从集合 s 中删除对象 obj</td> 
  </tr> 
  <tr> 
   <td>s.pop()</td> 
   <td>删除集合 s 中的任意一个对象,并返回它</td> 
  </tr> 
  <tr> 
   <td>s.clear()</td> 
   <td>删除集合 s 中的所有元素</td> 
  </tr> 
 </tbody> 
</table>

--------------------

参考资料：  
Python核心编程  
备注：  
转载请注明出处：[http://blog.csdn.net/wsyw126/article/details/53869855][http_blog.csdn.net_wsyw126_article_details_53869855]  
作者：WSYW126

[cmp]: /images/20220713/609b66ade03349069410b03cdfa7a0cd.png
[http_blog.csdn.net_wsyw126_article_details_53869855]: http://blog.csdn.net/wsyw126/article/details/53869855