python基本数据类型之集合set

一、集合的定义

set集合,是一个无序且不重复的元素集合。

集合对象是一组无序排列的可哈希的值,集合成员可以做字典中的键。集合支持用in和not in操作符检查成员,由len()内建函数得到集合的基数(大小), 用 for 循环迭代集合的成员。但是因为集合本身是无序的,不可以为集合创建索引或执行切片(slice)操作,也没有键(keys)可用来获取集合中元素的值。

二、集合的创建

s = set()
s = {11,22,33,44}

*注:创建空集合时,只能用set(),如果用第二种方法s={},创建的实际上是一个空字典。
s = {}
print(type(s))
<class ‘dict‘>
a=set(‘boy‘)
b=set([‘y‘, ‘b‘, ‘o‘,‘o‘])
c=set({"k1":‘v1‘,‘k2‘:‘v2‘})
d={‘k1‘,‘k2‘,‘k2‘}
e={(‘k1‘, ‘k2‘,‘k2‘)}
print(a,type(a))
print(b,type(b))
print(c,type(c))
print(d,type(d))
print(e,type(e))
执行结果如下:
{‘o‘, ‘b‘, ‘y‘} <class ‘set‘>
{‘o‘, ‘b‘, ‘y‘} <class ‘set‘>
{‘k1‘, ‘k2‘} <class ‘set‘>
{‘k1‘, ‘k2‘} <class ‘set‘>
{(‘k1‘, ‘k2‘, ‘k2‘)} <class ‘set‘>

三、集合的功能

class set(object):
    """
    set() -> new empty set object
    set(iterable) -> new set object

    Build an unordered collection of unique elements.
    """
    def add(self, *args, **kwargs): # real signature unknown
        """
        Add an element to a set,添加元素

        This has no effect if the element is already present.
        """
        pass

    def clear(self, *args, **kwargs): # real signature unknown
        """ Remove all elements from this set. 清楚内容"""
        pass

    def copy(self, *args, **kwargs): # real signature unknown
        """ Return a shallow copy of a set. 浅拷贝  """
        pass

    def difference(self, *args, **kwargs): # real signature unknown
        """
        Return the difference of two or more sets as a new set. A中存在,B中不存在

        (i.e. all elements that are in this set but not the others.)
        """
        pass

    def difference_update(self, *args, **kwargs): # real signature unknown
        """ Remove all elements of another set from this set.  从当前集合中删除和B中相同的元素"""
        pass

    def discard(self, *args, **kwargs): # real signature unknown
        """
        Remove an element from a set if it is a member.

        If the element is not a member, do nothing. 移除指定元素,不存在不保错
        """
        pass

    def intersection(self, *args, **kwargs): # real signature unknown
        """
        Return the intersection of two sets as a new set. 交集

        (i.e. all elements that are in both sets.)
        """
        pass

    def intersection_update(self, *args, **kwargs): # real signature unknown
        """ Update a set with the intersection of itself and another.  取交集并更更新到A中 """
        pass

    def isdisjoint(self, *args, **kwargs): # real signature unknown
        """ Return True if two sets have a null intersection.  如果没有交集,返回True,否则返回False"""
        pass

    def issubset(self, *args, **kwargs): # real signature unknown
        """ Report whether another set contains this set.  是否是子序列"""
        pass

    def issuperset(self, *args, **kwargs): # real signature unknown
        """ Report whether this set contains another set. 是否是父序列"""
        pass

    def pop(self, *args, **kwargs): # real signature unknown
        """
        Remove and return an arbitrary set element.
        Raises KeyError if the set is empty. 移除元素
        """
        pass

    def remove(self, *args, **kwargs): # real signature unknown
        """
        Remove an element from a set; it must be a member.

        If the element is not a member, raise a KeyError. 移除指定元素,不存在保错
        """
        pass

    def symmetric_difference(self, *args, **kwargs): # real signature unknown
        """
        Return the symmetric difference of two sets as a new set.  对称交集

        (i.e. all elements that are in exactly one of the sets.)
        """
        pass

    def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
        """ Update a set with the symmetric difference of itself and another. 对称交集,并更新到a中 """
        pass

    def union(self, *args, **kwargs): # real signature unknown
        """
        Return the union of sets as a new set.  并集

        (i.e. all elements that are in either set.)
        """
        pass

    def update(self, *args, **kwargs): # real signature unknown
        """ Update a set with the union of itself and others. 更新 """
        pass

源码

基本功能:

  • 增加
