Fork me on GitHub

数据类型之集合

一、概要

  • 集合基础
  • 集合方法
  • 集合常用方法
  • 集合与函数
  • 案例
  • 数据类型总结

一、集合基础

（一）创建集合

  • 使用set类创建集合

　　在使用set类创建集合是=时，需要为set类的构造方法提供一个列表或者元组类型的值，用于建立集合的数据源；这也就是说set类可以将元组或列表转为集合，并且去除重复元素，元素顺序可能也会被打乱，因为集合是无序的。

#利用列表创建集合
s=set([1,2,3])
print(s) #{1, 2, 3}

#利用元组创建集合
s=set((1,2,3))
print(s) #{1, 2, 3}
  • 使用{}直接创建
s={1,2,3}
print(type(s))#<class 'set'>

（二）集合特性

（1）无序性

集合中的值是平等的，元素之间是无序的，无法通过索引和分片进行操作。

（2）互异性

集合中任意两个元素之间是不同的，即每个元素只能出现一次，常常用于去重应用。

（3）确定性

集合内的元素是不可变数据类型，例如，集合、列表、字典都不能作为集合的元素，因为它们都是可变的。

（三） 元素检测

判断一个元素是否属于该集合，使用in，如果在就返回True，如果不在就返回False。

s=set("hello")
print("h" in s)#True

（四）集合遍历

######遍历字符串#####
s=set("hello")
for i in s:
    print(i)
#########输出#####
        o
        e
        l
        h


#######遍历元组####
　s={(1,2),(3,4),(5,6)}
  for item in s:
    print(item)
#########输出##########
　　(5, 6)
　　(3, 4)
　　(1, 2)

二、集合方法

集合方法很多：

  • add 向集合中添加一个元素
  • clear 从集合中移除所有元素
  • copy 返回集合的浅拷贝
  • difference 将两个或多个集合的差集作为一个新集合返回
  • difference_update 从这个集合中删除另一个集合的所有元素
  • discard 移除一个已经存在于集合中的元素（如果元素不存在，则不执行任何操作）
  • intersection 将两个集合的交集作为一个新集合返回
  • intersection_update 自身集合和另一个的交集来更新这个集合
  • isdisjoint 如果两个集合有一个空交集，返回 True
  • issubset 如果另一个集合包含这个集合，返回 True
  • issuperset 如果这个集合包含另一个集合，返回 True
  • pop 删除并返回任意的集合元素（如果集合为空，会抛出 KeyError异常）
  • remove 删除集合中的一个元素（如果元素不存在，会抛出KeyError异常）
  • symmetric_difference 将两个集合的对称差作为一个新集合返回(两个集合合并删除相同部分，其余保留)
  • symmetric_difference_update 用自己和另一个的对称差来更新这个集合
  • union 将集合的并集作为一个新集合返回
  • update 用自己和另一个的并集来更新这个集合

（一）add()

向集合中添加一个元素

s={1,2,4,}
s.add(5)
print(s)#{1, 2, 4, 5}

（二）clear()

从集合中移除所有元素

s={'hell0','world'}
s.clear()
print(s)#set()

（三）copy ()

返回集合的浅拷贝

s1={1,2,3,}
s2=s1.copy()
print(s2)#{1, 2, 3}

（四）difference()

将两个或多个集合的差集作为一个新集合返回

s1={'a','b','c'}
s2={'a','d','c','e'}
#求出s1和s2之间的差集，保留s1中不同的元素
print(s1.difference(s2))#{'b'}
print(s1-s2)#{'b'}

#保留s2中相同的元素
print(s2.difference(s1))#{'d', 'e'}
print(s2-s1)#{'d', 'e'}

（五）difference_update()

从这个集合中删除另一个集合的所有元素

s1={1,2,4,5,}
s2={2,4,6,8}
s3={6}
s1.difference_update(s2)
#从s1中删除存在s2的元素
print(s1)#{1, 5}

#从s2中删除存在s3的元素
s2.difference_update(s3)
print(s2)#{8, 2, 4}

（六）discard()

移除一个已经存在于集合中的元素（如果元素不存在，则不执行任何操作）

s={"a","b","c"}
s.discard("b")
#从s中移除元素b
print(s)#{'a', 'c'}

（七）intersection()

将两个集合的交集作为一个新集合返回

s1={1,2,4,5,}
s2={2,4,6,8}
#将s1和s2求交集并且返回新的集合
print(s1.intersection(s2))#{2, 4}
print(s1&s2)#{2, 4}

