例如，有一个无序的集合 A，你可以这样转换它：

Copy code

A = {3, 2, 1}

B = sorted(A)

print(B) # 输出 [1, 2, 3]

sorted() 函数默认按升序排列，也可以通过参数 reverse 指定按降序排列。例如：

Copy code

A = {3, 2, 1}

B = sorted(A, reverse=True)

print(B) # 输出 [3, 2, 1]

注意，sorted() 函数是一个针对列表、元组、字符串等序列类型的排序函数，如果要对集合进行排序，需要先将集合转换为序列类型，再使用 sorted() 函数。

希望这些信息能帮到你！

在python中，数据类型主要由以下几类组成：

列表(list): [a, b]

元组(tuple)：(a, b, )

集合(set)： {a, b}

字典(Dictonary): {a: ‘aaa’, b: ‘bbb’}

1. 列表

列表(List)

列表是Python中使用最频繁的数据类型，专门用于存储一串信息

列表是一种有序和可更改的集合。允许重复的元素

列表使用[]定义，元素之间使用，分隔。例：[1,2, ...]

列表的索引从位置0开始

索引就是元素在列表中的位置编号，索引又可以被称为下标

注意：从列表中取值时，如果超过索引范围，程序会报错

虽然列表可以存储不同类型元素，但是曰常中一般存储相同类型的元素

如何使用列表

列表[索引]: 从列表中取值，获取指定索引的元素

列表[开始索引:结束索引:步长]:

返回从开始索引到结束索引-1的列表，如果设置步长，按步长跳过元素

len(列表): 获取列表的长度

元素 in 列表: 判断元素是否在列表中

列表.count(元素): 返回指定元素在列表中的个数

列表.index(元素): 返回指定元素在列表中第一次出现的索引，查找失败时报错

列表.sort(): 从小到大排序，括号内增加reverse=True ,则是从大到小排序

列表_reverse(): 逆序(反转)列表

列表.clear(): 清空列表

Eg:

# 0 init listL = [1, 2, 3, 4, 5, 7, 6]# 1 index valueL[1]# -->2# 2 stepL[2: 5: 2] # -->[3, 5]# 3 lengthlen(L) # -->6# 4 in6 in L # --->True8 in L # --->False# 5 countL.count(1) # --->1# 6 indexL.index(2) # --->1# 7 sortL.sort() # --->[1, 2, 3, 4, 5, 6, 7] 注意：会改变自己 返回None # 8 reverseL.reverse() # 由于第7步改变了自己， 这里变成[7, 6, 5, 4, 3, 2, 1] 会改变自己 返回None # 9. clearL.clear() # --->[]

列表特有的一些使用方法

L = [1, 2, 3, 4, 5]

列表[索引]=元素：修改指定索引的元素，索引不存在会报错

L[2] = 7 L# --->[1, 2, 7, 4, 5]

列表 . append(元素)：在列表的末尾追加元素

L.append(6)L # --->[1, 2, 7, 4, 5, 6]

列表 . insert(索引，元素)：在指定索引位置插入元素，索引不存在时在末尾追加

L.insert(3, 9)L # --->[1, 2, 7, 4, 9, 5, 6]

列表.pop(索引)：

删除并返回指定索引的元素，未指定索引时删除最后一项，索引不存在时报错

L.pop(3) # 4, L 变成[1, 2, 7, 9, 5, 6]L.pop() # 6, L 变成[1, 2, 7, 9, 5]

列表 . remove(元素)：删除列表中第一个出现的指定元素，查找失败时报错

L.remove(2) # L 变成[1, 7, 9, 5]

del 列表[索引]: 删除指定索引位置的元素，索引不存在时报错

del L[3] # L 变成[1, 7, 9]

列表l.extend(列表2): 将列表2拼接在列表1后

L.extend([8, 9, 10]) L # L 变成[1, 7, 9, 8, 9, 10], 等价于 L = L + [8, 9, 10]

2. 元组

元组(Tuple)

元组是一种有序且不可更改的集合, 允许重复的成员

元组与列表的类似，不同之处在于元组元素不可修改

元组使用()定义，元素之间使用,分隔。例：(a, b, …)

元组中只包含一个元素时，可以省略()，只需要在元素后加逗号

init_tuple = 100,type(init_tuple) # --->tuple# ---- 另外写法init_tuple = (100, ) # 逗号一定要加

注意：如果一个非元组类型的数据突然变成元组，检查是不是误加了逗号

集合与元组的通用方法

元组[索引]:从元组中取值，获取指定索弓丨的元素

元组[开始索引:结束索引:步长]:

返回从开始索引到结束索引-1的元组，如果设置步长，按步长跳过元素

len(元组)：获取元组的长度

元素in元组：判断元素是否在元组中

元组.count(元素)：返回指定元素在元组中的个数

元组.index(元素)：返回指定元素在元组中第一次出现的索引，查找失败会报错

元组和列表之间的转换

