python的组合数据类型实验结果 python组合数据类型题目

Outline

1. 集合类型及操作；
2. 序列类型及操作；
3. 实例9：基本统计值计算；
4. 字典类型及操作；
5. 模块5：jieba库的使用；
6. 实例10：文本词频统计；
7. 方法论：Python三种主流组合数据类型的使用方法；
8. 实践能力：学会编写处理一组数据的程序。

1.集合类型及操作

集合类型的定义

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

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

示例

# 使用{}建立集合
A = {"python", 123, ("python", 123)}
print(A)
# {123, 'python', ('python', 123)}

# 使用 set() 建立集合
B = set("pypy123")
print(B)
# {'y', '1', '3', 'p', '2'}

C = {"python", 123, "python", 123}
print(C)
# {123, 'python'}

重点：

• 集合用 大括号{} 表示，元素间用 逗号分隔；
• 集合中 每个元素唯一，不存在相同元素；
• 集合元素之间无序。

集合操作符

操作符 及 应用	图形	描述
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 的包含关系

 4个增强操作符

操作符 及应用	解释	描述
S |= T	S = S | T	更新集合S，包括在集合S和T中的所有元素
S -= T	S = S - T	更新集合S，包括在集合S但不在T中的元素
S &= T	S = S & T	更新集合S，包括同时在集合S和T中的元素
S ^= T	S = S ^ T	更新集合S，包括在集合S和T中的非相同元素

A = {"p", "y", 123} # p,y,123
B = set("pypy123") # p,y,1,2,3
print(A-B) # {123} 在A中但不在B中
print(B-A) # {'3', '1', '2'} 在B中但不在A中
print(A&B) # {'y', 'p'} 交
print(A|B) # {'y', 'p', '1', '2', 123, '3'} 并
print(A^B) # {'2', 123, '3', '1'} 包括A和B中的所有非相同元素

 集合处理方法

操作函数 或 方法	描述
S.add(x)	如果 x 不在集合中，将 x 增加到 S
S.discard(x)	移除 S 中元素 x，如果 x 不在集合中，不报错
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 在集合中，则返回True，否则返回False
x not in S	判断 S 中元素 x，x 不在集合中，则返回True，否则返回False
set(x)	将 其他类型变量 x 转变为集合类型

 遍历

# 法1：for方式
A = {"p", "y", 123}
for item in A:
    print(item, end="") 
# p123y

# 法2：while方式
A = {"p", "y", 123}
try:
    while True:
        print(A.pop(), end="")
except:
    pass
# yp123

集合类型应用场景

包含关系比较

>>> "p" in {"p", "y", 123}
True
>>> {"p", "y"} >= {"p", "y", 123}
False

☆数据去重：集合类型所有元素无重复

ls = ["p", "p", "y", "y", 123]
# 将 列表 转换成 集合类型，利用集合类型无重复元素 的特点进行去重
s = set(ls)
print(s) # {'y', 123, 'p'}
# 去重之后，再把 “集合类型” 转换成 “列表”
lt = list(s) 
print(lt) # ['y', 123, 'p']

集合小结

• 创建：使用 {} 和 set() ；
• 集合间操作：交(&)、并(|)、差(-)、补(^)、比较(>=<)；
• 集合类型方法：.add()、.discard()、.pop()等；
• 主要应用于：包含关系比较、数据去重。

2.序列类型 及 操作

序列类型定义

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

• 序列是一维元素向量，元素类型可以不同；
• 类似 数学元素序列：s0, s1, ..., sn-1
• 元素间由序号引导，通过下标访问序列的特定元素。

序列是一个基类类型（不直接使用，经常使用它衍生出来的几种数据类型）

 序号的定义

 序列处理函数 及 方法

操作符

操作符 及应用	描述
x in s	如果 x 是序列 s 的元素，返回 True，否则 返回 False
x not in s	如果 x 是序列 s 的元素，返回 False，否则 返回 True
s + t	连接两个序列 s 和 t
s*n 或 n*s	将序列 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

5个函数和

函数和方法	描述
len(s)	返回序列 s 的长度
min(s)	返回序列 s 的最小元素，s 中元素需要可比较
max(x)	返回序列 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
# 输出 从下标1开始到下标6 第一次出现字符 'h' 的下标
print( s.count('h', 1, 6) ) # 1

元组类型 及操作

定义

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

• 元组是一种序列类型，一旦创建就不能被修改；
• 使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔；
• 可以使用 或 不使用 小括号。

def func():
    return 1, 2
# 这里实际上返回的是一个元组

creature = "cat", "dog", "tiger", "human"
print(creature)
# ('cat', 'dog', 'tiger', 'human')

color = (0x001100, "blue", creature)
print(color)
# (4352, 'blue', ('cat', 'dog', 'tiger', 'human'))

元组类型操作

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

creature = "cat", "dog", "tiger", "human"
print(creature[::-1])
# ('human', 'tiger', 'dog', 'cat')

