设置类型、字典视图对象、上下文管理器、类与类实例(8)Python语言(必读进阶学习教程)(参考资料)

设置类型 – set，frozenset

甲组对象是不同的无序集合可哈希对象。常见用途包括成员资格测试，从序列中删除重复项，以及计算数学运算，如交集，并集，差异和对称差异。（对于其它容器看到内置的dict，list和tuple类和collections模块）。

像其他收藏品，集支持，和。作为无序集合，集合不记录元素位置或插入顺序。因此，集合不支持索引，切片或其他类似序列的行为。x in setlen(set)for x in set

目前有两种内置集类型，set和frozenset。的set类型是可变的-内容可使用类似的方法来改变add()和remove()。由于它是可变的，因此它没有哈希值，不能用作字典键或另一组的元素。该frozenset类型是不可变的和可散列的– 其内容在创建后不能更改; 因此，它可以用作字典键或另一组的元素。

非空集（不是frozensets）可以通过在大括号中放置以逗号分隔的元素列表来创建，例如：除了 构造函数之外。{'jack', 'sjoerd'}set

两个类的构造函数的工作方式相同：

class set（[ iterable ] ）

class frozenset（[ iterable ] ）

返回一个新的set或frozenset对象，其元素取自 iterable。集合的元素必须是可以清除的。要表示集合集，内部集合必须是frozenset 对象。如果未指定iterable，则返回新的空集。

实例set并frozenset提供以下操作：

len(s)

返回集合的元素数小号（基数小号）。

x in s

测试x是否为s的成员资格。

x not in s

测试X在非会员小号。

isdisjoint（其他）

True如果集合没有与其他元素共有的元素，则返回。当且仅当它们的交集是空集时，集是不相交的。

issubset（其他）

set <= other

测试集合中的每个元素是否在其他元素中。

set < other

测试集合是否是其他集合的适当子集，即 。set <= other and set != other

issuperset（其他）

set >= other

测试其他元素是否在集合中。

set > other

测试集合是否是其他集合的正确超集，即。set >= other and set != other

union（*其他）

set | other | ...

返回包含集合和所有其他元素的新集合。

intersection（*其他）

set & other & ...

返回一个新集合，其中包含集合和所有其他元素共有的元素。

difference（*其他）

set - other - ...

返回一个新集合，其中集合中的元素不在其他元素中。

symmetric_difference（其他）

set ^ other

返回一个新集合，其中包含集合中的元素或其他元素，但不是两者。

copy（）

返回带有s的浅表副本的新集。

注意，对非运营商的版本union()，intersection()， difference()，和symmetric_difference()，issubset()和 issuperset()方法将接受任何可迭代作为参数。相比之下，他们基于运营商的同行要求他们的论点是集合。这排除了易于出错的结构，例如 更有可读性。set('abc') &'cbs'set('abc').intersection('cbs')

两者set和frozenset支持设置为设置比较。当且仅当每组中的每个元素都包含在另一组中时，两组相等（每组都是另一组的子集）。当且仅当第一组是第二组的适当子集（是子集，但不相等）时，集合小于另一个集合。当且仅当第一个集合是第二个集合的正确超集（是超集，但不相等）时，集合大于另一个集合。

的实例set进行比较的情况下，frozenset 根据自己的成员。例如， 退货等等。set('abc') ==frozenset('abc')Trueset('abc') in set([frozenset('abc')])

子集和相等比较不推广到总排序函数。例如，任何两个非空不相交的集合不相等，并且不彼此的子集，所以所有的以下返回False：a<b， a==b，或a>b。

由于集合仅定义了部分排序（子集关系），因此list.sort()对于集合列表，方法的输出是未定义的。

设置元素（如字典键）必须是可清除的。

混合set实例的二进制操作frozenset 返回第一个操作数的类型。例如：返回一个实例。frozenset('ab') |set('bc')frozenset

下表列出了可用于的操作set，不适用于以下的不可变实例frozenset：

update（*其他）

set |= other | ...

更新集合，添加所有其他元素。

intersection_update（*其他）

set &= other & ...

更新集合，仅保留其中的元素和所有其他元素。

difference_update（*其他）

set -= other | ...

更新集合，删除其他人中找到的元素。

symmetric_difference_update（其他）

set ^= other

更新集合，仅保留在任一集中找到的元素，但不保留两者中的元素。

add（elem ）

将元素elem添加到集合中。

remove（elem ）

从集合中删除元素elem。KeyError如果elem未包含在集合中，则引发。

discard（elem ）

如果存在，则从集合中删除元素elem。

pop（）

从集合中删除并返回任意元素。KeyError如果集合为空则引发 。

clear（）

从集合中删除所有元素。

需要注意的的非运营商的版本update()， intersection_update()，difference_update()，和symmetric_difference_update()方法会接受任何迭代器作为参数。

请注意，该ELEM参数的__contains__()，remove()和 discard()方法可能是一组。为了支持搜索等效的冻结集，从elem创建临时冻结集。

