集合类型及操作：

多个元素的无序组合
-用大括号表示，逗号分隔
-建立集合类型使用{}或者set()
例如：

a = set("PYPY123")
print(a)
#由于集合中不能存在相同的元素而且元素无序所以输出结果为{'3', 'Y', '1', 'P', '2'}（每次的顺序都可能不一样）

集合操作符：

操作符及应用 描述
S | T 返回一个新集合，包括在集合S和T中的所有元素
S - T 返回一个新集合，包括在集合S但不在T中的元素
S & T 返回一个新集合，包括同时在集合S和T中的元素
S ^ T 返回一个新集合，包括集合S和T中的非相同元素
S <= T 或 S < T 返回True/False，判断S和T的子集关系
S >= T 或 S > T 返回True/False，判断S和T的子集关系

例如：

a = {"p","y",123}
b = set("pypy123") # 初始化字符串 也可以set([xx,xx,xx,xx])
print("a - b = {}\nb - a = {}\na & b = {}\na | b = {}\na ^ b = {}\n".format(a-b,b-a,a&b,a|b,a^b))
#输出结果为：
#a - b = {123}
#b - a = {'3', '1', '2'}
#a & b = {'y', 'p'}
#a | b = {'y', '3', 'p', '1', '2', 123}
#a ^ b = {'3', '1', '2', 123}

集合处理方法：

操作函数或方法 描述
s.add(x) 如果x不在集合s中，将x增加到集合s
s.discard(x) 将x从集合s移除，如果x不在集合s中不报错
s.remove(x) 将x从集合s移除，如果x不在集合x中，产生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

例如：

#简单操作
a = set("1234")
a.add("5")
print(a)
a.remove("1")
if 2 in a:
    print("2 is in a")
else:
    print("2 is not in a")
print(a)

数据去重：

集合类型可以用于各种数据去重，例如：给出一个列表ls，要求去掉列表中的重复元素，我们可以这样操作：

#先将列表类型转换为集合类型，再把集合类型转换为列表类型，这样就实现了简单的数据去重
ls = ['1','1','2','3','4','4']
s = set(ls)
ls = list(s)
print(ls)

序列类型及操作：

序列是具有先后关系的一组元素
-序列是一维元素向量，元素类型可以不同

序列类型的操作方法：

函数和方法 描述
max(s) 返回序列s中的最大元素，s中元素需要可比较
min(s) 返回序列s中的最小元素，s中元素需要可比较
s.index(x) 返回序列s中x第一次出现的位置
s.index(x,i,j) 返回序列s从i开始到j位置中第一次出现元素x的位置 
#定义ls1，ls2为两个列表，一个存放数字，一个存放字符
#max，min函数会根据字典序或者数字大小进行排序
ls1 = [1,2,3,4,1]
ls2 = ["a","b","c","d"]
print(max(ls1))
print(min(ls2))
#输出结果：4 a
#返回ls中元素1的第一次出现的位置
ls = [1,2,3,4,1]
print(ls.index(1))
#输出结果为：0

元组类型及操作：

元素是序列类型的一种扩展
-元组是一种序列类型，一旦创建就不能被修改
-使用小括号()或tuple()创建，元素间用逗号，分隔

#元组的定义
s = "1","2","3"
print(s)
ss = (123,"456",s)
print(ss)
#s是一个元组，ss也是一个元组，但他内部有一个s元组，所以要想使用ss调用s中的元素，可以这样
s = "1","2","3"
ss = (123,"456",s)
print(ss[2][1])
#输出结果为：2

列表类型及操作：

列表是序列类型的一种扩展
-列表是一种序列类型，创建后可以随意被修改
-使用[]或list()创建，元素间用逗号分隔

函数及方法 描述
ls[i] = x 将列表里第i的元素替换为x
ls[i:j:k] = lt 用列表lt替换ls切片后所对应元素子列表
del ls[i] 删除列表ls中的第i个元素
del ls[i:j:k] 删除列表从i到j，k为步长的元素
ls += lt 将lt中的元素增加到ls中，并更新ls 
#简单操作
ls = ["cat","dog","tiger",1024]
ls[1:2] = [1,2,3,4] #将第1个元素换成[1,2,3,4]组成的列表
print(ls)
del ls[::3] #删除步长为3的元素
print(ls)
函数及方法 描述
ls.append(x) 在列表ls后增加一个元素x
ls.pop(i) 取出ls中第i个元素，并删除（类似C/C++中的弹栈）
ls.remove(x) 删除列表ls中第一次出现的x
ls.reverse() 反转列表ls
ls.insert(i,x) 在列表第i个位置插入元素x
ls.copy() 生成一个新的列表，并复制ls中的所有元素
ls.clear() 清除列表ls中的所有元素 
#利用上面的函数进行操作：
ls = [1,2,3,4,5,6,7]
print(ls)
ls.append(3)    #在列表末尾增加一个元素3
print(ls)
ls.insert(3,5)  #在列表的第3个位置增加一个元素5
print(ls)
ls.pop(1)       #取出列表中的第1个元素并删除
print(ls)
ls.remove(3)    #删除列表中第一次出现的元素3
print(ls)
ls.reverse()   #列表反转
print(ls)
ls.clear()      #清空列表
print(ls)

