zoukankan      html  css  js  c++  java
  • Python数据结构之四——set(集合)

      Python版本:3.6.2  操作系统:Windows  作者:SmallWZQ

      经过几天的回顾和学习,我终于把Python 3.x中的基础知识介绍好啦。下面将要继续什么呢?让我想想先~~~嗯,还是先整理一下近期有关Python基础知识的随笔吧。

      Python编程软件的安装与使用——Windows、Linux和Mac

      Python基础——输出[print()]与输入[input()]

      Python基础——数据类型与基本运算【主要为除法】

           Python基础——字符串

           Python基础——条件判断

           Python基础——for/while循环

      上述六篇均为Python 3.x的基础知识。九尺高台,起于累土。学习Python就要从最基本开始,经过逐步的积累,才能有所成就。

      Python基础知识再次回顾好了,接下来该干嘛呢?这不继续Python数据结构了吗?

      上次我写了有关Python数据结构(列表、元组、字典)的3篇随笔:

      Python数据结构之一——list(列表)

      Python数据结构之二——tuple(元组)

      Python数据结构之三——dict(字典)

      本篇随笔将开始一段关于set(集合)之旅吧。

      什么是集合呢?

      说到集合,我首先想到了高中的数学。高中,人生学习中最繁忙的一段时光。直到现在,我能回忆起最多的就是学习、学习、还是读书……言归正传,高一时的数学,我们就接触到了集合。书中应该是这样定义的:

      集合:由一个或多个确定的元素所构成的整体。若x是集合A元素,则记作xA

      集合中的元素有三个特征:

      1. 确定性:集合中的元素必须是确定的;

      2. 互异性:集合中的元素互不相同,例如:集合A={1,a},则a不能等于1);

      3. 无序性:集合中的元素没有先后之分,例如:集合{3,4,5}和{3,5,4}算作同一个集合。

      Python 3.x中的set特征与数学中类似。我们之前学过list、tuple以及dict。其实,set与dict大致相同,但set没有Value,只有key。因此,set只是一组key的集合。由于key不能重复,所以,在set中,没有重复的key。

    创建集合

     1.1 创建空集合

      在集合中,创建空集合(set)必须使用函数set()。

    1 #创建空集合
    2 >>>a = set()
    3 >>>a
    4 set()
    5 >>>type(a)
    6 <class 'set'>

      注:不能使用{},{}用于创建空字典。

    1.2 创建非空集合

      非空集合可以用大括号{}或 set() 函数来创建。

     1 #创建集合
     2 >>>a={'a','b','c','d'}
     3 >>>b=set('abcdefabcd')
     4 >>>c=set({'a':1,'b':2,'c':3})
     5 >>>d=set(['a','b','c','a'])
     6 #运行结果
     7 >>>print(a,type(a))
     8 {'c', 'd', 'b', 'a'} <class 'set'>
     9 >>>print(b,type(b))
    10 {'f', 'e', 'b', 'c', 'd', 'a'} <class 'set'>
    11 >>>print(c,type(c))
    12 {'b', 'a','c'} <class 'set'>
    13 >>>print(d,type(d))
    14 {'c', 'b', 'a'} <class 'set'>

      特别地,set中的元素是无序的,并且重复元素在set中自动被过滤。

    1 #set中重复元素被自动过滤
    2 >>>s = {1,2,,1,2,4,4,3,3}
    3 >>>s
    4 {1,2,3,4}

     

    功能属性

      set有很多很多的功能属性。你们不信?不信的话,继续往下看呗~~~

      set功能属性如下:

    1 class set(object):
      2     """
      3     set() -> new empty set object
      4     set(iterable) -> new set object
      5     
      6     Build an unordered collection of unique elements.
      7     """
      8     def add(self, *args, **kwargs): # real signature unknown
      9         """
     10         Add an element to a set.
     11         
     12         This has no effect if the element is already present.
     13         """
     14         pass
     15 
     16     def clear(self, *args, **kwargs): # real signature unknown
     17         """ Remove all elements from this set. """
     18         pass
     19 
     20     def copy(self, *args, **kwargs): # real signature unknown
     21         """ Return a shallow copy of a set. """
     22         pass
     23 
     24     def difference(self, *args, **kwargs): # real signature unknown
     25         """
     26         Return the difference of two or more sets as a new set.
     27         
     28         (i.e. all elements that are in this set but not the others.)
     29         """
     30         pass
     31 
     32     def difference_update(self, *args, **kwargs): # real signature unknown
     33         """ Remove all elements of another set from this set. """
     34         pass
     35 
     36     def discard(self, *args, **kwargs): # real signature unknown
     37         """
     38         Remove an element from a set if it is a member.
     39         
     40         If the element is not a member, do nothing.
     41         """
     42         pass
     43 
     44     def intersection(self, *args, **kwargs): # real signature unknown
     45         """
     46         Return the intersection of two sets as a new set.
     47         
     48         (i.e. all elements that are in both sets.)
     49         """
     50         pass
     51 
     52     def intersection_update(self, *args, **kwargs): # real signature unknown
     53         """ Update a set with the intersection of itself and another. """
     54         pass
     55 
     56     def isdisjoint(self, *args, **kwargs): # real signature unknown
     57         """ Return True if two sets have a null intersection. """
     58         pass
     59 
     60     def issubset(self, *args, **kwargs): # real signature unknown
     61         """ Report whether another set contains this set. """
     62         pass
     63 
     64     def issuperset(self, *args, **kwargs): # real signature unknown
     65         """ Report whether this set contains another set. """
     66         pass
     67 
     68     def pop(self, *args, **kwargs): # real signature unknown
     69         """
     70         Remove and return an arbitrary set element.
     71         Raises KeyError if the set is empty.
     72         """
     73         pass
     74 
     75     def remove(self, *args, **kwargs): # real signature unknown
     76         """
     77         Remove an element from a set; it must be a member.
     78         
     79         If the element is not a member, raise a KeyError.
     80         """
     81         pass
     82 
     83     def symmetric_difference(self, *args, **kwargs): # real signature unknown
     84         """
     85         Return the symmetric difference of two sets as a new set.
     86         
     87         (i.e. all elements that are in exactly one of the sets.)
     88         """
     89         pass
     90 
     91     def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
     92         """ Update a set with the symmetric difference of itself and another. """
     93         pass
     94 
     95     def union(self, *args, **kwargs): # real signature unknown
     96         """
     97         Return the union of sets as a new set.
     98         
     99         (i.e. all elements that are in either set.)
    100         """
    101         pass
    102 
    103     def update(self, *args, **kwargs): # real signature unknown
    104         """ Update a set with the union of itself and others. """
    105         pass
    106 
    107     def __and__(self, *args, **kwargs): # real signature unknown
    108         """ Return self&value. """
    109         pass
    110 
    111     def __contains__(self, y): # real signature unknown; restored from __doc__
    112         """ x.__contains__(y) <==> y in x. """
    113         pass
    114 
    115     def __eq__(self, *args, **kwargs): # real signature unknown
    116         """ Return self==value. """
    117         pass
    118 
    119     def __getattribute__(self, *args, **kwargs): # real signature unknown
    120         """ Return getattr(self, name). """
    121         pass
    122 
    123     def __ge__(self, *args, **kwargs): # real signature unknown
    124         """ Return self>=value. """
    125         pass
    126 
    127     def __gt__(self, *args, **kwargs): # real signature unknown
    128         """ Return self>value. """
    129         pass
    130 
    131     def __iand__(self, *args, **kwargs): # real signature unknown
    132         """ Return self&=value. """
    133         pass
    134 
    135     def __init__(self, seq=()): # known special case of set.__init__
    136         """
    137         set() -> new empty set object
    138         set(iterable) -> new set object
    139         
    140         Build an unordered collection of unique elements.
    141         # (copied from class doc)
    142         """
    143         pass
    144 
    145     def __ior__(self, *args, **kwargs): # real signature unknown
    146         """ Return self|=value. """
    147         pass
    148 
    149     def __isub__(self, *args, **kwargs): # real signature unknown
    150         """ Return self-=value. """
    151         pass
    152 
    153     def __iter__(self, *args, **kwargs): # real signature unknown
    154         """ Implement iter(self). """
    155         pass
    156 
    157     def __ixor__(self, *args, **kwargs): # real signature unknown
    158         """ Return self^=value. """
    159         pass
    160 
    161     def __len__(self, *args, **kwargs): # real signature unknown
    162         """ Return len(self). """
    163         pass
    164 
    165     def __le__(self, *args, **kwargs): # real signature unknown
    166         """ Return self<=value. """
    167         pass
    168 
    169     def __lt__(self, *args, **kwargs): # real signature unknown
    170         """ Return self<value. """
    171         pass
    172 
    173     @staticmethod # known case of __new__
    174     def __new__(*args, **kwargs): # real signature unknown
    175         """ Create and return a new object.  See help(type) for accurate signature. """
    176         pass
    177 
    178     def __ne__(self, *args, **kwargs): # real signature unknown
    179         """ Return self!=value. """
    180         pass
    181 
    182     def __or__(self, *args, **kwargs): # real signature unknown
    183         """ Return self|value. """
    184         pass
    185 
    186     def __rand__(self, *args, **kwargs): # real signature unknown
    187         """ Return value&self. """
    188         pass
    189 
    190     def __reduce__(self, *args, **kwargs): # real signature unknown
    191         """ Return state information for pickling. """
    192         pass
    193 
    194     def __repr__(self, *args, **kwargs): # real signature unknown
    195         """ Return repr(self). """
    196         pass
    197 
    198     def __ror__(self, *args, **kwargs): # real signature unknown
    199         """ Return value|self. """
    200         pass
    201 
    202     def __rsub__(self, *args, **kwargs): # real signature unknown
    203         """ Return value-self. """
    204         pass
    205 
    206     def __rxor__(self, *args, **kwargs): # real signature unknown
    207         """ Return value^self. """
    208         pass
    209 
    210     def __sizeof__(self): # real signature unknown; restored from __doc__
    211         """ S.__sizeof__() -> size of S in memory, in bytes """
    212         pass
    213 
    214     def __sub__(self, *args, **kwargs): # real signature unknown
    215         """ Return self-value. """
    216         pass
    217 
    218     def __xor__(self, *args, **kwargs): # real signature unknown
    219         """ Return self^value. """
    220         pass
    221 
    222     __hash__ = None
    set

       set功能属性虽多,但平时常用的也就那么几个。

    常用属性

      1. 添加元素

      在集合中添加元素,可以使用add()方法,并且不生成一个新的集合。

     1 #添加元素:add()
     2 >>>s = {1,2,3}
     3 >>>s.add(4)
     4 >>>s
     5 {1,2,3,4}
     6 >>>s.add('g')
     7 >>>s
     8 {1,2,3,4,'g'}
     9 >>>s.add(4)
    10 >>>s
    11 {1,2,3,4,'g'}

      add()方法可以向set中添加元素,可以重复添加,但不会有效果。

      2. 删除元素

       set中利用remove()方法可以删除集合中的元素。

    1 #删除元素
    2 >>>s
    3 {1,2,3,4,'g'}
    4 >>>s.remove('g')
    5 >>>s
    6 {1,2,3,4}

      3. 清空元素

      clear()方法可以清空set中的元素。

    1 #清空元素
    2 >>>a = {1,2,3,4}
    3 >>>b = a.clear()
    4 >>>print(a,type(a))
    5 set() <class 'set'>
    6 >>>print(b,type(b))
    7 None <class 'NoneType'>

      4. 复制元素

      copy()方法只能浅拷贝set中的元素,并生成一个新的集合。

     1 #浅拷贝:copy()
     2 >>>a = {1,(9,2),3}
     3 >>>b = a.copy()
     4 >>>print(a,id(a))
     5 {(9, 2), 1, 3} 2097937619880
     6 >>>print(b,id(b))
     7 {(9, 2), 1, 3} 2097937620776
     8 
     9 #赋值
    10 >>>s = {1,2,3,4}
    11 >>>d = s
    12 >>>print(s,id(s))
    13 {1, 2, 3, 4} 2097937785128
    14 >>>print(d,id(d))
    15 {1, 2, 3, 4} 2097937785128

      5. pop()

      pop()方法用于从set中随机取一个元素。记住,是随机的~~~

    1 #pop()方法
    2 >>>s = {1,2,3,4,5,'g','s'}
    3 >>>s.pop()
    4 'g'
    5 >>>s.pop()
    6 3

      6. set集合操作

      set与数学中的集合类似,是无序的和无重复元素的集合。因此,在Python中,set可以进行交集、并集、补集等操作。

    Python set集合操作
    数学符号 Python符号 含义
    - 或 - 差集,相对补集
    & 交集
    | 并集
    != 不等于
    == 等于
    in 是成员关系
    not in 非成员关系
     1 #set集合操作
     2 >>>s = {1,2,3,4}
     3 >>>d = {2.3.5.6}
     4 >>>s & d
     5 {2.3}
     6 >>>s | d
     7 {1,2,3,4,5,6}
     8 >>>s - d
     9 {1,4}
    10 >>>d - s
    11 {5,6}

      set和dict的唯一区别仅在于没有存储对应的value,但是,set的原理和dict一样,所以,同样不可以放入可变对象,因为无法判断两个可变对象是否相等,也就无法保证set内部“不会有重复元素”。因此,最常用的key是字符串。

    “思想者”

      set中存储着key,集合中不能放入可变的对象。之前的文章也说过:tuple是不可变的,而list是可变的。因此,set中是可以存储tuple的。这是真的吗?

      时间是检验真理的唯一标准。下面请看示例代码:

     1 #tuple可以作为集合中的元素
     2 >>>s = {(1,),(1,2,3),1,2,'g'}
     3 >>>s
     4 {(1,),(1,2,3),1,2,'g'}
     5 
     6 #tuple也有失灵的时候
     7 >>>t = (1,2,[1,2,3],4)
     8 >>>type(t)
     9 <class 'tuple'>
    10 >>>d = {1,2,(1,2,[1,2,3],4)}
    11 Traceback (most recent call last):
    12   File "<stdin>", line 1, in <module>
    13 TypeError: unhashable type: 'list'

      为什么会有错误呢?我也不清楚哎~~~这里面的道道很深,请读者细细体会。

      set是一种数据结构。如果要详细的介绍set,我应该可以去出书了。这篇随笔只是起到入门的效果。

      正所谓“师傅”领进门,修行靠大家嘛!

  • 相关阅读:
    tomcat请求流程浅解
    jdk8为啥lambda表达式建议你用冒号形式调用方法
    打印目录树形结构
    类斐波那契数列的java实现
    sping boot 如何将外部引入的jar包打到fat jar里面
    java多线程之生产者消费者
    Hadoop、Hbase、ZooKeeper的搭建
    java 静态代码块、构造代码块、构造函数调用顺序
    MyBatis的 or 和and 问题
    mysql
  • 原文地址:https://www.cnblogs.com/SmallWZQ/p/8488744.html
Copyright © 2011-2022 走看看