一、回顾Python基础语法-列表、字典、元组、集合_python集合元组列表字典的内置函数-CSDN博客

本文链接：https://blog.csdn.net/qq_33181292/article/details/131367654

Python基础语法-列表、字典、元组、集合

条件表达式

True if x>y else False

x = 10
y = 20
z = "x大于y" if x > y else "x小于y"

print(z)

x小于y

列表

列表相当于其他语言中的数组
是一个可变序列

列表创建方式

中括号

lst = ["hello", "world", "qwer",98]

list内置函数

lst2 = list(["hello", "world", "qwer",98])

lst = list(range(1, 10))
print(lst)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

列表生成表达式

lst = [i * i for i in range(1, 11)]
print("lst:", lst)

lst1 = [i for i in range(1, 11)]
print("lst1:", lst1)

lst2 = [i % 2 == 0 for i in range(1, 11)]
print("lst2:", lst2)

lst3 = [i * 2 for i in range(1, 11)]
print("lst3:", lst3)

lst: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
lst1: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
lst2: [False, True, False, True, False, True, False, True, False, True]
lst3: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

空列表[]\list()

# 空列表
lst = []
lst1 = list()

print(lst, lst1, type(lst), type(lst1))

[] [] <class 'list'> <class 'list'>

列表的特点

列表元素按照顺序有序排列
列表可以存储重复数据
列表可以存储任意类型
列表索引映射唯一数据
根据需要动态分配和回收内存

判断元素是否存在

in/not in

lst = [10, 20, 30, 40]

print(lst)
# 判断10是否存在于lst
print(10 in lst)
# 判断10不存在于lst
print(10 not in lst)

[10, 20, 30, 40]
True
False

列表获取指定元素索引

index(“qwer”)

lst = ["hello", "world", "qwer", 98, "qwer"]

print(lst.index("qwer"))

2

index(“qwer”,3,5)

根据指定的范围内，查找元素

lst = ["hello", "world", "qwer", 98, "qwer"]

print(lst.index("qwer", 3, 5))

4

如果列表中存在多个相同元素，只会返回元素中的第一个出现的索引；
如果查询的元素在列表中不存在，则会抛出异常ValueError；
还可以在指定范围内进行查找元素的索引；

列表根据索引获取指定元素

lst[2]

正向索引从0 --（N-1）

lst = ["hello", "world", "qwer", 98, "qwer"]

print(lst[2])

qwer

lst[-2]

逆向索引从-N – （-1）

lst = ["hello", "world", "qwer", 98, "qwer"]

print(lst[-2])

98

指定的索引不存在，报错indexError；

列表切片

[start : stop : step]
[开始：结束：步长]
切片结果：原列表片段的拷贝
切片的范围：[start,stop)
step步长，默认为1，可省略，[start,stop)

正向切片

步长

[1:6:1]

列表从0开始计算，包前不包后

lst = [10, 20, 30, 40, 50, 60, 70, 80]

# start=1,stop=6,step=1
print(lst[1:6:1])

[20, 30, 40, 50, 60]

[1:6:2]

lst = [10, 20, 30, 40, 50, 60, 70, 80]

# start=1,stop=6,step=1
print(lst[1:6:1])
# step=2
print(lst[1:6:2])

[20, 30, 40, 50, 60]
[20, 40, 60]

[1:6]

lst = [10, 20, 30, 40, 50, 60, 70, 80]

# start=1,stop=6,step=1
print(lst[1:6])
print(lst[1:6:])
print(lst[1:6:1])

[20, 30, 40, 50, 60]
[20, 30, 40, 50, 60]
[20, 30, 40, 50, 60]

start

[:6:2]

不写start，默认从0开始

lst = [10, 20, 30, 40, 50, 60, 70, 80]

# start=0,stop=6,step=2
print(lst[:6:2])

[10, 30, 50]

stop

[1::2]

