您的位置:时时app平台注册网站 > 编程知识 > Python数据结构之四——set(集合)

Python数据结构之四——set(集合)

2019-11-21 02:20

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

Python中常见的数据类型小结,python数据类型小结

Python提供多种数据类型来存放数据项集合,主要包括序列(列表list和元组tuple),映射(如字典dict),集合(set),下面对这几种一一介绍:

一 序列

1.列表list

列表是一种有序的集合,相对于元组和字符串的不同是它其中的元素可变,可以随时添加和删除其中的元素。

(1)创建list

在命令行中测试,如下:

>>> L1 = [1,2,3]
>>> L1
[1, 2, 3]
>>> L2 = ['abc']
>>> L2
['abc']
>>> L3 = ["a","b","c"]
>>> L3
['a', 'b', 'c']

注意,字符串的一定要加引号。

通过list对字符串创建列表非常有效,比如:

>>> L = list("Python")
>>> L
['P', 'y', 't', 'h', 'o', 'n']

(2)访问list

根据索引来访问,注意不能越界,这一点跟数组特别像:

>>> L[0]
'P'
>>> L[-1]
'n'

(3)添加新元素

用append()方法,把新元素追加到list的末尾;insert()可以将一个新元素添加到特定的位置。

(4) 删除元素

删除元素可以采用pop()方法,执行L.pop()删除list的最后一个元素,如果是特定位置的话可以采用pop(2),2表示的是位置。

(5)替换

替换很简单,直接索引就可以。

(6)打印

>>> L = ['a','b','c']
>>> for i in L:
 print(i) 
a
b
c

2. tuple

(1)创建

与list所不同的是,tuple一般采用()括起来,命令行中测试,如下:

T= 1,2,3
>>> T
(1, 2, 3)
>>> T = (1,2,3)
>>> T
(1, 2, 3)
>>> T = "abc"
>>> T
'abc'

创建空元组:T = ()

定义一个元素的元组:

>>> T = (1)
>>> T
1
这样运行了结果是对的,看起来也没错,但是这种定义其实并不正确,这种定义的不是tupel,而是1这个数,这是因为括号()既可以表示tuple,又可以表示数学公式中的小括号,这就产生了歧义,因此,Python规定,这种情况下,按小括号进行计算,计算结果自然是1。所以定义含一个元素的元组时必须加一个逗号,如下:

>>> T = (1,)
>>> T
(1,)

(2)访问

直接索引就好,如下:

>>> T =(1,2,3)
>>> T[1]
2

(3)更改

上述定义的tuple是不变的,但是我们可以在tuple中定义list对其进行修改:

>>> T = (1,2,['a','b'])
>>> T[2][0]
'a'
>>> T[2][0] = 'c'
>>> T
(1, 2, ['c', 'b'])

在tuple中,虽然元素不可以修改,但是我们可以对其进行连接组合:

>>> T1 = [1,2,3]
>>> T2 = [4,5,6]
>>> T3 = T1   T2
>>> T3
[1, 2, 3, 4, 5, 6]

3.字符串

(1)创建

>>> str = "Hello Python"
>>> str
'Hello Python'

(2)访问

>>> str[0]

'H'

(3)相加

>>>str = "hello "
>>>str = "Python"
>>> str3 = str1   str2
>>> str3

'Hello Python'

4.通用的序列操作方法

(1)索引

在访问序列元素中用到,如下:

>>> L = ['a','b','c']
>>> L[1]

'b'

>>> T = (1,2,3)
>>> T[0]

1

>>> str = "Python"
>>> str[4]

'o'

(2)分片

分片用来访问一定范围内的元素,分片通常通过冒号相隔的两个索引来实现,常见的有如下几种:

>>> a = list(range(10))
>>> a

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> b = a[1:5]
>>> b

[1, 2, 3, 4]
>>> c = a[-3:-1]
>>> c

[7, 8]
>>> d = a[1:10:2]
>>> d

[1, 3, 5, 7, 9]

二 映射(字典)

映射中的每个元素都有一个专业的名字,叫做键。字典是Python中唯一内建的映射类型,下来我们对其进行详细介绍:

(1)键类型

字典(dict)是一个存放无序的键值映射(key/value)类型数据的容器字典的键可以是数

字、字符串或者是元组,键必须唯一。在Python中,数字、字符串和元组都被设计成不可变类型,而常见的列表以及集合(set)都是可变的,所以列表和集合不能作为字典的键。键可以为任何不可变类型,这正是Python中的字典最强大的地方。

(2)创建

>>> d = {}
>>> d[1] = 1
>>> d

{1: 1}
>>> d['cat'] = 'Lucy'
>>> d

{1: 1, 'cat': 'Lucy'}