（八）intersection_update()

自身集合和另一个的交集来更新这个集合

s1={'a','b','c'}
s2={'a','d','c','e'}
#相当于s1-s2，这与差集difference差不多
s1.intersection_update(s2)
print(s1)#{'a', 'c'}

（九）isdisjoint()

如果两个集合有一个空交集，返回 True

s1={'a','b','c'}
s2={'a','d','c','e'}
#判断s1与s2之间是否有空交集，如果没有返回False
print(s1.isdisjoint(s2))#False

（十）issubset()

如果另一个集合包含这个集合，返回 True

s1={1,2,3}
s2={2}
#因为s1集合包含s2，所以返回True
print(s2.issubset(s1))#True

（十一）issuperset()

如果这个集合包含另一个集合，返回 True

s1={1,2,3}
s2={2}
#因为s1集合包含s2，所以返回True
print(s1.issuperset(s2))#True

它与issubset的区别在于，包含的集合作为方法的调用者，被包含集合作为方法的参数。

（十二）pop()

删除并返回任意的集合元素（如果集合为空，会抛出 KeyError异常）

s={1,3,5,2,8,3,9}
#随机删除元素并且返回删除元素
print(s.pop())#1
print(s)#{2, 3, 5, 8, 9}

（十三）remove()

删除集合中的一个元素（如果元素不存在，会抛出KeyError异常）

s={1,3,5,2,8,3,9}
#删除指定元素并且无返回元素
print(s.remove(5))#None
print(s)#{1, 2, 3, 8, 9}

（十四）symmetric_difference()

将两个集合的对称差作为一个新集合返回(两个集合合并删除相同部分，其余保留)

s1={'a','b','c'}
s2={'a','d','c','e'}
#s1与s2中删除相同元素，保留不同元素，求对称差，相当于s1-s2与s2-s1的并集
print(s1.symmetric_difference(s2))#{'d', 'b', 'e'}

（十五）symmetric_difference_update()

用自己和另一个的对称差来更新这个集合

s1={1,2,3,4,5}
s2={2,3,4}
s3={1,}
#将s1与s2集合的对称集求出来，然后与s1集合进行更新
s1.symmetric_difference_update(s2)
print(s1)#{1, 5}
#将s3与s2集合的对称集求出来，然后与s3集合进行更新
s3.symmetric_difference_update(s2)
print(s3)#{1, 2, 3, 4}

（十六）union()

将集合的并集作为一个新集合返回

s1={1,2,3,4,5}
s2={2,3,4}
#求出s1与s2的并集
print(s1.union(s2))#{1, 2, 3, 4, 5}
print(s1|s2)#{1, 2, 3, 4, 5}

（十七）update()

用自己和另一个的并集来更新这个集合

s1={1,2,3,4,5}
s2={2,3,4}
#对s1进行更新，相当于求两个集合的并集
s1.update(s2)
print(s1)#{1, 2, 3, 4, 5}

三、集合常用方法

（一）并集

使用union方法或者操作符“|”进行两个或者多个集合求并集

namelist1={'alia','sanb','lige'}
namelist2={'alia','bobu'}
print(namelist1|namelist2)#{'alia', 'sanb', 'bobu', 'lige'}
print(namelist1.union(namelist2))#{'alia', 'sanb', 'bobu', 'lige'}

（二）交集

使用intersection方法或者操作符“&”进行两个或多个集合求交集

namelist1={'alia','sanb','lige'}
namelist2={'alia','bobu'}
print(namelist1&namelist2)#{'alia'}
print(namelist1.intersection(namelist2))#{'alia'}

（三）差集

使用difference方法或者操作符“-”进行两个或多个集合求差集

namelist1={'alia','sanb','lige'}
namelist2={'alia','bobu'}
print(namelist1-namelist2)#{'sanb', 'lige'}
print(namelist1.difference(namelist2))#{'sanb', 'lige'}

（四）对称差集

使用symmetric_difference方法或者操作符“^”进行两个或多个集合求对称差集

namelist1={'alia','sanb','lige'}
namelist2={'alia','bobu'}
print(namelist1^namelist2)#{'sanb', 'bobu', 'lige'}
print(namelist1.symmetric_difference(namelist2))#{'sanb', 'bobu', 'lige'}

（五）子集

使用issubset方法或者操作符“<”判断当前集合是否是某个集合的子集

str1=set("hello")
str2=set("he")
#判断str2是否是str1的子集
print(str2<str1)#True
print(str2.issubset(str1))#True

