集合类型及操作

集合类型定义

集合是多个元素的无序组合

  • 集合类型与数学中的集合概念一致
  • 集合元素之间无序，每个元素唯一，不存在相同元素
  • 集合元素不可更改，不能是可变数据类型
  • 集合用大括号{}表示，元素间用逗号分隔
  • 建立集合类型用{}或set()
    • 建立空集合类型，必须使用set()。使用{}建立的是字典 ```python A={“python”,123,(“python”,123)} #使用{}建立集合 print(A)

      {123,’python’,(‘python’,123)}

B=set(“pypy123”) #使用set()建立集合 print(B)

{‘1’,’p’,’2’,’3’,’y’}

C={“python”,123,”python”,123} #元素唯一 print(C) {‘python’,123}

dictA = {} #直接用{}创建的空内容是字典类型，不是集合类型！！！！！ print(type(dictA))

  2. <a name="s1IJp"></a>
  3. #### 集合操作符
  5. ![image.png](https://cdn.nlark.com/yuque/0/2020/png/92803/1588405450074-48aa60f9-5971-4989-ace3-282434327800.png#align=left&display=inline&height=144&margin=%5Bobject%20Object%5D&name=image.png&originHeight=287&originWidth=643&size=60035&status=done&style=none&width=321.5)<br />常用操作符
  7. | 操作符及应用 | 描述 |
  8. | --- | --- |
  9. | S &#124; T | 并，返回一个新集合，包括在集合S和T中的所有元素 |
  10. | S - T | 差，返回一个新集合，包括在集合S但不在T中的元素 |
  11. | S & T | 交，返回一个新集合，包括同时在集合S和T中的元素 |
  12. | S ^ T | 补，返回一个新集合，包括集合S和T中的非相同元素 |
  13. | S <= T 或 S < T | 返回True/False，判断S和T的子集关系 |
  14. | S >= T 或 S > T | 返回True/False，判断S和T的包含关系 |
  16. 增强操作符
  18. | 操作符及应用 | 描述 |
  19. | --- | --- |
  20. | S &#124;= T | 并，更新集合S，包括在集合S和T中的所有元素 |
  21. | S -= T | 差，更新集合S，包括在集合S但不在T中的元素 |
  22. | S &= T | 交，更新集合S，包括同时在集合S和T中的元素 |
  23. | S ^= T | 补，更新集合S，包括集合S和T中的非相同元素 |
  25. ```python
  26. A = {"p","y",123}    #{'p','y',123}
  27. B = set{"pypy123"}     #{'p','y','1','2','3'}
  28. print(A-B)
  29. #{123}
  30. print(A&B)
  31. #{'p','y'}
  32. print(A^B)
  33. #{'1',123,'2','3'}
  34. print(B-A)
  35. #{'3','2','1'}
  36. print(A|B}
  37. #{'1','p','2','y',123,'3'}

集合处理方法

操作函数或方法 描述
S.add(x) 如果x不在集合S中，将x增加到S
S.discard(x) 移除S中元素x，如果x不在集合S中，不报错
S.remove(x) 移除S中元素x，如果x不在集合S中，产生KeyError异常
S.clear() 移除S中所有元素
S.pop() 随机返回S的一个元素，更新S，若S为空产生KeyError异常
S.copy() 返回集合S的一个副本
len(S) 返回集合S的元素个数
x in S 判断S中元素x，x在集合S中，返回True，否则返回False
x not in S 判断S中元素x，x不在集合S中，返回True，否则返回False
set(x) 将其他类型变量x转变为集合类型 
A={'p','y',123}
for item in A:
    print(item,end="")
#y123p

print(A)
#{'y', 123, 'p'}

try:
    while True:
        print(A.pop(),end="")
except:
    pass
#y123p

print(A)
#set()

集合类型应用场景

  • 包含关系比较 ```python “p” in {‘p’,’y’,123}

    True

{‘p’,’y’} >={‘p’,’y’,123}

False


- 数据去重：集合类型所有元素无重复
```python
ls = ['p','p','y','y',123]
s=set(ls)    #利用了集合无重复元素的特定
print(s)
{'p','y',123}
lt = list(s)
print(lt)    #还可以将集合转换为列表
['p','y',123]