不写stop，默认为列表长度，切片的最后一个元素默认是列表的最后一个元素

lst = [10, 20, 30, 40, 50, 60, 70, 80] 

# stop为空
print(lst[1::2])
[20, 40, 60, 80]

反向切片

步长

[::-1]

切片的第一个元素就是列表的最后一个元素

lst = [10, 20, 30, 40, 50, 60, 70, 80]

# step =-1
print(lst[::-1])

[80, 70, 60, 50, 40, 30, 20, 10]

[6:0:-2]

包前不包后，索引为0的元素不囊括在内；

lst = [10, 20, 30, 40, 50, 60, 70, 80]

# start=6,stop=0,step=-2
print(lst[6:0:-2])

[70, 50, 30]

stop

[7::-1]

根据包前不包后的原则，包含最后一个元素，步长为-1，则倒序排列，stop为空，则取整个列表；

lst = [10, 20, 30, 40, 50, 60, 70, 80]

# start=7,step=-1
print(lst[7::-1])
[80, 70, 60, 50, 40, 30, 20, 10]

列表添加元素

append()

在一个列表的末尾添加一个元素

lst = [10, 20, 30, 40]

# 在一个列表的末尾添加一个元素
lst.append(50)
print(lst)

lst2 = ["a","b"]
# 添加一个列表
lst.append(lst2)
print(lst)

[10, 20, 30, 40, 50]
[10, 20, 30, 40, 50, ["a","b"]]

extend()

在一个列表的末尾添加多个元素

lst = [10, 20, 30, 40]
lst2 = ["a","b"]

# 在一个列表的末尾添加多个元素
lst.extend(lst2)
print(lst)

[10, 20, 30, 40, 50, "a","b"]

insert()

在列表中的任意索引位置添加元素

lst = [10, 20, 30, 40]

# 在列表的任意索引位置插入元素
lst.insert(1, 100)
print(lst)

[10, 100, 20, 30, 40]

切片

将切片的元素内容替换为，其他列表内的元素

lst = [10, 20, 30, 40]
lst3 = [True, False, "hello world"]

print(lst[1:])
# 对lst列表做切片，将切片的内容替换为lst3列表中的内容
# 也可以理解为：把lst列表索引为1后面的内容，以lst3列表进行替代赋值；
lst[1:] = lst3
print(lst)

[20, 30, 40]
[10, True, False, 'hello world']

列表删除元素

remove()

根据元素值进行移除，移除列表中的元素，一次只能删除一个元素
如果列表中要移除的元素存在多个，则只会移除索引最靠前的元素
如果要移除元素不存在，则会报错ValueError

lst = [10, 20, "30", 40, 50, 60, "30"]

print(lst)
# 移除lst中的元素值为30的
lst.remove("30")
print(lst)

# 移除了索引为2的，元素30
[10, 20, "30", 40, 50, 60, "30"]
[10, 20, 40, 50, 60, "30"]

pop()

根据元素索引，来移除元素
不添加索引，则移除列表中最后一个元素

lst = [10, 20, 30, 40, 50, 60, 30]

print(lst)
# 移除索引为5的元素
lst.pop(5)
print(lst)

# 移除了元素60
[10, 20, 30, 40, 50, 60, 30]
[10, 20, 30, 40, 50, 30]

切片

使用切片，一般会生成一个新的列表，通过生成新列表的方式来达到删除的目的
通过赋值的方式删除元素，不需要生成新的列表，需要先指定删除范围

# 生成新的列表
lst = [10, 20, 30, 40, 50, 60, 30]

print(lst)
# 通过切片的方式，我只保留列表中索引为1到3之间的元素，[1,3)
new_lst = lst[1:3]
print(new_lst)

# 结果为：1-3之间的元素为20,30
[10, 20, 30, 40, 50, 60, 30]
[20, 30]

# 切片赋值删除
lst = [10, 20, 30, 40, 50, 60, 30]

