Python语言程序设计第6周笔记（第6章 组合数据类型）

6.1 集合类型及操作

1. 集合类型定义：集合是多个元素的无序组合

• 集合用大括号 {} 表示，元素间用逗号分隔
• 建立集合类型用 {} 或 set()
• 建立空集合类型，必须使用set()

# 使用{}建立集合 
>>> A = {"python", 123, ("python",123)}
{123, 'python', ('python', 123)} 
# 使用set()建立集合
>>> B = set("pypy123") 
{'1', 'p', '2', '3', 'y'} 
>>>> C = {"python", 123, "python",123} 
{'python', 123}

2. 集合操作符

• 6个操作符

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

>>> 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}

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中，返回True，否则返回False
x not in S	判断S中元素x，x不在集合S中，返回True，否则返回False
set(x)	将其他类型变量x转变为集合类型

>>> A = {"p", "y",123}
>>> for item in A:
		print(item, end="")
# p123y
# 集合中取出元素时，可能与定义的顺序不同
>>> try:
		while True:
			print(A.pop(), end="")
		except:
			pass
# p123y
# 不断取出集合A中的元素，直至A为空
>>> A
set()

4. 集合类型应用场景

• 包含关系比较

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

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

>>> ls = ["p", "p", "y", "y", 123]
>>> s = set(ls)
# 利用了集合无重复性元素的特点
{'p', 'y', 123}
>>> lt = list(s)
# 将集合转换为列表
['p', 'y', 123]

6.2 序列类型及操作（元组类型、列表类型）

1. 序列类型定义

• 序列：具有先后关系的一组元素
• 序列是一维元素向量，元素类型可以不同
• 类似数学元素序列：s₀，s₁，…，s_n-1
• 元素间由序号引导，通过下标访问序列的特定元素，元素存在正向递增的序号的索引关系和反向递减序号的索引关系
• 序列是一个基类类型

$$序列类型\{\begin{array}{l}字符串类型\\ 元组类型\\ 列表类型\end{array}$$

2. 序列处理函数及方法

• 6个操作符

操作符及应用	描述
x in S	如果x是序列S的元素，返回True，否则返回False
x not in S	如果x不是序列S的元素，返回True，否则返回False
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"]
>>> ls[::-1]
[".io", 123, "python"]
>>> s = "python123.io"
>>> s[::-1]
'oi.321nohtyp'

• 5个函数和方法

函数或方法	描述
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'

3. 元组类型及操作

• 元组是序列类型的一种扩展，一旦创建就不能被修改
• 使用小括号()或tuple()创建，元素间用逗号，分隔
• 可以使用或不使用小括号
• 元组继承了序列类型的全部通用操作
• 元组因为创建后不能修改，因此没有特殊操作

def func():
	return 1, 2
# 返回的(1, 2)是一个元组
>>> creature = "cat", "dog", "tiger", "human"
>>> creature
("cat", "dog", "tiger", "human")
>>> color = (0x001100, "blue", creature)
>>> color
(0x001100, "blue", ("cat", "dog", "tiger", "human"))
>>> creature[::-1]
("human", "tiger", "dog", "cat")
# 不改变原有元组值，而是产生了一个新的元组
>>> color[-1][2]
"tiger"

4. 列表类型及操作

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

>>> ls = ["cat", "dog", "tiger", 1024]
>>> ls
["cat", "dog", "tiger", 1024]
>>> lt = ls.
>>> lt
["cat", "dog", "tiger", 1024]
# 方括号[]真正创建一个列表，赋值仅传递引用

函数或方法	描述
ls = 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]
>>> ls[1:2] = [1, 2, 3, 4]
["cat", 1, 2, 3, 4, "tiger", 1024]
#  0    1  2  3  4     5       6
#  ×    √  √  ×  √     √       ×
>>> del ls[::3]
[1, 2, 4, "tiger"]
>>> ls * 2
[1, 2, 4, "tiger", 1, 2, 4, "tiger"]

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