color = (0x001100, "blue", creature)
print(color[-1][2])
# tiger

4.列表类型 及操作

定义

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

• 列表是一种序列类型，创建后可以随机被修改；
• 使用方括号 [] 或 list() 创建，元素间用逗号分隔；
• 列表中各元素类型可以不同，无长度限制。

ls = ["cat", "dog", "tiger", 1024]
print(ls)

lt = ls # 赋值仅传递引用，并没有新建一个列表
print(lt)

列表类型 操作函数 和 方法

函数 or 方法	描述
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]
# 1.把列表下标为2 的元素替换为 “pig”
ls[2] = "pig"
print(ls)
# ['cat', 'dog', 'pig', 1024]

# 2.把列表a中，从下标为0开始到4，步长为2的位置，替换为lt列表中的元素
a = ["hello", "hangzhou", "dianzi", "keji", "daxue"]
lt = ["1", "2", "3"]
a[0: 5: 2] = lt
print(lt)
# ['1', '2', '3']

# 3.删除列表b中，下标为1的元素
b = ["ni", "hao"]
del b[1]
print(b)
# ['ni']

# 4.删除列表c中，从下标0开始到5，且步长为2的元素
c = ["hang", "zhou", "dian", "zi", "da", "xue"]
del c[0: 6: 2]
print(c)
# ['zhou', 'zi', 'xue']

# 5.更新列表d，将列表e中的元素增加到列表d的后面
d = ["hello"]
e = ["hdu"]
d += e # d = d + e
print(d)
# ['hello', 'hdu']

# 6.更新列表f，其元素重复3次
f = ["i", "love", "you"]
n = 3
f *= n # f = f * n
print(f)
# ['i', 'love', 'you', 'i', 'love', 'you', 'i', 'love', 'you']

函数 or 方法	描述
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中的元素

# 1.在列表a最后增加一个元素
a = ["hello", "h", "d"]
a.append('u')
print(a)
# ['hello', 'h', 'd', 'u']

# 2.删除列表b中的所有元素
b = ['h', 'd', 'u']
b.clear()
print(b)
# []

# 3.生成一个新列表，赋值 a 中的所有元素
c = a.copy()
print(c)
# ['hello', 'h', 'd', 'u']

# 4.在列表d的下标为1的位置 增加元素 'hao'
d = ['ni', 'hdu']
d.insert(1, 'hao')
print(d)
# ['ni', 'hao', 'hdu']

# 5.将列表e中的下标为2的位置弹出
e = ['i', 'love', 'hdu']
e.pop(2)
print(e)
# ['i', 'love']

# 6.将列表f中出现的第一个'h'元素删除
f = ['h', 'h', 'h']
f.remove('h')
print(f)
# ['h', 'h']

# 7.反转列表中的元素
g = [1, 2, 3]
g.reverse()
print(g)
# [3, 2, 1]

几个不熟悉的操作

列表功能	操作
向 lt 中新增 5 个元素	lt += [1, 2, 3, 4, 5]
判断 lt 中是否包含 数字0	0 in lt
返回数字0 所在 lt 中的索引	lt.index(0)

5.序列类型应用场景

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

元素遍历

for item in ls:
    <语句块>

for item in tp:
    <语句块>

数据保护

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

ls = ["cat", "dog", "tiger", 1024]
# 将 列表ls 转换成 元组类型的lt
lt = tuple(ls)
print(lt)
# ('cat', 'dog', 'tiger', 1024)

单元小结：

序列是 基类类型，扩展类型包括：字符串、元组、列表；

元组用 ( ) 和 tuple() 创建，列表用 [ ] 和 list() 创建；

元组操作

列表操作 在序列操作基础上，增加了更多的灵活性。

三、实例9 基本统计值计算问题

问题分析

需求：给出一组数，对他们有个概要理解：总个数、求和、平均值、方差、中位数

基本统计值

• 总个数:len()
• 求和：for ... in 
• 平均值：求和 / 总个数
• 方差：各数据 与 平均数差 的平方的和的平均数
• 中位数：排序，然后... 奇数找中间1个，偶数找中间2个取平均

# 获取输入值
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)))

举一反三

技术能力扩展

• 获取多个数据：从控制台获取多个不确定数据的方法；
• 分隔多个函数：模块化设计方法；
• 充分利用函数：充分利用 Python 提供的内容函数。

4. 字典类型 及操作

字典类型定义

映射

映射是一种 键(索引) 和 值(数据) 的对应

字典类型是“映射”的体现

键值对：键是数据索引的扩展；

字典是键值对的集合，键值对之间无序；

采用大括号 {} 和 dict() 创建，键值对 用冒号 : 表示

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

在字典变量中，通过 键 获得值

<字典变量> = {<键1>:<值1>, ..., <键n>:<值n>}
<值> = <字典变量>[<键>]
<字典变量>[<键>] = <值>

