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)      '返回<list_iterator object at 0x00000000021AA278>'
print(type(iter1))  "返回<class 'list_iterator'>"
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,<default>)	键k存在则返回对应的数据值，不存在则返回<default>值
d.pop(k,<default>)	键k存在则取出对应的数据值，不存在则返回<default>值
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