【Python系列3】列表、元素、字典和集合<2万字整理> 建议收藏!!!

列表、元组、字典和集合

    • 序列
      • 检查元素是否包含在序列中
      • 和序列相关的内置函数
    • list 列表
      • 创建列表
      • 访问列表元素
      • 删除列表
      • 列表添加元素
      • 列表删除元素
      • 列表修改元素
      • 列表查找元素
    • tuple元组
      • 创建元组
      • 访问元组
      • 修改元祖
      • 删除元组
    • dict 字典
      • 创建字典
      • 访问字典
      • 删除字典
      • 字典添加键值对
      • 字典修改键值对
      • 字典删除键值对
      • 判断字典中是否存在指定键值对
      • dict 字典方法完全攻略
      • keys()、values() 和 items() 方法
      • copy() 方法
      • `update()`方法
      • `pop()`和`popitem()`方法
      • 对 popitem() 的说明
      • `setdefault()`方法
    • set集合
      • 创建set集合
      • 访问set集合元素
      • 删除set集合
      • set集合基本操作
      • 1. 向set集合添加元素
      • 2. 从set集合中删除元素
      • 3. set集合做交集、并集、差集运算
      • set集合方法全
    • frozenset集合(set集合的不可变版)

序列

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

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

  • 序列索引

    • 正索引值:从起始元素开始,索引值从 0 开始递增

      img

    • 负索引值:Python 还支持索引值是负数,此类索引是从右向左计数,换句话说,从最后一个元素开始计数,从索引值 -1 开始

      img

在使用负值作为列序中各元素的索引值时,是从 -1 开始,而不是从 0 开始。

【示例】

​ 我 爱 派 森

正:0 1 2 3

负:-4 -3 -2 -1

str="我爱派森"
print(str[0],"==",str[-4])
//运行结果
我 ==
  • 序列切片

切片操作是访问序列中元素的另一种方法,它可以访问一定范围内的元素通过切片操作,可以生成一个新的序列。

序列实现切片操作的语法格式

sname[start: end: step]
  • sname:表示序列的名称;
  • start:表示切片的开始索引位置(包括该位置),此参数也可以不指定,会默认为 0,也就是从序列的开头进行切片;
  • end:表示切片的结束索引位置(不包括该位置),如果不指定,则默认为序列的长度;左闭右开
  • step:表示在切片过程中,隔几个存储位置(包含当前位置)取一次元素,也就是说,如果 step 的值大于 1,则在进行切片去序列元素时,会“跳跃式”的取元素。如果省略设置 step 的值,则最后一个冒号就可以省略。 根据我的测试,每次跳的个数时step-1
str = "123456789"
# 取索引区间[0,2)之间字符串
print(str[:2])
# 隔1个字符取1个字符,区间是整个字符串
print(str[::2])
# 取整个字符串,此时[]中只1个冒号
print(str[:])

运行结果

12
13579
123456789
  • 序列相加

Python 中,支持两种类型相同的序列使用“+”运算符做相加操作,它会将两个序列进行连接,但不会去除重复的元素。

这里所说的“类型相同”,指的是“+”运算符的两侧序列要么都是列表类型,要么都是元组类型,要么都是字符串。

  • 序列相乘

Python 中,使用数字 n 乘以一个序列会生成新的序列,其内容为原来序列被重复 n 次的结果。

str = "apple"
print(str*3)

输出

appleappleapple

检查元素是否包含在序列中

  • in关键字

语法格式

value in sequence

value 表示要检查的元素,sequence 表示指定的序列。

  • not in关键字

和序列相关的内置函数

函数 功能
len() 计算序列的长度,即返回序列中包含多少个元素。
max() 找出序列中的最大元素。注意,对序列使用 sum() 函数时,做加和操作的必须都是数字,不能是字符或字符串,否则该函数将抛出异常,因为解释器无法判定是要做连接操作(+ 运算符可以连接两个序列),还是做加和操作。
min() 找出序列中的最小元素。
list() 将序列转换为列表。
str() 将序列转换为字符串。
sum() 计算元素和。
sorted() 对元素进行排序。
reversed() 反向序列中的元素。
enumerate() 将序列组合为一个索引序列,多用在 for 循环中。

