python序列的应用

序列

在python中，序列结果主要有列表，元组，集合，字典和字符串，对于这些序列结果有以下几个通用的操作。其中，集合和字典不支持索引，切片，相加和换乘操作

1.索引

序列中的每一个元素都有一个编号，也称为索引。这个索引是从0开始递增的，即下标为0表示第一个元素，下表为1表示2个元素，以此类推。

Python中，它的索引可以是负数。这个索引从右边向左计数，也就是从最后一个元素开始计数，及最后一个元素的索引值是-1，倒数第二个元素的索引值是-2，以此类推。

通过索引可以访问序列中的任何元素，例如定义一个四个元素的列表，要访问它的第3个和最后一个元素，可以使用下面的代码：
 

verse=["春眠不觉晓"，"python不得了"，"夜来爬数据"，"好评知多少"]
print(verse[2])
print(verse[-1])

结果如下：

 2.切片

切片操作是访问序列中元素的另一种方法，他可以访问一定范围内的元素。通过切片操作可以生成一个新的序列。实现切片的语句如下：

sname[start : end : strp]

 例如，通过切片先获取NBA历史上十大巨星列表第二到第五个元素，在获取第一个，第三个和第五个元素，可以使用以下代码：

nba=["迈克尔·乔丹","比尔·拉塞尔","卡里姆·阿布杜尔·贾巴尔","威尔特·张伯伦","埃尔文·约翰逊","科比·布莱恩","蒂姆·邓肯","勒布朗·詹姆斯","拉里·伯德","沙奎尔·奥尼尔"]
print(nba[1:5])
print(nba[0:5:2])

运行结果：

3.序列相加

在python中，支持两种相同类型的序列相加操作，即将两个序列进行连接，不会去除重复的元素，使用（+）运算符实现。例如，将两个列表相加，可以使用下面代码：

nba1=["迈克尔·乔丹","比尔·拉塞尔","卡里姆·阿布杜尔·贾巴尔","勒布朗·詹姆斯","拉里·伯德","沙奎尔·奥尼尔"]
nba2=["威尔特·张伯伦","埃尔文·约翰逊","科比·布莱恩","蒂姆·邓肯"]
print(nba1+nba2)

运行结果：

4.乘法

在python中，使用数字n乘以一个序列会审生成新的序列。新的序列内容为原来序列被重复n次的结果。例如，下面的代码，将实现把一个序列乘以三生成一个新的序列并输出

phone=["华为mate 10","vivo x21"]
print(phone*3)

运行结果如下：

5.检查某个元素是否是序列的成员

在python中，可以使用in关键字来检查某个元素是否为序列的成员，及检查某个元素是否包含在某个序列中。语法格式如下：
 

value in sequence

其中value表示要检查的元素，sequence表示指定序列。

例如要检查名称为nba的序列中，是否包含元素“保罗·加索尔”，可以使用以下代码：

nba=["德怀曼·霍华德","德维恩·韦德","凯里·欧文","保罗·加索尔"]
print("保罗·加索尔"in nba)

运行上面代码。将显示结果Ture，表示序列中存在指定元素。

6.计算序列的长度，最大值和最小值

在python中，提供了内置函数计算序列的长度，最大时和最小值。分别是：使用len（）函数计算序列的长度，即返回序列包含了多少个元素；使用max()函数返回序列中最大的元素；使用min()函数返回序列中最小的元素；

定义一个包含九个元素的列表，平通过len()函数计算列表的长度，可以使用以下的代码：

num=[7,14,21,28,35,42,49,56,63]
print("序列num长度为",lem(num))

运行上面代码，显示以下结果：

序列的长度为 9

同样用上面的列表通过max()函数计算列表的最大元素。

num=[7,14,21,28,35,42,49,56,63]
print("序列",num,"中的最大值为"max(num))

运行上面代码，显示以下结果：

序列 [7,14,21,28,35,42,49,56,63] 中的最大值为63

同样的列表用min()函数计算列表是最小元素

num=[7,14,21,28,35,42,49,56,63]
print("序列",num,"中的最小值为"min(num))