print(lst)
# 通过赋值的方式，将索引为1后的所有元素移除，包括索引1的元素
lst[1:] = []
print(lst)

# 结果为：将索引大于1的所有元素，通过赋值的方式删除
[10, 20, 30, 40, 50, 60, 30]
[10]

clear()

将列表中所有的元素清空，但会保留列表对象

lst = [10, 20, 30, 40, 50, 60, 30]

print(lst)
# 将列表中所有的元素清空
lst.clear()
print(lst)

[10, 20, 30, 40, 50, 60, 30]
[]

del

将列表整个删除，包括元素和列表对象
删除后，再输出列表对象会报错name 'lst' is not defined

lst = [10, 20, 30, 40, 50, 60, 30]

print(lst)
# 删除列表对象
del lst
print(lst)

[10, 20, 30, 40, 50, 60, 30]
Traceback (most recent call last):
  File "D:\develop\vPython\csTest\demo\listqiepianremove.py", line 12, in <module>
    print(lst)
NameError: name 'lst' is not defined

列表修改元素

切片

修改单个元素

根据索引进行修改

lst = [10, 20, 30, 40]

print(lst)
# 修改索引为2的元素值为100
lst[2] = 100
print(lst)

[10, 20, 30, 40]
[10, 20, 100, 40]

修改多个元素

修改多个值，通过赋值的方式进行
需要通过切片定位要修改的索引范围

lst = [10, 20, 30, 40]

# 将索引为1到3的元素值，替换为aa,bb,cc
lst[1:3] = ["aa", "bb", "cc"]
print(lst)

[10, 20, 30, 40]
[10, 'aa', 'bb', 'cc', 40]

列表元素排序

sort()方法

列表中的默认元素按照从小到大的方式进行，升序排序
可以使用，reverse=True，进行降序排列

lst = [84, 12, 45, 96, 32, 45]

print("原列表：", lst)

# 对列表进行升序排列
lst.sort()
print("升序排列：", lst)

# 对列表进行降序排列
lst.sort(reverse=True)
print("降序排列：", lst)

sorted()内置函数

sorted()内置函数，会产生一个新的排序后的列表，原列表不变；
可以使用，reverse=True进行，倒序排列

lst = [84, 12, 45, 96, 32, 45]

# 使用内置函数，会生成一个新的序列
new_lst = sorted(lst)
print("新列表——默认升序：", new_lst)
print("原列表：", lst)

# 使用内置函数，进行降序排列
new_lst2 = sorted(lst, reverse=True)
print("新列表——降序排列：", new_lst2)
print("原列表：", lst)

新列表——默认升序： [12, 32, 45, 45, 84, 96]
原列表： [84, 12, 45, 96, 32, 45]

新列表——降序排列： [96, 84, 45, 45, 32, 12]
原列表： [84, 12, 45, 96, 32, 45]

列表元素个数

len()内置函数

lst = [1, 2, 5, 3, 3, 45, 6]
print(len(lst))

'''
7
'''

len()特殊方法

lst = [1, 2, 5, 3, 3, 45, 6]
print(lst.__len__())

'''
7
'''

字典

相当于java中的map

什么是字典

Python内置的数据结构之一，与列表一样是一个可变序列
以键值对的方式存储数据，字典是一个无序的序列

字典的特点

字典中所有元素都是一个key-value对，key不允许重复，value可以重复
字典中的元素是无序的（根据hash(key)，计算存储位置）
字典中key必须是不可变对象（int，str）
字典也可以根据需要动态伸缩
字典会浪费较大的内存，是一种使用空间换时间的数据结构

空间换时间：

首先我们存入一对key,value，如：q:123，hash(q)后计算得到的结果为4，则字典会提前创建出4个空间，将q:123存入4的位置，空出来3处位置空间
我们再存入一对key,value，如：w:456，hash(w)后的结果为5，则需要在4的后面添加新的空间，存放5，空闲出4处位置空间；
只是模糊的举例，了解空间换时间，hash的结果也只是举例；

