[Python]View Plaincopy
- Python's set is similar to other languages and is an unordered set of distinct elements, with basic functionality including relationship testing and de-duplication elements. The collection object also supports mathematical operations such as Union (union), intersection (intersection), Difference (poor), and sysmmetric difference (symmetric difference sets).
- Sets supports X in set, Len (set), and for X in set. As an unordered collection, sets does not record the element position or insertion point. Therefore, sets does not support the operation of indexing, slicing, or other class sequences (Sequence-like).
- Here's a little simple example to illustrate the point.
- >>> x = set (' spam ')
- >>> y = set ([' h ',' a ',' m '])
- >>> x, y
- (Set ([' a ', ' P ', ' s ', ' m ']), set ([' a ', ' h ', ' m '] )
- Come back to the little apps.
- >>> x & y # intersection
- Set ([' a ', ' m '])
- >>> x | Y # and set
- Set ([' a ', ' P ', ' s ', ' h ', ' m '])
- >>> x-y # difference set
- Set ([' P ', ' s '])
- Remember the previous netizen asked how to remove the huge list of repeating elements, with a hash to solve the line, but the performance is not very high, with set to solve or is very good, examples are as follows:
- >>> a = [one, one, one, one, one, one]
- >>> B = Set (a)
- >>> b
- Set ([One, one, one, and one ])
- >>> C = [I for I in b]
- >>> C
- [One, one, one, and one ]
- It's cool, you can do it in a few lines.
- 1.8 Integrated
- The collection is used to contain a set of unordered objects. To create a collection, you can use the set () function and provide a series of items as follows:
- s = Set ([3,5,9,Ten]) #创建一个数值集合
- t = Set ("Hello") #创建一个唯一字符的集合
- Unlike lists and tuples, collections are unordered and cannot be indexed by numbers. Additionally, the elements in the collection cannot be duplicated. For example, if you examine the value of the T collection in the preceding code, the result would be:
- >>> T
- Set ([' H ', ' e ', ' l ', ' o '])
- Note that only one ' l ' appears.
- A collection supports a range of standard operations, including the set, intersection, difference set, and symmetric difference sets, such as:
- A = T | the set of S # T and S
- b = Intersection of T & S # T and S
- c = T–s # differential Set (item in T, but not in s)
- D = t ^ s # symmetric difference set (items in t or S, but not both)
- Basic operation:
- T.add (' x ') # Add an item
- S.update ([Ten,Panax Notoginseng]) # Add multiple items in S
- Use Remove () to delete an item:
- T.remove (' H ')
- Len (s)
- The length of the set
- X in s
- Test if X is a member of S
- X not in s
- Test if X is not a member of S
- S.issubset (t)
- S <= t
- Test if every element in S is in t
- S.issuperset (t)
- S >= t
- Tests if every element in T is in S
- S.union (t)
- s | T
- Returns a new set containing each element in S and T
- S.intersection (t)
- S & T
- Returns a new set containing the common elements in S and T
- S.difference (t)
- S-t
- Returns a new set containing elements in s but not in t
- S.symmetric_difference (t)
- s ^ t
- Returns a new set containing elements that are not duplicates in S and T
- S.copy ()
- Returns a shallow copy of the set "s"
- Note: Unions (), intersection (), difference (), and symmetric_difference () are non-operators (non-operator, which are shapes such as s.union (), will accept any Iterable as a parameter. Instead, their version of the operator (operator based counterparts) requires that the parameter must be sets. This avoids potential errors such as using Set (' abc ') & ' CBS ' instead of Set (' abc ') for more readable use . Intersection ('CBS '). From 2.3. Changes made in version 1: All previous parameters must be sets.
- In addition, both set and Immutableset support the comparison between set and set. Two sets in this case it is equal only: the elements in each set are the elements in the other (the two are subset). A set is smaller than another set, only when the first set is the subset of the second set (it is a subset, but not equal). A set is hit by another set, only when the first set is the superset of the second set (it is a superset, but not equal).
- Sub-set and equality comparisons do not produce a complete sorting function. For example: Any two sets are not equal or sub-set, so the following operations will return False:a<b, a==b, or a>b. Therefore, sets does not provide a __cmp__ method.
- Because sets only defines a partial sort function (subset relationship), the output of the List.sort () method is not defined for the list of sets.
- Operator
- Result of Operation
- Hash (s)
- Returns the hash value of s
- The following table lists the operations that are not available for Immutableset for Set two:
- Operator (Voperator)
- Equivalent to
- Result of Operation
- S.update (t)
- S |= t
- Returns the set "S" after the element in set "T" is added
- S.intersection_update (t)
- S &= t
- Returns only the set "s" containing the elements in set "T"
- S.difference_update (t)
- S-= t
- Returns the set "S" after deleting the element contained in set "T"
- S.symmetric_difference_update (t)
- S ^= t
- Returns a set "s" containing elements in set "T" or set "s", rather than both
- S.add (x)
- add element x to set "s"
- S.remove (x)
- remove element x from set "s" and throw keyerror if not present
- S.discard (x)
- If element x exists in set "s", delete
- S.pop ()
- Deletes and returns an indeterminate element in the set "s" and throws a keyerror if it is empty
- S.clear ()
- Delete all elements in set "s"
- Note: The non-operator version of Update (), Intersection_update (), Difference_update (), and Symmetric_difference_update () will accept any iterable as parameters. From 2.3. Changes made in version 1: All previous parameters must be sets.
- Also note: This module also contains a union_update () method, which is an alias for the update () method. This method is included for backwards compatibility. Programmers should use the update () method more, because this method is also supported by the built-in set () and Frozenset () types.
Python collection (set) type of operation "Go"