运行上面代码，显示以下结果：
 

序列 [7,14,21,28,35,42,49,56,63] 中的最小值为7

列表

python中的列表和歌曲列表类似，也是由有一系列按特定顺序排列的元素组成的。它是python中内置的可变序列。在形式上，列表的所有元素都放在一堆中括号“[]”中，两个相邻的元素间使用逗号“，”分隔。在内容上，可以将整数，实数，字符串，列表，元组等任何类型的内容放入列表中，并且同一个列表中，元素的类型可以不同，因为它们之间没有任何关系。

1.列表的创建和删除

（1）使用赋值运算符直接创建列表

同其他类型的python变量一样，创建列表时，也可以使用赋值运算符“=”直接将一个列表赋值给变量，语法如下：

listname=[element 1,element 2,element 3,...,element n]

其中listname表示列表的名称，可以是任何符合Python命名规则的标识符：“element 1,element 2,element 3,...,element n”表示列表中的元素，个数没有限制，并且只要是Python支持的数据类型就可以

 （2）创建空列表

在Python中也可以创建空列表，例如，要创建一个名称为emptylist的空列表，可以使用下面的代码：

emptylist=[]

 （3）创建数值列表

在python，数值列表很常用。

list()函数的基本语法如下：

list(data)

其中，data表示可以转换为列表的数据，其类型可以是range对象,字符串，元组或者其他可选迭代类型的数据。

例如创建一个10~20之间说有的偶数的列表，可以用以下代码：

list(range(10,20,2))

运行上面代码后，等到一以下列表：

[10,12,14,16,18]

 （4）删除列表

对于已经创建的列表，不再使用时，可以使用del语句将其删除。语句如下：
 

del listname

其中，listname为要删除列表的名称。

2.访问列表元素

在python中，如果想将列表的内容输出也比较简单，可以直接使用print()函数即可。例如,创建一个名称为untitle的列表，并打印列表，可以使用以下代码：

untitle=['python',28,"人生苦短，我用python",['爬虫',"自动化运维",'云计算','web开发']]
print(untitle)

执行结果如下:

['python',28,"人生苦短，我用python",['爬虫',"自动化运维",'云计算','web开发']]

从上卖弄的执行结果可以看吃，在输出列表是，是包括左右两侧的中括号。如果不想要输出全部的元素，也可以通过列表的索引获取指定的元素。例：要获取untitle列表中索引为2的元素，可以使用下面的代码

print(untitle)

执行结果如下：

人生苦短，我用python

从上面的执行结果可以看出，在输出单个列表元素时，不包括中括号，如果是字符串，还不包括左右的引号。

实例：

import datetime                 #导图日期时间类
#定义一个列表
mot=["今天星期一：\n坚持下去不因为我坚强，而是我别无选择。",
     "今天星期二：\n含泪播种的人一定能笑着收获。",
     "今天星期三：\n做对的事情比把事情做对更重要。",
     "今天星期四：\n命运给予我们的不是失望之酒，而是机会之杯。",
     "今天星期五：\n不要等到明天，明天太遥远，今天就行动。",
     "今天星期六：\n求知若渴，虚心若愚。",
     "今天星期天：\n成功将属于那些从不说“不可能”的人。"]
day=datetime.datetime.now().weekday()
print(mot[day])                 #输出每日一贴

运行结果：

3.遍历列表

遍历列表中所有元素是常用的一种操作，在遍历的过程中可以完成查询，处理等功能

（1）直接使用for循环实现

直接使用for循环遍历列表，只输出元素的值，语法格式如下：

for item in listname
    #输出item

其中，liem用于保存获取到的元素值，要输出元素内容时，直接输出该变量即可；listname为列表名称。

 （2）使用for循环和enumerate()函数实现

使用后for循环和enumerate()函数可以实现同时输出和索引值和元素内容，语法格式如下：

for index,item in enumerate(listname):
    #输出index和item

例如，定义一个保存2017~2018赛季NBA西部联盟前八名的列表，然后通过for循环和enumerate()函数遍历该列表，并输出索引和球队名称。