list 列表

Python中没有数组,但是加入了更加强大的列表。如果把数组看做是一个集装箱,那么 Python 的列表就是一个工厂的仓库。

从形式上看,列表会将所有元素都放在一对中括号[ ]里面,相邻元素之间用逗号,分隔

[element1, element2, element3, ..., elementn]
  • 格式中,element1 ~ elementn 表示列表中的元素,个数没有限制,只要是 Python 支持的数据类型就可以。

  • 从内容上看,列表可以存储整数、小数、字符串、列表、元组等任何类型的数据,并且同一个列表中元素的类型也可以不同。(通常情况下不这么做)

["http://c.biancheng.net/python/", 1, [2,3,4] , 3.0]

创建列表

  • 使用[]直接创建链表
    • 使用[ ]创建列表后,一般使用=将它赋值给某个变量
listname = [element1 , element2 , element3 , ... , elementn]

其中,listname 表示变量名,element1 ~ elementn 表示列表元素。

列表元素可以有多个,也可以一个都没有

emptylist = []
  • 使用list()函数创建列表

除了使用[ ]创建列表外,Python 还提供了一个内置的函数 list(),使用它可以将其它数据类型转换为列表类型。

# 将字符串转换成列表
list1 = list("hello")
print(list1)

# 将元组转化成列表
tuple1 = ('python', 'c++', 'java')
list2 = list(tuple1)
print(list2)

# 将字典转换成列表
dict1 = {
     'a':100, 'b':42, 'c':8}
list3 = list(dict1)
print(list3)

# 将区间转换成列表
range1 = range(1, 6)
list4 = list(range1)
print(list4)

# 创建空列表
print(list())

访问列表元素

  • 使用索引访问列表中的某1个元素
listname[i]

listname 表示列表名字,i 表示索引值。列表的索引可以是正数,也可以是负数。

  • 使用切片访问列表中的一组元素(得到一个新的子列表)
listname[start : end : step]

listname 表示列表名字,start 表示起始索引,end 表示结束索引,step 表示步长。

删除列表

del关键字进行删除

实际开发中并不经常使用 del 来删除列表,因为 Python 自带的垃圾回收机制会自动销毁无用的列表,即使开发者不手动删除,Python 也会自动将其回收。

语法格式

del listname

其中,listname 表示要删除列表的名称。

【删除示例】

intlist = [1, 45, 8, 34]
print(intlist)
del intlist
print(intlist)

运行结果

[1, 45, 8, 34]
Traceback (most recent call last):
    File "C:\Users\mozhiyan\Desktop\demo.py", line 4, in <module>
        print(intlist)
NameError: name 'intlist' is not defined

列表添加元素

  • 使用+拼接列表

demo

language = ["Python", "C++", "Java"]
birthday = [1991, 1998, 1995]
info = language + birthday
print("language =", language)
print("birthday =", birthday)
print("info =", info)

运行结果

language = ['Python', 'C++', 'Java']
birthday = [1991, 1998, 1995]
info = ['Python', 'C++', 'Java', 1991, 1998, 1995]
  • ** append()方法添加列表**

在列表末尾追加元素

listname.append(obj)

listname 表示要添加元素的列表;obj 表示到添加到列表末尾的数据,它可以是单个元素,也可以是列表、元组等。

当给 append() 方法传递列表或者元组时,此方法会将它们视为一个整体,作为一个元素添加到列表中,从而形成包含列表和元组的新列表。

  • ** extend()添加元素**

extend() 和 append() 的不同之处在于:extend() 不会把列表或者元祖视为一个整体,而是把它们包含的元素逐个添加到列表中。

listname.extend(obj)
  • ** insert()插入元素**