映射类型 – dict

甲映射对象映射可哈希值到任意对象。映射是可变对象。目前只有一种标准的映射类型，即字典。（对于其它容器看到内置的 list，set和tuple类和 collections模块）。

字典的键几乎是任意值。不可 清除的值，即包含列表，字典或其他可变类型（通过值而不是按对象标识进行比较）的值不能用作键。用于键的数字类型遵循用于数字比较的常规规则：如果两个数字比较相等（例如1和1.0），则它们可以互换地用于索引相同的字典条目。（但请注意，由于计算机将浮点数存储为近似值，因此将它们用作字典键通常是不明智的。）

可以通过 在大括号中放置以逗号分隔的对列表来创建字典，例如：或，或由构造函数创建。key: value{'jack':4098, 'sjoerd': 4127}{4098: 'jack', 4127: 'sjoerd'}dict

class dict（** kwarg ）

class dict（mapping，** kwarg ）

class dict（iterable，** kwarg ）

返回从可选位置参数和可能为空的关键字参数集初始化的新字典。

如果没有给出位置参数，则创建一个空字典。如果给出位置参数并且它是映射对象，则创建具有与映射对象相同的键 – 值对的字典。否则，位置参数必须是可迭代对象。iterable中的每个项目本身都必须是具有两个对象的可迭代项。每个项目的第一个对象成为新词典中的一个键，第二个对象成为相应的值。如果某个键出现多次，则该键的最后一个值将成为新字典中的相应值。

如果给出了关键字参数，则将关键字参数及其值添加到从位置参数创建的字典中。如果已添加的键已存在，则keyword参数中的值将替换位置参数中的值。

为了说明，以下示例都返回一个等于的字典 ：{"one": 1, "two": 2, "three": 3}

>>>
>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> a == b == c == d == e
True

 

提供第一个示例中的关键字参数仅适用于有效Python标识符的键。否则，可以使用任何有效密钥。

这些是字典支持的操作（因此，自定义映射类型也应该支持）：

len(d)

返回字典中的项目数d。

d[key]

用钥匙键返回d 项。引发KeyErrorif 键不在地图中。

如果dict的子类定义了方法__missing__()并且键 不存在，则该d[key]操作使用键键 作为参数调用该方法。然后d[key]操作返回或引发__missing__(key)调用返回或引发的任何内容。没有其他操作或方法调用__missing__()。如果 __missing__()未定义，KeyError则引发。 __missing__()必须是一种方法; 它不能是实例变量：

>>>
>>> class Counter(dict):
...     def __missing__(self, key):
...         return 0
>>> c = Counter()
>>> c['red']
0
>>> c['red'] += 1
>>> c['red']
1

 

上面的例子显示了部分实现 collections.Counter。使用不同的__missing__方法collections.defaultdict。

d[key] = value

设置d[key]为值。

del d[key]

d[key]从d中删除。引发KeyErrorif 键不在地图中。

key in d

True如果d有钥匙钥匙，则返回False。

key not in d

相当于。not key in d

iter(d)

在字典的键上返回一个迭代器。这是一个捷径iter(d.keys())。

clear（）

从字典中删除所有项目。

copy（）

返回字典的浅表副本。

classmethod fromkeys（iterable [，value ] ）

使用来自iterable和值设置为value的键创建一个新字典。

fromkeys()是一个返回新字典的类方法。值 默认为None。

get（键[，默认] ）

如果key在字典中，则返回key的值，否则返回default。如果未给出default，则默认为，因此此方法永远不会引发a 。NoneKeyError

items（）

返回字典项目（对）的新视图。请参阅视图对象的文档。(key, value)

keys（）

返回字典键的新视图。请参阅视图对象的文档。

pop（键[，默认] ）

如果key在字典中，则将其删除并返回其值，否则返回 default。如果未给出default并且key不在字典中，KeyError则引发a。

popitem（）

从字典中删除并返回一对。对子以LIFO顺序退回。(key, value)

popitem()对于在字典中进行破坏性迭代很有用，就像在集合算法中经常使用的那样。如果字典为空，则调用 popitem()会引发a KeyError。

在版本3.7中更改：现在保证LIFO订单。在先前版本中，popitem()将返回任意键/值对。

setdefault（键[，默认] ）

如果key在字典中，则返回其值。如果没有，插入钥匙 ，值为默认和返回默认值。 默认默认为 None。

update（[ 其他] ）

更新与来自键/值对字典等，覆盖现有的密钥。返回None。

update()接受另一个字典对象或可重复的键/值对（作为元组或长度为2的其他迭代）。如果指定了关键字参数，则使用这些键/值对更新字典：。d.update(red=1, blue=2)

values（）

返回字典值的新视图。请参阅视图对象的 文档。

当且仅当它们具有相同的对时，字典才会相等。订单比较（'<‘，'<=’，’> =’，’>’）引发 。(key,value)TypeError

字典保留了插入顺序。请注意，更新密钥不会影响订单。删除后添加的键将在末尾插入。