**不可变序列：**int，str（以赋值的方式进行改变数据值，改变的是引用的内存中的地址，原数据值被丢弃，新值地址指向定义的对象）

不可变序列特点：不能进行增，删，改，查；

字典的查找：

查找过程就是存储过程，都需要对key进行hash()计算

字典是无序序列原因

字典以key，value键值对的形式进行存储，存储时会经过hash函数这个工序，要对key进行hash()计算，计算的结果就是存储位置；
也就会出现，第一个键的值hash()计算后，放到第一位，第二个键hash()计算后，要比第一个键的值小，他要放到第一位；
放入字典中的键（key）,是一个不可变序列的键

字典的实现原理

字典的实现原理与查字典类似，查字典是先根据首部或拼音查找对应的页码，Python中的字典是根据key查询value所在的位置；

字典的创建

大括号{}

d = {"张三": 10, "李四": 20, "王五": 30}
print(d, type(d))

# 创建空字典
c = {}
print(c, type(c))

{'张三': 10, '李四': 20, '王五': 30} <class 'dict'>

{} <class 'dict'>

内置函数dict()

s = dict(name="张三", age=20)
print(s, type(s))

{'name': '张三', 'age': 20} <class 'dict'>

字典生成表达式zip()

内置函数zip():
- 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表
如果列表长度不对称，则会以最短的为主；

keys = ['qwer', 'time', '5h6m', 'cc']
values = [12, 67, 700, 33]

dicts = {key: value for key, value in zip(keys, values)}
print(dicts)

# 将key,转为大写
dicts = {key.upper(): value for key, value in zip(keys, values)}
print(dicts)

张三 10 10
李四 20 20
王五 30 30
{'qwer': 12, 'time': 67, '5h6m': 700, 'cc': 33}

{'QWER': 12, 'TIME': 67, '5H6M': 700, 'CC': 33}

空字典\dict()

# 空字典
d = {}
d1 = dict()

print(d, d1, type(d), type(d1))

{} {} <class 'dict'> <class 'dict'>

字典根据key获取value

[]中括号

如果指定的key不存在，则会报错KeyError: '赵六'

d = {"张三": 10, "李四": 20, "王五": 30}
print(d, type(d))

print(d['张三'])
# 如果通过[]方式获取的值不存在，则会报错
print(d['赵六'])

{'张三': 10, '李四': 20, '王五': 30} <class 'dict'>
10

Traceback (most recent call last):
  File "D:\develop\vPython\csTest\dictDemo\create_dict.py", line 13, in <module>
    print(d['赵六'])
KeyError: '赵六'

.get()方法

如果指定的key不存在，不会抛出错误keyError，而会输出None；
如果指定的key不存在，我们也可以不输出默认值None，替换为其他的值，如：d.get('赵六'，99)

d = {"张三": 10, "李四": 20, "王五": 30}
print(d, type(d))

print(d.get('张三'))
# 指定的key,不存在则输出None
print(d.get('赵六'))
# 不存在key时，可以将默认值None替换为我们指定的数据
print(d.get('赵六', 'a'))

{'张三': 10, '李四': 20, '王五': 30} <class 'dict'>
10
None
a

判断Key是否在字典中存在

in/not in

d = {"张三": 10, "李四": 20, "王五": 30}
print(d, type(d))

print('张三' in d)
print('张三' not in d)

{'张三': 10, '李四': 20, '王五': 30} <class 'dict'>
True
False

字典添加key,value

d[‘赵六’] = 40

d = {"张三": 10, "李四": 20, "王五": 30}
print(d, type(d))

# 新增一个键值对
d['赵六'] = 40
print(d)

{'张三': 10, '李四': 20, '王五': 30} <class 'dict'>
{'张三': 10, '李四': 20, '王五': 30, '赵六': 40}

