六、组合数类型
6.1 集合类型及操作
6.1.1 集合类型定义
定义：集合是多个元素的无序组合
特点：集合类型与数学中的集合概念一致，几何元素之间无序、每个元素唯一、不存在相同元素，几何元素不可更待、不能存在可变数据类型。
非可变数据类型：整数、浮点数、复数、字符串类型、元组类型等
表示：{},元素间用，分隔
建立：{} 或者set{}，建立空集合必须使用set{}
举例：
A={"python",123,("python",123)}
{123,'pytnon',('python',123)}
B=set("pypy123")
{'1','p','2','3','y'}
C=("python",123,"python",123)
('python',123)
6.1.2 集合操作符
基本操作符：
| 操作符 | 含义 |
|---|---|
| S|T | 并 |
| S-T | 差 |
| S$T | 交 |
| S^T | 补 |
| S<=T或S<T | 判断S和T子集关系 |
| S>=T或S>T | 判断S和T包含关系 |
增强操作符：
| 操作符 | 含义 |
|---|---|
| S|=T | 利用并运算结果更新集合S |
| S-=T | 利用差运算结果更新集合S |
| S$=T | 利用交运算结果更新集合S |
| S^=T | 利用补运算结果更新集合S |
实例：
A={"P","Y",123}
B=set("pypy123")
A-B
{123}
B-A
{'3','1','2'}
A&B
{'p','y'}
A|B
{'1','p','2','y','3',123}
A^B
{'2',123,'3','1'}
6.1.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中返回Ture,否则返回False |
| x not in S | 判断S 中元素x，x不在集合S中返回Ture,否则返回False |
| set(x) | 将其他类型变量x转化为集合类型 |
A={"p","y",123}
for item in A:
print(item,end="")
p123y
try:
while True:
print(A.pop(),end="")
expece:
pass
A
set()
6.1.4 集合应用场景
1.包含关系比较：
"p" in {"p","y",123}
True
{"p","y"}>={"p","y",123}
False
2.数据去重
ls=["p","p","y","y",123]
s=set(ls) #利用几何元素无重复特点
{'p','y',123}
ls=["p","p","y","y",123]
s=set(ls) #利用几何元素无重复特点
lt=list(s)
['p','y',123]
6.2序列类型及操作
6.2.1 序列类型定义
定义：序列是具有先后关系的一组元素
特点：序列是一维元素向量，元素类型可以不同，元素可以相同：类似数学元素序列：元素间有序列引导，通过下标访问序列的特定元素
序列是一个基类类型，衍生为：字符串类型、元组类型、列表类型
序号的定义：正向递增序号、反向递减序号，与字符串中相似。
6.2.2 序列处理函数及方法
| 操作符及应用 | 描述 |
|---|---|
| x in S | 判断S 中元素x，x在集合S中返回Ture,否则返回False |
| x not in S | 判断S 中元素x，x不在集合S中返回Ture,否则返回False |
| 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"]
ls=[::-1]
['.io',123,'python']
s="python123.io"
ls[::-1]
'oi.321nohtyp'
序列类型的通用函数和方法：
| 函数和方法 | 描述 |
|---|---|
| len(s) | 返回序列s的长度 |
| min(s) | 返回序列s的最小元素，s中元素需要可比较 |
| max(s) | 返回序列s的最大元素，s中元素需要可比较 |
| s.index(x)或s.index(x,i,j) | 返回序列s从i开始到j位置中第一次出现x的位置 |
| s.count(x) | 返回序列s中出现x的总次数 |
ls=["python",123,".io"]
len(ls)
3
s="python123.io"
max(s)
'y'
6.2.3 元组类型及操作
定义：元组类型是序列类型的一种扩展，一旦创建就不能修改
形式：元组使用（）或者tuple（）创建，元素之间用逗号分隔：小括号使不使用都可以。
举例：
creature="cat","dog","tiger","human"
creature
('cat','dog','tiger','human')
creature="cat","dog","tiger","human"
color=(0x001100,"bule",creature)
color
(4352,'bule',('cat','dog','tiger','human'))
元组类型继承序列类型全部通用操作：操作符、处理函数、处理方法
元组类型创建后不能修改，因此没有特殊操作
creature="cat","dog","tiger","human"
creature[::-1]
('human','tiger',dog','cat')
creature="cat","dog","tiger","human"
color=(0x001100,"bule",creature)
color[-1][2]
'tiger'
6.2.4 列表类型及操作
定义：列表是序列类型的一种扩展，创建后其中的元素可以被随意修改
使用：[]或者list()创建，元素间可以用逗号隔开，列表中各元素类型可不同，无长度限制
ls=["cat","dog","tiger",1024]
ls
['cat','dog','tiger',1024]
ls=["cat","dog","tiger",1024]
lt=is.
lt
['cat','dog','tiger',1024]
列表类型操作函数及其方法：
| 函数或方法 | 描述 |
|---|---|
| ls[i]=x | 替换列表ls第i个元素为x |
| ls[i:j:k]=lt | 用列表il替换is切片后所对应元素子列表 |
| del ls [i] | 删除列表is中第i个元素 |
| del ls[i:j:k] | 删除列表is中第i到第j以k为步长的元素 |
| ls+=lt | 更新列表ls，将列表lt元素增加到列表ls中 |
| ls*=n | 更新列表ls，其元素重复n次 |
ls=["cat","dog","tiger",1024]
ls=[1:2]=1,2,3,4
['cat',1,2,3,4,'tiger',1024]
修改列表：
| 函数或方法 | 描述 |
|---|---|
| ls.append(x) | 在列表s最后增加一个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中元素反转 |
练习：
6.2.5 序列类型应用场景
序列：元组和列表两种重要类型
应用场景：元组用于元素不改变的场景，更多用于固定搭配场景：列表更加灵活，它是最常用的序列类型
作用：表达一组有序数据并且处理问题；数据保护
元素遍历：
for item in ls:
<语句块>
元组类型：
for item in tp:
<语句块>
数据保护：不希望数据被程序所改变，转换成元组类型
ls=["cat","dog","tiger",1024]
lt=tuple(ls)
lt
('cat',1,2,3,4,'tiger',1024)
6.3 基本统计值计算
6.3.1 问题分析
基本统计值需求：给出一组数并且理解
定义：总个数、求和、平均值、方差、中位数...
总个数：len()
求和：for...in
平均值：求和/总个数
方差：各数据与平均数差的平方的和的平均数
中位数：排序，然后... 奇数找中间一个，偶数中间两个的平均
6.3.2 问题实例
#CalStatisticsV1.py
def getNum(): #获取用户不定长度的输入
nums=[]
iNumStr=input("请输入数字（回车退出）:")
while iNumStr!="":
nums.append(eval(iNumStr))
iNumStr=input("请输入数字（回车退出）:")
return nums
def mean(numbers): #计算平均值
s=0.0
for num in numbers:
s=s+num
return s/len(numbers)
def dev(numbers,mean): #计算方差
sdev=0.0
for num in numbers:
sdev=sdev+(num-mean)**2
return pow(sdev/(len(numbers)-1),0.5)
def median(numbers): #计算中位数
sorted(numbers)
size=len(numbers)
if size % 2 == 0:
med=(numbers[size//2-1]+numbers[size//2])/2
else:
med=numbers[size//2]
return med
n=getNum()
m=mean(n)
print("平均值:{},方差:{:.2},中位数:{}.".format(m,dev(n,m),median(n)))
6.4 字典类型及操作
6.4.1 字典类型定义
映射：是一种索引和数据的对应关系，也是键和值的对应关系。
映射类型：由用户数据为定义索引
字典类型：数据的组织与表达的一种新的形态，是映射的体现。
键值对：键是数据索引的扩展，字典是键值对的集合，键值对间无序。
生成：{}和dict()创建，键值对之间用冒号：表示
举例：{<键1>:<值1>,<键2>:<值2>,...,<键n>:<值n>}
在字典变量中，通过键获得值：
<字典变量>={<键1>:<值1>,...,<键n>:<值n>}
<值>=<字典变量>[<键>]
<字典变量>[<键>]=<值>
用[]来向字典中增加或者索引键值对
举例：
d={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
d["中国"]
'北京'
生成空字典：
de={};type(de)
<class 'dict'>
type(x) 返回变量x的类型
6.4.2 字典处理函数及方法
| 函数 | 描述 |
|---|---|
| del d[k] | 删除字典d中键k对应的数据值 |
| k in d | 判断k是否在字典d中，如果在返回True，不在返回False |
| d.keys() | 返回字典d中所有的键信息 |
| d.values() | 返回字典d中所有的值信息 |
| d.items() | 返回字典d中所有的键值对信息 |
举例：
d={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
"中国" in d
True
d={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
d.keys()
dict_keys(['中国','美国','法国])
d={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
d.values()
dict_values(['北京','华盛顿','巴黎'])
| 函数 | 描述 |
|---|---|
| d.get(k,<default>) | 键k存在，则返回相应值，不存在则返回<default>值 |
| d.pop(k,<default>) | 键k存在，则取出相应值，不存在则返回<default>值 |
| d.popitem() | 随机从字典里取出一对键值对，以元组形式返回 |
| d.clear() | 删除所有的键值对 |
| len(d) | 返回字典d中的元素个数 |
实例：
d={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
d.get("中国"，"伊斯兰堡")
'北京'
d={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
d.get("巴黎"，"伊斯兰堡")
'伊斯兰堡'
d={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
d.popitem()
('中国','北京')
练习：
6.4.3字典应用场景
1.映射的表达：映射无处不在，键值对也无处不在，统计数据出现的次数，数据是键，次数是值。
字典的主要作用：表达键值对的数据进而操作他们
2.元素遍历：
for k in d:
<语句块>
6.5 jieba库
6.5.1 jieba库简介
定义：jieba库是优秀的第三方中文分词库，需要额外安装
安装方法：（cmd命令下）pip install jieba
作用：利用中文词库确定汉字间的关联概率，字间概率大的组成词组，形成分词效果，用户还可以向其中自定义的添加词组。
6.5.2 jieba库使用说明
分类：精确模式、全模式、搜索引擎模式
精确模式：将词组精确的分开，不存在冗余单词
全模式：将所有可能的词组都扫描出来，有冗余
搜索引擎模式：在精确模式的基础上，将长词再次切分
| 函数 | 描述 |
|---|---|
| jieba.lcut(s) | 精确模式，返回一个列表类型的分词结果 |
| jieba.lcut(s,cut_all=True) | 全模式，返回一个列表类型的分词结果，有冗余 |
| jieba.lcut_for_search(s) | 搜索引擎模式，返回一个列表类型的分词结果，有冗余 |
| jieba.add_word(w) | 向分词词典中添加新词 |
举例：
jieba.lcut("中国是一个伟大的国家")
['中国','是','一个','伟大','的','国家']
jieba.lcut("中国是一个伟大的国家",cut_all=True)
['中国','国是','一个','伟大','的','国家']
jieba.lcut_for_search("中华人民共和国是伟大的")
['中华','华人','人民','共和','共和国','中华人民共和国','是','伟大','的']
jieba.add_word("蟒蛇语言")
6.6 文本词频统计实例
需求：一篇文章中出现的词的频率统计
分类：英文文本，中文文本
举例：
英文：哈姆雷特（hamlet）
中文：三国演义（threekingdoms）
6.6.1 哈姆雷特实例
#CalHamletV1.py
def getText():
txt=open("hamlet.txt","r").read()
txt=txt.lower()
for ch in '`~!@#$%^&*()_+={}[]|\?/";:<>,./':
txt=txt.replace(ch,"")
return txt
hamletTxt=getText()
words=hamletTxt.split()
counts={}
for word in words:
counts[word]=count.get(wora,0)+1
items=list(counts,items())
items.sort(key=lambda x:x[1],reverse=True)
for i in range (10):
word,count=item[i]
print("{0:<10}{1:>5}".format(word.count))
6.6.2 三国演义实例
#CalThreeKingdomsV1.py
import jieba
txt=open("threekingdoms.txt","r",encoding="utf-8").read()
words=jieba.lcut(txt)
counts={}
for word in words:
if len(word) == 1:
continue
else:
counts[word]=count.get(wora,0)+1
items=list(counts,items())
items.sort(key=lambda x:x[1],reverse=True)
for i in range (15):
word,count=item[i]
print("{0:<10}{1:>5}".format(word.count))
6.6.3 三国演义修改版实例
#CalThreeKingdomsV1.py
import jieba
txt=open("threekingdoms.txt","r",encoding="utf-8").read()
excludes={"将军","二人","荆州","却说","不能","如此"}
words=jieba.lcut(txt)
counts={}
for word in words:
if len(word) == 1:
continue
elif word =="诸葛亮" or word =="孔明曰":
rword="孔明"
elif word =="关公" or word =="云长曰":
rword="关羽"
elif word =="玄德" or word =="玄德曰":
rword="刘备"
elif word =="孟德" or word =="孟德曰":
rword="曹操"
else:
rword=word
counts[word]=count.get(wora,0)+1
items=list(counts,items())
items.sort(key=lambda x:x[1],reverse=True)
for i in range (15):
word,count=item[i]
print("{0:<10}{1:>5}".format(word.count))
