python 开发 -- 16集合类型内置方法

Posted 2022-12-01 FikL-09-19

文章目录

• • 一.用途
  • • 1.关系运算
    • 2.去重
  • 二.定义方式
  • 三.类型转换
  • 四.常用操作
  • 🐹关系运算
  • • 1.交集 : `&`, `.intersection()`
    • 2.并集 : `|`, `.union()`
    • 3.差集 : `-`, `.difference()`
    • 4.对称差集 : `^`, `.symmetric_difference()`
    • 5.父集 ：`>=`, `.issuperset()`
    • 6.子集 : `<=`, `.issubset()`
  • 🐰去重
  • • 1.简单去重(无法保证顺序)
    • 2.去重并保证原来的顺序(了解)
  • 五.内置方法
  • 🐼优先掌握的操作(*********)
  • • 1.长度 : .len( )
    • 2.成员运算 in 和 not in
    • 3.循环取值
  • 🐨需要掌握的操作(****)
  • • 1.更新 .update( )
    • 2.添加 .add( )
    • 3.取走一个值 .pop( )
    • 4.删除 .remove( ), .discard( )
    • 5.无交集 .isdisjoint( )
  • 🐻不怎么需要了解的操作(***)
  • • 1..difference_update( )
    • 2..intersection_ update( )
    • 3..symmetric_ difference_ update( )
  • 六.总结
  • • 可以存多个值
    • • 无序
      • 可变类型--->不可 hash 类型

一.用途

1.关系运算

• 交集 : &
• 并集 : |
• 差集 : -
• 交叉补集 : ^

2.去重

• 简单示例

l = [1,1,2,2,1,3]
s = set(l)
print(list(s))  #[1,2,3]

二.定义方式

• 在 “ ” 内用逗号分隔开一个个元素
  \\1. 集合的元素必须是不可变类型
  \\2. 集合内元素无序
  \\3. 集合内元素唯一
• 集合的"工厂" : set

s=1,2,3,4,4,4,4,4,4,4,'a' 
#  背后的操作就是
s=set(1,2,3,4,'a')

#  如果元素重复, 只会取一个
print(type(s),s)  
#<class 'set'> 1, 2, 3, 4, 'a'

#  加入可变类型报错 
s=[1,2,3],'aa'  #报错

#  无序的
s = 1,2,"b",4,"a",6,7
print(s)  #1, 2, 4, 6, 7, 'b', 'a'

ps : 定义空集合 与 定义空字典

#  定义空集合
s = set()
print(s,type(s))      
#set() <class 'set'>

#  定义空字典
dic = 
print(dic,type(dic))  
# <class 'dict'>

三.类型转换

• 只要存在可变类型就无法转换, 会报错
• 我们说字典的 key 是不可变类型, value 是任意类型, 所以转换时转的就是字典的 key, 而不是 value

#  整型--->集合
# res = set(1, 2, 3, 4)
res = 1, 2, 3, 4
print(res, type(res))
# 1, 2, 3, 4 <class 'set'>

#  浮点型--->集合
# res1 = set(1.1, 2.2, 3.3, 4.4)
res = 1.1, 2.2, 3.3, 4.4
print(res, type(res))  
# 1.1, 2.2, 3.3, 4.4 <class 'set'>

#  字符串--->集合
res = set('shawn')
print(res, type(res))
# 'a', 'h', 'n', 'w', 's' <class 'set'>

#  元组--->集合
res = set((1, 2, 3, (1, 2, 3)))
print(res, type(res)) 
# 1, 2, 3, (1, 2, 3) <class 'set'>

#  字典--->集合
🐳存到集合里面的是字典的 key (不可变)
res = set('name':'shawn','age':22)
print(res, type(res))
# 'name', 'age' <class 'set'>

#  整型、浮点型、字符串、元组、综合--->集合
res = set((2, 1.1,"song", (111, 222)))
print(res, type(res))
#1.1, 2, (111, 222), 'song' <class 'set'>
🐳当综合里边存在字典(可变类型)时无法转换, 并报错
res = set((2, 1.1,"song", (111, 222),'name': 'shawn', 'age': 22))
print(res, type(res))  #报错

四.常用操作

🐹关系运算

#  之后就以以下示例来讲解
linux=["song","hai","xing","shawn","shang"]  #学Linux的学生
python=["shang","hai","qing","pu","qu","hi"]  #学Python的学生

# 使用"for"循环取出两个都学的学生
linux_python=[]
for s in linux:
    if s in python:                  #两个都学的学生
        linux_python.append(s)       #加入到列表里面
print(linux_python)                  #["shang","hai"]

• 图解

1.交集 : &, .intersection()

#  取出两门课程都学习的学生
linux="song","hai","xing","shawn","shang",
python="shang","hai","qing","pu","qu","hi" 
print(linux & python)                #["shang","hai"]
print(linux.intersection(python))   #["shang","hai"]