(3)查找

dict是通过key来查找value,表示的是意义对应的关系,可以通过d[key]的方式来访问dict:

>>> d['cat']

'Lucy'

(4)遍历

>>> d = {}
>>> d['cat'] = 'Lucy'
>>> d['dog'] = 'Ben'
>>> for key in d:

print(key   ":",d[key])

结果

cat: Lucy

dog: Ben

(5)优缺点

dict的第一个特点是查找速度快,而且查找的速度与元素的个数无关,而list的查找速度是随着元素的增加而逐渐下降的;第二个特点是存储的key-value序对是没有顺序的;第三个特点是作为key得到元素是不可变的,所以list不能作为key。

dict的缺点是占用内存大,还会浪费很多内容。
三 集合(set)

dict是建立了一系列的映射关系,而set是建立一系列无序的,不重复的元素。

(1)创建

创建set的方式是调用set()并传入一个list,list的元素将作为set的元素。

>>> S = set([1,2,3])
>>> S

{1, 2, 3}

重复元素在Set中自动过滤,如:

>>> S = set([1,1,2,3,4,5,4])
>>> S

{1, 2, 3, 4, 5}

(2)添加

add()添加,有重复元素可以添加,但不会有效果:

>>> S.add(4)
>>> S

{1, 2, 3, 4, 5}

>>> S.add(9)
>>> S

{1, 2, 3, 4, 5, 9}

(3)删除

>>> S.remove(9)
>>> S

{1, 2, 3, 4, 5}
(4)交集,并集

set可以看成数学意义上的无序和无重复元素的集合,因此,两个set可以做数学意义上的交集、并集:

>>> S1 = set([1,2])
>>> S2 = set([2,3])
>>> S1&S2

{2}
>>> S1|S2

{1, 2, 3}

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

四 list,tuple,dict和set的主要区别

1 .list

list是一个使用方括号括起来的有序元素集合;

List 可以作为以 0 下标开始的数组,任何一个非空 list 的第一个元素总是 L[0],负数索引从 list 的尾部开始向前计数来存取元素。任何一个非空的 list 最后一个元素总是 L[-1];

有分片功能,两个list可以相加;

append 向 list 的末尾追加单个元素;

insert 将单个元素插入到 list 中;

extend 用来连接 list,使用一个 list 参数进行调用;

append 接受一个参数, 这个参数可以是任何数据类型, 并且简单地追加到 list 的尾部;

index 在 list 中查找一个值的首次出现并返回索引值;

要测试一个值是否在 list 内, 使用 in, 如果值存在, 它返回 True, 否则返为 False ;

remove 从 list 中删除一个值的首次出现;

pop 可以删除 list 的最后一个元素, 然后返回删除元素的值,用索引删除制定位置的值; 

2.tuple

tuple是不可变的list,创建了一个tuple就不能以任何方式改变它;

定义tuple是将整个元素集是用小括号括起来,是有序集合;

tuple的索引与list一样从0开始,所以一个非空的tuple的第一个元素总是t[0];

负数索引与 list 一样从 tuple 的尾部开始计数;

与 list 一样分片 (slice) 也可以使用。分割一个 tuple 时, 会得到一个新的 tuple;

没有 append、extend、remove或pop方法以及index方法;

可以使用in来查看一个元素是否存在于tuple 中。

3.dict

dict定义了键和值之间的一一对应关系,每个元素都是一个key-value对;

整个元素集合用大括号括起来,有序集合;

可以通过 key 得到value, 但不能通过vaule获取 key;

在一个 dict中不能有重复的 key, 并且 key 是大小写敏感的;

键可以是数字、字符串或者是元组等不可变类型;

用del使用key可以删除dict中的独立元素;

用clear可以清除dict中的所有元素。

4.set

set是建立一系列无序的,不重复的元素;

创建set的方式是调用set()并传入一个list,list的元素将作为set的元素;

set和dict的唯一区别仅在于没有存储对应的value。

以上是就是对Python数据类型的全部总结,希望对大家的学习有所帮助。

Python提供多种数据类型来存放数据项集合,主要包括序列(列表list和元组tuple),映射(如...

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

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

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

功能属性

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

  set功能属性如下:

图片 1图片 2

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功能属性虽多,但平时常用的也就那么几个。

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

 

       Python基础——字符串

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

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

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}

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

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

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

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

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

       Python基础——条件判断

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

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

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

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

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

  什么是集合呢?

常用属性

  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,我应该可以去出书了。这篇随笔只是起到入门的效果。

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

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

       Python基础——for/while循环

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

创建集合

 1.1 创建空集合

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

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

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

本文由时时app平台注册网站发布于编程知识,转载请注明出处:Python数据结构之四——set(集合)

关键词: