1. 序列类型

计算机不仅对单个变量表示的数据进行处理，更多情况，计算机需要对一组数据进行批量处理。一些例子包括：

• 处理计算机中一组文件；
• 统计一组问卷调查结果；
• 给定一组工资基本信息，计算应纳个人所得税；
• 给定一个学院学生信息，统计一下男女生比例；
• 一次实验产生了很多组数据，对这些大量数据进行分析；

序列类型是组合数据类型的一类，能够将多个同类型或不同类型的数据组织起来，通过单一的表示使数据操作更有序更容易。

序列类型是一个元素向量，元素之间存在先后关系，通过序号访问，元素之间不排他。

由于元素之间存在顺序关系，所以序列中可以存在相同数值但位置不同的元素。序列类型支持成员关系操作符（in）、长度计算函数（len()）、分片（[]），元素本身也可以是序列类型。

Python中的主要序列类型：

• str（字符串）:由字符构成的序列;
• list（列表）:一个可以修改数据项的序列类型，使用也最灵活;
• tuple（元组）:包含0个或多个数据项的不可变序列类型。元组生成后是固定的，其中任何数据项不能替换或删除。
  
  序列类型有12个通用的操作符和函数:

操作符	描述
x in s	如果x是s的元素，返回True，否则返回False
x not in s	如果x不是s的元素，返回True，否则返回False
s + t	连接s和t
s * n 或 n * s	将序列s复制n次
s[i]	索引，返回序列的第i个元素
s[i: j]	分片，返回包含序列s第i到j个元素的子序列（不包含第j个元素）
s[i: j: k]	步骤分片，返回包含序列s第i到j个元素以k为步数的子序列
len(s)	序列s的元素个数（长度）
min(s)	序列s中的最小元素
max(s)	序列s中的最大元素
s.index(x[, i[, j]])	序列s中从i开始到j位置中第一次出现元素x的位置
s.count(x)	序列s中出现x的总次数

2. 序列类型：列表

• “列表”是一个值，它包含多个值构成的序列。
• 术语“列表值”指的是列表本身（它作为一个值，可以保存在变量中，或传递给函数，像所有其他值一样），而不是指列表值之内的那些值。
  列表值看起来像这样：[‘西南财经大学’, ‘电子科技大学’, ‘四川大学’, ‘西南交通大学’]。就像字符串值用引号来标记字符串的起止一样，列表用左方括号开始，右方括号结束，即[ ]。列表中的值也称为“表项”。表项用逗号分隔（就是说，它们是“逗号分隔的”）。-
• 列表的长度和内容都是可变的，可自由对列表中数据项进行增加、删除或替换。列表没有长度限制，元素类型可以不同，使用非常灵活。
• 由于列表属于序列类型，所以列表也支持成员关系操作符（in）、长度计算函数（len()）、分片（[]）。
• 列表可以同时使用正向递增序号和反向递减序号，可以采用标准的比较操作符（<、<=、==、!=、>=、>）进行比较，列表的比较实际上是单个数据项的逐个比较。

列表的操作

函数或方法	描述
ls[i] = x	替换列表ls第i数据项为x
ls[i: j] = lt	用列表lt替换列表ls中第 i 到 j 项数据（不含第 j 项，下同）
ls[i: j: k] = lt	用列表lt替换列表ls中第i到j以k为步的数据
del ls[i: j]	删除列表ls第i到j项数据，等价于ls[i: j]=[]
del ls[i: j: k]	删除列表ls第i到j以k为步的数据
ls += lt或ls.extend(lt)	将列表lt元素增加到列表ls中
ls *= n	更新列表ls，其元素重复n次
ls.append(x)	在列表ls最后增加一个元素x
ls.clear()	删除ls中所有元素
ls.copy()	生成一个新列表，复制ls中所有元素
ls.insert(i, x)	在列表ls第i位置增加元素x
ls.pop(i)	将列表ls中第i项元素取出并删除该元素
ls.remove(x)	将列表中出现的第一个元素x删除
ls.reverse(x)	列表ls中元素反转

2.1 用下标取得列表中的单个值

列表用中括号（[]）表示，通过下标取单个值，下标只能是整数，不能是浮点值。下标就是元素在列表中的偏移量。

LIST=["苹果","香蕉","梨子"]
LIST
LIST[1]
LIST[1][0]

['苹果', '香蕉', '梨子']
'香蕉'
'香'

如果使用的下标超出了列表中值的个数，Python 将给出IndexError 出错信息。

# 编号,姓名,基本工资,奖金,住房补助,五险一金,其他扣款,专项附加扣除
incomeList = [['10932','张珊',15000.00 ,4000.00 ,2300.00 ,980.00 ,300.00 ,1000.00],['10933','李思',12000.00 ,5000.00 ,2600.00 ,890.00 ,400.00 ,2000.00],['10934','王武',10100.00 ,2000.00 ,2500.00 ,860.00 ,500.00 ,1500.00],['10935','赵柳',10050.00 ,1000.00 ,2700.00 ,1080.00 ,300.00 ,2000.00],['10936','钱棋',10200.00 ,2000.00 ,2400.00 ,1000.00 ,600.00 ,1000.00],['10941','张明',13600.00 ,4000.00 ,2100.00 ,680.00 ,300.00 ,1000.00],['10942','赵敏',13200.00 ,2500.00 ,2300.00 ,670.00 ,400.00 ,3000.00],['10945','王红',13600.00 ,2600.00 ,2030.00 ,560.00 ,400.00 ,2000.00],['10946','李萧',12500.00 ,2800.00 ,2400.00 ,420.00 ,500.00 ,1500.00],['10947','孙科',12000.00 ,3500.00 ,2030.00 ,880.00 ,300.00 ,1000.00],['10948','刘利',14200.00 ,2500.00 ,2020.00 ,900.00 ,400.00 ,2000.00]
]

[['10932', '张珊', 15000.0, 4000.0, 2300.0, 980.0, 300.0, 1000.0],['10933', '李思', 12000.0, 5000.0, 2600.0, 890.0, 400.0, 2000.0],['10934', '王武', 10100.0, 2000.0, 2500.0, 860.0, 500.0, 1500.0],['10935', '赵柳', 10050.0, 1000.0, 2700.0, 1080.0, 300.0, 2000.0],['10936', '钱棋', 10200.0, 2000.0, 2400.0, 1000.0, 600.0, 1000.0],['10941', '张明', 13600.0, 4000.0, 2100.0, 680.0, 300.0, 1000.0],['10942', '赵敏', 13200.0, 2500.0, 2300.0, 670.0, 400.0, 3000.0],['10945', '王红', 13600.0, 2600.0, 2030.0, 560.0, 400.0, 2000.0],['10946', '李萧', 12500.0, 2800.0, 2400.0, 420.0, 500.0, 1500.0],['10947', '孙科', 12000.0, 3500.0, 2030.0, 880.0, 300.0, 1000.0],['10948', '刘利', 14200.0, 2500.0, 2020.0, 900.0, 400.0, 2000.0]]

2.2 负数下标

• 虽然下标从0 开始并向上增长，但也可以用负整数作为下标。
• 整数值−1 指的是列表中的最后一个下标，−2 指的是列表中倒数第二个下标，以此类推。

incomeList[-1]

['10948', '刘利', 14200.0, 2500.0, 2020.0, 900.0, 400.0, 2000.0]

incomeList[-11]

['10932', '张珊', 15000.0, 4000.0, 2300.0, 980.0, 300.0, 1000.0]

2.3 利用切片取得子列表

就像下标可以从列表中取得单个值一样，“切片”可以从列表中取得多个值，结果是一个新列表。切片输入在一对方括号中，像下标一样，但它有两个冒号分隔的整数。请注意下标和切片的不同。

• incomeList[2]是一个列表和下标（一个整数）。
• incomeList[1:4]是一个列表和切片（两个整数）。

在一个切片中，第一个整数是切片开始处的下标。第二个整数是切片结束处的下标。切片向上增长，直至第二个下标的值，但不包括它。切片求值为一个新的列表值。

incomeList[1:4]

