Python联合数据类型
集合
集合操作符
| 操作符及应用 | 描述 |
|---|---|
| S|T(并) | 返回一个新的集合，包括S和T中的所有元素 |
| S-T(差) | 返回一个新的集合，包括在S中却不在T中的元素 |
| S&T(交) | 返回一个新的集合，包括同时在S和T中的元素 |
| S^T(补) | 返回一个新的集合，包括S和T中非相同元素 |
A={'p','y',123}
B=set('py123')
print(A-B)>>>{123}
print(B-A)>>>{'3', '2', '1'}
'注意差集运算的区别'
print(A&B)>>>{'y', 'p'}
print(A|B)>>>{'y', '1', '2', '3', 123, 'p'}差集运算符会把放在前面的作为主体比如A-B的意思是返回一个集合，这个集合包括在A中却不在B中的元素
B-A就恰恰相反返回一个集合，这个集合包括在B中却不在A中的元素
增强操作符
Python又提供了对应的4种增强操作符
| 操作符及应用 | 描述 |
|---|---|
| S|=T | 更新S集合，包括S和T中的所有元素 |
| S-=T | 更新S集合，包括在S中却不在T中的元素 |
| S&=T | 更新S集合，包括同时在S和T中的元素 |
| S^=T | 更新S集合，包括S和T中非相同元素 |
如果不使用增强操作符的话，返回的是一个新的集合A，如果使用了的话，相当于把原来的集合S更新为集合A
集合的方法或方法
| 方法或函数 | 描述 |
|---|---|
| S.add(x) | 如果x不在S中，将x添加的S中 |
| S.discard(x) | 将x从S中移除，如果x不存在S中，不报错 |
| S.remove(x) | 将x从S中移除，如果x不存在S中，产生KeyError异常 |
| S.clear() | 移除S中的所有元素 |
| S.pop() | 随机移除一个元素x并把x返回，如果S为空则产生KeyError异常 |
| S.copy() | 返回一个S的副本 |
| len(S) | 返回S的元素个数 |
| x in S | 判断x是否在S中，在就返回True，不在就返回False |
| x not in S | 与上面返回结果相反 |
| set(x) | 将其他类型x转变为集合类型x |
值得注意是
printf(set(3))
>>>TypeError: 'int' object is not iterable
'"int"类型的对象是不可迭代的'这里我们就不得不说一下迭代器和可迭代对象的事情了
可迭代对象
| 可迭代对象 | 常见的可迭代对象 |
|---|---|
| 能直接作用于for循环的对象我们统称为可迭代对象 | list、set，dict，tuple，str，range，生成器 |
生成器
定义：一边循环一边计算的这种机制我们称之为生成器[可以不断推算出下一个元素
注意：生成器只能迭代一遍
创建生成器
g = (result for x in range(m,n))
g1 = (x for x in range(10))
for x in g1:
print(x,end="\t") '输出0 1 2 3 4 5 6 7 8 9'迭代器
不但能够作用于for循环，还可以被next函数调用，不断返回下一个值，这样的对象我们就称之为迭代器
常见的只有生成器是迭代器，其他类型的都不是。
可以通过iter()函数将可迭代对象转为迭代器。
iter1 = iter([1,2,3])
print(iter1) '返回'
print(type(iter1)) "返回"
print(next(iter1)) '输出1'iterator一定iterable，但是iterable不一定是iterator
只有生成器是iterator
import collections
g = (x for x in range(10))
print(isinstance([],collections.abc.Iterable)) '返回True'
print(isinstance("",collections.abc.Iterable)) '返回True'
print(isinstance({},collections.abc.Iterable)) '返回True'
print(isinstance((),collections.abc.Iterable)) '返回True'
print(isinstance(range(10),collections.abc.Iterable)) '返回True'
print(isinstance(g,collections.abc.Iterable)) '返回True'
print(isinstance([],collections.abc.Iterator)) '返回False'
print(isinstance("",collections.abc.Iterator)) '返回False'
print(isinstance({},collections.abc.Iterator)) '返回False'
print(isinstance((),collections.abc.Iterator)) '返回False'
print(isinstance(range(10),collections.abc.Iterator)) '返回False'
print(isinstance(g,collections.abc.Iterator)) '返回True'可以看出在判断是否是iterator的时候只有生成器g返回了True。
集合的应用场景
1.数据去重
ls=['p','p','y','y','123']
s=set(ls) '转换为集合'
print(s)
ls=list(s) '再转换为列表'
print(ls) '现在的列表没有重复的元素'
{'y', '123', 'p'}
['y', '123', 'p']
>>> 序列
序列是具有先后关系的一组元素。他是一维元素向量，元素类型可以不同。元素间由特定的序号引导，通过下标访问特定的元素
序列是一种基类型，我们通常使用的是序列衍生出来的类型
序列操作
序列的操作对它的衍生类型都是适用的
| 操作符及应用 | 描述 |
|---|---|
| x in S | 判断x是否在S中，在就返回True，不在就返回False |
| x not in S | 与上面返回结果相反 |
| x+t | 将x和t连接 |
| n*s或s*n | 将s复制n次 |
| s[i] | 返回s的第i个元素 |
| s[i:j:k] | 切片，返回s中从序号i到j-1以k为步长的子序列 |
值得注意的是连接操作中的序列必须是同一类型才行
ls=['p','p','y','y','123']
s=tuple(ls)
print(s)
ls=list(s)
print(ls)
print(ls+s)
('p', 'p', 'y', 'y', '123')
['p', 'p', 'y', 'y', '123']
TypeError: can only concatenate"v.连接" list (not "tuple") to list
'仅能list之间进行连接，而不是元组类型和列表类型'| 函数和方法 | 描述 |
|---|---|
| len(s) | 返回s的长度 |
| min(s) | 返回s中最小的元素，前提是s中的元素能够比较 |
| max(s) | 返回s中最大的元素，前提是s中的元素能够比较 |
| s.index(x)或s.index(x,j,k) | 返回元素x在序号j到k-1之间第一次出现的序号 |
| s.count(x) | 返回x在s中出现的总次数 |
又值得注意的是s.index(x,j,k)这个函数
ls=['p','p','y','y','123']
print(ls.index('y'))
print(ls.index('y',0,2))
2
ValueError: 'y' is not in list
'也就是说只会寻找序号0到2-1=1的元素，所以出现了ValueError异常'元组类型
元组一旦被创建就不能修改，正因为此元组没有什么特殊的操作。
稍微值得一讲的就是
'元组在创建时可以不用小括号'
import operator
A='p','y','1','2','3'
B=('p','y','1','2','3')
print(operator.eq(A,B))
print(A is B)
True
True
>>>可以看出元组A和元组B是一样的，不仅内容相同，就连引用对象也是相同的
还有一个就是怎么取元组中的联合类型的元素
B=('p',('y','123'))
print(B[0])
print(B[1][0])
print(B[1][1])
'B[1]取出元组('y','123')，然后再用一个中括号来取'
'学过C,C艹,java的同学一定觉得很眼熟，这跟二维数组是一个道理'
p
y
123
>>>列表
函数或方法
| 函数和方法 | 描述 |
|---|---|
| ls[x]=i | 将ls中的第x元素替换为i |
| ls[i:j:k]=lt | 用lt替换ls切片后对应元素的子列表 |
| del ls[i] | 删除ls的第i元素 |
| del ls[i:j:k] | 删除ls里从i到j-1步长为k的元素 |
| ls+=lt | 更新ls列表，并把lt添加到ls中 |
| ls.append(x) | 将x添加到ls中 |
| ls.clear() | 将ls全部清除 |
| ls.copy() | 生成一个新列表，复制了ls的所有元素 |
| ls.insert(i,x) | 将x插入到ls的序号i位置上 |
| ls.pop(i) | 返回第i号元素并删除 |
| ls.remove(x) | 讲第一个出现的x删除 |
| ls.reverse | 把ls倒置 |
序列类型应用场景
元组用于元素不改变的场合
比如保护数据，我们可以把某些数据转换为元组类型再进行操作。这正是利用了元组一旦被创立就不能被修改的特点
列表灵活，是最常用的序列类型
最主要的作用：表现一组有序数据并操作他们
字典类型
字典是映射的一种表现
实际上生活中，映射是一种非常常见的数据类型。
下面来介绍一下字典的一些基本概念和操作
##键值对
键Key用来对应值，key同样可以翻译为钥匙，这样可能更好理解key和value的关系。
字典是键值对的集合，在字典内部键值对是无序的。
字典与集合
字典与集合都是用大括号来的，但是
d={}'这样创建的是一个空字典'
'如果想创建一个空集合该怎么办的？我们需要用到set()函数'
d=set()因为字典是非常常用的数据类型所以创建的方法留给了字典。
字典的方法和函数
| 函数和方法 | 描述 |
|---|---|
| del d[k] | 删除d中k对应的数据值 |
| k in d | 判断键值k是否在d中 |
| d.keys() | 返回d中所有key的信息 |
| d.values() | 返回d中所有value的信息 |
| d.items() | 返回d中所有键值对的信息 |
| d.get(k, |
键k存在则返回对应的数据值，不存在则返回 |
| d.pop(k, |
键k存在则取出对应的数据值，不存在则返回 |
| d.popitem() | 随机取出一对键值对，以元组形式返回 |
| d.clear() | 删除d中所有键值对 |
| len(d) | 返回d中元素的个数 |
jieba库的使用
jieb是非常棒的分词第三方库，因此我们需要下载。而且要使用命令行操作。
jieba库的安装
首先我们打开命令行然后输入pip install jieba命令下载jieba库。但是可能出现我们需要更新pip的情况，会提示warning。我们只需要在warning中找到python -m pip install --upgrade pip然后复制粘贴对pip进行更新即可。
jieba库的三种模式
| 模式 | 描述 |
|---|---|
| 精确模式 | 把文本精确的切开，不存在冗余单词 |
| 全模式 | 把文本中所有可能的单词都扫描出来，存在冗余单词 |
| 搜索引擎模式 | 在精确模式的基础上对长单词再切分，有冗余 |
精确模式是常常使用的模式
jieba库的方法和函数
| 函数和方法 | 描述 |
|---|---|
| jieba.lcuts(s) | 精确模式，返回一个列表形式的分词结果 |
| jieba.lcuts(s,cut_all=True) | 全模式，返回一个列表形式的分词结果，存在冗余 |
| jieba.lcuts() | 精确模式，返回一个列表形式的分词结果 |
| jieba.lcut_for_search(s) | 搜索引擎模式，返回一个列表形式的分词结果，有冗余 |
| jieba.add_word(w) | 向分词词典中添加w |