print("2017~2018赛季NBA西部联盟前八名：")
team=["休斯顿 火箭","金州 勇士","波特兰 开拓者","犹他 爵士","新奥尔良 鹈鹕","圣安东尼奥 马刺","俄克拉荷马城 雷霆","明尼苏达 森林狼"]
for index,item in enumerate(team):
    print(index + 1,item)

执行上面代码：

4.添加，修改和删除列表元素

添加，修改和删除列表元素也称为更新列表。在实际开发的时候经常需要对列表进行更新。

（1）添加元素

使用列表对象的append()方法实现，列表对象的append()方法用于在列表的末尾追加元素，语法格式如下：
 

listname.append(obj)

其中，listname为要添加元素的列表名称，obj胃药添加到列表末尾的对象。

上面介绍的时向列表中添加一个元素，如果想要将一个列表中的元素全部都添加到另一个列表中，可以使用列表对象extend()方法实现。extend()方法的语法如下。

listname.extend(seq)

其中，listname为原列表，sep为要添加的列表，语句执行后，sep的内容将追加到listname的后面。

（2）修改元素

修改列表中的元素只需要通过索引获取该元素，然后再为其重新复制即可。例如定义一个保存3个元素的列表，然后修改索引值为2的元素，代码如下：

verse=["长亭外","古道边","芳草碧连天"]
print(verse)
verse[2]="一行白鹭上青天"
print(verse)

运行过程：