[['10933', '李思', 12000.0, 5000.0, 2600.0, 890.0, 400.0, 2000.0],['10934', '王武', 10100.0, 2000.0, 2500.0, 860.0, 500.0, 1500.0],['10935', '赵柳', 10050.0, 1000.0, 2700.0, 1080.0, 300.0, 2000.0]]

省略下标
作为快捷方法，你可以省略切片中冒号两边的一个下标或两个下标。

• 省略第一个下标相当于使用0，或列表的开始；
• 省略第二个下标相当于使用列表的长度，意味着分片直至列表的末尾。

2.4 用len()取得列表的长度

len()函数将返回传递给它的列表中值的个数，就像它能计算字符串中字符的个数一样。

len(incomeList)
len(incomeList[0])

11
8

2.5 用下标和切片改变列表中的值

一般情况下，赋值语句左边是一个变量名，就像price = 4.00。但是，也可以使用列表的下标来改变下标处的值。

LIST[0:2]=["西瓜","樱桃"]
LIST

['西瓜', '樱桃', '梨子']

当使用一个列表改变另一个列表值时，Python不要求两个列表长度一样，但遵循**“多增少减”**的原则，例子如下：

LIST=["苹果","香蕉","梨子"]
LIST[0:1]=["西瓜","樱桃"]
LIST

['西瓜', '樱桃', '香蕉', '梨子']

LIST=["苹果","香蕉","梨子"]
LIST[0:2]=["西瓜"]
LIST

['西瓜', '梨子']

2.6 列表连接和列表复制

+操作符可以连接两个列表，得到一个新列表，就像它将两个字符串合并成一个新字符串一样。

\*操作符可以用于一个列表和一个整数，实现列表的复制。

ls =  ['A', 'B', 'C']
ls += [1, 2, 3]
ls

['A', 'B', 'C', 1, 2, 3]

2.7 用del 语句从列表中删除值

del 语句将删除列表中下标处的值，表中被删除值后面的所有值，都将向前移动一个下标。

LIST=["苹果","香蕉","梨子"]
del LIST[0:2]
LIST

['梨子']

2.8 用list()函数产生列表

vList = list(range(5))
vList

[0, 1, 2, 3, 4]

alphaList = list('aabbcc')
alphaList

['a', 'a', 'b', 'b', 'c', 'c']

emptyList = list()
emptyList

[]

2.9 列表用于循环

一个常见的Python 技巧，是在for 循环中使用range(len(someList))，迭代列表的每一个下标。
下标循环
计算所有人的基本工资之和：

#编号,姓名,基本工资,奖金,住房补助,五险一金,其他扣款,专项附加扣除
incomeList = [['10932','张珊',15000.00 ,4000.00 ,2300.00 ,980.00 ,300.00 ,1000.00],['10933','李思',12000.00 ,5000.00 ,2600.00 ,890.00 ,400.00 ,2000.00],['10934','王武',10100.00 ,2000.00 ,2500.00 ,860.00 ,500.00 ,1500.00],['10935','赵柳',10050.00 ,1000.00 ,2700.00 ,1080.00 ,300.00 ,2000.00],['10936','钱棋',10200.00 ,2000.00 ,2400.00 ,1000.00 ,600.00 ,1000.00],['10941','张明',13600.00 ,4000.00 ,2100.00 ,680.00 ,300.00 ,1000.00],['10942','赵敏',13200.00 ,2500.00 ,2300.00 ,670.00 ,400.00 ,3000.00],['10945','王红',13600.00 ,2600.00 ,2030.00 ,560.00 ,400.00 ,2000.00],['10946','李萧',12500.00 ,2800.00 ,2400.00 ,420.00 ,500.00 ,1500.00],['10947','孙科',12000.00 ,3500.00 ,2030.00 ,880.00 ,300.00 ,1000.00],['10948','刘利',14200.00 ,2500.00 ,2020.00 ,900.00 ,400.00 ,2000.00]
]
totalSalary = 0
for i in range(len(incomeList)):totalSalary = totalSalary + incomeList[i][2]
print('所有人的基本工资和为：', totalSalary)

所有人的基本工资和为： 136450.0