字典修改key,value

d[‘王五’] = 99

通过赋值的方式进行修改，也就是改变对象的引用地址

d = {"张三": 10, "李四": 20, "王五": 30}
print(d, type(d))

# 通过赋值的方式修改
d['王五'] = 99
print(d, type(d))

{'张三': 10, '李四': 20, '王五': 30} <class 'dict'>
{'张三': 10, '李四': 20, '王五': 99} <class 'dict'>

字典删除key,value

del d[“王五”]

删除指定的key和value值

d.clear()

清空整个字典，保留字典对象；

d = {"张三": 10, "李四": 20, "王五": 30}
print(d, type(d))

# 删除指定的key
del d["王五"]
print(d)

# 清空字典所有的键值对
d.clear()
print(d)

字典的视图

d = {"张三": 10, "李四": 20, "王五": 30}
print(d, type(d))

{'张三': 10, '李四': 20, '王五': 30} <class 'dict'>

.keys()

# 获取所有的key
print(d.keys(), "类型：", type(d.keys()))

dict_keys(['张三', '李四', '王五']) 类型： <class 'dict_keys'>

.values()

# 获取所有的value
print(d.values(), "类型：", type(d.values()))

dict_values([10, 20, 30]) 类型： <class 'dict_values'>

.items()

# 获取所有的key，value键值对
print(d.items(), "类型：", type(d.items()))

dict_items([('张三', 10), ('李四', 20), ('王五', 30)]) 类型： <class 'dict_items'>

视图转为列表list()

lst_key = list(d.keys())
print(lst_key, "类型：", type(lst_key))

lst_value = list(d.values())
print(lst_value, "类型：", type(lst_value))

['张三', '李四', '王五'] 类型： <class 'list'>
[10, 20, 30] 类型： <class 'list'>

将itmes转为列表，特殊的一种：
该列表的元素是由元组（下一章讲，还没学呢，就是两个小括号包裹起来的）组成的

item = list(d.items())
print(item)

[('张三', 10), ('李四', 20), ('王五', 30)] 类型： <class 'list'>

字典的遍历

item代表字典的键key

d = {"张三": 10, "李四": 20, "王五": 30}

for item in d:
    print(item, d[item], d.get(item))

张三 10 10
李四 20 20
王五 30 30

元组

什么是元组

元组是Python内置的数据结构之一，是一个不可变序列

t = ('Python', 'hello', '99')

# t：元组对象
# 元祖被(小括号)包裹
# 中间以逗号分割

不可变序列与可变序列：

**不可变序列：**int、字符串、元组

不可变序列：没有增删改查

**可变序列：**列表，字典

可变序列：可以对序列执行增删改操作，对象地址不发生改变；

# 可变序列
lst = [10, 20, 30]
print(lst, id(lst))
lst.append(40)
print(lst, id(lst))

# 不可变序列
s = "hello"
print(s, id(s))
s = s + "world"
print(s, id(s))

[10, 20, 30] 2504544058496
[10, 20, 30, 40] 2504544058496
hello 2504541422128
helloworld 2504541382128

元组的创建方式

小括号()

元组内只有一个元素需要添加逗号，见方法三；

# 创建元组
# 方式一：
t = (12, 34, 56, 'qwer')
print(t, type(t))

# 方式二：存在多个元组元素时，可省略小括号
t1 = 12, 34, 56, 'qwer'
print(t1, type(t1))

# 方式三：只有一个元组元素时，需要添加小括号和逗号
t2 = (12,)
print(t2, type(t2))

(12, 34, 56, 'qwer') <class 'tuple'>
(12, 34, 56, 'qwer') <class 'tuple'>
(12,) <class 'tuple'>

内置函数tuple()

# 通过内置函数
tt = tuple(('1234', 12))
print(tt, type(tt))

('1234', 12) <class 'tuple'>

空元组\tuple()