>>> ls = ["cat", "dog", "tiger", 1024]
>>> ls.append(1234)
["cat", "dog", "tiger", 1024, 1234]
>>> ls.insert(3, "human")
["cat", "dog", "tiger", "human", 1024, 1234]
>>> ls.reverse()
[1234, 1024, 'human', 'tiger', 'dog', 'cat']

# 定义空列表lt
>>> lt = []
# 向lt新增5个元素
>>> lt += [1, 2, 3, 4, 5]
# 修改lt中第2个元素
>>> lt[2] = 6
# 向lt中第2个位置增加一个元素
>>> lt.insert(2, 7)
# 从lt中第1个位置删除一个元素
>>> del lt[1]
# 删除lt中第1-3位置元素
>>> del lt[1:4]
# 判断lt中是否包含数字0
>>> 0 in lt
# 向lt新增数字0
>>> lt.append(0)
# 返回数字0所在lt中的索引
>>> lt.index(0)
# lt的长度
>>> len(lt)
# lt中最大元素
>>> max(lt)
# 清空lt
>>> lt.clear()

5. 序列类型应用场景

• 元组用于元素不改变的应用场景，更多用于固定搭配场景

• 列表更加灵活，他是最常用的序列类型

• 最主要作用：表示一组有序数据，进而操作它们

• 元素遍历

for item in tp:
	<语句块>

for item in ls:
	<语句块>

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

>>> ls = ["cat", "dog", "tiger", 1024]
>>> lt = tuple(ls)
>>> lt
("cat", "dog", "tiger", 1024)

6.3 实例9: 基本统计值计算

1. “基本统计值计算”问题分析

• 需求：给出一组数，对他们有个概要理解
• 该怎么做呢？
• 总个数：len()
• 求和：for … in
• 平均值：求和/总个数
• 方差：各数据与平均数差的平方的和的平均数
• 中位数：排序，然后奇数找中间1个，偶数找中间2个取平均

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("平均值：{}，方差：{}，中位数：{}。".format(m, dev(n, m), median(n)))

3. “基本统计值计算”举一反三

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

6.4 字典类型及操作

1. 字典类型定义

• 映射：一种键（索引）和值（数据）的对应
• 序列类型由0…N整数作为数据的默认索引
• 字典类型则由用户为数据定义索引
• 键值对：键是数据索引的扩展
• 字典是键值对的集合，键值对之间无序
• 采用大括号{ }和dict()创建，键值对用冒号:表示
• [ ]用来向字典变量中索引或添加元素

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

