精华内容
下载资源
问答
  • python 集合运算 Python中的数学集合运算 (Mathematical Set Operations in Python) Python’s set is an unordered collection in Python. It can be used to compute standard math operations, such as ...

    python 集合运算

    Python中的数学集合运算 (Mathematical Set Operations in Python)

    Python’s set is an unordered collection in Python. It can be used to compute standard math operations, such as intersection, union, difference, and symmetric difference. Other collections — like list, tuple, and dictionary — don’t support set operations. Dict view objects are set-like, which allows set operations. Refer to my story on Python sets.

    Python的set是Python中的无序集合。 它可以用于计算标准数学运算,例如交集,并集,差和对称差。 Other集合(例如列表,元组和字典)不支持集合操作。 Dict视图对象类似于集合,可以进行集合操作。 请参阅我关于Python集的故事。

    This article will explore the mathematical operations supported by set objects in detail.

    本文将详细探讨set对象支持的数学运算。

    让我们看一下Set对象支持的数学运算 (Let's Look at the Mathematical Operations Supported by the Set Object)

    • union()

      union()

    • update()

      update()

    • intersection()

      intersection()

    • intersection_update()

      intersection_update()

    • difference()

      difference()

    • difference_update()

      difference_update()

    • symmetric_difference()

      symmetric_difference()

    • symmetric_difference_update()

      symmetric_difference_update()

    • isdisjoint()

      isdisjoint()

    • issubset()

      issubset()

    • issuperset()

      issuperset()

    Set operations can be done in two ways. By using the method or by using an operator.

    设置操作可以通过两种方式完成。 通过使用该方法或使用一个运算符。

    '联盟()' (‘union()’)

    Return a new set with elements from the set and the other. It’s performed by union() or by using the | operator

    返回一个新的集合 与集合中的元素和other 。 它是由union()或使用| 算子

    Syntax

    句法

    union(*others)

    union ( *others )

    set | other | ...

    set | other | ...

    Image for post
    ‘union()’
    '联盟()'

    Example 1: Find the union of two sets — A and B

    示例1:找到两个集合 A 集— A B

    It’ll return a new set containing elements from set A and set B. But it won’t repeat elements. All elements in the set are unique.

    它将返回一个新集合,其中包含来自集合A和集合B元素。 但这不会重复元素。 集合中的所有元素都是唯一的。

    A={1,2,3,4,5}
    B={2,4,6,8}
    print (A.union(B))#Output:{1, 2, 3, 4, 5, 6, 8}
    print (A|B)#Output:{1, 2, 3, 4, 5, 6, 8}

    Example 2: Find the union of more than two sets

    示例2:查找两个以上集合的并集

    A={1,2,3,4,5}
    B={2,4,6,8,10}
    C={1,3,5,7,9}
    print (A|B|C)#Output:{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    print (A.union(B,C))#Output:{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

    Difference between the union() method and the | operator:

    union()方法和|之间的区别 操作员:

    • union(): It’ll accept any iterable as an argument

      union() :它将接受任何可迭代的参数

    • | operator: It’ll accept only a set as an argument. Otherwise, it’ll raise a TypeError.

      | 运算符:它仅接受一个set作为参数。 否则,它将引发TypeError

    Example 3: Giving iterable as an argument in the union() method

    示例3: union() 方法 中将 iterable 用作参数

    A={1,2,3,4,5}
    #iterable is given as list
    print (A.union([2,4,6]))#Output:{1, 2, 3, 4, 5, 6}
    #iterable is given as tuple
    print (A.union((2,4,6)))#Output:{1, 2, 3, 4, 5, 6}
    #iterable is given as range object
    print (A.union(range(5,10)))#Output:{1, 2, 3, 4, 5, 6, 7, 8, 9}
    #iterable is given as a dictionary
    print (A.union({'a':6,'b':7}))#Output:{1, 2, 3, 4, 5, 'b', 'a'}

    Example 4: Giving iterable as an argument for the| operator

    示例4: iterable 用作 | 的参数 算子

    A={1,2,3,4,5}
    B=[1,2,3]
    print (A|B)#Output:TypeError: unsupported operand type(s) for |: 'set' and 'list'

    'update()' (‘update()’)

    It updates the set, adding elements from the other. But it won’t repeat elements. All elements in the set are unique. It’s performed by using update() or by using the |= operator. The return type is None. It’ll modify the original set itself.

    它更新集合,并从other元素中添加元素。 但这不会重复元素。 集合中的所有元素都是唯一的。 通过使用update()或使用|=运算符来执行。 返回类型为None 。 它将修改原始集本身。

    Syntax

    句法

    update(*others)

    update ( *others )

    set |= other | ...

    set |= other | ...

    Example 1: Calling update() between two sets — A and B

    示例1: 在两个集合之间 调用 update() - A B

    It’ll update set A by adding elements found in both sets.

    它将通过添加两个集合中找到的元素来更新集合A

    #update()A={1,2,3,4,5}
    B={4,5,6,7,8}
    print (A.update(B)) #Output: Noneprint (A) #Output: {1, 2, 3, 4, 5, 6, 7, 8}A={1,2,3,4,5}
    B={4,5,6,7,8}
    A|=B
    print (A) #Output: {1, 2, 3, 4, 5, 6, 7, 8}

    Example 2: Calling update() between more than two sets

    示例2: 在两个以上集合之间 调用 update()

    #update()A={1,2,3}
    B={3,4,5}
    C={5,6,7}
    print (A.update(B,C)) #Output: Noneprint (A) #Output: {1, 2, 3, 4, 5, 6, 7}A={1,2,3}
    B={3,4,5}
    C={5,6,7}
    A|=B|C
    print (A) #Output: {1, 2, 3, 4, 5, 6, 7}

    Difference between the update() method and the |= operator:

    update()方法和|=运算符之间的区别:

    • update(): It’ll accept any iterable as an argument

      update() :它将接受任何可迭代的参数

    • |= operator: It’ll accept only a set as an argument. Otherwise, it’ll raise a TypeError.

      |=运算符:它将仅接受set作为参数。 否则,它将引发TypeError

    Example 3: Giving iterable as an argument in the update() method

    示例3: update() 方法 中将 iterable 用作参数

    A={1,2,3}#iterable is given as listprint (A.update([2,3,4]))#Output:Noneprint (A)#Output:{1,2,3,4}
    #iterable is given as tuple
    A={1,2,3}
    A.update((2,3,4))
    print (A)#Output:{1,2,3,4}
    #iterable is given as range object
    A={1,2,3}
    A.update(range(2,5))
    print (A)#Output:{1,2,3,4}
    #iterable is given as a dictionary
    A={1,2,3}
    A.update({2:'a',3:'b'})
    print (A) #Output:{1, 2, 3}

    Example 4: Giving iterable as an argument for the |= operator

    示例4: |= 运算符 提供 iterable 作为参数

    #iterable is given as tupleA={1,2,3}
    B=(3,4)
    A|=B#Output:TypeError: unsupported operand type(s) for |=: 'set' and 'tuple'

    '路口()' (‘intersection()’)

    Return a new set with elements common to the set and the other. It’s performed by intersection() or by using the &operator.

    返回一个新集合,该集合具有该集合和other集合共同的元素。 它是由intersection()或使用&运算符执行的。

    Syntax

    句法

    intersection(*others)

    intersection ( *others )

    set & other & ...

    set & other & ...

    Image for post
    ‘intersection()’
    '路口()'

    Example 1: Find the intersection of two sets — A and B

    示例1:找到两个集合的交集— A B

    It’ll return a new set containing common elements from the set A and set B.

    它将返回一个新集合,其中包含集合A和集合B中的公共元素。

    A={1,2,3,4,5}
    B={2,4,6,8}#intersection is performed by intersection() method or & operatorprint (A.intersection(B))#Output:{2,4}print (A&B)#Output:{2,4}

    Example 2: Find the intersection of more than two sets

    示例2:找到两个以上的交集

    A={1,2,3,4,5}
    B={2,4,6,8,10}
    C={2,4}
    print (A&B&C)#Output:{2,4}print (A.intersection(B,C))#Output:{2,4}

    Difference between the intersection() method and the & operator:

    intersection()方法和&运算符之间的区别:

    • intersection(): It’ll accept any iterable as an argument

      intersection() :它将接受任何可迭代的参数

    • & operator: It’ll accept only a set as an argument. Otherwise, it’ll raise a TypeError.

      &运算符:仅接受set作为参数。 否则,它将引发TypeError

    Example 3: Giving iterable as an argument in the intersection() method

    示例3: intersection() 方法 中将 iterable 用作参数

    A={1,2,3,4,5}#iterable is given as listprint (A.intersection([1,4,6]))#Output:{1,4}
    #iterable is given as tuple
    print (A.intersection((2,4,6)))#Output:{2,4}
    #iterable is given as range object
    print (A.intersection(range(5,10)))#Output:{5}
    #iterable is given as a dictionary
    print (A.intersection({1:'a','b':7}))#Output:{1}

    Example 4: Giving iterable as an argument for the & operator

    示例4: & 运算符 提供 iterable 作为参数

    A={1,2,3,4,5}
    B=[1,2,3]
    print (A&B)#Output:TypeError: unsupported operand type(s) for &: 'set' and 'list'

    'intersection_update()' (’intersection_update()’)

    It updates the set, keeping only elements found in it and the other. It’s performed by using intersection_update() or by using the&= operator. The return type is None. It’ll modify the original set itself.

    它更新集合,只保留其中的元素和other 。 它是通过使用intersection_update()或使用&=运算符来执行的。 返回类型为None 。 它将修改原始集本身。

    Syntax

    句法

    intersection_update(*others)

    intersection_update ( *others )

    set &= other & …

    set &= other & …

    Example 1: Find the intersection_update() between two sets — A and B

    示例1:找到 两个集合 A B 之间 intersection_update()

    It’ll update set A by keeping only the elements found in both of the sets.

    通过仅保留在两个集合中找到的元素,它将更新集合A

    #intersection_update()A={1,2,3,4,5}
    B={4,5,6,7,8}
    print (A.intersection_update(B)) #Output: Noneprint (A) #Output: {4,5}A={1,2,3,4,5}
    B={4,5,6,7,8}
    A&=B
    print (A) #Output: {4,5}

    '区别()' (‘difference()’)

    Returns a new set with elements in the set that aren’t in the other. It’s performed by difference() or by using the -operator.

    返回一个新集合,该集合中的元素不在other集合中。 它是通过difference()或使用-运算符执行的。

    Syntax

    句法

    difference(*others)

    difference ( *others )

    set - other - ...

    set - other - ...

    Image for post
    ‘difference()’
    '区别()'

    Example 1: Find the difference between two sets — A and B

    示例1:找出两组之间的差异— A B

    It’ll return a new set containing elements from set A not in set B.

    它将返回一个新集合,其中包含集合A不在集合A中的元素。

    A={1,2,3,4,5}
    B={2,4,6,8}print (A.difference(B))#Output:{1,3,5}print (A-B)#Output:{1,3,5}

    Example 2: Find the difference between more than two sets

    示例2:找出两个以上集合之间的差异

    A={1,2,3,4,5}
    B={2,4,6,8,10}
    C={2,3}
    print (A-B-C)#Output:{1,5}print (A.difference(B,C))#Output:{1,5}

    Difference between the difference() method and the -operator:

    Difference difference()方法和-运算符之间的difference()

    • difference(): It’ll accept any iterable as an argument

      Difference difference() :它将接受任何可迭代的参数

    • - operator: It’ll accept only a set as an argument. Otherwise, it’ll raise a TypeError.

      -运算符:它将仅接受set作为参数。 否则,它将引发TypeError

    Example 3: Giving iterable as an argument in the difference() method

    例3: difference() 方法 中将 iterable 作为参数

    A={1,2,3,4,5}#iterable is given as listprint (A.difference([1,2,3]))#Output:{4,5}
    #iterable is given as tuple
    print (A.difference((1,2,3)))#Output:{4,5}
    #iterable is given as range object
    print (A.difference(range(1,4)))#Output:{4,5}
    #iterable is given as a dictionary
    print (A.difference({1:'a',2:'b',3:'c'}))#Output:{4,5}

    Example 4: Giving iterable as an argument for the - operator

    示例4: - 运算符 提供 iterable 作为参数

    A={1,2,3,4,5}
    B=[1,2,3]
    print (A-B)#Output:TypeError: unsupported operand type(s) for -: 'set' and 'list'

    'difference_update()' (‘difference_update()’)

    Removes the element from the set that’s also present in the other set. It’s performed by using the -= operator or by using the difference_update() method. The return type is None. It’ll modify the original set itself.

    other集合中也存在的集合中删除元素。 通过使用-=运算符或使用difference_update()方法来执行。 返回类型为None 。 它将修改原始集本身。

    Syntax

    句法

    difference_update(*others)

    difference_update ( *others )

    set -= other | ...

    set -= other | ...

    Image for post
    ‘difference_update()’
    'difference_update()'

    Example 1: Find the difference_update() between two sets — A and B

    示例1:找到 两个集合 A B 之间 difference_update()

    It’ll update set A by removing elements that are also present in set B.

    它将通过删除集合B中也存在的元素来更新集合A

    A={1,2,3,4,5}
    B={2,4,6}#Return type is None.print (A.difference_update(B))#Output:None
    #It will update the original set
    print (A) #Output: {1,3,5}
    # difference_update by using -= operator
    A-=(B)
    print (A) #Output: {1,3,5}

    Example 2: Find the difference_update between more than two sets

    示例2:查找 两个以上集合之间 difference_update

    #difference_update() will modify the original set.A={1,2,3}
    B={1}
    C={2}#Return type is None.print (A.difference_update(B,C))#Output:None
    #It will update the original set
    print (A) #Output: {3}
    # difference_update by using -= operator
    A={1,2,3}
    B={1}
    C={2}
    A-=B|C
    print (A) #Output: {3}

    Difference between the difference_update() method and the -= operator:

    Difference_update difference_update()方法和-=运算符之间的difference_update()

    • difference_update(): It’ll accept any iterable as an argument

      Difference_update difference_update() :它将接受任何可迭代的参数

    • -= operator: It’ll accept only a set as an argument. Otherwise, it’ll raise a TypeError.

      -= operator :它将仅接受set作为参数。 否则,它将引发TypeError

    Example 3: Giving iterable as an argument in the difference_update() method

    示例3: difference_update() 方法 中将 iterable 作为参数

    #iterable is given as listA={1,2,3}
    B=[1]
    print (A.difference_update(B))#Output:Noneprint (A)#Output:{2,3}

    Example 4: Giving iterable as an argument for -=operator

    示例4: -= 运算符 提供 iterable 作为参数

    A={1,2,3}
    B=[1]
    A-=B
    print (A) #Output: TypeError: unsupported operand type(s) for -=: 'set' and 'list'

    'symmetric_difference()' (‘symmetric_difference()’)

    Return a new set with elements in either the set or other but not both. It’s performed by symmetric_difference() or by using the ^ operator.

    返回一个新集合,该集合中有一个或other元素,但不包含两个元素。 它是由symmetric_difference()或使用^运算符执行的。

    Syntax

    句法

    symmetric_difference(other)

    symmetric_difference ( other )

    set ^ other

    set ^ other

    Image for post
    symmetric_difference()
    symmetric_difference()

    Example 1: Find the symmetric_difference between two sets — A and B

    示例1:找到 两组 A B 之间 symmetric_difference

    It’ll return a new set containing elements from either set A and set B but not elements found in both sets.

    它将返回一个新集合,其中包含来自集合A和集合B元素,但不包含在两个集合中都找到的元素。

    A={1,2}
    B={2,3}print (A.symmetric_difference(B))#Output:{1,3}print (A^B)#Output:{1,3}

    Example 2: symmetric_difference is only performed between two sets

    示例2: symmetric_difference 差异仅在两组之间执行

    The symmetric_difference() method isn’t supported by multiple sets. If more than two sets are given, it’ll raise a TypeError.

    多个集不支持symmetric_difference() method 。 如果给出两个以上的集合,它将引发TypeError

    A={1,2}
    B={2,3,5}
    C={3,4}print (A.symmetric_difference(B,C))#Output:TypeError: symmetric_difference() takes exactly one argument (2 given)

    But we can find the symmetric_difference of multiple sets using ^.

    但是我们可以使用^找到多个集合的symmetric_difference

    A={1,2}
    B={2,3,5}
    C={3,4}
    print (A^B^C)#Output:{1,4,5}

    The difference between the symmetric_difference method and the& operator:

    symmetric_difference方法和&运算符之间的区别:

    • symmetric_difference(): It’ll accept any iterable as an argument. This method doesn’t allow for multiple sets.

      symmetric_difference() :它将接受任何可迭代的参数。 此方法不允许使用多个集合。

    • ^ operator: It’ll accept only a set as an argument. Otherwise, it’ll raise a TypeError. By using the ^ operator, you can find the symmetric_difference between multiple sets.

      ^运算符:它仅接受set作为参数。 否则,它将引发TypeError 。 通过使用^运算符,您可以找到多个集合之间的symmetric_difference

    Example 3: Giving iterable as an argument in the symmetric_difference method

    示例3: symmetric_difference 方法 中将 iterable 作为参数

    #iterable is given as listA={1,2,3}
    B=[1]
    print (A.symmetric_difference(B))#Output:{2,3}
    #iterable is given as tuple
    A={1,2,3}
    B=(1,)
    print (A.symmetric_difference(B))#Output:{2,3}
    #iterable is given as range object
    A={1,2,3}
    B=range(2)
    print (A.symmetric_difference(B))#Output:{2,3}

    Example 4: Giving iterable as an argument for the ^ operator

    示例4: ^ 运算符 提供 iterable 作为参数

    A={1,2,3}
    B=[1]
    A^B
    print (A) #Output: TypeError: unsupported operand type(s) for ^: 'set' and 'list'

    'symmetric_difference_update()' (‘symmetric_difference_update()’)

    Updates the set, keeping only elements found in either set but not in both. It’s performed by using symmetric_difference_update() or by using the ^= operator. The return type is None. It’ll modify the original set itself.

    更新集合,仅保留在两个集合中均找到的元素,而不同时在两个集合中均找到。 通过使用symmetric_difference_update()或使用^=运算符来执行。 返回类型为None 。 它将修改原始集本身。

    Syntax

    句法

    symmetric_difference_update(other)

    symmetric_difference_update ( other )

    set ^= other

    set ^= other

    Example 1: Find the symmetric_difference_update() between two sets — A and B

    示例1: 在两组A和B之间 找到 symmetric_difference_update()

    It will update set A by keeping only elements found in either set but not in both.

    它将通过仅保留在任一集合中找到但不在两个集合中找到的元素来更新集合A

    #symmetric_difference_update()A={1,2,3,4,5}
    B={4,5,6,7,8}
    print (A.symmetric_difference_update(B)) #Output: Noneprint (A) #Output: {1, 2, 3, 6, 7, 8}A={1,2,3,4,5}
    B={4,5,6,7,8}
    A^=B
    print (A) #Output: {1, 2, 3, 6, 7, 8}

    'isdisjoint()' (‘isdisjoint()’)

    Returns True if the set has no elements in common with the other. Sets are disjointed if and only if their intersection is the empty set.

    如果集合没有与other集合相同的元素,则返回True 。 当且仅当它们的交集为空集时,集才脱节。

    Syntax

    句法

    isdisjoint(other)

    isdisjoint ( other )

    Image for post
    isdisjoint()
    isdisjoint()

    Example

    #Set A and Set B containing common elementsA={1,2,3,4,5}
    B={4,5,6,7,8}
    print (A.isdisjoint(B))#Output:False
    #Set A and Set B not containing common elements
    A={1,2}
    B={3,4}
    print (A.isdisjoint(B))#Output:True

    'issubset()' (‘issubset()’)

    Test whether every element in the set is in other.

    测试集合中的每个元素是否都在other

    Syntax:

    句法:

    issubset(other)

    issubset ( other )

    set <= other

    set <= other

    Image for post
    issubset()
    issubset()

    Example: Check whether set A is a subset of B

    示例:检查集合 A 是否 B 的子集

    Can be done by the issubset()method or by using the operator.

    可以通过issubset()方法或使用运算符来完成。

    A={1,2,3,4,5}
    B={4,5,6,7,8}
    print (A.issubset(B)) #Output: Falseprint (A<=B)#Output: FalseA={1,2,3}
    B={1,2,3,4,5}
    print (A.issubset(B)) #Output: Trueprint (A<=B)#Output: False

    Proper subset

    适当的子集

    Test whether the set is a proper subset of other — that is, set <= other and set != other.

    测试set是否为other的适当子集,即set <= other and set != other

    Syntax

    句法

    set < other

    set < other

    Example: Check whether set A is a proper subset of B

    示例:检查集合 A 是否 B 的适当子集

    If both sets are equal, this means A.issubsetset(B) returns True. But the proper subset A<B will return False.

    如果两个集合相等,则意味着A.issubsetset(B)返回True 。 但是适当的子集A<B将返回False

    A={1,2,3,4,5}
    B={4,5,6,7,8}
    print (A<B)#Output: FalseA={1,2,3,4,5}
    B={1,2,3,4,5}
    print (A<B)#Output: FalseA={1,2,3}
    B={1,2,3,4,5}
    print (A<B)#Output: True

    'issuperset()' (‘issuperset()’)

    Test whether every element in other is in the set.

    测试other元素是否在集合中。

    Syntax

    句法

    issuperset(other)

    issuperset ( other )

    set >= other

    set >= other

    Image for post
    issuperset()
    issuperset()

    Example: Check whether set A is a superset of B

    示例:检查集合 A 是否 B 的超集

    Can be done by theissuperset() method or by using the operator.

    可以通过issuperset()方法或使用运算符来完成。

    A={1,2,3,4,5}
    B={4,5,6,7,8}
    print (A.issuperset(B)) #Output: Falseprint (A>=B)#Output:TrueA={1,2,3,4,5}
    B={1,2,3}
    print (A.issuperset(B)) #Output: Trueprint (A>=B)#Output:True

    Proper superset

    适当的超集

    Test whether the set is a proper superset of other— that is, set >= other and set != other.

    测试集合是否为other的适当超集-即, set >= other and set != other

    Syntax

    句法

    set > other

    set > other

    Example: Check whether set A is a proper superset of B.

    示例:检查集合 A 是否 B 的适当超集

    If both sets are equal, it means A.issuperset(B) returns True. But the proper superset A>B will return False.

    如果两个集合相等,则意味着A.issuperset(B)返回True 。 但是适当的超集A>B将返回 False

    A={1,2,3,4,5}
    B={4,5}
    print (A>B)#Output: TrueA={1,2,3,4,5}
    B={1,2,3,4,5}
    print (A>B)#Output: FalseA={1,2,3}
    B={1,2,3,4,5}
    print (A>B)#Output: True

    注意 (Note)

    Image for post

    All update methods are not supported by frozenset. The frozenset type is immutable and hashable — its contents can’t be altered after it’s created. Since all update methods modify the original set, it’s not supported by frozenset.

    frozenset不支持所有更新方法。 该frozenset类型是不可改变的, 可哈希 -它的创建后,其内容不能被改变。 由于所有更新方法都修改了原始集,所以frozenset不支持frozenset

    结论 (Conclusion)

    Mathematical set operations can be performed in two ways: by using an operator or by using a method.

    可以通过两种方式执行数学设置操作:使用运算符或使用方法。

    The difference is if we use methods, they’ll accept iterable as an argument. But for operators, arguments should be set only. If not, it’ll raise a TypeError. All update methods will update the original set, and it’s not supported in frozenset. Other than update methods, all other methods return a new set.

    区别在于,如果我们使用方法,它们将接受 iterable作为参数。 但是对于运算符,仅应设置参数。 如果没有,它将引发TypeError 。 所有更新方法都将更新原始集合,而且frozenset不支持frozenset 。 除了更新方法外,所有其他方法都返回一个新集合。

    I hope you have found this article helpful — thanks for reading!

    希望本文对您有所帮助-感谢您的阅读!

    翻译自: https://medium.com/better-programming/mathematical-set-operations-in-python-e065aac07413

    python 集合运算

    展开全文
  • python 集合运算

    2019-07-18 12:50:00
    转载于:https://www.cnblogs.com/fanweisheng/p/11206592.html

     

    转载于:https://www.cnblogs.com/fanweisheng/p/11206592.html

    展开全文
  • python集合运算

    2018-10-23 17:08:01
    class orderset:  def __init__(self,list=[]):  self.data = [x for x in list]  def __repr__(self):  return "orderset(%r)"... def __and__(self,rhs): #与运算 取交集&amp;  ...

    class orderset:
        def __init__(self,list=[]):
            self.data = [x for x in list]
        def __repr__(self):
            return "orderset(%r)" % self.data
        def __and__(self,rhs): #与运算 取交集&
            lst = []
            i = [x for x in self.data if x in rhs.data]
            lst.extend(i)
            return lst 
        def __or__(self,rhs):#或运算 取并集|
            lst = []
            lst.extend(self.data)
            i = [x for x in rhs.data if x not in self.data]
            lst.extend(i)
            return lst
        def __xor__(self,rhs): #异或 取对称补集^
            lst = []
            # i = [x for x in self.data if x not in rhs.data]
            # lst.extend(i)
            for x in rhs.data:
                if x not in self.data:
                    lst.append(x)
            for y in self.data:
                if y not in rhs.data:
                   lst.append(y)
            return lst
        def __eq__(self,rhs):
            if self.data == rhs.data:
                return True
            return False
        def __contains__(self,e):
            if e in self.data:
                return True
            return False
    s1 = orderset([1,2,3,4])
    s2 = orderset([3,4,5])
    print(s1)
    print(s2)
    print(s1 & s2)
    print(s1 | s2)
    print(s1 ^ s2)
    if orderset([1,2,3]) != orderset([1,2,3,4]):
        print("orderset([1,2,3])","不相等","orderset([1,2,3,4])")
    if s2 == orderset([3,4,5]):
        print(s2,"等于","orderset([3,4,5])")
    if 2 in s1:
        print("2","在s1内")

    展开全文
  • 每个韦恩(venn)图中的红色部分是给定集合运算得到的结果。? python 集合有一些让你能够执行这些数学运算的方法,还有一些给你等价结果的运算符。 在研究这些方法之前,让我们首先初始化「datascientist」和「data...

    o55g08d9dv.jpg广告关闭

    腾讯云11.11云上盛惠 ,精选热门产品助力上云,云服务器首年88元起,买的越多返的越多,最高返5000元!

    每个韦恩(venn)图中的红色部分是给定集合运算得到的结果。? python 集合有一些让你能够执行这些数学运算的方法,还有一些给你等价结果的运算符。 在研究这些方法之前,让我们首先初始化「datascientist」和「dataengineer」这两个集合。 datascientist = set()dataengineer = set()并集一个表示为「datascientist ...

    两个集合的运算有:交集、并集、差集 分别对应的操作符:& | ^test_list1 = test_list2 = test_set1 = set(test_list1)test_set2 =set(test_list2)print(test_set1 & test_set2)print(test_set1 | test_set2)print(test_set1 ^ test_set2)上面一段代码的运行结果如下:{3, 4} {1, 2, 3, 4, 5, 7} {1, 2, 5, 7}...

    q7myh4hc8a.jpeg

    但集合独特的元素唯一性与 o(1) 时间复杂度的成员检测方法,令其在很多任务中有特别的优势。 本文介绍了 python 集合的常见方法与概念,包括集合元素的操作、基本集合运算以及不可变集等。 了解 python 集合: 它们是什么,如何创建它们,何时使用它们,什么是内置函数,以及它们与集合论操作的关系集合、 列表与元组...

    7g6hzxr3je.jpeg

    但集合独特的元素唯一性与 o(1) 时间复杂度的成员检测方法,令其在很多任务中有特别的优势。 本文介绍了 python 集合的常见方法与概念,包括集合元素的操作、基本集合运算以及不可变集等。 了解 python 集合: 它们是什么,如何创建它们,何时使用它们,什么是内置函数,以及它们与集合论操作的关系集合、 列表与元组...

    这样定义就不会是字典,里面加一些内容。? 2 元祖和列表是有序的,集合是无序的且集合中的元素不重复。 (python根据集合中的每个元素的hash值来判断元素是否重复,所以集合中的每个元素必须是可hash的对象,在python中如果一个对象有一个_hash_的方法,表示该对象可hash)? 3 集合的操作。 (1)add(添加的数是随机...

    c91myfl7j2.jpeg

    密码字符串的安全强度不仅取决于字符串长度,更取决于字符串中包含的字符串种类,包含的种类越多则认为越安全。 除了下面比较传统的方式, ? 之前推送过使用groupby函数实现该功能的代码:python根据字符分组数量判断密码安全强度本文再分享一个使用集合实现同样功能的代码: ?...

    吴六 53 80 97 230 76.673 95001 赵一 68 69 90 227 75.674 95007 郑七 63 82 74219 73.005 95004 李四 56 72 85 213 71.007 95010 陈十 63 60 83 206 68.678 95009冯九 90 56 56 202 67.339 95002 钱二 66 56 76 198 66.0010 95008 王八 58 60 7319163.67=====本节python集合与字典的知识就介绍到这里,下一节我们...

    4tqtkm1d9r.png

    也可以来找它们的相同部分:? 最后来看把它们合并起来形成一个新的set:? 新的set包含它们两个中所有元素。 总结我们看过了list,string(虽然不属于集合),dictionary和set。 我们学习了它们所有的特定运算和独有功能。 我希望这个介绍可以让你对python的集合多点认识...

    4dfbrsjnyh.png

    特点:无序、元素唯一,不支持索引 集合操作 集合创建 ? 添加元素 ? 删除元素 ? 支持删除指定元素。 s2.remove(element)运算:交叉并补 college={语文,高数,物理,体育,电路,python}high={语文,数学,体育,理科,文科} #差集运算 print(college-high) #交集运算print(college&high) #并集运算 print(college|high) #交集...

    *集合: set:持有一系列元素,但是set元素没有重复,并且无序 如何创建:set()并传入一个list,list的元素将作为set 的元素。 s=set()print(s)set()print(len(s))3如何访问:用in操作符判断有没有=()()true set的特点: 1. 内部结构和字典很像,唯一区别是不存储value=()x1=x2=x1:()(x2):()ok 遍历set:通过for循环来...

    python中有两种不同的类型的集合:可变集合和不可变集合。 可变集合可以添加或删除元素,但可变集合存储的元素不能被哈希,因此不能用做字典的键。 不可变集合不能添加或删除元素,集合存储的元素元素可以被哈希,因此可以用做字典的键。 python中集合之间也可以求并集、交集、差集、差分等运算。 二、集合的定义和...

    flm5bklkgu.jpeg

    {6, 虚竹, 乔峰, 段誉}c集合的元素:set()*****d集合的元素:{python爬虫, python基础, python面向对象}set()d集合的元素:set()*****e集合的元素:{0, 1, 2, 3, 4}f集合的元素: {3, 4, 5, 6}e和f执行并集的结果:{0, 1, 2, 3, 4, 5, 6}e集合的元素: {0, 1, 2, 3, 4, 5, 6}? 三.set集合运算符=:相当于调用 issuper...

    创建格式:parame = {value01,value02,...}或者set(value)代码实例student ={tom,jim,mary,tom,jack} #创建集合print(student) #显示集合以及去重功能#判断 tom是否在集合中if(tom in student) : print(true)else :print(false)#集合间的运算 #创建集合a = set(abcd)b = set(abc)#输出集合print(a)print(a-b) #a b的...

    python集合与字典的用法集合:1. 增加 add2. 删除 del 删除集合 discard(常用)删除集合中的元素#删除一个不存在的元素不会报错 remove 删除一个不存在的元素会报错pop随机删除一个值并弹出删除的值3.clear 清除 #清空集合中的元素,集合还存在4.in 判断一个元素是否在集合中5. 去重 例:把列表去重 a= a=list(set(a))6...

    s5gzh1zft.jpeg

    系统:windows 10python:3. 6.0 这个系列是python基础入门今天讲讲: 集合写在前面的话python集合和数学中的集合具有相同的概念集合:由一组不同的元素组合而成集合分为可变集合和不可变集合part 1:集合创建通过set创建可变集合通过frozenset创建不可变集合set(序列),其中序列可以是字符串,列表,元组注意输出的...

    q40h791200.png

    集合list_1 = #列表中有重复的内容 list_1 = set(list_1) #将列表转成集合 print(list_1,type(list_1))? 可以看到转成集合后,会将重复的内容去掉。 集合...运算符list_1 = set() list_2 = set() list_3 = set() list_4 = set() print(list_1 & list_2) #交集print (list_1 | list_2) #并集print (list_1 - list...

    #连接两个字符串abcd1234-运算符除了用于算数减法,还可以用于集合的差集运算:{1, 2, 3, 4, 5} - {3} #差集{1, 2, 4, 5}*运算符除了表示算术乘法,还可用于序列与整数的乘法,表示序列元素的重复,生成新的序列对象:* 3>>> (1, 2, 3) * 3(1, 2, 3, 1, 2, 3, 1, 2, 3)>>> abc *3abcabcabc运算符和在python中分别表示...

    三种方式实现 python 中的集合的交、并、补运算一背景集合这个概念在我们高中阶段就有所了解,毕业已多年,我们一起回顾一下几个集合相关的基本概念吧? 集合是指具有某种特定性质的具体的或抽象的对象汇总而成的集体。 其中,构成集合的这些对象则称为该集合的元素。 集合具有以下几种性质: 确定性 给定一个集合...

    字典字典是python中唯一的映射类型,采用键值对(key-value)的形式存储数据。 python对key进行哈希函数运算,根据计算的结果决定value的存储地址,所以字典是无序存储的,且key必须是可哈希的。 可哈希表示key必须是不可变类型,如:数字、字符串、只含不可变类型元素的元组(1,2,3,’abc’)、实现__hash__()方法的...

    《玩转python轻松过二级》. 清华大学出版社,2018. 第2章 运算符、表达式与内置对象2. 2.4 位运算符与集合运算符 视频内容...

    展开全文
  • Python set是基本数据类型的一种集合类型,它有可变集合(set())和不可变集合(frozenset)两种。创建集合set、集合set添加、集合删除、交集、并集、差集的操作都是非常实用的方法。玩蛇网python之家提示: 推荐在...
  • python集合运算案例

    千次阅读 2018-04-15 18:36:53
    python生成不重复随机数放在列表中的效率比较import random import time def RandomNumbers(number, start, end): '''使用列表来生成number个介于start和end之间的不重复随机数''' data = [] n = 0 while True:...
  • python 集合运算 神器

    2013-05-01 14:42:27
    一. 集合运算 a = [1,2,3] b = [3,4,5] 求a与b的交集 set(a) &amp; set(b)   求a与b的并集 set(a) | set(b)   求a有b没有的集合(a-b) set(a) - set(b)  
  • Python 集合与集合运算

    万次阅读 多人点赞 2019-01-14 10:32:55
    了解 Python 集合: 它们是什么,如何创建它们,何时使用它们,什么是内置函数,以及它们与集合论操作的关系 集合、 列表与元组 列表(list)和元组(tuple)是标准的 Python 数据类型,它们将值存储在一个序列中。...
  • 关于python集合运算谁能解释一下差集、并集、交集、最好能举例说明,差集 a-b 从集合a中去除所有在集合b中出现的元素集合 并集 a|b 集合a,b中所有不重复的元素集合 交集 a&b 集合a,b中均出现的元素集合 如 a={1,2,3,...
  • Python中的集合是一种无序的,无重复值的数据结构类型。Python中的集合可以用来检测元素检测或消除重复的元素。一、python 集合概述(1)Python中的集合元素是无序的,即元素没有顺序问题,也不能像数组、列表、字符...
  • 主要介绍了python集合常见运算,结合具体实例形式分析了Python使用集合生成随机数的几种常用算法的效率比较,需要的朋友可以参考下
  • python 集合运算

    2020-04-07 23:34:49
    Python 集合运算 s = {1,2,3,4,5} s2 = {3,4,5,6,7} # & 交集运算 result = s & s2 # {3, 4, 5} # | 并集运算 result = s | s2 # {1,2,3,4,5,6,7} # - 差集 result = s - s2 # {1, 2} # ^ 异或...
  • python集合运算

    2019-10-07 01:41:26
    python集合运算 & 交集 | 并集 - 差集^ 异或集 # 在对集合做运算时,不会影响原来的集合,而是返回一个运算结果 # 创建两个集合 s = {1,2,3,4,5} s2 = {3,4,5,6,7} # &am...
  • 机器之心编译了解 Python 集合: 它们是什么,如何创建它们,何时使用它们,什么是内置函数,以及它们与集合论操作的关系集合、 列表与元组列表(list)和元组(tup...
  • python集合及其运算

    千次阅读 2019-06-30 23:45:43
    python集合数据类型有可变集合对象(set)和不可变集合对象(frozenset) 集合元素必须是可hash对象,可哈希对象的hash码对应唯一值,所以就是说集合元素必须是不可变的,例如bool, int , float, complex, str, tuple,...
  • 3分钟带你系统的了解Python集合与基本的集合运算.pdf
  • Python集合运算

    千次阅读 2015-09-10 10:22:54
    数学里集合运算Python的set中也有对应运算。
  • Python集合运算

    千次阅读 2020-03-23 11:04:22
    Python中这两个符号可以用来求集合的交集和并集 set_a = {1, 2, 3, 4} set_b = {1, 2, 3, 5} print(set_a & set_b) # 交集:{1, 2, 3} print(set_a | set_b) # 并集:{1, 2, 3, 4, 5} ...
  • >>> set_test {'name', 'age', 'hometown'} >>> set_test.pop() 'name' >>> set_test.pop() 'age'

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 68,723
精华内容 27,489
关键字:

python集合运算

python 订阅