2.并集 : |, .union()

#  取出全部的学生
print(linux | python)
#'shawn', 'qing', 'hai', 'song', 'hi', 'qu', 'xing', 'shang', 'pu'

print(linux.union(python))
#'shawn', 'qing', 'hai', 'song', 'hi', 'qu', 'xing', 'shang', 'pu'

3.差集 : -, .difference()

#  只学习"linux"的,没学习"python"的 (在"linux"班级里看)
print(linux - python)            #'song', 'xing', 'shawn'
print(linux.difference(python))  #'song', 'xing', 'shawn'

#  只学习"python"的,没学习"linux"的 (在"python"班级里看)
print(python -  linux)           #'qing', 'qu', 'hi', 'pu'
print(python.difference(linux))  #'qing', 'qu', 'hi', 'pu'

4.对称差集 : ^, .symmetric_difference()

#  两个班级加起来看只学习了一门课程的学生
print(stus_linux ^ stus_python)
# 'pu', 'qing', 'shawn', 'xing', 'song', 'qu', 'hi'

print(stus_linux.symmetric_difference(stus_python))
# 'pu', 'qing', 'shawn', 'xing', 'song', 'qu', 'hi'

5.父集 ：>=, .issuperset()

 s1=1,2,3,4,5
 s2=3,2,1
 print(s1 >= s2)           #True
 print(s1.issuperset(s2))  #True

6.子集 : <=, .issubset()

print(s2 <= s1)
print(s2.issubset(s1))

ps ：如果两两相同，则互为父子集

🐰去重

1.简单去重(无法保证顺序)

s1=set('hello')
print(s1)  #'l','h','o','e'

#  将一个列表去重
l=['a','b',1,'a','a']
print(list(set(l)))    #先变成集合去重，再list变成列表
#[1,'a','b']  无法保证顺序

2.去重并保证原来的顺序(了解)

l = ['a', 'b', 1, 'a', 'a']
l2=[]
s=set()

#  通过"for"循环一个一个取, 一个一个加
for item in l:
    if item not in s:
        l2.append(item)       #l2=['a','b',1]   一个一个加进来
print(l2)  #['a','b','1']

五.内置方法

🐼优先掌握的操作(*********)

1.长度 : .len( )

s1=1,'a','b','c','d'
print(len(s1))  #5

2.成员运算 in 和 not in

s1=1,'a','b','c','d'
print(len(s1))
s1=1,'a','b','c','d'
print("c" in s1)      #True
print("c" not in s1)  #False

3.循环取值

• 集合是无序的, 所以使用 for 循环取出来的值也是无序的

s1=1,'a','b','c','d'
for i in s1:
    print(i)
# d
# 1
# c
# b
# a

🐨需要掌握的操作(****)

1.更新 .update( )

• 新集合更新旧集合, 有则不添加, 无则添加
• 可以一次添加多个值

s1='a','b','c'
s1.update("a",3,4,5)
print(s1)   # 'a','b','c',3,4,5

2.添加 .add( )

• 一次只能添加一个值

s1='a','b','c'
s1.add(4)
print(s1)  #'c', 'b', 'a', 4

3.取走一个值 .pop( )

• 不指定参数, 随机删除集合中的任意元素, 并且返回这个值

s="aaa",22,3,"bbb"
res=s.pop()
print(s)    #3, 'aaa', 22
print(res)  #bbb

4.删除 .remove( ), .discard( )

• .remove( ) : 当删除的元素不存在时, 报错
• .discard( ) : 当删除的元素不存在时, 不报错

s1='a','b','c'
#  "remove"删除
s1.remove(4)  #报错

#  "discard"删除
s1.discard(4)  #不报错

5.无交集 .isdisjoint( )

• 如果两个集合没有任何交集则返回 True

#  无交集实验
s1=1,2,3
s2=4,5,6
print(s1.isdisjoint(s2))   #T
print(s2.isdisjoint(s1))   #T

#  有交集实验
s1=1,2,3
s2=4,5,6,3
print(s1.isdisjoint(s2))   #T
print(s2.isdisjoint(s1))   #T

🐻不怎么需要了解的操作(***)

1…difference_update( )

2…intersection_ update( )

3…symmetric_ difference_ update( )

六.总结

• 可以存多个值

• 无序

• 可变类型—>不可 hash 类型

ps : 集合里面的值必须不可变

print(s1.isdisjoint(s2)) #T
print(s2.isdisjoint(s1)) #T

## 🐻不怎么需要了解的操作(***)

### 1..difference_update( )

### 2..intersection_ update( )

### 3..symmetric_ difference_ update( )

## 六.总结

- ### 可以存多个值

- #### 无序

- #### 可变类型--->不可 hash 类型

[外链图片转存中...(img-2rHa53oA-1656084132890)]

ps : 集合里面的值必须不可变