列表与元组的区别：

列表内容可变，元组不可变，例如给出一个序列ls，一个元组s，对于序列ls，ls[0] = 1这种操作是正确的，但对与元组s，s[0] = 1是错误的，因而，列表中的元素可以改变，而元组中的元素不可变，所以列表是最常用的一种序列，元组类型主要用于数据保护。

字典类型及操作：

字典类型是“映射”的体现
-键值对：键是对数据索引的扩展
-字典是键值对的集合，键值对之间无序
-采用大括号{}和dict()创建，键值对用冒号:表示

函数或方法 描述
del d[k] 删除字典d中键k对应的数据值
k in d 判断键k是否在字典d中，在返回True否则返回False
d.keys() 返回字典d中所有的键的信息
d.values() 返回字典中所有值的信息
d.items() 返回字典d中所有的键值对信息 
d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"}
if "中国" in d:
    print("Yes")
else:
    print("NO")
print(d.values()) #输出所有的值
print(d.keys()) #输出所有的键
函数或方法 描述
d.get(k,) 键k存在就返回对应值，否则返回值
d.pop(k,) 键k存在就取出对应值，否则返回值
d.popitem() 随机从字典d中取出一个键值对，以元组类型返回
d.clear() 删除所有的键值对
len(d) 返回字典d中键值对的个数 
#新建字典d并向字典d中增加元素
d = dict()
for i in range(5):
    key,val = input("请输入键以及对应的值（空格隔开）").split()
    d[key] = val
print(d.keys())
print(d.values())

相关函数介绍：

enumerate 函数使用方式：

描述：

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中

遍历方式：

①遍历时返回一个元组，第一个元素为下标，第二个元素为下标对应的值

ls = [21,32,19,3,4]
lss = enumerate(ls)

for item in lss:
    print("下标{}对应的值为{}".format(item[0],item[1]))

②用两个不同的变量表示遍历返回的元组，一个为下标，一个为对应的值

ls = [21,32,19,3,4]
lss = enumerate(ls)
for i,item in lss:
    print("下标{}对应的值为{}".format(i,item))

zip函数使用方式：

描述：将多个迭代器对象中的元素压缩，返回一个zip对象

使用方式：

ls1 = ['1','2','3']
ls2 = ['4','5','6']
ls = zip(ls1,ls2)
for i in ls:
    print(i)

推导式

简介

推导式（comprehensions），又称解析式。利用列表推导式、字典推导式、集合推导式可以从一个数据对象构建另一个新的数据对象。利用生成器推导式可以构建生成器对象。

列表推导式

列表推导式和循环语句

假如想用一个列表中所有元素的平方以构成一个新列表，当然，可以使用append进行添加，但是为了让程序更加简单，可以利用列表推导式与循环的结合

ls = [i ** 2 for i in range(10)]
print(ls)

列表推导式和循环语句以及条件语句

除了上面说的列表推导式，进一步拓展，如果想要对序列中所有正整数进行平方运算，并形成一个新的列表，可以加入条件语句进行判断

ls0 = [-10,2,3,5,-1,-5]
ls = [i ** 2 for i in ls0 if i > 0]
print(ls)

在此基础上，如果想要将列表中的正整数平方，负整数保持不变，形成一个列表，可以使用三目运算符来完成

ls0 = [-10,2,3,5,-1,-5]
ls = [i ** 2 if i > 0 else i for i in ls0]
print(ls)

字典推导式

字典推导式和循环语句

将分别存有学生姓名与成绩的列表，整合到一个字典中，当然你可以，采用直接添加键值对的方式进行整合，这里介绍一种使用字典推导式的方法

id = ['A','B','C','D']
score = [100,90,85,95]
dic = {i:j for i,j in zip(id,score)}
for item in dic.items():
    print("{} {}".format(item[0],item[1]))

字典推导式和循环语句及条件语句

使用方式与列表推导式一致，这里不多赘述

Tip：集合推导式博主不再介绍，个人感觉用处不大