>>> d = {"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
>>> d
{"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
>>> d["中国"]
"北京"
# type(x)
# 返回变量x的类型
>>> de = {}; type(de)
<class 'dict'>

2. 字典处理函数及方法

函数或方法	描述
d[k]	索引或赋值
del d[k]	删除字典d中键k对应的数据值
k in d	判断键k是否在字典d中，如果在返回True，否则False
d.keys()	返回字典d中所有的键信息
d.values()	返回字典d中所有的值信息
d.items()	返回字典d中所有的键值对信息
d.get(k, <default>)	键k存在，则返回相应值，不在则返回<default>值
d.pop(k, <default>)	键k存在，则取出相应值，不在则返回<default>值
d.popitem()	随机从字典d中取出一个键值对，以元组形式返回
d.clear()	删除所有的键值对
len(d)	返回字典d中元素的个数

>>> d = {"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
>>> "中国" in d
True
>>> d.keys()
dict_keys(['中国', '美国', '法国'])
>>> d.values()
dict_values(['北京', '华盛顿', '巴黎'])
>>> d.get("中国", "伊斯兰堡") 
'北京'
>>> d.get("巴基斯坦", "伊斯兰堡") 
'伊斯兰堡'
>>> d.popitem()                   
('法国', '巴黎')

# 定义空字典d
>>> d = {}
# 向d新增2个键值对元素
>>> d["a"] = 1; d["b"] = 2
# 修改第2个元素
# 字典中的元素并没有顺序关系，这里指对之前增加的第2个元素d["b"] = 2进行修改
>>>  d["b"] = 3
# 判断字符"c"是否是d的键
>>> "c" in d
# 计算d的长度
>>> len(d)
# 清空d
>>> d.clear()

3. 字典类型应用场景

• 映射的表达
  • 映射无处不在，键值对无处不在
  • 例如：统计数据出现的次数，数据是键，次数是值
  • 最主要的作用：表达键值对数据，进而操作它们
• 元素遍历

for k in d:
	<语句块>

>>> d = {"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
>>> for k in d:
...     print(k)  
中国
美国
法国

6.5 模块5: jieba库的使用

1. jieba库基本介绍

• jieba是优秀的中文分词第三方库，需要额外安装
• 中文文本需要通过分词获得单个的词语
• jiaba库提供三种分词模式，最简单只需掌握一个函数
• jieba利用一个中文词库，确定汉字之间的关联概率
• 汉字间概率大的组成词组，形成分词结果
• 除了分词，用户还可以添加自定义的词组

cmd命令行
pip install jieba

2. jieba库使用说明

• 精确模式：把文本精确的切分开，不存在冗余单词，返回一个列表类型的分词结果
• 全模式：把文本中所有可能的词语都扫描出来，有冗余，返回一个列表类型的分词结果
• 搜索引擎模式：在精确模式基础上，对长词再次切分
• jieba.lcut(s) → list cut
• jieba.add_word(w)：向分词词典增加新词w

函数	模式或方法	描述
jieba.lcut(s)	精确模式	>>>jieba.lcut("中国是一个伟大的国家") ['中国', '是', '一个', '伟大', '的', '国家']
jieba.lcut(s, cut_all=True)	全模式	>>>jieba.lcut("中国是一个伟大的国家", cut_all=True) ['中国', '国是', '是', '一个', '伟大', '的', '国家']
jieba.lcut_for_search(s)	搜索引擎模式	>>>jieba.lcut_for_search("中华人民共和国是伟大的") ['中华', '华人', '人民', '共和', '共和国', '中华人民共和国', '是', '伟大', '的']
jieba.add_word(w)	向分词词典增加新词w	>>>jieba.add_word("蟒蛇语言")

6.6 实例10: 文本词频统计

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

# CalHamletV1.py
def getText():
    txt = open("hamlet.txt", "r").read()
    txt = txt.lower()
    for ch in '!"#$%&()*+,-./:;<=>?@[\\]^_‘{|}~':
        txt = txt.replace(ch, " ")   #将文本中特殊字符替换为空格
    return txt

hamletTxt = getText()
# 以空格为分隔符，包含 \n，返回分割后的字符串列表
words = hamletTxt.split() 
counts = {}
for word in words:			
    counts[word] = counts.get(word, 0) + 1
items = list(counts.items())
# lambda函数：返回函数名来作为结果，是一种匿名函数，没有名字，使用lambda保留字定义，函数名是返回结果
# 用于定义简单的，能够在一行内表示的函数
# 用法：<函数名>=lambda<参数>:<表达式>
# sort()函数默认升序
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))

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

# CalThreeKingdomsV1.py
# 并不能完成人物出场统计，只能是统计文章中分词的出现频率
import jieba
txt = open("threekingdoms.txt", "r", encoding='utf-8').read()
words = jieba.lcut(txt)
counts = {}
for word in words:
# 如果word的长度为1，即只有一个字
    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))

# CalThreeKingdomsV2.py
# 需要根据词频结果不断优化
import jieba
# excludes中不是人名，但词频排名靠前
excludes = {"将军", "却说", "荆州", "二人", "不可", "不能", "如此"}
txt = open("threekingdoms.txt", "r", encoding='utf-8').read()
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))

3. “文本词频统计”举一反三

• 《红楼梦》、《西游记》、《水浒传》…
• 政府工作报告、科研论文、新闻报道…
• 词云