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

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 Valuesfrozenset (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 OperatorsAll
      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
True
>>> three
True
>>> craps
True
>>> 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 .
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)可查一下
Help on class set in module __builtin__:
class set(object)
|  set(iterable) --> set object
|  
|  Build an unordered collection of unique elements.
|  
|  Methods defined here:
|  
|  __and__(...)
|      x.__and__(y)  x&y
|  
|  __cmp__(...)
|      x.__cmp__(y)  cmp(x,y)
|  
|  __contains__(...)
|      x.__contains__(y)  y in x.
|  
|  __eq__(...)
|      x.__eq__(y)  x==y
|  
|  __ge__(...)
|      x.__ge__(y)  x>=y
.............................