序列类型及操作

序列类型定义

序列是具有先后关系的一组元素

  • 序列是一维元素向量，元素类型可以不同
  • 类似数学元素序列，S，S，…，S
  • 元素间由序号引导，通过下标访问序列的特定元素

序列是一个基类类型 组合数据类型 - 图1image.png

序列处理函数及方法

操作符

操作符及应用 描述
x in s 如果x是序列s的元素，返回True，否则返回False
x not in s 如果x是序列s的元素，返回False，否则返回True
s + t 链接两个序列s和t
sn 或 ns 将序列s复制n次
s[i] 索引，返回s中的第i个元素，i是序列的序号
s[i:j] 或 s[i:j:k] 切片，返回序列s中第i到j以k为步长的元素子序列 
ls = ["python",123,".io"]
print(ls[::-1])
#['.io', 123, 'python']

s = "python123.io"
print(s[::-1])
#oi.321nohtyp

函数和方法

函数和方法 描述
len(s) 返回序列s的长度，即元素个数，长度类型位int整数型
min(s) 返回序列s的最小元素，s中元素需要可比较
max(s) 返回序列s的最大元素，s中元素需要可比较
sum(s) 返回序列s中所有数之和，s中元素需要时数值
s.index(x) 或 s.index(x,i,j) 返回序列s从i开始到j位置中第一次出现元素x的位置
s.count(x) 返回序列s中出现x的总次数 
ls = ["python",123,".io"]
print(len(ls))
#3

s = "python123.io"
print(max(s))
#'y'

元组类型及操作

元组是序列类型的一种扩展

  • 元组是一种序列类型，一旦创建就不能被修改
  • 使用小括号()或tuple()创建，元素间用逗号,分隔
  • 可以使用或不使用小括号 ```python creature = “cat”,”dog”,”tiger”,”human” #可以不使用小括号 print(creature)

    (‘cat’, ‘dog’, ‘tiger’, ‘human’)

color = (0x001100,”blue”,creature) print(color)

(4352, ‘blue’, (‘cat’, ‘dog’, ‘tiger’, ‘human’))


元组类型操作：元组继承序列类型的全部通用操作

- 元组继承了序列类型的全部通用操作
- 元组因为创建后不能修改，因此没有特殊操作
- 使用或不使用小括号


<a name="yYU13"></a>
#### 列表类型及操作

列表类型定义：列表是序列类型的一种扩展，十分常用

- 列表是一种序列类型，创建后可以随意被修改
- 使用方括号[]或者list()创建，元素间用逗号,分隔
- 列表中各元素类型可以不同，无长度限制
```python
ls = ["cat","dog","tiger",1024]
print(ls)
#['cat', 'dog', 'tiger', 1024]
lt = ls  #方括号[]真正创建一个列表，赋值仅传递引用
print(lt)
#['cat', 'dog', 'tiger', 1024]

列表类型操作函数和方法（一）

函数和方法 描述
ls[i]=x 替换列表ls第i元素为x
ls[i:j:k] = lt 用列表lt替换ls切片后所对应元素子列表
del ls[i] 删除列表ls中第i元素
del ls[i:j:k] 删除列表ls中第i到第j以k为步长的元素
ls +=lt 更新列表ls，将列表lt元素增加到列表ls中
ls *=n 更新列表ls，其元素重复n次 
ls = ["cat","dog","tiger",1024]
ls[1:2] = [1,2,3,4]
print(ls)
#['cat', 1, 2, 3, 4, 'tiger', 1024]
del ls[::3]
print(ls)
#[1, 2, 4, 'tiger']
print(ls*2)
#[1, 2, 4, 'tiger', 1, 2, 4, 'tiger']

列表类型操作函数和方法（二）