a=set(‘python‘)
a.add(‘tina‘)
print(a)
b=set(‘python‘)
b.update(‘tina‘)
print(b)
执行结果如下:
{‘tina‘, ‘o‘, ‘p‘, ‘n‘, ‘t‘, ‘y‘, ‘h‘}
{‘o‘, ‘i‘, ‘p‘, ‘a‘, ‘n‘, ‘t‘, ‘y‘, ‘h‘}
##################
由以上代码可以看出,add是单个元素的添加,而update是批量的添加。输出结果是无序的,并非添加到尾部。
  • 删除(remove,discard,pop)
c={‘p‘, ‘i‘, ‘h‘, ‘n‘, ‘o‘, ‘y‘, ‘t‘}
c.remove(‘p‘)
print(c)
c={‘p‘, ‘i‘, ‘h‘, ‘n‘, ‘o‘, ‘y‘, ‘t‘}c.discard(‘p‘)print(c)
c={‘p‘, ‘i‘, ‘h‘, ‘n‘, ‘o‘, ‘y‘, ‘t‘}c.pop()print(c)
执行结果如下: {‘i‘, ‘h‘, ‘t‘, ‘o‘, ‘y‘, ‘n‘} #####
当执行c.remove(‘p‘,‘i‘)和c.discard(‘p‘,‘i‘)时,报错:TypeError: remove() takes exactly one argument (2 given),说明remove和discard删除元素时都只能一个一个的删,同add对应。#################################################################################remove,pop和discard的区别:discard删除指定元素,当指定元素不存在时,不报错;remove删除指定元素,但当指定元素不存在时,报错:KeyError。pop删除任意元素,并可将移除的元素赋值给一个变量,不能指定元素移除。
  • 清空
c={‘p‘, ‘i‘, ‘h‘, ‘n‘, ‘o‘, ‘y‘, ‘t‘}
c.clear()
print(c)
执行结果如下:
set()

set的特有功能:

s1 = {0}
s2 = {i % 2 for i in range(10)}
s = set(‘hi‘)
t = set([‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘])
print(s.intersection(t), s & t)  # 交集
print(s.union(t), s | t)   # 并集
print(s.difference(t), s - t)  # 差集
print(s.symmetric_difference(t), s ^ t) # 对称差集
print(s1.issubset(s2), s1 <= s2) # 子集(被包含)
print(s1.issuperset(s2), s1 >= s2)   # 父集(包含)

执行结果如下:
{‘h‘} {‘h‘}
{‘i‘, ‘e‘, ‘h‘, ‘l‘, ‘o‘} {‘i‘, ‘e‘, ‘h‘, ‘l‘, ‘o‘}
{‘i‘} {‘i‘}
{‘e‘, ‘l‘, ‘o‘, ‘i‘} {‘e‘, ‘l‘, ‘o‘, ‘i‘}
True True
False False
s = {11,22,33}
t = {22,44}
print(s.isdisjoint(t))#(disjoint脱节的,)即如果没有交集,返回True,否则返回False
s.difference_update(t)#将差集覆盖到源集合,即从当前集合中删除和B中相同的元素
print(s)
执行结果如下:
False
{33, 11}

s = {11,22,33}
t = {22,44}
s.intersection_update(t)#将交集覆盖到源集合
print(s)
执行结果如下:
{22}

s = {11,22,33}
t = {22,44}
s.symmetric_difference_update(t)#将对称差集覆盖到源集合
print(s)
执行结果如下:
{33, 11, 44}

四、集合的转换

se = set(range(4))
li = list(se)
tu = tuple(se)
st = str(se)
print(li,type(li))
print(tu,type(tu))
print(st,type(st))
执行结果如下:
[0, 1, 2, 3] <class ‘list‘>
(0, 1, 2, 3) <class ‘tuple‘>
{0, 1, 2, 3} <class ‘str‘>

五、练习题

寻找差异:哪些需要删除?哪些需要新建?哪些需要更新?

# 数据库中原有
old_dict = {
    "#1":{ ‘hostname‘:c1, ‘cpu_count‘: 2, ‘mem_capicity‘: 80 },
    "#2":{ ‘hostname‘:c1, ‘cpu_count‘: 2, ‘mem_capicity‘: 80 }
    "#3":{ ‘hostname‘:c1, ‘cpu_count‘: 2, ‘mem_capicity‘: 80 }
}

# cmdb 新汇报的数据
new_dict = {
    "#1":{ ‘hostname‘:c1, ‘cpu_count‘: 2, ‘mem_capicity‘: 800 },
    "#3":{ ‘hostname‘:c1, ‘cpu_count‘: 2, ‘mem_capicity‘: 80 }
    "#4":{ ‘hostname‘:c2, ‘cpu_count‘: 2, ‘mem_capicity‘: 80 }
} 

注意:无需考虑内部元素是否改变,只要原来存在,新汇报也存在,就是需要更新