通过for…in语句对其元素进行遍历
列表可以通过for…in语句对其元素进行遍历，基本语法结构如下：

for <任意变量名> in <列表名>:语句块

LIST=["苹果","香蕉","梨子"]
for name in LIST:print(name)

苹果
香蕉
梨子

2.10 in 和not in 操作符

利用in 和not in 操作符，可以确定一个值否在列表中。像其他操作符一样，in和not in 用在表达式中，连接两个值：一个要在列表中查找的值，以及待查找
的列表。这些表达式将求值为布尔值。

LIST=["苹果","香蕉","梨子"]
#"香蕉"in LIST
'香蕉' in LIST

True

2.11 多重赋值技巧

多重赋值技巧是一种快捷方式，让你在一行代码中，用列表中的值为多个变量赋值。(这种方式常见于元组类型)

employeeBasicInfo = incomeList[0][:3]
employeeBasicInfo
type(employeeBasicInfo)
employeeNo, name, salary = employeeBasicInfo
print('编号为{}的员工{}基本工资为：{:.2f}'.format(employeeNo, name, salary))

['10932', '张珊', 15000.0]
list
编号为10932的员工张珊基本工资为：15000.00

2.12 用index()方法在列表中查找值

列表值有一个index()方法，可以传入一个值，如果该值存在于列表中，就返回它的下标。如果该值不在列表中，Python 就报ValueError。

LIST=["苹果","香蕉","梨子"]
LIST.index("苹果")

0

如果列表中存在重复的值，就返回它第一次出现的下标。

LIST=["苹果","香蕉","梨子"]
LIST*=2
LIST
LIST.index("香蕉")

['苹果', '香蕉', '梨子', '苹果', '香蕉', '梨子']
1

2.13 用append()和insert()方法在列表中添加值

• 要在列表中添加新值，就使用append()和 insert()方法。
• append()和insert()都不会将LIST的新值作为其返回值（实际上，append()和insert()的返回值是None，所以你肯定不希望将它保存为变量的新值）。
• 但是，列表被“当场”修改了。

LIST=["苹果","香蕉","梨子"]
LIST.append("樱桃")
LIST

['苹果', '香蕉', '梨子', '樱桃']

LIST=["苹果","香蕉","梨子"]
LIST.insert(1,"西瓜")
LIST

['苹果', '西瓜', '香蕉', '梨子']

2.14 使用extend()或+=合并列表

• 使用extend() 可以将一个列表合并到另一个列表中。

LIST=["苹果","香蕉","梨子"]
LIST.extend(["樱桃","西瓜"])
LIST

['苹果', '香蕉', '梨子', '樱桃', '西瓜']

• 也可以使用+=：

LIST=["苹果","香蕉","梨子"]
LIST+=(["樱桃","西瓜"])
LIST

• 注意区分append()和extend()方法：

LIST=["苹果","香蕉","梨子"]
LIST.append(["樱桃","西瓜"])
LIST

['苹果', '香蕉', '梨子', ['樱桃', '西瓜']]

LIST=["苹果","香蕉","梨子"]
LIST.extend(["樱桃","西瓜"])
LIST

['苹果', '香蕉', '梨子', '樱桃', '西瓜']

2.15 用remove()方法从列表中删除值

• 给 remove()方法传入一个值，它将从被调用的列表中删除。

LIST=["苹果","香蕉","梨子"]
LIST.remove("香蕉")
LIST

['苹果', '梨子']

• 试图删除列表中不存在的值，将导致ValueError 错误。
• 如果该值在列表中出现多次，只有第一次出现的值会被删除。

LIST=["苹果","香蕉","梨子"]
LIST*=2
LIST.remove("香蕉")
LIST

['苹果', '梨子', '苹果', '香蕉', '梨子']

• 如果知道想要删除的值在列表中的下标，del 语句就很好用。
• 如果知道想要从列表中删除的值，remove()方法就很好用。

2.16 用sort()方法将列表中的值排序

• 数值的列表或字符串的列表，能用sort()方法排序。sort()方法当场对列表排序

numberList = [2, 10, 3.14, -20, -50]
numberList.sort()    #默认为顺序（从小到大）
numberList