函数和方法 描述
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) 将列表ls中出现的第一个元素x删除
ls.reverse() 将列表ls中的元素反转
ls.sort() 将列表ls进行永久性排序
ls.sort(reverse=True)表示进行颠倒排序
sorted(ls) 将列表ls进行临时排序并返回排序的值
sorted(reverse=True)表示进行颠倒排序		 
ls = ["cat","dog","tiger",1024]
ls.append(1234)
print(ls)
#['cat', 'dog', 'tiger', 1024, 1234]
ls.insert(3,"human")
print(ls)
#['cat', 'dog', 'tiger', 'human', 1024, 1234]
ls.reverse()
print(ls)
#[1234, 1024, 'human', 'tiger', 'dog', 'cat']

列表注意情况

my_foods = ['pizza','falafel','carrot cake']
friend_foods = my_foods[:]
my_foods.append('cannoli')
friend_foods.append('ice cream')
print("My favorite foods are:")
print(my_foods)
print("\nMy friend's favorite foods are:")
print(friend_foods)
# My favorite foods are:
# ['pizza', 'falafel', 'carrot cake', 'cannoli']
# My friend's favorite foods are:
# ['pizza', 'falafel', 'carrot cake', 'ice cream']

my_foods = ['pizza','falafel','carrot cake']
friend_foods = my_foods   #注意这里变量 friend_foods 和 my_foods 所指向的是一个值
my_foods.append('cannoli')
friend_foods.append('ice cream')
print("My favorite foods are:")
print(my_foods)
print("My friend's favorite foods are:")
print(friend_foods)
# My favorite foods are:
# ['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']
# My friend's favorite foods are:
# ['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']

序列类型应用场景

数据表示：元组 和 列表

  • 元组用于元素不改变的应用场景，更多用于固定搭配场景
  • 列表更加灵活，它是最常用的序列类型
  • 最主要作用：表示一组有序列表，进而操作它们

元素遍历

for item in ls:
    #语句块

for item in tp:
    #语句块

数据保护：如果不希望数据被程序所改变，转换成元组类型

ls = ["cat","dog","tiger",1024]
lt = tuple(ls)
print(lt)
#('cat','dog','tiger',1024)

字典类型及操作

字典类型定义

理解映射：映射是一种键（索引）和值（数据）的对应
字典类型是“映射”的体现

  • 键值对：键是数据索引的扩展
  • 字典是键值对的集合，键值对之间无序
  • 采用大括号{}和dict()创建，键值对用冒号:表示

{<键1>:<值1>,<键2>:<值2>, … ,<键n>:<值n>}

字典类型的用法
<字典变量> = {<键1>:<值1>,<键2>:<值2>, … ,<键n>:<值n>}
<值> = <字典变量>[<键>] <字典变量>[键] = <值>

d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"}
print(d)
#{"中国":"北京","美国":"华盛顿","法国":"巴黎"}
print(d["中国"])
#'北京'
de = {};
print(type(de))
#<class 'dict'>

字典处理函数及方法

函数或方法 描述
del d[k] 删除字典d中键k对应的数据值
k in d 判断键k是否在字典d中，如果在返回True，否则False
d.keys() 返回字典d中所有的键信息
d.values() 返回字典d中所有的值信息
d.items() 返回字典d中所有的键值对信息 
d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"}
print("中国" in d)
#True
print(d.keys())
#dict_keys(['中国', '美国', '法国'])
print(d.values())
#dict_values(['北京', '华盛顿', '巴黎'])
print(d.items())
#dict_items([('中国', '北京'), ('美国', '华盛顿'), ('法国', '巴黎')])
函数或方法 描述
d.get(k,) 键k存在，则返回相应值，不在则返回值
d.pop(k,) 键k存在，则取出相应值，不在则返回值
d.popitem() 随机从字典d中取出一个键值对，以元组形式返回
d.clear() 删除所有的键值对
len(d) 返回字典d中元素的个数 
d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"}
print(d)
#{'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
print(d.get("中国","伊斯兰堡"))
#北京
print(d.get("巴基斯坦","伊斯兰堡"))
#伊斯兰堡
print(d.popitem())
#('法国', '巴黎')
print(d)
#{'中国': '北京', '美国': '华盛顿'}

字典类型应用场景

  • 映射的表达
    • 映射无处不在，键值对无处不在
    • 例如：统计数据出现的次数，数据是键，次数是值
    • 做主要作用：表达键值对数据，进而操作它们
  • 元素遍历

for k in d:
<语句块>