append() 和 extend() 方法只能在列表末尾插入元素,如果希望在列表中间某个位置插入元素,那么可以使用 insert() 方法。

listname.insert(index , obj)

index 表示指定位置的索引值。insert() 会将 obj 插入到 listname 列表第 index 个元素的位置。

当插入列表或者元祖时,insert() 也会将它们视为一个整体,作为一个元素插入到列表中,这一点和 append() 是一样的。

列表删除元素

  • del:根据索引值删除元素

    • 删除列表中的单个元素 del listname[index]
    • 删除中间一段连续的元素 del listname[start : end],start 表示起始索引,end 表示结束索引。del 会删除从索引 start 到 end 之间的元素,不包括 end 位置的元素。
  • pop():根据索引值删除元素

    listname.pop(index),如果不写 index 参数,默认会删除列表中的最后一个元素。

    Python 并没有提供 push() 方法,因为完全可以使用 append()来代替 push() 的功能。

  • remove():根据元素值进行删除

    根据元素本身的值来进行删除操作,需要注意的是,remove()方法只会删除第一个和指定值相同的元素,而且必须保证该元素是存在的,否则会引发 ValueError 错误。

  • clear():删除列表所有元素

    clear() 用来删除列表的所有元素,也即清空列表。

    language = ["python", "cpp", "java"]
    language.clear()
    
    print(language)
    
    // 输出
    []
    

列表修改元素

  • 修改单个元素:直接对元素赋值

    nums = [40, 36, 89, 2, 36, 100, 7]
    nums[2] = -26  #使用正数索引
    nums[-3] = -66.2  #使用负数索引
    print(nums)
    
  • 修改一组元素:切片语法给一组元素赋值

    nums = [40, 36, 89, 2, 36, 100, 7]
    #修改第 1~4 个元素的值(不包括第4个元素)
    nums[1: 4] = [45.25, -77, -52.5]
    print(nums)
    

列表查找元素

  • index()

    listname.index(obj, start, end)
    

    listname 表示列表名称,obj 表示要查找的元素,start 表示起始位置,end 表示结束位置。

    start 和 end 参数用来指定检索范围:

    • start 和 end 可以都不写,此时会检索整个列表;
    • 如果只写 start 不写 end,那么表示检索从 start 到末尾的元素;
    • 如果 start 和 end 都写,那么表示检索 start 和 end 之间的元素。

    index() 方法会返回元素所在列表中的索引值。

  • count()

    listname.count(obj)
    

    count() 方法用来统计某个元素在列表中出现的次数。

    如果 count() 返回 0,就表示列表中不存在该元素,所以 count() 也可以用来判断列表中的某个元素是否存在。

tuple元组

元组和列表(list)的不同之处在于:

  • 列表的元素是可以更改的,包括修改元素值,删除和插入元素,所以列表是可变序列;
  • 而元组一旦被创建,它的元素就不可更改了,所以元组是不可变序列

元组的所有元素都放在一对小括号( )中,相邻元素之间用逗号,分隔。

(element1, element2, ... , elementn)

从存储内容上看,元组可以存储整数、实数、字符串、列表、元组等任何类型的数据,并且在同一个元组中,元素的类型可以不同。

("c.biancheng.net", 1, [2,'a'], ("abc",3.0))

创建元组

  • ()直接创建

    在 Python 中,元组通常都是使用一对小括号将所有元素包围起来的,但小括号不是必须的,只要将各元素用逗号隔开,Python 就会将其视为元组。需要注意的一点是,当创建的元组中只有一个字符串类型的元素时,该元素后面必须要加一个逗号,,否则 Python 解释器会将它视为字符串。

  • 使用tuple()函数创建元组,也可以把列表、字典、、、、转换为元组

    tuple(data)
    

访问元组

  • tuplename[i]
  • tuplename[start : end : step]

修改元祖