四、集合与函数

（一）len()

获取集合中元素的个数

s={1,2,4,5,3,8}
print(len(s))#6

（二）max()

获取集合中最大的元素

s={1,2,4,5,3,8}
print(max(s))#8

（三）min()

获取集合中最小的元素

s={1,2,4,5,3,8}
print(min(s))#1

（四）sum()

返回集合的所有元素之和

s={1,2,4,5,3,8}
print(sum(s))#23

（五）sorted()

返回排序后的集合列表

s={1,2,4,5,3,8}
print(sorted(s))#[1, 2, 3, 4, 5, 8]

（六）enumerate()

返回一个可迭代的enumerate的数据类型，迭代后可以取出索引值及其具体的值。

s={1,2,4,5,3,8}
print(enumerate(s))#<enumerate object at 0x00000000054DA558>
for i,j in enumerate(s):
    print(i,j)

#######输出#######
    <enumerate object at 0x00000000054DA558>
    0 1
    1 2
    2 3
    3 4
    4 5
    5 8

（七）all()

如果集合中的所有元素都是 True（或者集合为空），则返回 True。

s={0,1,2}
print(all(s))#False#集合为空s={}print(all(s))#True

（八）any()

如果集合中的所有元素都是 True，则返回 True；如果集合为空，则返回 False。

s={0,1,2}
print(any(s))#True

#集合为空
s={}
print(any(s))#False

五、案例

有一段英文是这样的：

this is mY PEN

里面有些由于摘抄错误导致的大小写混合，现在要求:

  • 将每个英文的首字母大写，其余小写;
  • 另外统计这里面一共有多少个不同的英文字符;
  • 并且取出数量top2的英文字符
param = "this is mY PEN"
# 将每个英文的首字母大写，其余小写;
param_list = param.split()
param_list_new = []
for i in param_list:
    param_list_new.append(i.capitalize())
param_new = " ".join(param_list_new)
print(param_new) # This Is My Pen

# 另外统计这里面一共有多少个不同的英文字符
param_str = param.replace(" ", "")
s = set(param_str)
print(s)
print(len(s))

# 并且取出数量top2的英文字符
# 方式一
# order_dict = {}
# for i in param_str:
#     order_dict.setdefault(i, 0)
#     order_dict[i] += 1
# print(order_dict)
# 方式二
# order_dict = {}
# for i in param_str:
#     order_dict[i] = order_dict.get(i, 0) + 1
# print(order_dict)
# 方式三
order_dict = {}
for i in param_str:
    if not order_dict.get(i):
        order_dict[i] = 0
    order_dict[i] += 1
print(order_dict)
"""
{'t': 1, 'h': 1, 'i': 2, 's': 2, 'm': 1, 'Y': 1, 'P': 1, 'E': 1, 'N': 1}
"""
order_dict_new = sorted(order_dict.items(), key=lambda x:x[1], reverse=True)
print(order_dict_new)
"""
[('i', 2), ('s', 2), ('t', 1), ('h', 1), ('m', 1), ('Y', 1), ('P', 1), ('E', 1), ('N', 1)]
"""

六、数据类型总结

  • 种类
  • 是否可变
  • 是否有序
  • 序列

（一）种类

  • 数字（Number）
  • 字符串（String）
  • 元组（Tuple）
  • 集合（Sets）
  • 列表（List）
  • 字典（Dictionary）

（二）是否可变

可变类型：就是这个数据类型的值在不改变这一块内存空间，而去改变这个数据类型的值。

不可变类型：当改变值得时候，会申请一块新的内存空间，不再是原来的那一块内存空间了。

是否可变 数据类型
可变 列表，字典、集合
不可变 数字，字符串，元组 
# 不可变
>>> s1 = "abc"
>>> id(s1)
1918904352368
>>> s1[0] = "d"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

（三）是否有序

有、无序 数据类型
有序 元组、列表
无序 集合、字典

（四）序列

所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。

在Python中最基本的数据结构是序列（sequence），序列中的每一个元素被分配一个编号，这个编号称为索引。序列的第一个元素的索引是0，第二个是1，以此类推。

在 Python 中，序列类型包括字符串、列表、元组、集合和字典，这些序列支持以下几种通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

  • 索引取值
  • 分片
  • 序列相加
  • 序列乘法
  • in运算符
  • 序列内建函数
posted @ 2023-01-19 16:58  iveBoy  阅读(27)  评论(0)    收藏  举报
TOP