list(元组)：将元组转换成列表

tuple(列表): 将列表转换成元组

3. 集合

集合(Set)

集合是一种无序和无索引的序列。没有重复的元素

集合会自动删除重复的元素，一般应用于去重、交并差运算场景

集合使用{}定义，元素之间使用，分隔。例：{a, b, …}

集合与列表的通用方法

len(集合)：获取集合的长度

元素in集合：判断元素是否在集合中

集合.clear(): 清空集合

集合特有的使用方法

s = {1, 2, 3}

集合.add(元素)：将元素添加到集合中

s.add(5) # --->{1, 2, 3, 5}

集合1.update(集合2): 添加新的元素或集合到当前集合中

s.add{4, 5, 6} # --->{1, 2, 3, 5, 4, 6}

集合.remove(元素): 删除指定的元素，元素不存在时报错

s.remove(4) # ---->{1, 2, 3, 5, 6}

集合1&集合2 : 交集，获得由集合1和集合2中都存在的元素组成的新集合

s &{3, 4, 5} # --->{3, 5}

集合1|集合2: 并集，获得集合1和集合2中所有元素的新集合

s | {8, 9, 10} # --->{1, 2, 3, 5, 6, 8, 9, 10}

集合1 - 集合2 : 差集，获得在集合1中存在但是在集合2中不存在的元素集合

s - {9, 10} # --->{1, 2, 3, 5, 6, 8}

集合和列表之间的转换(也可以和元组进行转换，方式类似)

list(集合)：将集合转换成列表

set(列表)：将列表转换成集合

    2.基本功能是进行成员关系测试和删除重复元素

    3.可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典

    4.因为set存储的是无序集合，所以我们没法通过索引来访问。访问 set中的某个元素实际上就是判断一个元素是否在set中。

1.创建集合

s=set()#创建一个空集合

s1={1,2,3,'a','python'}

2.删除重复的元素

集合是一个无序不重复元素的序列(意思是有重复的会自动删除,每次打印元素的位置不一定)

3.成员关系测试(检测某个成员是否在集合中)

案例:从终端输入5位数,以空格隔开,把这5位数存入列表中,剔除重复的数据,打印出来

#提示,列表转集合,集合转列表

a=input("请输入5位数字:")

mylist=a.split()

print(mylist)

b=set(mylist)

c=list(b)

print(c)

4.集合常用操作

    1.添加元素

    2.删除元素

    3.删除整个集合

    4.获取集合的长度

    5.不支持改元素

集合操作-添加元素

格式:

集合.add(元素)

格式:

集合.update(元素)

区别:

add不能添加列表,update可以

update是将字符串中的拆分成字符进行追加

add，是当做整体追加在集合中

#案例:从终端输入一个数字就加入集合中,然后打印,又输入一个数字,然后打印,直到输入-1,退出输入

#然后打印最终的集合

ms=set()

while 1:

a=int(input("请输入一个数字:"))

if a==-1:

    break

    ms.add(a)

print(ms)

print(ms)

#案例:从终端输入一个字符串就加入集合中,然后打印,又输入一个字符串,然后打印,直到输入q,退出输入

#然后打印最终的集合,字符串要分开存储,如输入hello,存储的列表是{'h','e','l','0'}

ms=set()

while 1:

a=input("请输入一个字符串:")

if a=='q':

    break

    ms.update(a)

print(ms)

print(ms)

集合操作-删除元素及删除整个集合

格式:

集合.remove(元素)  # 元素如果不存在会引发KeyError

集合.discard(元素)  # 元素如果不存在不发生任何事

集合.pop()  # 集合元素是字符串类型时删除随机元素。 集合元素是其他数据类型时，删除左边第一个元素

del 集合名 #删除整个集合

#案例:有集合{1,2,3,'hello','world'},删除全部字符串,然后最左边第一个元素

a={1,2,3,'hello','world'}

a.discard("hello")

a.discard("world")

a.pop()

print(a)

集合操作-获取集合的长度

格式:

len(集合名)

#案例:有集合{1,2,3,4,'hello','a'},保留1个元素,其他的删除,假如元素个数不确定

s={1,2,3,4,'hello','a'}

for i  in range(len(s)-1):

            s.pop()

  print(s)

集合的集运算

集合的交集,并集,差集,对称差集的运算

{1,2,3,4}交集{4,5,6,7} -->4   交集(&)

{1,2,3,4}并集{4,5,6,7} ->1,2,3,4,5,6,7  并集(|)

{1,2,3,4}差集{4,5,6,7} ->1,2,3  差集(-)

{1,2,3,4}对称差集{4,5,6,7}->1,2,3,5,6,7 4同时出现在两个集合中,不选它 对称差集(^)

#案例:使用花括号和set创建各一个集合,然后对集合进行交、并、差、对称差运算

s={1,2,3,4,5,6}

s1=set([6,7,8,9,10])

print(s&s1)

print(s|s1)

print(s-s1)

print(s^s1)