>>>
>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> d
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> list(d)
['one', 'two', 'three', 'four']
>>> list(d.values())
[1, 2, 3, 4]
>>> d["one"] = 42
>>> d
{'one': 42, 'two': 2, 'three': 3, 'four': 4}
>>> del d["two"]
>>> d["two"] = None
>>> d
{'one': 42, 'three': 3, 'four': 4, 'two': None}

 

在版本3.7中更改：字典顺序保证为插入顺序。此行为是来自3.6的CPython的实现细节。

>>>
>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
>>> keys = dishes.keys()
>>> values = dishes.values()

>>> # iteration
>>> n = 0
>>> for val in values:
...     n += val
>>> print(n)
504

>>> # keys and values are iterated over in the same order (insertion order)
>>> list(keys)
['eggs', 'sausage', 'bacon', 'spam']
>>> list(values)
[2, 1, 1, 500]

>>> # view objects are dynamic and reflect dict changes
>>> del dishes['eggs']
>>> del dishes['sausage']
>>> list(keys)
['bacon', 'spam']

>>> # set operations
>>> keys & {'eggs', 'bacon', 'salad'}
{'bacon'}
>>> keys ^ {'sausage', 'juice'}
{'juice', 'sausage', 'bacon', 'spam'}

上下文管理器类型

Python的with语句支持由上下文管理器定义的运行时上下文的概念。这是使用一对方法实现的，这些方法允许用户定义的类定义在语句体执行之前输入的运行时上下文，并在语句结束时退出：

contextmanager.__enter__（）

输入运行时上下文并返回此对象或与运行时上下文相关的其他对象。此方法返回的值绑定到使用此上下文管理器as的with语句子句中的标识符。

返回自身的上下文管理器的示例是文件对象。文件对象从__enter __（）返回，以允许open()在with语句中用作上下文表达式。

返回相关对象的上下文管理器的示例是返回的对象decimal.localcontext()。这些管理器将活动的十进制上下文设置为原始十进制上下文的副本，然后返回该副本。这允许对with语句正文中的当前十进制上下文进行更改，而不会影响with语句外的代码 。

contextmanager.__exit__（exc_type，exc_val，exc_tb ）

退出运行时上下文并返回一个布尔标志，指示是否应该抑制发生的任何异常。如果在执行with语句主体时发生异常，则参数包含异常类型，值和回溯信息。否则，所有三个参数都是None。

从此方法返回true值将导致with语句禁止异常并继续执行紧跟语句后面的with语句。否则，在此方法执行完毕后，异常将继续传播。执行此方法期间发生的异常将替换with语句正文中发生的任何异常。

传入的异常永远不应该显式重新标记 – 相反，此方法应返回false值以指示方法已成功完成且不希望抑制引发的异常。这允许上下文管理代码轻松检测__exit__() 方法是否实际失败。

Python定义了几个上下文管理器，以支持简单的线程同步，文件或其他对象的快速关闭，以及对活动十进制算术上下文的简单操作。除了实现上下文管理协议之外，特定类型不会被特别处理。有关contextlib示例，请参阅 模块。

Python的生成器和contextlib.contextmanager装饰器提供了一种实现这些协议的便捷方式。如果使用contextlib.contextmanager装饰器修饰生成器函数，它将返回实现必要__enter__()和 __exit__()方法的上下文管理器，而不是由未修饰的生成器函数生成的迭代器。

请注意，Python / C API中Python对象的类型结构中没有针对这些方法的特定插槽。想要定义这些方法的扩展类型必须将它们作为普通的Python可访问方法提供。与设置运行时上下文的开销相比，单个类字典查找的开销可以忽略不计。

其他内置类型

解释器支持其他几种对象。其中大多数只支持一两个操作。

>>>
>>> class C:
...     def method(self):
...         pass
...
>>> c = C()
>>> c.method.whoami = 'my name is method'  # can't set on the method
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'method' object has no attribute 'whoami'
>>> c.method.__func__.whoami = 'my name is method'
>>> c.method.whoami
'my name is method'

特殊属性

该实现为几个对象类型添加了一些特殊的只读属性，它们是相关的。其中一些内容功能未报告 dir()。

object.__dict__

用于存储对象（可写）属性的字典或其他映射对象。

instance.__class__

类实例所属的类。

class.__bases__

类对象的基类的元组。

definition.__name__

类，函数，方法，描述符或生成器实例的名称。

definition.__qualname__

类，函数，方法，描述符或生成器实例的限定名称。

版本3.3中的新功能。

class.__mro__

此属性是在方法解析期间查找基类时考虑的类的元组。

class.mro（）

元类可以重写此方法，以自定义其实例的方法解析顺序。它在类实例化时调用，其结果存储在__mro__。

class.__subclasses__（）

每个类都保留一个对其直接子类的弱引用列表。此方法返回所有仍然存活的引用的列表。例：

>>>

>>> int.__subclasses__()
[<class 'bool'>]

脚注