[-50, -20, 2, 3.14, 10]

• 也可以指定reverse关键字参数为True，让sort()按逆序排序。

numberList.sort(reverse=True)
numberList

[10, 3.14, 2, -20, -50]

• 不能对既有数字又有字符串值的列表排序，因为Python 不知道如何比较它们。
• sort()方法对字符串排序时，使用“ASCII 字符顺序”，而不是实际的字典顺序。这意味着大写字母排在小写字母之前。因此在排序时，小写的a 在大写的Z 之后:

someWords = ['Alice', 'ants', 'Bob', 'badgers', 'Carol', 'cats']
someWords.sort()
someWords

['Alice', 'Bob', 'Carol', 'ants', 'badgers', 'cats']

扩展
sort()方法有一个key的关键字参数，可以指定排序方法，例如：

• 按照每一项的长度进行排序

someWords = ['Alice', 'ants', 'Bob', 'badgers', 'Carol', 'cats']
someWords.sort(key=len)  #按照每一项的长度进行排序
someWords

['Bob', 'ants', 'cats', 'Alice', 'Carol', 'badgers']

• 按照每一项的第 i 个字符进行排序

someWords = ['Alice', 'ants', 'Bob', 'badgers', 'Carol', 'cats']
someWords.sort(key=lambda x: x[1])
someWords #按照每一项的第二个字符进行排序

['badgers', 'Carol', 'cats', 'Alice', 'ants', 'Bob']

2.17 使用count()记录特定值出现的次数

使用count() 可以记录某一个特定值在列表中出现的次数：

LIST=["苹果","香蕉","梨子"]*2
LIST.count("梨子")

2

2.18 基本统计值计算

以最简单的统计问题为例，求解一组不定长数据的基本统计值，即平均值、标准差、中位数。

一组数据表示为S=s0,s1,…,sn−1S = s_{0}, s_{1}, …, s_{n-1}S=s0​,s1​,…,sn−1​，其算术平均值表示为：

m=(∑i=0n−1si)/nm = (\sum_{i=0}^{n-1}s_{i})/nm=(∑i=0n−1​si​)/n

标准差表示为：

d=(∑i=0n−1(si−m)2)/(n−1)d = \sqrt{(\sum_{i=0}^{n-1}(s_{i}-m)^2)/(n-1)}d=(∑i=0n−1​(si​−m)2)/(n−1)​

由于平均数、标准差和中位数是三个不同的计算目标，使用函数方式编写计算程序。

• getNum()函数从用户输入获得数据
• mean()函数计算平均值
• dev()函数计算标准差
• median()函数计算中位数

from math import sqrt
def getNum():       #获取用户输入nums = []iNumStr = input("请输入数字(直接输入回车退出): ")while iNumStr != "":nums.append(eval(iNumStr))iNumStr = input("请输入数字(直接输入回车退出): ")return numsdef mean(numbers):  #计算平均值s = 0.0for num in numbers:s = s + numreturn s / len(numbers)def dev(numbers, mean): #计算方差sdev = 0.0for num in numbers:sdev = sdev + (num - mean)**2return sqrt(sdev / (len(numbers)-1))def median(numbers):    #计算中位数sorted(numbers)size = len(numbers)if size % 2 == 0:med = (numbers[size//2-1] + numbers[size//2])/2else:med = numbers[size//2]    # a/b 的商return medn =  getNum()  #主体函数
m =  mean(n)
print("平均值:{},方差:{:.2},中位数:{}.".format(m,dev(n,m),median(n)))

请输入数字(直接输入回车退出): 98
请输入数字(直接输入回车退出): 97
请输入数字(直接输入回车退出): 96
请输入数字(直接输入回车退出): 95
请输入数字(直接输入回车退出): 94
请输入数字(直接输入回车退出):
平均值:96.0,方差:1.6,中位数:96.

3. 元组

除了两个方面，“元组”数据类型几乎与列表数据类型一样。

• 首先，元组输入时用圆括号()，而不是用方括号[].

tuple=("苹果","香蕉","梨子")
type(tuple)

tuple