# 空元组
t = ()
t1 = tuple()

print(t, t1, type(t), type(t1))

() () <class 'tuple'> <class 'tuple'>

为什么要把元组设计为不可变序列

在多任务环境下，同时操作对象时不需要加锁
因此，在程序中尽量使用不可变序列；

**注意事项：**元组中存储的是对象的引用（地址）

如果元组中对象本身是不可变对象，则不能再引用其他对象的引用；（s =“qwer” ,不能再对s进行赋值；s=“abcd”）
如果元组中的对象是可变序列，则可变对象的引用不能改变，但数据可以改变；

t = (10, [10, 20, 30], 33)
'''
元组t中包含2个不可变序列int，10,30
还包含一个可变序列t[1]列表
我们不能再对元组内的对象引用地址改变，但可以改变可变序列对象内的值
'''
t[1] = [100]
print(t)

# 结果报错	
Traceback (most recent call last):
  File "D:\develop\vPython\csTest\dictDemo\tuple_demo.py", line 25, in <module>
    t[1] = [100]
TypeError: 'tuple' object does not support item assignment

改变元组内的可变序列

t = (10, [10, 20, 30], 33)    
'''
我们可以改变元组内的，可变序列对象的值
'''
# 输出改变前元组的数据：
print(t)
# 对元组内的列表添加元素
t[1].append(23)
print(t)

# 结果为：
(10, [10, 20, 30], 33)
(10, [10, 20, 30, 23], 33)

元组的遍历

索引t[1]

需要知道元组的长度，否则容易出现越界的情况

# 元组的遍历
t = (10, 3, 23, 55)

# 根据索引输出元组的元素
print(t[0])
print(t[1])
print(t[2])
print(t[3])

循环for in

# 元组的遍历
t = (10, 3, 23, 55)

# 根据for in 循环遍历输出元素
for item in t:
    print(item)

集合

什么是集合

集合是Python语言提供的内置数据结构
与列表、字典一样都属于可变类型的序列；
集合也是通过**{大括号}**进行创建的，集合是没有的value的字典
集合也是通过hash()对数据进行计算存储的，因此也是无序的；

集合的创建

大括号{}

# 集合的创建
# 直接使用{}进行创建
s = {1, 78, 7, 21, 36}
print(s, type(s))

{1, 36, 21, 7, 78} <class 'set'>

内置函数set()

# 内置函数set创建集合
s1 = set(range(6))
print(s1, type(s1))

{0, 1, 2, 3, 4, 5} <class 'set'>

列表转集合set()

# 列表转为集合，通过内置函数set()
s2 = set([1, 23, 56, 88, 0, 'a'])
print(s2, type(s2))

{0, 1, 'a', 23, 56, 88} <class 'set'>

字符串转集合set()

# 将不可变序列str字符串转为集合，通过内置函数set()
s3 = set('Python')
print(s3, type(s3))

{'y', 'n', 't', 'P', 'h', 'o'} <class 'set'>

集合转集合set()

# 将集合转为集合，通过内置函数set()
s4 = set({'1', 34, '6', 'qa', 'a'})
print(s4, type(s4))

{34, '6', 'a', 'qa', '1'} <class 'set'>

元组转集合set()

# 将元组转为集合，通过内置函数set()
s6 = set((1, '2', 3, 44))
print(s6, type(s6))

{'2', 1, 3, 44} <class 'set'>

集合生成表达式

集合生成式与列表生成式的区别是，将[中括号]变为了{大括号}

# 集合生成式
s = {i * i for i in range(10)}
print(s)

空集合set()

# 创建空集合，通过内置函数set()
s5 = set()
print(s5, type(s5))

set() <class 'set'>

判断元素是否存在于集合

in\not in

# 判断元素
s = {1, '22', 324, 50, 'w', 44, 77}
print(1 in s)
print(1 not in s)

True
False

集合添加元素

.add()