元组是不可变序列,元组中的元素不能被修改,所以我们只能创建一个新的元组去替代旧的元组。

  • 对元组进行重新赋值

  • 通过连接多个元组(使用+可以拼接元组)的方式向元组中添加新元素

    tup1 = tuple("hello")
    tup2 = tuple("world")
    print(tup1 + tup2)
    
    # 输出
    ('h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd')
    

删除元组

del关键字

tup1 = tuple("hello")
tup2 = tuple("world")
print(tup1 + tup2)
del tup1
print(tup1)

# 输出
('h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd')
Traceback (most recent call last):
  File "D:\桌面\py\main.py", line 5, in <module>
    print(tup1)
NameError: name 'tup1' is not defined

Python 自带垃圾回收功能,会自动销毁不用的元组,所以一般不需要通过 del 来手动删除。

dict 字典

字典(dict)是一种无序的、可变的序列,它的元素以“键值对(key-value)”的形式存储。相对地,列表(list)和元组(tuple)都是有序的序列,它们的元素在底层是挨着存放的。

字典类型是 Python 中唯一的映射类型。“映射”是数学中的术语,简单理解,它指的是元素之间相互对应的关系,即通过一个元素,可以唯一找到另一个元素。

【Python系列3】列表、元素、字典和集合<2万字整理> 建议收藏!!!_第1张图片

字典中,习惯将各元素对应的索引称为键(key),各个键对应的元素称为值(value),键及其关联的值称为“键值对”。

字典里的音节表就相当于字典类型中的键,而键对应的汉字则相当于值。

创建字典

  • 使用{}创建字典

    dictname = {
           'key':'value1', 'key2':'value2', ..., 'keyn':valuen}
    

    其中 dictname 表示字典变量名,keyn : valuen 表示各个元素的键值对。需要注意的是,同一字典中的各个键必须唯一,不能重复。

  • 通过fromkeys方法创建

    dictname = dict.fromkeys(list,value=None)
    

    其中,list 参数表示字典中所有键的列表(list);value 参数表示默认值,如果不写,则为空值 None。

    l = ['math', 'english', 'science']
    d = dict.fromkeys(l, 90)
    print(d)
    
    # {'math': 90, 'english': 90, 'science': 90}
    
  • 通过dict()映射函数创建字典

创建格式 注意事项
a = dict(str1=value1, str2=value2, str3=value3) str 表示字符串类型的键,value 表示键对应的值。使用此方式创建字典时,字符串不能带引号。
#方式1 demo = [(‘two’,2), (‘one’,1), (‘three’,3)] #方式2 demo = [[‘two’,2], [‘one’,1], [‘three’,3]] #方式3 demo = ((‘two’,2), (‘one’,1), (‘three’,3)) #方式4 demo = ([‘two’,2], [‘one’,1], [‘three’,3]) a = dict(demo) 向 dict() 函数传入列表或元组,而它们中的元素又各自是包含 2 个元素的列表或元组,其中第一个元素作为键,第二个元素作为值。
keys = [‘one’, ‘two’, ‘three’] #还可以是字符串或元组 values = [1, 2, 3] #还可以是字符串或元组 a = dict( zip(keys, values) ) 通过应用 dict() 函数和 zip() 函数,可将前两个列表转换为对应的字典。

注意,无论采用以上哪种方式创建字典,字典中各元素的键都只能是字符串、元组或数字,不能是列表。列表是可变的,不能作为键。

访问字典

列表和元组是通过下标来访问元素的,而字典不同,它通过键来访问对应的值。因为字典中的元素是无序的,每个元素的位置都不固定,所以字典也不能像列表和元组那样,采用切片的方式一次性访问多个元素。

  • dictname[key]

  • 更推荐使用 dict 类型提供的 get() 方法来获取指定键对应的值。dictname.get(key[,default])其中,dictname 表示字典变量的名字;key 表示指定的键;default 用于指定要查询的键不存在时,此方法返回的默认值,如果不手动指定,会返回 None。

    demo1

    a = dict(two=0.65, one=88, three=100, four=-59)
    print( a.get('five', '该键不存在') )
    

    demo2

    a = dict(two=0.65, one=88, three=100, four=-59)
    print( a.get('one') )
    