• 元组与列表的主要区别还在于，元组像字符串一样，是***不可变的***。元组不能让它们的值被修改、添加或删除

• 如果元组中只有一个值，你可以在括号内该值的后面跟上一个逗号，逗号告诉
  Python，这是一个元组（不像其他编程语言，Python 接受列表或元组中最后表项后面跟的逗号）。否则，Python 将认为，你只是在一个普通括号内输入了一个值。

turple=("苹果")
type(turple)

str

turple=("苹果",)
type(turple)

tuple

如果需要一个永远不会改变的值的序列，就使用元组。使用元组而不是列表的第二个好处在于，因为它们是不可变的，它们的内容不会变化，Python 可以实现一些优化，让使用元组的代码比使用列表的代码更快。

3.1 使用()创建元组

可以用() 创建一个空元组：

empty_tuple = ()
empty_tuple

()

创建包含一个或多个元素的元组时，每一个元素后面都需要跟着一个逗号，即使只包含一个元素也不能省略，括号可以省略：

empty_tuple = ()
empty_tuple

tuple

3.2 用list()和tuple()函数来转换类型

函数list()和tuple()将返回传递给它们的值的列表和元组版本。

myLIST=["苹果","香蕉","梨子"]
myTuple= tuple(myLIST)
type(myTuple)
myTuple

tuple
('苹果', '香蕉', '梨子')

3.3 元组解包

可以一口气将元组赋值给多个变量，这个过程被称为元组解包。

incomeList = [['10932','张珊',15000.00 ,4000.00 ,2300.00 ,980.00 ,300.00 ,1000.00],['10933','李思',12000.00 ,5000.00 ,2600.00 ,890.00 ,400.00 ,2000.00],['10934','王武',10100.00 ,2000.00 ,2500.00 ,860.00 ,500.00 ,1500.00],['10935','赵柳',10050.00 ,1000.00 ,2700.00 ,1080.00 ,300.00 ,2000.00],['10936','钱棋',10200.00 ,2000.00 ,2400.00 ,1000.00 ,600.00 ,1000.00],['10941','张明',13600.00 ,4000.00 ,2100.00 ,680.00 ,300.00 ,1000.00],['10942','赵敏',13200.00 ,2500.00 ,2300.00 ,670.00 ,400.00 ,3000.00],['10945','王红',13600.00 ,2600.00 ,2030.00 ,560.00 ,400.00 ,2000.00],['10946','李萧',12500.00 ,2800.00 ,2400.00 ,420.00 ,500.00 ,1500.00],['10947','孙科',12000.00 ,3500.00 ,2030.00 ,880.00 ,300.00 ,1000.00],['10948','刘利',14200.00 ,2500.00 ,2020.00 ,900.00 ,400.00 ,2000.00]
]
employeeInfo = tuple(incomeList[-1][:2])
employeeInfo
empNo, empName = employeeInfo
print(empNo+" "+empName)

('10948', '刘利')
10948 刘利

3.4 元组与列表

在许多地方都可以用元组代替列表，但元组的方法函数与列表相比要少一些——元组没有append()、insert()，等等——因为一旦创建元组便无法修改。既然列表更加灵活，那为什么不在所有地方都使用列表呢？原因如下所示：

• 元组占用的空间较小
• 你不会意外修改元组的值
• 可以将元组用作字典的键
• 函数的参数是以元组形式传递的

4. 集合

很久以前，当你还在小学时，可能就学到过一些关于集合论的知识。下图展示了对于集合进行的最基本的操作——交和并。

• 集合类型与数学中集合的概念一致，即包含0个或多个数据项的无序组合。
• 集合中元素不可重复，元素类型只能是固定数据类型，例如：整数、浮点数、字符串、元组等，
• 列表、字典和集合类型本身都是可变数据类型，不能作为集合的元素出现。

4.1 使用set()创建集合

可以使用set() 函数创建一个集合，或者用大括号将一系列以逗号隔开的值包裹起来，如下所示：

mySet = set('AA', 'BB', 'CC', 'DD')
mySet

报错

mySet = set(['AA', 'BB', 'CC', 'DD'])
mySet

{'AA', 'BB', 'CC', 'DD'}