add()方法，一次只能添加一个元素

s = {1, '22', 324, 50, 'w', 44, 77}
print(s)

# 集合添加元素
s.add('qwer')
print(s)

{1, 'w', 50, 324, '22', 44, 77}
{1, 'w', 50, 324, '22', 'qwer', 44, 77}

.update()

update()方法，一次最少可以添加一个元素

.update(列表)

可以使用update()方法添加列表，到集合中

s = {1, '22', 324, 50, 'w', 44, 77}
print(s)

# 通过update()方法，添加列表
s.update([1, 2, 4, 5, 6])
print(s)

{1, 50, '22', 'w', 324, 44, 77}
{1, 2, 'w', 324, 4, 5, 6, 77, '22', 44, 50}

.update(元组)

可以使用update()方法添加元组，到集合中
元组中如果只有一个元素，需要在元素后面添加逗号；

s = {1, '22', 324, 50, 'w', 44, 77}
print(s)

# 通过update()方法，添加元组
s.update(('qa', 'qqq', 'cc'))
print(s)

{1, 50, 324, '22', 'w', 44, 77}
{1, 324, 77, 'qa', '22', 'cc', 44, 50, 'qqq', 'w'}

添加元组（只有一个元素）

s = {1, '22', 324, 50, 'w', 44, 77}
print(s)

# 通过update添加一个元组元素
s.update(('qwer',))
print(s)

{1, 50, 'w', 324, '22', 44, 77}
{1, 50, 'w', 324, 'qwer', '22', 44, 77}

集合删除元素

.remove()方法

remove()方法，输入元素值进行删除
一次只能删除一个集合元素

s = {1, 2, 3, 4, 5, 'a', 'b', 'c'}
print(s)

# 通过remove()方法，删除元素,集合没有索引的概念
s.remove(1)
print(s)

{1, 2, 3, 4, 5, 'a', 'c', 'b'}
{2, 3, 4, 5, 'a', 'c', 'b'}

如果删除不存在的集合元素，则会报错KeyError: 1111

s = {1, 2, 3, 4, 5, 'a', 'b', 'c'}
print(s)

# 通过remove()方法，删除一个不存在的元素
s.remove(1111)
print(s)

{1, 2, 3, 4, 5, 'c', 'b', 'a'}
Traceback (most recent call last):
  File "D:\develop\vPython\csTest\setDemo\setDel.py", line 8, in <module>
    s.remove(1111)
KeyError: 1111

.discard()方法[得死歌儿的]

一次只能删除一个集合元素

s = {1, 2, 3, 4, 5, 'a', 'b', 'c'}
print(s)

# 通过discard()方法，删除元素，每次只能删除一个元素，删除不存在元素不会报错
s.discard('a')
print(s)

{1, 2, 3, 4, 5, 'a', 'b', 'c'}
{1, 2, 3, 4, 5, 'b', 'c'}

如果删除的集合元素不存在，不会报错，无任何输出；

s = {1, 2, 3, 4, 5, 'a', 'b', 'c'}
print(s)

# 通过discard()方法，，删除不存在元素不会报错
s.discard('a')
print(s)

# 删除不存在的数据，无报错，我们原样输出了s集合
{1, 2, 3, 4, 5, 'c', 'a', 'b'}
{1, 2, 3, 4, 5, 'c', 'a', 'b'}

.pop()方法

每次随机删除一个元素，不能指定删除的元素，和索引（集合都是hash key值，不存在索引概念）
集合元素计算hash()后，hash值是不固定的，多次计算后会出现不同的情况（不信自己执行看看）（hash是无序的，插入位置和输出位置不相同）
列表中的pop()方法，根据索引进行删除，不添加索引则删除列表中的最后一个元素；

s = {'ddd', 1, 2, 3, 4, 5, 'a', 'b', 'c'}
print(s)

# 通过pop()方法，随机删除元素
s.pop()
print(s)
s.pop()
print(s)
s.pop()
print(s)