d = {"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
print(d)
# {'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
print( d["中国"] )
# 北京

de = {}
print( type(de) ) # type(x)返回变量x的类型
# <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(['北京', '华盛顿', '巴黎'])

函数 或 方法	描述
d.get(k, <default>)	键k 存在，则返回相应值，否则返回<default>
d.pop(k, <default>)	键k 存在，则取出相应值，否则返回<default>
d.popitem()	随机从 字典d 中取出一个键值对，以元组形式返回
d.clear()	删除所有的 键值对
len(d)	返回 字典d 中元素的个数

d = {"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
# 1.如果 键"中国"存在，则返回对应的值"北京"
print( d.get("中国", "伊斯兰堡") )
# 北京

# 2.如果 键"巴基斯坦"不存在，则返回后面的默认值"伊斯兰堡"
print( d.get("巴基斯坦", "伊斯兰堡") )
# 伊斯兰堡

# 3.随机返回一个键值对
print( d.popitem() )
# ('法国', '巴黎')

几个不熟悉的字典功能：

字典功能	对应代码
向 d 中新增两个键值对元素	d["a"] = 1 d["b"] = 2

字典类型应用场景

映射的表达

映射无处不在，键值对无处不在；

例如：统计数据出现的次数，数据是 键，次数 是值

元素遍历

for k in d:
    <语句块>

单元小结

• 映射关系 采用 键值对表达；
• 字典类型使用 {} 和 dict{} 创建，键值对之间用 : 分隔；
• d[key] 方式既可以索引，也可以赋值；
• 字典类型有一批操作方法和函数，最重要的是 .get()

五、模块5：jieba库的使用

jieba是优秀的中文分词第三方库

• 中文文本需要通过 分词 获得单个的词语；
• jieba 是优秀的中文分词第三方库，需要额外安装；
• jieba库 提供三种分词模式，最简单只需掌握一个函数。

jieba库的安装

jieba分词的原理

jieba分词依靠中文词库

• 利用一个中文词库，确定汉字之间的关联概率；
• 汉字间概率大的组成词组，形成分词结果；
• 除了分词，用户还可以添加自定义的词组。

jieba分词的三种模式

• 精确模式：把文本精确的切分开，不存在冗余单词；
• 全模式：把文本中所有可能的词语都扫描出来，有冗余；
• 搜索引擎模式：在精确模式基础上，对长词再次划分。

函数

函数	描述
jieba.lcut(s)	精确模式，返回一个列表类型的分词结果 import jieba s = "中国是一个伟大的国家" print( jieba.lcut(s) ) # ['中国', '是', '一个', '伟大', '的', '国家']
jieba.lcut(s, cut_all = True)	全模式，返回一个列表类型的分词结果，存在冗余 import jieba s = "中国是一个伟大的国家" print( jieba.lcut(s, cut_all=True) ) # ['中国', '国是', '一个', '伟大', '的', '国家']
jieba.lcut_for_search(s)	搜索引擎模式，返回一个列表类型的分词结果，存在冗余 import jieba s = "中华人民共和国是伟大的" print( jieba.lcut_for_search(s) ) # ['中华', '华人', '人民', '共和', '共和国', '中华人民共和国', '是', '伟大', '的']
jieba.add_word(w)	向分词词典增加新词w jieba.add_word("蟒蛇语言")

六、实例10：文本词频统计

重要性：可以练习组合数据类型中的 元组、列表、字典，必须掌握！

问题分析

文本词频统计

需求：一篇文章，出现了哪些词？哪些词出现的最多？该怎么做呢？

英文文本：Hamet 分析词频 文本资源

中文文本：《三国演义》 分析人物 文本资源

1.Hamlet英文词频统计 实例讲解

噪声：单词大小写，逗号等符号，要进行归一化

# 归一化处理
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，用来存储 单词 及 对应出现次数 的映射关系
counts = {}
# 逐一从列表中取出单词，如果这个单词在字典中就+1，不在的话就新建映射关系并设为0
for word in words:
	counts[word] = counts.get(word, 0) + 1
# 字典类型 转换为 列表类型
items = list(counts.items())
# 对列表进行排序，按照键值对的第二个元素进行排序，从大到小
items.sort(key=lambda x:x[1], reverse=True)
# 输出前10个出现次数最多的单词及出现次数
for i in range(10):
	word, count = items[i]
	print("{0:<10}{1:>5}".format(word, count))

输出：

2.《三国演义》人物出场统计 实例讲解

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] = counts.get(word, 0) + 1
items = list(counts.items())
items.sort(key=lambda x:x[1], reverse=True)
for i in range(15):
	word, count = items[i]
	print("{0:<10}{1:>5}".format(word, count))

 V2版本

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[rword] = counts.get(rword, 0) + 1
for word in excludes:
	del counts[word]
items = list(counts.items())
items.sort(key=lambda x:x[1], reverse=True)
for i in range(10):
	word, count = items[i]
	print("{0:<10}{1:>5}".format(word, count))

举一反三