mySet = {'AA', 'BB', 'CC', 'DD'}
type(mySet)
mySet

set
{'AA', 'BB', 'CC', 'DD'}

• 由于[] 能创建一个空列表，你可能期望{}也能创建空集。但事实上，{}会创建一个空字典。
• 由于集合是无序组合，它没有索引和位置的概念，不能分片，集合中元素可以动态增加或删除。

4.2 使用set()将其他类型转换为集合

• 可以利用已有列表、字符串、元组或字典的内容来创建集合，其中重复的值会被丢弃。

myLIST = ['AA', 'BB', 'CC', 'DD']
myset=set(myLIST)
myset

{'AA', 'BB', 'CC', 'DD'}

• 由于集合元素独一无二，使用集合类型能够过滤掉重复元素。

set('letters')

{'e', 'l', 'r', 's', 't'}

4.3 使用in测试值是否存在

这是集合里最常用的功能。

"BIT" in {"PYTHON", "BIT", 123, "GOOD"} #成员关系测试

True

4.4 删除数据项

集合类型与其他类型最大的不同在于它不包含重复元素，因此，当需要对一维数据进行去重或进行数据重复处理时，一般通过集合来完成。

tup = ("PYTHON", "BIT", 123, "GOOD", 123)
tup
newtup = tuple(set(tup)-{'PYTHON'})
newtup

('PYTHON', 'BIT', 123, 'GOOD', 123)
('BIT', 123, 'GOOD')

4.5 集合类型的操作符 、函数或方法

集合类型有10个操作符:

操作符	描述
S – T 或 S.difference(T)	返回一个新集合，包括在集合S中但不在集合T中的元素
S-=T或S.difference_update(T)	更新集合S，包括在集合S中但不在集合T中的元素
S & T或S.intersection(T)	返回一个新集合，包括同时在集合S和T中的元素
S&=T或S.intersection_update(T)	更新集合S，包括同时在集合S和T中的元素。
S^T或s.symmetric_difference(T)	返回一个新集合，包括集合S和T中元素，但不包括同时在其中的元素
S=^T或s.symmetric_difference_update(T)	更新集合S，包括集合S和T中元素，但不包括同时在其中的元素
S|T或S.union(T)	返回一个新集合，包括集合S和T中所有元素
S=|T或S.update(T)	更新集合S，包括集合S和T中所有元素
S<=T或S.issubset(T)	如果S与T相同或S是T的子集，返回True，否则返回False，可以用S<T判断S是否是T的真子集
S>=T或S.issuperset(T)	如果S与T相同或S是T的超集，返回True，否则返回False，可以用S>T判断S是否是T的真超集

上述操作符表达了集合类型的4种基本操作，交集（&）、并集（|）、差集（-）、补集（^），操作逻辑与数学定义相同：

集合类型有10个操作函数或方法:

函数或方法	描述
S.add(x)	如果数据项x不在集合S中，将x增加到s
S.clear()	移除S中所有数据项
S.copy()	返回集合S的一个拷贝
S.pop()	随机返回集合S中的一个元素，如果S为空，产生KeyError异常
S.discard(x)	如果x在集合S中，移除该元素；如果x不在，不报错
S.remove(x)	如果x在集合S中，移除该元素；不在产生KeyError异常
S.isdisjoint(T)	如果集合S与T没有相同元素，返回True
len(S)	返回集合S元素个数
x in S	如果x是S的元素，返回True，否则返回False
x not in S	如果x不是S的元素，返回True，否则返回False

5. 列表、元组和集合相关推荐

1. python中列表 元组 字典 集合的区别

   参考文章:python中列表 元组 字典 集合的区别

2. python_列表——元组——字典——集合

   列表--元组--字典--集合: 列表: # 一:基本使用# 1.用途:存放多个值 # 定义方式:[]内以逗号为分隔多个元素,列表内元素无类型限制# l=['a','b','c'] #l=list([' ...

3. python列表元组字典集合实验心得_python学习小总结（列表、元组、字典、集合、字符串）...

   ---恢复内容开始--- 一.列表(list) 1.添加 append():追加,在列表末尾添加元素. 列表名.append(添加的元素) extend():扩展,在列表末尾添加元素. 列表名.ext ...