删除字典

del关键字

a = dict(two=0.65, one=88, three=100, four=-59)
print(a)
del a
print(a)

Python 自带垃圾回收功能,会自动销毁不用的字典,所以一般不需要通过 del 来手动删除。

字典是由一个一个的 key-value 构成的,key 是找到数据的关键,Python 对字典的操作都是通过 key 来完成的。

字典添加键值对

直接给不存在的 key 赋值即可

dictname[key] = value

  • dictname 表示字典名称。
  • key 表示新的键。
  • value 表示新的值,只要是 Python 支持的数据类型都可以。
a = {
     '数学': 98}
print(a)
a['音乐'] = 90
print(a)
a['英语'] = 100
print(a)

结果

{
     '数学': 98}
{
     '数学': 98, '音乐': 90}
{
     '数学': 98, '音乐': 90, '英语': 100}

字典修改键值对

Python 字典中键(key)的名字不能被修改,我们只能修改值(value)。

字典中各元素的键必须是唯一的,因此,如果新添加元素的键与已存在元素的键相同,那么键所对应的值就会被新的值替换掉,以此达到修改元素值的目的。

字典删除键值对

要删除字典中的键值对,还是可以使用 del 语句。

# 使用del语句删除键值对
a = {
     '数学': 95, '语文': 89, '英语': 90}
del a['语文']
del a['数学']
print(a)

判断字典中是否存在指定键值对

如果要判断字典中是否存在指定键值对,首先应判断字典中是否有对应的键。判断字典是否包含指定键值对的键,可以使用 in 或 not in 运算符。

需要指出的是,对于 dict 而言,in 或 not in 运算符都是基于 key 来判断的

a = {
     '数学': 98, '音乐': 90, '英语': 100}
print('数学' in a)
print('科学' in a)
print('科学' not in a)

'''
True
False
True
'''

通过 in(或 not in)运算符,我们可以很轻易地判断出现有字典中是否包含某个键,如果存在,由于通过键可以很轻易的获取对应的值,因此很容易就能判断出字典中是否有指定的键值对。

dict 字典方法完全攻略

可使用 dir(dict) 来查看该类型包含哪些方法,例如:

>>> dir(dict)
['clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

keys()、values() 和 items() 方法

  • keys() 方法用于返回字典中的所有键(key);
  • values() 方法用于返回字典中所有键对应的值(value);
  • items() 用于返回字典中所有的键值对(key-value)。
a = {
     '数学': 98, '音乐': 90, '英语': 100}
print(a.keys())
print(a.values())
print(a.items())

'''
dict_keys(['数学', '音乐', '英语'])
dict_values([98, 90, 100])
dict_items([('数学', 98), ('音乐', 90), ('英语', 100)])
'''

可以发现,keys()、values() 和 items() 返回值的类型分别为 dict_keys、dict_values 和 dict_items。

  1. 使用 list() 函数,将它们返回的数据转换成列表
a = {
     '数学': 98, '音乐': 90, '英语': 100}
b = list(a.keys())
c = list(a.values())
d = list(a.items())
print(b)
print(c)
print(d)

'''
['数学', '音乐', '英语']
[98, 90, 100]
[('数学', 98), ('音乐', 90), ('英语', 100)]
'''
  1. 使用 for in 循环遍历它们的返回值
a = {
     '数学': 98, '音乐': 90, '英语': 100}

for k in a.keys():
    print(k, end=' ')

print("\n--------------------")

for v in a.values():
    print(v, end=' ')

print("\n--------------------")

for k,v in a.items():
    print("key:", k, ", value:", v)
    
'''
数学 音乐 英语 
--------------------
98 90 100 
--------------------
key: 数学 , value: 98
key: 音乐 , value: 90
key: 英语 , value: 100
'''

copy() 方法

copy() 方法返回一个字典的拷贝,也即返回一个具有相同键值对的新字典。

a = {
     'one': 1, 'two': 2, 'three': [1,2,3]}
b = a.copy()
print(b)

注意,copy() 方法所遵循的拷贝原理,既有深拷贝,也有浅拷贝。

拿拷贝字典 a 为例,copy() 方法只会对最表层的键值对进行深拷贝,也就是说,它会再申请一块内存用来存放 {‘one’: 1, ‘two’: 2, ‘three’: []};

而对于某些列表类型的值来说,此方法对其做的是浅拷贝,也就是说,b 中的 [1,2,3] 的值不是自己独有,而是和 a 共有。

  • 字典遵循深拷贝
  • 列表遵循浅拷贝
a = {
     'one': 1, 'two': 2, 'three': [1,2,3]}
b = a.copy()

a['four'] = 4
print("a: ", a)
print("b: ", b)
print('--------------------------------')
a['three'].remove(3)
print("a: ", a)
print("b: ", b)

'''
a:  {'one': 1, 'two': 2, 'three': [1, 2, 3], 'four': 4}
b:  {'one': 1, 'two': 2, 'three': [1, 2, 3]}
--------------------------------
a:  {'one': 1, 'two': 2, 'three': [1, 2], 'four': 4}
b:  {'one': 1, 'two': 2, 'three': [1, 2]}
'''

从运行结果不难看出,对 a 增加新键值对,b 不变;而修改 a 某键值对中列表内的元素,b也会相应改变。

update()方法

update() 方法可以使用一个字典所包含的键值对来更新己有的字典。

在执行 update() 方法时,如果被更新的字典中己包含对应的键值对,那么原 value 会被覆盖;如果被更新的字典中不包含对应的键值对,则该键值对被添加进去。

a = {
     'one':1, 'two':2, 'three':3}
a.update({
     'one':4.5, 'four':9.3})
print(a)

'''
{'one': 4.5, 'two': 2, 'three': 3, 'four': 9.3}
'''

pop()popitem()方法

pop() 和 popitem() 都用来删除字典中的键值对,不同的是,pop() 用来删除指定的键值对,而 popitem() 用来随机删除一个键值对。

dictname.pop(key)
dictname.popitem()

其中,dictname 表示字典名称,key 表示键。

看到这里,我认为键就是和索引差不多,但是字典是无序的,就酱,不废话,继续学~

对 popitem() 的说明

其实,说 popitem() 随机删除字典中的一个键值对是不准确的,虽然字典是一种无须的列表,但键值对在底层也是有存储顺序的,popitem() 总是弹出底层中的最后一个 key-value,这和列表的 pop() 方法类似,都实现了数据结构中“出栈”的操作。

a = {
     '数学': 95, '语文': 89, '英语': 90, '化学': 83, '生物': 98, '物理': 89}
print(a)
a.popitem()
print(a)
a.popitem()
print(a)

'''
{'数学': 95, '语文': 89, '英语': 90, '化学': 83, '生物': 98, '物理': 89}
{'数学': 95, '语文': 89, '英语': 90, '化学': 83, '生物': 98}
{'数学': 95, '语文': 89, '英语': 90, '化学': 83}
'''

setdefault()方法

setdefault() 方法用来返回某个 key 对应的 value:

dictname.setdefault(key, defaultvalue)

说明,dictname 表示字典名称,key 表示键,defaultvalue 表示默认值(可以不写,不写的话是 None)。

当指定的 key 不存在时,setdefault() 会先为这个不存在的 key 设置一个默认的 defaultvalue,然后再返回 defaultvalue。

也就是说,setdefault() 方法总能返回指定 key 对应的 value:

  • 如果该 key 存在,那么直接返回该 key 对应的 value;
  • 如果该 key 不存在,那么先为该 key 设置默认的 defaultvalue,然后再返回该 key 对应的 defaultvalue。
a = {
     '数学': 95, '语文': 89, '英语': 90}
a.setdefault('物理', 0)
a.setdefault('化学')
a.setdefault('数学', 0)
print(a)

'''
{'数学': 95, '语文': 89, '英语': 90, '物理': 0, '化学': None}
'''

set集合

  • 集合中元素互不重复
  • 只存储不可变的数据类型(列表、字典、集合是可变的)
  • 无序

和数学中的集合概念一样,用来保存不重复的元素,即集合中的元素都是唯一的,互不相同

Python 集合会将所有元素放在一对大括号 {} 中,相邻元素之间用“,”分隔:

{element1,element2,...,elementn}

  • 同一集合中,只能存储不可变的数据类型,包括整形、浮点型、字符串、元组,无法存储列表、字典、集合这些可变的数据类型,否则 Python 解释器会抛出 TypeError 错误。
  • 由于 Python 中的 set 集合是无序的,所以每次输出时元素的排序顺序可能都不相同。

创建set集合

  • 使用{}创建
  • set()函数创建集合

set() 函数为 Python 的内置函数,其功能是将字符串、列表、元组、range 对象等可迭代对象转换成集合。

setname = set(iteration)

如果要创建空集合,只能使用 set() 函数实现。因为直接使用一对 {},Python 解释器会将其视为一个空字典

访问set集合元素

由于集合中的元素是无序的,因此无法向列表那样使用下标访问元素。Python 中,访问集合元素最常用的方法是使用循环结构,将集合中的数据逐一读取出来。

s = {
     1,'c',1,(1,2,3),'c'}
for e in s:
    print(e, end=' ')
    
'''
1 c (1, 2, 3) 
'''

删除set集合

使用del()语句

s = {
     1,'c',1,(1,2,3),'c'}
print(s)
del(s)
print(s)

'''
Traceback (most recent call last):
  File "D:\桌面\py\main.py", line 4, in 
    print(s)
NameError: name 's' is not defined
{'c', 1, (1, 2, 3)}
'''

set集合基本操作

set 集合最常用的操作是向集合中添加、删除元素,以及集合之间做交集、并集、差集等运算。

1. 向set集合添加元素

add()方法

语法:setname.add(element)

需要注意的是,使用 add() 方法添加的元素,只能是数字、字符串、元组或者布尔类型(True 和 False)值,不能添加列表、字典、集合这类可变的数据,否则 Python 解释器会报 TypeError 错误。

a = {
     1,2,3} # 集合
a.add(4)
a.add((4,5)) # 添加元组
a.add("hello set")
print(a)

'''
{1, 2, 3, 4, 'hello set', (4, 5)}
'''

2. 从set集合中删除元素

  • remove()

删除现有 set 集合中的指定元素,可以使用 remove() 方法

setname.remove(element)

被删除元素本就不包含在集合中,则此方法会抛出 KeyError 错误。

  • discard()

不想在删除失败时令解释器提示 KeyError 错误,还可以使用 discard() 方法,此方法和 remove() 方法的用法完全相同,唯一的区别就是,当删除集合中元素失败时,此方法不会抛出任何错误。

3. set集合做交集、并集、差集运算

运算操作 Python运算符 含义 例子
交集 & 取两集合公共的元素 >>> set1 & set2 {3}
并集 | 取两集合全部的元素 >>> set1 | set2 {1,2,3,4,5}
差集 - 取一个集合中另一集合没有的元素 >>> set1 - set2 {1,2} >>> set2 - set1 {4,5}
对称差集 ^ 取集合 A 和 B 中不属于 A&B 的元素 >>> set1 ^ set2 {1,2,4,5}

set集合方法全

方法名 语法格式 功能 实例
add() set1.add() 向 set1 集合中添加数字、字符串、元组或者布尔类型 >>> set1 = {1,2,3} >>> set1.add((1,2)) >>> set1 {(1, 2), 1, 2, 3}
clear() set1.clear() 清空 set1 集合中所有元素 >>> set1 = {1,2,3} >>> set1.clear() >>> set1 set() set()才表示空集合,{}表示的是空字典
copy() set2 = set1.copy() 拷贝 set1 集合给 set2 >>> set1 = {1,2,3} >>> set2 = set1.copy() >>> set1.add(4) >>> set1 {1, 2, 3, 4} >>> set1 {1, 2, 3}
difference() set3 = set1.difference(set2) 将 set1 中有而 set2 没有的元素给 set3 >>> set1 = {1,2,3} >>> set2 = {3,4} >>> set3 = set1.difference(set2) >>> set3 {1, 2}
difference_update() set1.difference_update(set2) 从 set1 中删除与 set2 相同的元素 >>> set1 = {1,2,3} >>> set2 = {3,4} >>> set1.difference_update(set2) >>> set1 {1, 2}
discard() set1.discard(elem) 删除 set1 中的 elem 元素 >>> set1 = {1,2,3} >>> set1.discard(2) >>> set1 {1, 3} >>> set1.discard(4) {1, 3}
intersection() set3 = set1.intersection(set2) 取 set1 和 set2 的交集给 set3 >>> set1 = {1,2,3} >>> set2 = {3,4} >>> set3 = set1.intersection(set2) >>> set3 {3}
intersection_update() set1.intersection_update(set2) 取 set1和 set2 的交集,并更新给 set1 >>> set1 = {1,2,3} >>> set2 = {3,4} >>> set1.intersection_update(set2) >>> set1 {3}
isdisjoint() set1.isdisjoint(set2) 判断 set1 和 set2 是否没有交集,有交集返回 False;没有交集返回 True >>> set1 = {1,2,3} >>> set2 = {3,4} >>> set1.isdisjoint(set2) False
issubset() set1.issubset(set2) 判断 set1 是否是 set2 的子集 >>> set1 = {1,2,3} >>> set2 = {1,2} >>> set1.issubset(set2) False
issuperset() set1.issuperset(set2) 判断 set2 是否是 set1 的子集 >>> set1 = {1,2,3} >>> set2 = {1,2} >>> set1.issuperset(set2) True
pop() a = set1.pop() 取 set1 中一个元素,并赋值给 a >>> set1 = {1,2,3} >>> a = set1.pop() >>> set1 {2,3} >>> a 1
remove() set1.remove(elem) 移除 set1 中的 elem 元素 >>> set1 = {1,2,3} >>> set1.remove(2) >>> set1 {1, 3} >>> set1.remove(4) Traceback (most recent call last): File “”, line 1, in set1.remove(4) KeyError: 4
symmetric_difference() set3 = set1.symmetric_difference(set2) 取 set1 和 set2 中互不相同的元素,给 set3 >>> set1 = {1,2,3} >>> set2 = {3,4} >>> set3 = set1.symmetric_difference(set2) >>> set3 {1, 2, 4}
symmetric_difference_update() set1.symmetric_difference_update(set2) 取 set1 和 set2 中互不相同的元素,并更新给 set1 >>> set1 = {1,2,3} >>> set2 = {3,4} >>> set1.symmetric_difference_update(set2) >>> set1 {1, 2, 4}
union() set3 = set1.union(set2) 取 set1 和 set2 的并集,赋给 set3 >>> set1 = {1,2,3} >>> set2 = {3,4} >>> set3=set1.union(set2) >>> set3 {1, 2, 3, 4}
update() set1.update(elem) 添加列表或集合中的元素到 set1 >>> set1 = {1,2,3} >>> set1.update([3,4]) >>> set1 {1,2,3,4}

frozenset集合(set集合的不可变版)

set 集合是可变序列,程序可以改变序列中的元素;frozenset 集合是不可变序列,程序不能改变序列中的元素。

两种情况下可以使用 fronzenset:

  • 当集合的元素不需要改变时,我们可以使用 fronzenset 替代 set,这样更加安全。
  • 有时候程序要求必须是不可变对象,这个时候也要使用 fronzenset 替代 set。比如,字典(dict)的键(key)就要求是不可变对象。

你可能感兴趣的:(【编程语言】Python,python,pycharm,算法)