del_dict = set(old_dict).difference(set(new_dict))
add_dict = set(new_dict).difference(set(old_dict))
update_dict = set(new_dict).intersection(set(old_dict))
print(del_dict)
print(add_dict)
print(update_dict)
执行结果如下:
{‘#2‘}
{‘#4‘}
{‘#3‘, ‘#1‘}
时间: 2024-10-29 19:08:19

python基本数据类型之集合set的相关文章

python学习[第十二篇] 数据类型之 集合

python学习[第十二篇] 数据类型之 集合 集合概念 python中集合是一组无序排列的哈希值.集合分为两种可变集合(set)和不可变集合(frozenset) 对可变集合可以修改和删除元素,对于不可变集合不允许.可变集合是不可以哈希的,因此既不能用作字典的键,也不能做其他集合的元素. 集合的增删改查 集合的创建于赋值 集合与列表([]) 和字典({})不同,集合没有特别的语法格式.列表和字典可以通过他们自己的工厂方法创建,这也是集合的唯一的创建方式.set()和frozenset() #创

python之数据类型补充、集合、深浅copy

一.内容回顾 代码块: 一个函数,一个模块,一个类,一个文件,交互模式下,每一行就是一个代码块. is == id id()查询对象的内存地址 == 比较的是两边的数值. is 比较的是两边的内存地址. 小数据池: 前提:int,str,bool 1,节省内存. 2,提高性能和效率. 小数据池是什么? 在内存中,创建一个'池',提前存放了 -5 ~256 的整数,一定规则的字符串和bool值. 后续程序中,如果设置的变量指向的是小数据池的内容,那么就不会再内存中重新创建. 小数据池与代码块的关系

python基础数据类型之字典+集合

一.数据类型之字典 字典是python中唯一的映射类型,采用键值对(key-value)的形式存储数据.python对key进行哈希函数运算,根据计算的结果决定value的存储地址,所以字典是无序存储的,且key必须是可哈希的.可哈希表示key必须是不可变类型,如:数字.字符串.元组. 字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型.列表是有序的对象结合,字典是无序的对象集合.两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取. 总结:1.字

Python之路【第四篇】python基础 之基本数据类型之集合

基本数据类型之集合 set set集合,是一个无序且不重复的元素集合 1 # set 不允许重复的集合 set允许重复的列表但是集合是无序的 2 #例如 3 # s = {1,23,23,4,55,55} 4 # print(s) # 结果 {1, 4, 23, 55} 5 6 # 1.创建 7 # s = set() 8 # s = {11,22,33,44} 9 10 # 2.转换 11 # l = list() 12 # s = set() #创建集合 13 # s = set([11,2

7、python数据类型之集合set

数据类型之集合setset 不允许重复的无序集合,不能通过下标取值,因为无序1.创建   创建空集合   s ={} 默认类型为字典,所以不是空集合,空集合如下   s = set()   s = {11,12,12,34,23} #字典是有键值对,集合没有   s = set()#括号内可以接收可以迭代的元素,str list tuple dict2.转换   s = ([11,123,1234,12345])   l = "123"   l = [1,2,3,4]   l = (1

python常用数据类型内置方法介绍

熟练掌握python常用数据类型内置方法是每个初学者必须具备的内功. 一.整型 a = 100 a.xxx() class int(object): def bit_length(self): ##如果将某个整数用2进制表示,返回这个2进制所占bit位数. return 0 def conjugate(self, *args, **kwargs): ##共轭复数 @classmethod # known case def from_bytes(cls, bytes, byteorder, *ar

3.python基础补充(集合,collection系列,深浅拷贝)

一.集合 1.集合(set): 把不同的元素组成一起形成集合,是python基本的数据类型.集合元素(set elements):组成集合的成员 python的set和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算. sets 支持 x in set, len(set),和 for x in set.作

python核心数据类型笔记

在这里,首先声明,python核心数据类型在这里就认为是python内置的数据类型 在python中.序列类型包含字符串,列表和元组 字符串: 字符串字面量:将文本引入单引号,双引号,三引号 默认的编码类型是字符编码(8bit) 在python2中,如果要使用unicode编码(16bit),需在定义字符串的引号前面加u 在python中,有文档字符串的概念,所谓文档字符串就是在模块,类或则是函数中的第一条语句是一个字符的话(用引号定义),那么该字符就是文档字符串,可以使用__doc__属性引用

Python复杂数据类型

复杂数据类型有哪些? 各特性是什么? 各使用场景是什么? 列表和元组的区别是什么?为什么会有这两种数据类型? 列表和元组为什么可以存放不能类型的数据? 什么是工厂函数? 字符串     特性:         1.在Python中没有字符类型所以定义字符串可以用双引号或单引号         2.字符串是不可变类型         3.三引号可包含复杂字符串 >>> a=''' ... 1 ... 2 ... 3 ... ''' >>> a '\n1\n2\n3\n'