4. python入门——列表+元组+字典+集合

   列表 列表是最常用的python数据类型,它可以作为一个方括号内的逗号分隔值出现. 列表的数据项不需要具有相同的类型 1.列表嵌套(相当于二维数组) a=["b",'c','d'] ...

5. Python 列表元组字典集合

   列表(list) 有序性,可存储任意类型的值 通过偏移存取,支持索引来读取元素,第一个索引为0 ,倒数第一个索引为-1 可变性 ,支持切片.合并.删除等操作 可通过索引来向指定位置插入元素 可通过po ...

6. python列表添加元素的三种方法定义集合数据对象_（1） List，tuple，dictionary，Python语法基础集,一,之,列表,元组,字典,集合...

   Python序列(列表.元组.字典.集合) 一.列表(List)与列表推导式 (一)列表(list) 1.列表是Python内置 可变序列 (列表中元素可增加删除或修改): 2.列表元素放在一对中括号 ...

7. Python列表/元组/字典/集合详解

   本文是对Python中的列表.元组.字典.集合知识的梳理总结,将Python的重要知识点梳理成条,通过一个简单的员工管理系统(EMS)实战,可以深入的了解Python的基本知识.本文基本上涵盖了在日常 ...

8. python 数据类型：整型 字符串 布尔值 列表 元组 字典 集合

   不可变类型:整型 字符串 整型 字符串 可变类型:列表 字典 一.列表常用命令 #增删改查 #查  切片 [] # print(a[1:])#取到最后 # print(a[1:-1])#取到倒数第二值 ...

9. 4.Python基础语法(数字运算/字符串/列表/元组/字典/集合)

   4.1 数字运算 编程是将问题数据化的一个过程,数据离不开数字,Python的数字运算规则与我们学习的四则运算规则是一样的,即使不使用Python来编写复杂的程序,也可以将其当作一个强大的计算器.打开 ...

10. 元组字典集合内置方法与拷贝

    ''' 元组字典集合内置方法与拷贝 ''' # 什么是元组tuple(了解):只可取 不可更改 的列表,元组一创建就被写死了 lt = [1, 2, 3] lt[0] = 2 # 1. 作用:元组一创 ...

最新文章

1. iOS端实现React Native差异化增量更新
2. 腾讯视频免费下载安装_怎样下载腾讯视频里的视频
3. 多个集合合并成没有交集的集合-实现
4. python人工智能方向怎么学_人工智能方向需要学习python或是深度学习呢？
5. Shell脚本学习-阶段七-信息过滤磁盘分区
6. DataGrid中DropDownList触发SelectedIndexChanged事件并修改DataGrid行值(转载)
7. 3.21世纪计算机技术展望
8. 股票数据API接口文档说明
9. 学计算机的心理300字,心理作文300字3篇
10. pcb 布线电容 影响延时--信号跨分割
11. Thinking in React（翻译）
12. TF-IDF的原理概述
13. 8.8 json和文件操作
14. ORACLE 增删改查与更新
15. 单目多帧自监督深度估计(2021-2022)研究进展
16. 驱动篇：底层驱动移植（四）（摘录）
17. 工具软件价值分化，Adobe、万兴科技、猎豹移动们为何不同命？
18. 小白学Django第九天| Cookie和session的那些骚操作
19. python多因子量化选股模型_多因子量化选股模型的筛选和评价：打分法与回归法...
20. 亚马逊在游戏开发中踉跄前行

热门文章

1. python 对接萤石云,录制可播放的MP4视频
2. Echarts图的图例为自定义图片
3. html判断eq相反,HTML中Smarty中的if语句条件修饰词eq相等ne、neq不相等，gt大于
4. 11.1.5 线程与主线程UI界面交互(友元类)
5. WIN7桌面IE图标删除
6. python 打印下标和值
7. FPGA，verilog驱动VGA显示
8. 青龙自动薅羊毛—【万年历】秒到
9. PS如何制作火焰效果图特效步骤教程
10. webServer_国内手机号码归属地查询