精华内容
下载资源
问答
  • 离散数学作业:JAVA实现BitArray形式的集合(用HashSet实现)及其运算(交集,并集,差集)
  • Python集合及其运算

    2019-03-24 15:49:38
    Python集合及其运算 (一)集合 set 集合是由不同可hash的值组成的,里面所有的值都是唯一的,也是无序的 集合的创建 >>>set_test = {"name", "age", "hometown"} ## 把值放入{ }中 >>>lis = (...

    Python集合及其运算

    (一)集合 set

    集合是由不同可hash的值组成的,里面所有的值都是唯一的,也是无序的

    集合的创建
    >>>set_test = {"name", "age", "hometown"}
    ##  把值放入{ }中
    
    >>>lis = ("name", "age", "hometown")
    >>>set_test = set(lis)
    >>> set_test
    {'name', 'age', 'hometown'}
    ##利用set()函数,把其他类型转换为set
    
    >>> list_test = ["name", "age", "hometown"]
    >>> set_test = frozenset(list_test)
    >>> set_test
    frozenset({'name', 'age', 'hometown'})
    ##利用frozenset()函数可以创造一个set,并把它放到元组里面
    

    集合的操作
    • add(self, *args, **kwargs)

      添加值到集合里面

      >>> set_test
      {'name', 'age', 'hometown'}
      >>> set_test.add("hobby")
      >>> set_test
      {'name', 'age', 'hobby', 'hometown'}
      
    • clear(self, *args, **kwargs)

      清空集合

    • copy(self, *args, **kwargs)

      浅拷贝

    • discard(self, *args, **kwargs)

      删除某值,没有时不会报错

      >>> set_test
      {'name', 'age', 'hobby', 'hometown'}
      >>> set_test.discard("hobby")
      >>> set_test
      {'name', 'age', 'hometown'}
      
    • pop(self, *args, **kwargs)

      当集合是由列表和元组组成时,set.pop()是从左边删除元素的,并且可以得到被删除的值

      >>> set_test
      {'name', 'age', 'hometown'}
      >>> set_test.pop()
      'name'
      >>> set_test.pop()
      'age'
      
    • remove(self, *args, **kwargs)

      删除某值,但是如果没有的话,就会报错

      >>> set_test = {'name', 'age', 'hometown'}
      >>> set_test.remove("hometown")
      >>> set_test
      {'name', 'age'}
      
    • update(self, *args, **kwargs)

      更新值,可以在set里面添加多个值

      >>> set_test = {"Jack", "Mark", "Ada"}
      >>> set_test.update(["Jewish", "Obanma", "Anna"])
      >>> print(set_test)
      {'Obanma', 'Mark', 'Jack', 'Anna', 'Ada', 'Jewish'}
      

    集合的运算

    • 求交集

      >>> set_test1 = {"YuanMing", "Hermaeus", "Chenglong", "Kelan"}
      >>> set_test2 = {"YuanMing", "Hermaeus", "ZhangJie","Jack"}
      
      >>> test_result = set_test1.intersection(set_test2)
      >>> print(test_result)
      {'YuanMing', 'Hermaeus'}
      
      >>> test_result = set_test1&set_test2
      >>> print(test_result)
      {'YuanMing', 'Hermaeus'}
      
    • 求并集

      >>> set_test1 = {"YuanMing", "Hermaeus", "Chenglong", "Kelan"}
      >>> set_test2 = {"YuanMing", "Hermaeus", "ZhangJie","Jack"}
      
      >>> test_result = set_test1.union(set_test2)
      >>> print(test_result)
      {'Kelan', 'YuanMing', 'ZhangJie', 'Jack', 'Hermaeus', 'Chenglong'}
      
      >>> test_result = set_test1|set_test2
      >>> print(test_result)
      {'Kelan', 'YuanMing', 'ZhangJie', 'Jack', 'Hermaeus', 'Chenglong'}
      
    • 求差集

      >>> set_test1 = {"YuanMing", "Hermaeus", "Chenglong", "Kelan"}
      >>> set_test2 = {"YuanMing", "Hermaeus", "ZhangJie","Jack"}
      
      >>> test_result = set_test1.difference(set_test2)
      >>> test_result1 = set_test1.difference(set_test2)
      >>> print(test_result1)
      {'Kelan', 'Chenglong'}
      
      >>> test_result1 = set_test1-set_test2
      >>> print(test_result1)
      {'Kelan', 'Chenglong'}
      
      >>> test_result2 = set_test2.difference(set_test1)
      >>> print(test_result2)
      {'ZhangJie', 'Jack'}
      
      >>> test_result2 = set_test2-set_test1
      >>> print(test_result2)
      {'ZhangJie', 'Jack'}
      
    • 求交叉补集

      >>> set_test1 = {"YuanMing", "Hermaeus", "Chenglong", "Kelan"}
      >>> set_test2 = {"YuanMing", "Hermaeus", "ZhangJie","Jack"}
      >>> test_result = set_test1.symmetric_difference(set_test2)
      >>> print(test_result)
      {'ZhangJie', 'Jack', 'Kelan', 'Chenglong'}
      >>> test_result = set_test1^set_test2
      >>> print(test_result)
      {'ZhangJie', 'Jack', 'Kelan', 'Chenglong'}
      
    • 求集赋值

      • symmetric_difference_update(self, *args, **kwargs)

        >>> set_test1 = {"Jack", "Mark", "Devid"}
        >>> set_test2 = {"Jack", "Marish", "Good"}
        
        >>> set_test1.symmetric_update(set_test2)
        >>> set_test1.symmetric_difference_update(set_test2)  ## 把得到值赋予set_test1
        >>> set_test1, set_test2
        ({'Good', 'Marish', 'Devid', 'Mark'}, {'Good', 'Jack', 'Marish'})
        
        >>> set_test1 ^= set_test2			 
        >>> set_test1			 
        {'Good', 'Marish', 'Devid', 'Mark'}
        
      • intersection_update(self, *args, **kwargs)

        >>> set_test1 = {"Jack", "Mark", "Devid"}
        >>> set_test2 = {"Jack", "Marish", "Good"}
        
        >>> set_test1.intersection_update(set_test2)  ##把得到的值赋予set_test1
        >>> set_test1, set_test2
        ({'Jack'}, {'Good', 'Jack', 'Marish'})
        
        >>> set_test1 &= set_test2			 
        >>> set_test1			 
        {'Jack'}
        
      • difference_update(self, *args, **kwargs)

        >>> set_test1 = {"Jack", "Mark", "Devid"}
        >>> set_test2 = {"Jack", "Marish", "Good"}
        
        >>> set_test1.difference_update(set_test2)
        >>> set_test1, set_test2
        ({'Devid', 'Mark'}, {'Good', 'Jack', 'Marish'})
        >>> set_test1 = {"Jack", "Mark", "Devid"}			 
        >>> set_test2 = {"Jack", "Marish", "Good"}	
        
        >>> set_test1 -= set_test2			 
        >>> set_test1			 
        {'Devid', 'Mark'}
        
      • set_test1 |= set_test2

        >>> set_test1 = {"Jack", "Mark", "Devid"}			 
        >>> set_test2 = {"Jack", "Marish", "Good"}
        >>> set_test1 |= set_test2			 
        >>> set_test1		
        

    子集与父集

    • issubset(self, *args, **kwargs)

      A.issubset(B) A是B的子集吗? 返回bool

      >>> set_test2 = {"Jack", "Marish", "Good"}
      >>> set_test1 = {"Jack"}
      >>> set_test2.issubset(set_test1)
      False
      >>> set_test1.issubset(set_test2)
      True
      
    • issuperset(self, *args, **kwargs)

      A.issuperset(B) A是B的父集吗? 返回bool

      >>> set_test2 = {"Jack", "Marish", "Good"}
      >>> set_test1 = {"Jack"}
      >>> set_test1.issuperset(set_test2)
      False
      >>> set_test2.issuperset(set_test1)			 
      True
      
    • isdisjoint(self, *args, **kwargs)

      返回True如果两个set没有交集

      >>> set_test1 = {"Jack", "Mark", "Devid"}		 
      >>> set_test2 = {"Ada", "Marish", "Good"}			 
      >>> set_test1.isdisjoint(set_test2)			 
      True
      
    • <,<= OR >,>=

      >>> set_test1 = {"Jack", "Mark", "Devid"}			 
      >>> set_test2 = {"Jack", "Mark"
      >>> set_test1 < set_test2			 
      False
      >>> set_test1 > set_test2			 
      True
      
    展开全文
  • 第一章 集合及其运算

    集合的概念

    通常将一些具有确定的、可以区分的若干事件的全体称为集合,而将这些事件称为集合的元素。集合的元素不能重复出现,集合中的元素无顺序之分。

    集合的特点:
    (1)集合中的元素是确定的。
    (2)集合中的每个元素是可以互相区分开的。
    (3)组成一个集合的每个元素在该集合中是无次序的,可以任意列出。
    (4)集合的元素可以是任何事物,甚至是某个一集合。
    (5)集合元素的个数没有限制,它可以是有限个也可以是无限个

    有限集合:集合内元素个数有限(有限集合 A 中所含元素的个数记作 |A| )
    无限集合:集合内元素个数无限

    集合 与 元素 之间存在属于“ \in ”或不属于“\notin”关系

    集合的表示方法

    1.列举法,是列出集合的所有元素,并用花括号括起来

    例如:A={a,b,c,d}N={0,1,2,3,...}S={a,b,c,...,z}A=\{a,b,c,d\}、N=\{0,1,2,3,...\}、S=\{a,b,c,...,z\}

    2.描述法,是将集合中元素的共同属性描述出来

    例如:B={xx21=0xR}D={xx}B=\{x|x^2-1=0且x\in R\}、D=\{x|x是正整数\}

    3.文氏图法(图示法),是用一个简单的平面区域表示一个集合,用区域内的点表示集合内的元素

    常见的几个集合用特定的符号表示如下:
    1.自然数集合 N={0,1,2,3,...}N=\{0,1,2,3,...\}
    2.整数集合 Z={...,2,1,0,1,2,...}Z=\{...,-2,-1,0,1,2,...\}
    3.有理数集合 Q={xx}Q=\{x|x是有理数\}
    4.实数集合 R={xx}R=\{x|x是实数\}
    5.复数集合 C={xx=a+bi,a,bR,i=1}C=\{x|x=a+bi,a,b\in R,i=\sqrt {-1}\}

    集合之间的关系

    对任意两个集合AABB,若AA中的每个元素都是BB中的元素,则称AABB的子集,记作ABA \subseteq BBAB \supseteq A
    AABB的子集,也称BB包含AA,或AABB包含。
    AA不是BB的子集,即ABA \subseteq B不成立,则记作ABA\nsubseteq B
    自然数集合NN、有理数集合QQ、实数集合RR之间有关系NQRN \subseteq Q \subseteq R
    对任意两个集合AABB,若ABA \subseteq BBAB \subseteq A,则称AABB相等,记作 A=BA=B ,若AABB不相等,则记作 ABA≠B
    对任意两个集合AABB,若ABA \subseteq BABA≠B,则称AABB的真子集,记作ABA \subset BBAB \supset A
    AA不是BB的真子集,则记作(符号打不出来,实际没有下面那条横杠)ABA\nsubseteq B
    自然数集合NN、有理数集合QQ、实数集合RR之间有关系NQRN \subset Q \subset R

    包含关系具有下面一些重要性质:
    1.自反性:对于任意集合AA,有AAA\subseteq A
    2.反对称性:对任意两个集合AABB,若ABA\subseteq BBAB\subseteq A,则A=BA=B
    3.传递性:对任意3个集合ABCA、B、C,若ABBCA\subseteq B,B\subseteq C,则ACA\subseteq C

    特殊集合:

    空集、全集、幂集是3个特殊集合,它们在集合论中的地位非常重要。

    不含任何元素的集合为空集,记作\varnothing,空集是惟一的,它是任何集合的子集。

    含有nn个元素的集合简称nn元集,它的含有m(mn)m(m≤n)个元素的子集叫做它的mm元子集。

    任给一个nn元集,可用下列方法求出它的全部子集:
    例:设A=0,1,2A={0,1,2},写出AA的全部子集:
    解 将AA的子集分类如下:
    0元子集,即空集:\varnothing
    1元子集,即单元集:{0},{1},{2}\{0\},\{1\},\{2\}
    2元子集:{0,1},{0,2},{1,2}\{0,1\},\{0,2\},\{1,2\}
    3元子集:{0,1,2}\{0,1,2\}

    一般来说,对于nn元集AA,它的0元子集有Cn0C_n^0个,1元子集有Cn1C_n^1个,… m元子集有CnmC_n^m个,… n元子集有CnnC_n^n个,全部子集有Cn0+Cn1+...+Cnn=2nC_n^0+C_n^1+...+C_n^n=2^n个。

    在一个具体问题中,如果所涉及的集合都是某个集合的子集,则将这个集合称为全集,记作EE

    AA是一个集合,由AA的所有子集组成的集合,称为AA的幂集,记作 P(A)P( A )2A2^A。也可写成P(A)={xxA}P(A)=\{x|x \subseteq A\}。若集合 AA 是由 nn 个元素所组成的有限集合,即 An| A | = n ,则幂集是由2n2^n个元素组成,即P(A)=2n|P( A )|=2^n
    对任意集合AA,有A\varnothing \subseteq AAAA\subseteq A,因此有P(A)\varnothing \in P(A)AP(A)A \in P(A)

    集合的基本运算

    两个集合 AABB 之间存在并\cup、交\cap、差、补\sim和对称差\oplus等五种运算,通过这些运算就能得到新的集合。

    1. 并集AB={xxAxB}A \cup B = \{x|x \in A 或 x \in B\}AABB的所有元素组成的集合
    2. 交集AB={xxAxB}A \cap B = \{x|x \in A 且 x \in B\}AABB的公共元素组成的集合
    3. 差集AB={xxAxB}A-B=\{x|x \in A 且 x\notin B\} 由属于AA而不属于BB的所有元素组成的集合
    4. 补集A={xxExA}\sim A=\{x|x \in E 且 x \notin A\} 由属于全集EE且不属于AA的元素组成的集合
    5. 对称差AB=(AB)(BA)=(AB)(AB)A\oplus B=(A-B)\cup (B-A)=(A\cup B)-(A\cap B) 由分别属于AABB的元素但不属于它们公共元素组成的集合

    由以上定义可以推出以下关系式:
    AAB,BAB,ABA,ABB,ABAB,AB=AB A\subseteq A \cup B,B\subseteq A \cup B,\\ A\cap B\subseteq A,A\cap B\subseteq B,\\ A\cap B \subseteq A \cup B,\\ A-B=A\cap \sim B

    集合运算的性质

    下面以恒等式的形式给出集合运算满足的主要运算律,其中ABCA、B、C是任意集合和EE是全集。
    1.交换律AB=BAAB=BAA \cup B=B \cup A\\ A \cap B=B \cap A
    2.结合律(AB)C=A(BC)(AB)C=A(BC)(A \cup B)\cup C=A \cup (B \cup C)\\ (A \cap B) \cap C=A \cap (B \cap C)
    3.分配律A(BC)=(AB)(AC)A(BC)=(AB)(AC)A \cup (B \cap C)=(A \cup B) \cap (A \cup C)\\ A\cap (B \cup C)=(A \cap B) \cup (A \cap C)
    4.幂等律AA=AAA=AA \cup A = A\\ A \cap A = A
    5.同一律A=AAE=AA \cup \varnothing = A\\ A \cap E=A
    6.零律AE=EA=A \cup E = E\\ A \cap \varnothing = \varnothing
    7.补余律AA=EAA=A \cup \sim A=E\\ A \cap \sim A=\varnothing
    8.吸收率A(AB)=AA(AB)=AA \cup (A \cap B)=A\\ A \cap (A \cup B)=A
    9.德摩根律A(BC)=(AB)(AC)A(BC)=(AB)(AC)(BC)=BC(BC)=BC=EE=A-(B \cup C)=(A-B) \cap (A-C)\\ A-(B \cap C)=(A-B) \cup (A-C)\\ \sim (B \cup C)=\sim B \cap \sim C\\ \sim (B \cap C)=\sim B \cup \sim C\\ \sim \varnothing =E\\ \sim E=\varnothing
    10.双补率(A)=A\sim (\sim A)=A

    对称差运算也有类似的性质:
    11.交换律AB=BAA \oplus B = B \oplus A
    12.结合律(AB)C=A(BC)(A \oplus B) \oplus C =A \oplus (B \oplus C)
    13.分配律A(BC)=(AB)(AC)A \cap (B \oplus C)=(A\cap B) \oplus (A \cap C)
    14.同一律A=AA \oplus \varnothing =A
    15.零律AA=A \oplus A = \varnothing
    16.A(AB)=BA \oplus (A \oplus B)=B

    有限集合的计数

    计算有限集合中元素的个数就是有限集合的计数问题。
    假设AA是一个有限集合,A|A|表示有限集合AA中元素的个数。

    定理:对任意两个有限集合AABB,则:
    ABA+BABmin{A,B}ABABAB=A+B2AB |A \cup B|≤|A|+|B|\\ |A \cap B|≤min\{|A|,|B|\}\\ |A-B|≥|A|-|B|\\ |A \oplus B|=|A|+|B|-2|A \cap B|

    在计数时,为了使若干集合重叠部分的元素的个数不被重复计算,人们研究出一种计数方法,这种方法的基本思想是:先不考虑重叠的情况,把包含于这些集合中的所有元素个数先分别计算出来,然后再把计数时重复计算的元素个数排斥出去,使得计算的结果既无遗漏又无重复,这种计数的方法称为容斥定理。

    容斥定理(简单情况):
    对任意两个有限集合 AABB ,有
    AB=A+BAB|A \cup B|=|A|+|B|-|A \cap B|
    其中,AB|A|、|B|分别表示 AABB 的元素个数

    推广结论:对于任意三个有限集合 A,B,CA , B , C ,有
    ABC=A+B+CABACBC+ABC|A \cup B \cup C|=|A|+|B|+|C|-|A \cap B|-|A \cap C|-|B \cap C|+|A \cap B \cap C|

    进一步推广到nn个集合的情况,若nn是自然数,且n>1A1,A2,A3,...,Ann>1,A_1,A_2,A_3,...,A_n为有限集合,则A1A2A3...An=i=1nAi1i<jnAiAj+1i<j<knAiAjAk+...+(1)n1A1A2...An |A_1 \cup A_2 \cup A_3 \cup...\cup A_n|=\\ \sum^n_{i=1}|A_i|-\sum_{1≤i<j≤n}|A_i\cap A_j|+\sum_{1≤i<j<k≤n}|A_i\cap A_j \cap A_k|+...+(-1)^{n-1}|A_1\cap A_2 \cap ... \cap A_n|

    展开全文
  • python:集合及其运算

    2017-12-14 23:12:00
    #集合及其运算list_1 = set([1,4,5,7,3,6,7,9])list_2 = set([2,6,0,66,22,8,4])print(list_1, list_2)#交集print(list_1.intersection(list_2))print(list_1 & list_2)#并集print(list_1.union(list_2))print...
    #集合及其运算
    list_1 = set([1,4,5,7,3,6,7,9])
    list_2 = set([2,6,0,66,22,8,4])
    print(list_1, list_2)
    #交集
    print(list_1.intersection(list_2))
    print(list_1 & list_2)
    #并集
    print(list_1.union(list_2))
    print(list_1 | list_2)
    #差集
    print(list_1.difference(list_2))
    print(list_1 - list_2)
    #对称差集
    print(list_1.symmetric_difference(list_2))
    print(list_1 ^ list_2)
    #子集
    list_3 = set([1,3,7])
    print(list_3.issubset(list_1))
    print(list_1.issuperset(list_3))

    #没有交集
    list_4 = set([100])
    print(list_1.isdisjoint(list_4))

    #基本操作
    #添加元素
    list_1.add(100) #添加一项
    list_1.update([20,30,40])
    print(list_1)
    #删除元素
    print(list_1)
    list_1.remove(3)#若元素不包含在集合中,会报错
    list_1.discard(5)#若元素不包含在集合中,不会报错
    list_1.pop()
    print(list_1)
    #测试是否为成员
    print(100 in list_1)

    转载于:https://www.cnblogs.com/cansun/p/8040513.html

    展开全文
  • Python核心数据类型之集合类型及其运算集合:set、frozenset无序排列、可哈希;支持集合关系测试,成员关系测试(in,not in)、支持迭代集合支持操作:s | t :并集s &amp; t :交集s ^ t :对称差集s - t :差集...
    Python核心数据类型之集合类型及其运算

    集合:set、frozenset

    无序排列、可哈希;支持集合关系测试,成员关系测试(in,not in)、支持迭代

    集合支持操作:

    s | t :并集

    s & t :交集

    s ^ t :对称差集

    s - t :差集

    len(s):长度

    max(s):最大值

    min(s):最小值

    不支持操作:索引、元素获取、切片

    集合的类型:可变集合set(), 不可变集合frozenset()

    没有特定语法格式,只能通过工厂函数创建

    可变集合内置函数:          

    s1.add(v):集合中加入元素v

    s1.issubset(s2):s1是否是s2的子集

    s1.clear():清除s1中对象

    s1.issuperset():s1是否是s2的超集

    s1.isdisjoint(s2):是否有相同项,没有则返回true

    s1.copy():创建一个s1的副本

    s1.pop():弹出一个s1对象

    s1.difference(s2):求差集                  

    s1.remove(x):移除集合中的x元素,如果x不是s1中值,则引发keyError异常

    s1.difference_update(s2):求差集并将差集更新到s1

    s1.symmetric_difference(s2):求对称差集,返回所有在s或t中,但又同时不在这两个集合中的项

    s1.symmetric_difference_update(s2):求对称差集并将对称差集更新到s1

    s1.intersection(s2):求交集

    s1.union(s2):求并集

    s1.intersection_update(s2):求交集并将交集更新到s1

    s1.update(s2):将s2元素更新到s1中

    不可变集合内置函数:

    frozenset.copy                  frozenset.issuperset

    frozenset.difference            frozenset.mro

    frozenset.intersection          frozenset.symmetric_difference

    frozenset.isdisjoint            frozenset.union

    frozenset.issubset             

    例1:创建集合及其常用方法

    [root@test ~]# ipython

    In [1]: s1 = set()

    In [2]: type(s1)

    Out[2]: set

    In [3]: s1 = set([1,2,3,4])

    In [4]: len(s1)

    Out[4]: 4

    In [5]: max(s1)

    Out[5]: 4

    In [6]: min(s1)

    Out[6]: 1

    In [7]: s1.

    s1.add                          s1.issubset

    s1.clear                       s1.issuperset

    s1.copy                         s1.pop

    s1.difference                   s1.remove

    s1.difference_update            s1.symmetric_difference

    s1.discard                     s1.symmetric_difference_update

    s1.intersection                 s1.union

    s1.intersection_update          s1.update

    s1.isdisjoint

    例2:集合支持的操作                 

    In [7]: s2 = set([3,4,5,6])

    In [8]: s1 & s2

    Out[8]: {3, 4}

    In [9]: s1.intersection(s2)

    Out[9]: {3, 4}

    In [10]: s1 | s2

    Out[10]: {1, 2, 3, 4, 5, 6}

    In [11]: s1.union(s2)

    Out[11]: {1, 2, 3, 4, 5, 6}

    In [12]: s1 ^ s2

    Out[12]: {1, 2, 5, 6}

    In [13]: s1.symmetric_difference(s2)

    Out[13]: {1, 2, 5, 6}

    In [14]: s1 - s2

    Out[14]: {1, 2}

    In [15]: s1.difference(s2)

    Out[15]: {1, 2}

    In [16]: s1.symmetric_difference_update(s2)

    In [17]: print s1

    set([1, 2, 5, 6])

    In [18]: s1.difference(s2)

    Out[18]: {1, 2}

    In [19]: s1.difference_update(s2)

    In [20]: print s1

    set([1, 2])

    例3:集合内置方法的使用

    In [21]: s3 = set('xyz')

    In [22]: print s3

    set(['y', 'x', 'z'])

    In [23]: s3.pop()

    Out[23]: 'y'

    In [24]: s3.pop()

    Out[24]: 'x'

    In [25]: s3.pop()

    Out[25]: 'z'

    In [26]: s3.pop()

    ---------------------------------------------------------------------------

    KeyError                                  Traceback(most recent call last)

    <ipython-input-26-aa97d01de6b1> in<module>()

    ----> 1 s3.pop()

    KeyError: 'pop from an empty set'

    #使用pop()逐一弹出集合内元素,元素为空时会返回值错误

    In [27]: id(s1)

    Out[27]: 44439440

    In [28]: s3 = set('xyx')

    In [29]: s1.update(s3)

    In [30]: print s1

    set([1, 2, 'y', 'x'])

    In [31]: id(s1)

    Out[31]: 44439440

    #可变集合改变元素,id不变

    In [32]: s1.add('z')

    In [33]: print s1

    set([1, 2, 'y', 'x', 'z'])

    In [34]: s1.add('KEY')

    In [35]: print s1

    set([1, 2, 'KEY', 'y', 'x', 'z'])

    In [36]: s4=s1.copy()

    In [37]: id(s4)

    Out[37]: 45252920

    In [38]: print s4

    set([1, 2, 'KEY', 'y', 'x', 'z'])

    In [39]: s1.clear()

    In [40]: print s1

    set([])

    In [41]: help(s1.remove)

    In [42]: s4.remove('key')

    ---------------------------------------------------------------------------

    KeyError                                  Traceback(most recent call last)

    <ipython-input-42-b25bacfc3369> in<module>()

    ----> 1 s4.remove('key')

    KeyError: 'key'

    # 集合使用remove()方法移除一个不存在元素时,会返回值错误

    In [43]: s4.remove('KEY')

    In [44]: print s4

    set([1, 2, 'y', 'x', 'z'])

    In [45]: s4.remove('y')

    In [46]: print s4

    set([1, 2, 'x', 'z'])

    例4、不可变集合内置方法

    In [47]: frozenset.

    frozenset.copy                  frozenset.issuperset

    frozenset.difference            frozenset.mro

    frozenset.intersection          frozenset.symmetric_difference

    frozenset.isdisjoint            frozenset.union

    frozenset.issubset             



    展开全文
  • 一、集合定义及其功能集合是一个无序的、不重复的数据组合,和字典列表一样也是一种数据类型。集合两个最主要的功能:①去重(把一个列表变成集合,就自动去重了)②关系测试(测试两组数据之间的交、并、差集等关系...
  • 集合及其运算

    2018-01-21 21:01:00
    list_1=[1,4,5,7,3,6,7,9] list_1=set(list_1)#将列表转化成集合操作,集合最好的应用是去重 list_2=set([2,6,0,66,22,8]) print(list_1,list_2) #取两个集合交叉的内容,...#取两个集合的并集 print(list_1.uni...
  • python3.5-集合及其运算

    2019-06-27 12:06:22
    关系测试:测试两组数据之间的交集,差集,并集等关系。 ———————————————————————————— 第一部分,基本的,集合的操作,啥也不多说,直接上代码。 __author__="heixiong" # 使用set...
  • #并集 print(list_1.union(list_2 ) ) #联合 print(list_1 | list_2) #差集 print(list_1.difference(list_2) ) # in list_1 but not in list_2 print(list_1 - list_2) print(list_2.difference(list_1 ) ) # in ...
  • python集合及其运算

    千次阅读 2019-06-30 23:45:43
    3, 集合的运算并集, 交集, 差集和对称差集   运算符 说明 | 取并集 & 取交集 - 取差集 ...
  • | 并集运算(两个集合所有的元素,相同的合并) result = s | s2 3 - 差集运算(s2比s相差的元素) result = s - s2 # {1,2} result = s2 - s # {6,7} 4 ^ 亦或集( 两个集合不同的元素) result = s2 ...
  • 集合运算: s^s0:s集合-s0集合(差集) s|s0:s集合∪s0集合(并集) 集合运算技巧: 1.枚举s集合的所有子集 for(int s0=s;s0;s0=(s0-1)&s)//s0是s集合的所有子集
  • Python 集合及其运算

    2019-08-01 17:38:51
    # | 并集运算 result = s | s2 # {1,2,3,4,5,6,7} # - 差集 result = s - s2 # {1, 2} # ^ 异或集 获取只在一个集合中出现的元素 result = s ^ s2 # {1, 2, 6, 7} # 检查一个集合是否是另一个集合的子集 # 如果a...
  • 集合的表示及其运算

    2015-03-07 16:09:06
    下面来说明集合的表示及其运算。 一,集合的表示及基本操作 C语言中集合采用二进制码来表示,相当于将集合编码成一个整数。利用公式f(S)=∑2^i(i∈S)即可将集合编码成为一个整数。下面假设集合中一共有n个元素,编号...
  • 文章目录任务详解:1....【第一章 线性代数】1.1矩阵及其运算合集 虽然是数学基础,但是有些很基础的就略过。。。例如什么叫矩阵,但是提纲会列出来 任务详解: 本节课主要介绍了矩阵的基本概念及意义,矩阵...
  • 10.集合及其运算

    2019-10-08 09:55:57
    对称差集(去掉交集的并集) >>> a = set([1,2,3,4,5]) >>> b = set([3,4,5,6,7]) >>> print (a. symmetric_difference (b)) {1, 2, 6, 7}     二、求这些集合的方式也可以用符号表示 1、交集: &...
  • 主要介绍了Python3.5集合及其常见运算,结合实例形式分析了Python3.5集合的定义、功能、交集、并集、差集等常见操作技巧与相关注意事项,需要的朋友可以参考下
  • 一、集合定义及其功能 集合是一个无序的、不重复的数据组合,和字典列表一样也是一种数据类型。 集合两个最主要的功能:①去重(把一个列表变成集合,就自动去重了) ②关系测试(测试两组数据之间的交、并、差集...
  • Python3.5——集合及其运算

    千次阅读 2017-08-31 22:29:44
    (2)测试关系:测试两组数据之间交集、并集、差集等关系。 3、集合常用的操作: (1)去重复:将列表变成集合,形式:集合=set(列表) list_1 = [1,3,5,3,6,8,9,6,8,1] list_1 = set(list_1) print(l
  • 集合及其运算-prolog

    千次阅读 2007-11-30 17:46:00
    集合及其运算基本集合运算谓词通常我们用表结构来表示集合。集合与表的差别在于:集合中不容许包含重复元素,例如,[1,2,4,3]是一个集合,而[1,1,2,4,3]不是一个集合,它包含两个1。集合元素的枚举可以采用表元素的...
  • 第一节 集合及其运算 集合是中学时就接触过的概念,其运算性质有交换律、分配律、De Morgan律等。此节的重点是理解一下集合极限的概念。 首先定义一下多个集合的交与并的定义。对于可数个或可列个集合的交或并是显然...
  • 肖老师分享关于高中数学知识点总结汇总归纳:集合及其运算。 一、集 合 1.集合的含义与表示 (1)了解集合的含义、元素与集合的属于关系. (2)能用自然语言、图形语言、集合语言(列举法或描述法)描述不同的具体问题. 2...
  • print(list_1.union(list_2)) #求并集 print(list_1.difference(list_2)) #求差集 {8, 1, 4} print(list_1.issubset(list_2)) #求子集 判断1是否是2的子集 False print(list_1.issuperset(list_2)) #求父集 判断1...
  • # Author: Allenlee list_1 = [1,4,5,7,3,6,7,9] list_1 = set(list_1) list_2 = set([2,6,0,66,22,8,4]) print(list_1,list_2) #交集 print(list_1.intersection(list_2)) ...#并集 print(l...
  • # pcjlist_1=[1,2,3,4,5,6,1,4]print(list_1)list_1=set(list_1)print(list_1,type(list_1))list_2=set([1,5,9,8])print(list_1,list_2)#交集print(list_1.intersection(list_2))#并集 去重之后的print(list_1.union...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,291
精华内容 2,116
关键字:

并集及其运算