用户菜单

日历

存档

我的栏目

搜索标题

RSS订阅

关注开源技术（黑龙江。哈尔滨）倡导企业级开源应用，探索信息化方案标准；集成开源众多新成果，消除开源方案忧与患；力推低成本开源战车，笑纳八方来客叙开源；普及开源知识助推力，喜迎开源企业展宏图；

python数据结构--->set(集合）

2008-01-29 11:34:53 / 个人分类：开源开发类

主要了解集合的语义、组成、操作集、比较运算、集合的指令集、集合的内置函数与方法等信息。
集合：相关数据对象集.

Set Semantics

A set is, perhaps the simplest possible container, since it contains objects in no particular order with no particular identification. Objects stand for themselves. With a sequence, objects are identified by position. With a mapping, objects are identified by some key. With a set, objects stand for themselves.

Since each object stands for itself, elements of a set cannot be duplicated. A list or tuple, for example, can have any number of duplicate objects. For example, the tuple ( 1, 1, 2, 3 ) has four elements, which includes two copies of the integer 1; if we create a set from this tuple, the set will only have three elements.

A set has large number of operations for unions, intersections, and differences. A common need is to examine a set to see if a particular object is a member of that set, or if one set is contained within another set.

A set is mutable, which means that it cannot be used as a key for a dict for more information.) In order to use a set as a dict key, we can create a frozenset, which is an immutable copy of the original set. This allows us to accumulate a set of values to create a dict key.

Set Literal Values

frozenset (iterable) → set
set( iterable) → set

>>> set( ("hello", "world", "of", "words", "of", "world") )
set(['world', 'hello', 'words', 'of'])

Set Operations

>>> fib=set( (1,1,2,3,5,8,13) )
>>> prime=set( (2,3,5,7,11,13) )
>>> fib | prime
set([1, 2, 3, 5, 7, 8, 11, 13])
>>> fib & prime
set([2, 3, 5, 13])

>>> fib - prime
set([8, 1])
>>> prime - fib
set([11, 7])
>>> fib ^ prime
set([8, 1, 11, 7])

Set Comparison Operators

All of the standard comparisons (<, <=, >, >=, ==, !=, in, not in) work with sets

>>> craps= set( [ (1,1), (2,1), (1,2), (6,6) ] )
>>> (1,2) in craps
True
>>> (3,4) in craps
False

>>> three= set( [ (2,1), (1,2) ] )
>>> three < craps
True
>>> three <= craps
True
>>> craps <= craps
True
>>> craps < craps
False

Set Statements

>>> even= set( range(2,38,2) )
>>> ōdd= set( range(1,37,2) )
>>> zero= set( (0,'00') )
>>> for n in even|odd|zero:
        print n
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
00

Set Built-in Functions

A number of built-in functions create or process sets.

len(object ) → integer: Return the number of items of a set.
max(set ) → value: With a set, return its largest item
min(set ) → value: With a set, return its smallest item.

Set Methods

A set object has a number of member methods. In the following definitions, s is a set object.

The following transformation functions update a set.

s.clear: Remove all items from the set.
s.copy → set: Copy the set to make a new set. This is a shallow copy. All objects in the new set are references to the same objects as the original set.
s.pop → object: Remove an arbitrary object from the set, returning the object. If the set was already empty, this will raise a KeyError exception.
s.add(new): Adds element new to the set. If the object is already in the set, nothing happens.
s.remove(old): Removes element old from the set. If the object old is not in the set, this will raise a KeyError exception.
s.discard(old): Removes element old from the set. If the object old is not in the set, nothing happens.
s.update(new) → object: Merge values from the new set into the original set, adding elements as needed. It is equivalent to the following Python statement. s |= new.
s.intersection_update(new) → object: Update s to have the intersection of s and new. In effect, this discards elements from s, keeping only elements which are common to new and s. It is equivalent to the following Python statement. s &= new.
s.difference_update(new) → object: Update s to have the difference between s and new. In effect, this discards elements from s which are also in new. It is equivalent to the following Python statement. s -= new.
s.symmetric_difference_update(new) → object: Update s to have the symmetric difference between s and new. In effect, this both discards elements from s which are common with new and also inserts elements into s which are unique to new. It is equivalent to the following Python statement. s ^= new.

The following accessor methods provide information about a set.

s.issubset(set) → boolean

If s is a subset of set, return True, otherwise return False. Essentially, this is s <= set.

s.issuperset(set) → boolean

If s is a superset of set, return True, otherwise return False. Essentially, this is s >= set.

s.union(new) → set

If new is a proper set, return s | new. If new is a sequence or other iterable, make a new set from the value of new, then return the union, s | new. This does not update s.

>>> prime.union( (1, 2, 3, 4, 5) )
set([1, 2, 3, 4, 5, 7, 11, 13])

s.intersection(new) → set

If new is a proper set, return s & new. If new is a sequence or other iterable, make a new set from the value of new, then return the intersection, s & new. This does not update s.

s.difference(new) → set

If new is a proper set, return s - new. If new is a sequence or other iterable, make a new set from the value of new, then return the difference, s - new. This does not update s.

s.symmetric_difference(new) → set

If new is a proper set, return s ^ new. If new is a sequence or other iterable, make a new set from the value of new, then return the symmetric difference, s ^ new. This does not update s.

>>>help(set)可查一下

论坛模式推荐收藏等级(1) 编辑管理 查看(950) 评论(0)

TAG: 开源开发类

进入论坛，查看全部评论