# 虽然看着很有顺序，但是我有次输出打印的时候，c跑到了最前面，开头的地方，我也就明白了为啥是随机删除；
{1, 2, 3, 4, 5, 'a', 'b', 'c', 'ddd'}
{2, 3, 4, 5, 'a', 'b', 'c', 'ddd'}
{3, 4, 5, 'a', 'b', 'c', 'ddd'}
{4, 5, 'a', 'b', 'c', 'ddd'}

.clear()方法

清空集合元素，保留对象

s = {'ddd', 1, 2, 3, 4, 5, 'a', 'b', 'c'}
print(s)

# 通过clear()方法清空集合元素
s.clear()
print(s)

{1, 2, 3, 4, 5, 'ddd', 'a', 'b', 'c'}
set()

集合操作

集合相等

判断集合是否相等，取决于集合内的元素是否相同（忽略顺序，hash()计算位置）

s3 = {100, 200, 300}
s4 = {200, 100, 300}

# 判断两个集合是否相等
print(s3 == s4)

True

子集

A集合内元素包含B内所有的元素，我们称B为A的子集；

s1 = {1, 2, 3, 4, 5, 6, 7, 8}
s2 = {1, 2, 3, 4, 5, 6}

# 判断一个集合是否为另一个集合的子集
# s2 是 s1 的子集
print(s2.issubset(s1))

True

超集

A集合内元素包含B内所有的元素，我们称A为B的超集；

s1 = {1, 2, 3, 4, 5, 6, 7, 8}
s2 = {1, 2, 3, 4, 5, 6}

# 判断是否为超集
# s1 是 s2 的子集
print(s1.issuperset(s2))

True

交集

A集合内元素与B集合内的元素有重叠，那么重叠的元素我们称之为交集；

s1 = {1, 2, 3, 4, 5, 6, 7, 8}
s2 = {1, 2, 3, 4, 5, 6}

# 判断两个集合没有交集
print(s1.isdisjoint(s2))  # s1与s2有交集
print(s1.isdisjoint(s3))  # s1与s3没有交集

False
True

集合数学操作

交集

两个集合相同的元素

.intersection()/ &

s1 = {1, 2, 3, 4, 5}
s2 = {4, 5, 6, 7}
# 交集
print(s1.intersection(s2))
print(s1 & s2)

{4, 5}
{4, 5}

并集

两个集合所有元素相加（因为hash计算会去重）

.union()/ |

s1 = {1, 2, 3, 4, 5}
s2 = {4, 5, 6, 7}

# 并集
print(s1.union(s2))
print(s1 | s2)

{1, 2, 3, 4, 5, 6, 7}
{1, 2, 3, 4, 5, 6, 7}

差集

s1集合减去s1与s2集合的交集

.difference()/ -

s1 = {1, 2, 3, 4, 5}
s2 = {4, 5, 6, 7}

# 差集
print(s1.difference(s2))
print(s1 - s2)

{1, 2, 3}
{1, 2, 3}

对称差集

s1集合与s2集合同时减去交集后，得到的集合的并集

.symmetric_difference()/ ^

s1 = {1, 2, 3, 4, 5}
s2 = {4, 5, 6, 7}

# 对称差集
print(s1.symmetric_difference(s2))
print(s1 ^ s2)  # 数字6代码的符号

{1, 2, 3, 6, 7}
{1, 2, 3, 6, 7}

集合遍历

for/in

s = {1, 2, 4, 5, 6, 7, 8, 9, 'a'}
for i in s:
    print(i)

列表、字典、元组、集合异同

数据结构	是否可变	是否重复	是否有序	定义符号
列表（list）	可变	可重复	有序	[]
元组（tuple）	不可变	可重复	有序	()
字典（dict）	可变	key不可重复、value可重复	无序	{key,value}
集合	可变	不可重复	无序	{}