verse=["长亭外","古道边",芳草碧连天"]
print(verse)
["长亭外","古道边","芳草碧连天"]
verse[2]="一行白鹭上青天"
print(verse)
[长亭外","古道边","一行白鹭上青天"]

（3）删除元素

删除元素有两种情况，一种根据索引删除，另一种是根据元素值进行删除。

 根据索引删除

删除列表中的指定元素和删除列表相似，也可以使用del语句实现。所不同的就是就是指定列表名称时，换为列表元素。例如，定义一个保存3个元素的列表，删除最后一个元素，可以使用以下代码：

verse=["长亭外","古道边","芳草碧连天"]
del verse[-1]
print(verse)

 上面代码在IDLE中执行过程如下：

  根据元素值删除

如果想要删除一个不全定位置的元素(即根据元素值删除)，可以使用列表对象的remove()方法实现。

5.对列表进行统计和计算

（1）获取指定元素的出现次数

使用列表对象的count()方法可以获取指定元素在列表中出现的次数。基本语法格式如下：

listname.conut(obj)

例如创建一个列表，内容为听众点播的歌曲列表，然后应用列表对象的count()方法判断元素"云在飞"出现的次数，代码如下

song=["云在飞","半壶纱","飞毛腿","云在飞","遇见你"]
num=song.conut("云在飞")
print(num)

上面代码运行后结果显示为2，表示“云在飞”在song列表出现了两次

（2）获取指定元素首次出现的下标

使用列表对象的index()方法可以获取指定元素在列表中首次出现的位置（即索引）。基本语法格式如下：
 

listname.index(odj)

例如，创建一个列表，内容为听众点播的歌曲列表，然后应用列表对象的index()方法判断元素"半壶纱"首次出现的位置，代码如下：

song=["云在飞","半壶纱","飞毛腿","云在飞","遇见你"]
position=song.index("半壶纱")
print(position)

上面代码运行后，将显示1，表示“半壶纱”在song中首次出现的索引位置是3.

（3）统计数值列表的元素和

在python中，提供了sum()函数用于统计数值列表中个元素的和，语法格式如下：

sum(iterable[,start])

例如保存一个10名同学语文成绩的列表，然后应用sum()函数统计列表中元素的和，即统计总成绩，然后输出，代码如下：
 

grade=[98,99,97,100,100,96,94,89,100,95]
total=sum(grade)
print("语文成绩为：",total)

运行结果 

 6.对列表进行排列

在实际开发时，经常需要对列表进行排序。python提供了两种常用的对列表进行排序的方法：

使用列表对象的sort()方法，使用内置的sorted函数。

（1）使用列表对象的sort()方法

列表对象提供了sort()方法对于原列表中的元素进行排序。排序后原列表中的元素顺序将发生改变。列表对象的sort()方法的语法格式如下：

listname.sort(key=None,reverse=False)

☑listname:表示要进行排序的列表。
☑key：表示指定从每个元素中提取一个用于比较的键(例如，设置“key=str. lower”表示在排序时不区分字母大小写)。
☑reverse：可选参数，如果将其值指定为True，则表示降序排列；如果为False，则表示升序排列，默认为升序排列。
例如，定义一个保存10名学生语文成绩的列表，然后应用sort()方法对其进行排序，代码如下：

grade=[98,99,97,100,100,96,94,89,100,95]
print("原列表：",grade)
grade.sort()
print("升 序：",grade)
grade.sort()
print("降 序：",grade)

运行结果：

使用sort()方法进行数值列表的排序比较简单，但是使用sort()方法对字符串列表进行排序时，采用的规则是先对大写字母排序，然后再对小写字母排序。如果想要对字符串列表进行排序(不区分大小写时)，需要指定其key参数。例如，定义一个保存英文字符串的列表，然后应用sort()方法对其进行升序排列，可以使用下面的代码：

char=['cat','Tiom','Angela','pet']
char.sort()                    #默认区分字母大小写
print("区分字母大小写:",char)
char.sort(key=str. lower)      #不区分字母大小写
print("不区分字母大小写:",char)

运行结果：

（2）使用内置sorted()函数实现

在python中提供了一个内置函数sorted()函数，用于对列表进行排列，使用该函数进行排序后，原列表的元素顺序不变。sorted()函数的语法格式如下：
 

sorted(itreable,key=None,reverse=False)

☑iterable：表示要进行排序的列表名称。
☑key：表示指定从每个元素中提取一个用于比较的键(例如，设置“key=str. lower”表示在排序时不区分字母大小写)。
☑reverse：可选参数，如果将其值指定为True，则表示降序排列；如果为False，则表示升序排列，默认为升序排列。

例如，定义一个保存10名学生语文成绩的列表，然后应用sorted()函数对其进行排序，代码如下：

grade = [98,99,97,100,100,96,94,89,95,100]  #10名学生语文成绩列表
grade_as= sorted(grade)                   #进行升序排列
print("升序:",grade_as)
grade_des= sorted(grade,reverse= True)    #进行降序排列
print("降序:",grade_des)
print("原序列:",grade)

运行结果：

 7.列表推导式

使用列表推导式可以快速生成一个列表，或者根据某个列表生成满足指定需求的列表。列表推导式通常由这几个常用的语法格式.

（1）生成指定范围的数值列表，语法个数如下：

list=[Expression for var in range]

参数说明：
list：表示生成的列表名称

Expression：表达式，用于计算新列表元素

var：循环变量

range：采用range()函数生成新列表。

（2）根据列表生成指定需求的列表，语法格式如下：

newlist=[Expression for var in list]

newlist:表示新生成的列表名称。

Expression:表达式,用于计算新列表的元素。

var：变量，值为后面列表的每个元素值。

list：用于生成新列表的原列表。

（3）从列表中选择符合条件的元素组成新的列表，语法格式如下：

newlist=[Expression for var in list if condition]

newlist:表示新生成的列表名称。

Expression:表达式,用于计算新列表的元素。

var：变量，值为后面列表的每个元素值。

list：用于生成新列表的原列表。

condition:条件表达式,用于指定筛选条件。

8.二维列表的应用

在python中，由于列表元素还可以是列表，所以它也支持二维列表的概念。

（1）直接定义二维列表

在python中二维列表是包含列表的列表，即一个列表的每一个列表的每一个元素又都是一个列表。例如下面就是一个二维列表：

[['千',"山",'鸟','飞','绝'],
['万','径','人','宗','灭'],
['孤','舟','独','立','翁']]

在创建二维列表时，可以直接使用下面语格式进行定义：s

listname=[[元素11,元素12,元素13，元素14,...,元素1n],
[元素21,元素22,元素23,...,元素2n],
...,
[元素n1,元素n2,...,元素nn]]

（2）使用嵌套的for循环创建

创建二维列表，可以直接使用嵌套的for循环实现。例如下面代码：

arr=[]
for i in range(4):
    arr.append([])
    for j in range(5):
        arr[i].append(j)
print(arr)

 将上面代码在执行后，将创建以下二维列表：

（3）使用列表推导式创建

使用列表推导式也可以创建二维列表，因为这种方法比较简洁，所以建议使用这种方法创建二维列表。

arr=[[j for j in range(5)]for i in range(4)]
print(arr)

 上面代码执行后，将创建以下列表：

创建二维列表组后，可以通过一下语法格式访问列表中的元素:

listname[下表1][下表2]

元组

元组是Python中另一个重要的序列结构，与列表类似，也是有一系列按特定顺序排列的元素组成，但它是不可变的

1.元组创建和删除

在Python中提供了多种创建元组的方法，下面分别进行计算

（1）使用赋值运算符直接创建元组

同其他类型的python变量一样，创建元组时，也可以使用赋值运算符“=”直接将一个元组赋值给变量，语法格式如下：

tuplename=(element 1,element 2,element 3,...,element n)

其中，tuplename表示元组的名称，可以时任何符合Python命名规则的标识符；element1 element n都是元组中的元素，个数没有限制，并且只要是Python支持的数据类型就可以

（2）创建空原组

在Python中，也可以创建空元组，例如，创建一个名称为emptytuple的空元组，可以使用以下代码：

emptyuple=()

 空元组可以应用在为函数传递一个空值后返回空值时。

（3）创建数值元组

我们可以使用后tuple()函数直接将range()函数循环出来的结果转化为数值元组

tuple(data)

其中data表示可以转化为元组的数据。其类型可以是range对象，字符串，元组或其他可迭代的类型数据

（4）删除元组

对于已将创建的元组，不再使用时，可以使用del语句将其删除。语法格式如下：

del tuplename

tuplename为要删除的元组名称

2.访问元组元素

在Python中如果想将元组的内容输出也比较简单，可以直接使用print()函数输出即可。

3.修改元组元素

在ldle创建一个文件定义一个六个元素的元组

i=('12','23','34','45','56')
i[3]='65'
print(i)

这样输出的话就会出现异常

元组是不可变序列，我们只能对元组进行重新赋值。

i=('12','23','34','45','56')
i=('2','1','31','23')
print("新元组",i)

执行结果如下：

新元组('2','1','31','23')

4.元组推导式

使用元组推导式可以快速生成一个元组，我们用它来生成一个包含10个随机数的元组。

import random
randomnumber=(random.randint(10,100)) for i in range(10))
print("生成的元组为："randomnumber)

执行结果如下：

生成的元组为： <generator object <genexpr> at 0x000002C9803E7740>

从上面的执行结果中，可以看出使用元组推导式生成的结果并不是一个元组或列表，而是一个生成器对象，这一点和列表推导式是不同的。要是该生成器对象可以将其转化为元组或列表，其中，转换为元组使用tuple()函数，而转换列表则使用list()函数

5.元组和列表的区别

元组和列表都属于序列，而且它们又都可以按照特定顺序存放一组元素，类型又不受限制，只要是Python支持的类型都可以。那么它们之间有什么区别呢?
列表类似于我们用铅笔在纸上写下自己喜欢的歌词，写错了还可以擦掉;而元组则类似于用钢笔写下的歌词，写错了就擦不掉了，除非换一张纸重写。
列表和元组的区别主要体现在以下几个方面:
团列表属于可变序列，它的元素可以随时修改或者删除;元组属于不可变序列，其中的元素不可
使用_ 以修改，除非整体替换。 
日列表可以使用appendO、extendO、insertO、remove0和pop等方法实现添加和修改列表元素，而元组没有这几个方法，所以不能向元组中添加和修改元素。同样，元组也不能删除元素。
团列表可以使用切片访问和修改列表中的元素。元组也支持切片，但是它只支持通过切片访问元
组中的元素，不支持修改。 
元组比列表的访问和处理速度快，所以当只是需要对其中的元素进行访问，而不进行任何修改时，建议使用元组。
区列表不能作为字典的键，而元组则可以。

字典

在Python中，字典与列表类似，是可变序列，不过与列表不同的是它是可变序列，保存的内容是以“建-值对”的形式存放的。

1.字典的创建和删除

定义字典时，每个元素都包含两个部分“键”和“值”之间用冒号分隔，所有元素放在一对“{}”中，语法格式如下：
 

dictionary={'key1':'value1','key2':'value2',....'keyn':'valuen'}

dictionary：表示字典名称

key：表示元素的键，必须是唯一的，并且不能改变可以是字符串，数字或元组

value：表示元素的值，可以是任何数据类型，不是必须委会议的。

同列表和原组一样，也可以创建空字典，可以使用以下两种方法：

dictionary={}

和

dictionary=dict()

dict()方法还可以用来通过已有的数据快速创建字典

（1）通过映射函数创建字典

通过映射函数创建字典语法如下：

dictionary=dict(zip(list1,list2))

dictionary：表示字典名称

zip()函数：用于将多个列表或元组对应位置的元素组合转化为元组并返回包含的这些内容的zip对象

list1：列表，用于指定生成字典的键

list2：列表，用于指定生成字典的值

如果list1，2的长度不同则与最短的列表长度相同

例，创建一个保存女神字典： 

name=['晓红','伊一','花花']
sign=['水瓶座','射手座','双鱼座']
dicionary=dict(zip(name,sign))
print(dicionary)

 运行结果：

（2）通过给定的关键字参数创建字典

语法如下：
 

dictionary=dict(key1=value1,key=value,...,keyn=valuen)

dictionary：表示字典名称。

key：表示参数名，必须是唯一的，并且符合Python标识符的命名规则，=。该参数名换转化为字典的键。

value：表示参数值，可以是任何类型数据不必是唯一。该参数值转化为字典的值。

还有fromkeys()方法创建字典语法如下：

dictionary=dict.fromkeys(list1)

dictionary：表示字典的名字

list1：作为字典键的列表

用del删除整个字典

del dictionary

 用clear()方法删除字典的所有元素

dictionary.clear()

2.通过键值对访问字典

访问字典的元素可以通过下标的方式实现与列表元组不一样，这里的下表不是索引号，而是键。

使用以下代码：

print(dictionary['伊一'])

执行结果如下：

 3.遍历字典

字典是以“键-值对”的形式存储数据的，所有需要通过这些“键-值对”进行获取。

使用items()方法可以获取“键-值对”列表语法格式如下：

dictionary,itens()

其中， dictionary为字典对象；返回值为可遍历的(键-值对)的元组列表。想要获取到具体的“键-值对”，可以通过for循环遍历该元组列表。

例如，定义一个字典，然后通过items()方法获取“键-值对”的元组列表，并输出全部“键-值对”，代码如下：

dictionary={'qq':'84978981','明日科技':'84978982','无语':' 0431-84978981 '}
for item in dictionary. items():
    print(item)

执行结果如下:

 4.添加，修改和删除字典元素

由于字典是可变序列，所以可以随时在字典中添加“键-值对”。向字典中添加元素的语法格式如下：

dictionary[key]=value

dictionary:表示字典名称

key：表示要添加元素的键，必须是唯一的，并且不可变，例如可以是字符串、数字或者元组

value：表示元素的值，可以是任何数据类型，不是必须唯一的。

例如，还以保存4位美女星座的场景为例，在创建的字典中添加一个元素，并显示添加后的字典，代码如下：

dictionary=dict((('绮梦','水瓶座'),('冷伊一','射手座'),('香凝','双鱼座'),('黛兰','双子座')))
dictionary["碧琦"]="巨蟹座"     #添加一个元素
print(dictionary)

执行结果如下：
 从上面的结果中可以看到，字典中又添加了一个键为“碧琦”的元素。
由于在字典中，“键”必须是唯一的，如果新添加元素的“键”与已经存在的“键”重复，那么将使用新的“值”替换原来该“键”的值，这也相当于修改字典的元素。例如，再添加一个“键”为“香凝”的元素，设置她的星座为“天蝎座”。可以使用下面的代码：

dictionary=dict((('绮梦','水瓶座'),('冷伊一','射手座'),('香凝','双鱼座'),('黛兰','双子座')))
dictionary["香凝"]="天蝎座"     #添加一个元素，当元素存在时，则相当于修改功能
print(dictionary)

运行结果如下：

 从上面的结果可以看到，字典中并没有添加一个新的“键” —“香凝”，而是直接对“香凝”进行了修改。
当字典中的某一个元素不需要时，可以使用del命令将其删除。例如，要删除字典dictionary中的键为“香凝”的元素，可以使用下面的代码：

dictionary=dict((('绮梦','水瓶座'),('冷伊一','射手座'),('香凝','双鱼座'),('黛兰','双子座')))
del dictionary["香凝"]            #删除一个元素
print(dictionary)

运行结果如下：

 5.字典推导式

使用字典推导式可以快速生成一个字典，他的表现和列表推导式类似。理生成一个包含四个数的随机数字典

import random
randomdict={i:random.randint(10,100) for i in range(1,5)}
print("生成的字典为：",randomdict)

运行结果如下：

集合

Python中的集合同数学的集合概念类似，也是用于保存不重复元素的。他有可变集合（set）和不可变集合（frozenset）两种。

1.集合的创建

在Python中提供了两种方法

（1）直接用'{}'创建集合

在Python中创建set集合也可以像列表，元组和字典伊一，直接将集合复制个变量从而实现创建集合，即直接使用“{}”创建，语法格式如下：
 

setname={element1,element2,....element n}

setname：表示集合名字

element：表示集合中的元素，个数没有限制

（2）使用set()函数创建

可以使用set()函数将列表，元组等其他可迭代对象转化为集合。set()函数的语法格式如下：

setname=set(iteration)

setname：表示集合名称

iteration：表示转换为集合的可迭代对象。

2.集合的添加和删除

集合是可变序列，所以在创建之后还可以添加和删除元素。

（1）向集合中添加元素

我们向集合中添加元素可以用add()方法实现，格式如下：

setname.add(element)

setname:表示要添加元素的集合

element:表示添加元素的内容，只能使用字符串，数字，布尔类型的True或者False及元组不可变对象，不能使用列表，字典等可变对象。

（2）从集合中删除元素

在Python中，可以使用del命令删除整个集合，也可以使用集合的pop()方法或者remove()方法删除一个元素，或者使用集合对象的clear()方法清空集合，即删除集合中的全部元素，使其变为空集合。

3.集合的交集，并集和差集运算

集合最常用的操作就是进行交集、并集、差集和对称差集运算。进行交集运算时使用“&”符号，进行并集运算时使用“1”符号，进行差集运算时使用“-”符号，进行对称差集运算时使用“^”符号。下面通过一个具体的实例演示如何对集合进行交集、并集和差集运算

场景模拟|某大学的学生选课系统，学生选课完毕后，老师要对选课结果进行统计。这时，需要知道哪些学生既选择了Python语言又选择了C语言、哪些学生只选择了Python语言但没有选择C语言，以及参与选课的全部学生。

python=set(['绮梦','冷伊一','香凝','梓轩']) #保存选择Python语言的学生姓名
c=set(['冷伊一','零语','梓轩','圣博'])      #保存选择C语言的学生姓名
print('选择Python语言的学生有:', python)    #输出选择Python语言的学生姓名
print('选择C语言的学生有:',c)               #输出选择C语言的学生姓名
print('交集运算:', python&c)                #输出既选择了Python语言又选择了C语言的学生姓名
print('并集运算:', python|c)                #输出参与选课的全部学生姓名
print('差集运算:', python-c)                #输出只选择了Python语言但没有选择C语言的学生姓名 

运行结果:

列表，元组，字典，集合的区别

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