【2023】某python语言程序设计跟学第六周内容

1.集合类型及操作

1.1.集合类型定义

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

• 集合类型与数学中集合概念一致

• 集合元素之间无序，每个元素唯一，不存在相同元素

• 集合元素不可修改，不能是可变数据类型

• 集合用{}表示，元素之间用逗号分隔

• 建立集合类型用{}或set()

• 建立空集合类型，必须使用set()

1.2.集合操作符

集合间有多种操作，常见集合间运算分别为并（|）、交（&）、差（-）、补（^）运算

Python集合有多种集合间运算，以下是常见的集合间运算：

1. 并集：使用 | 或 union() 方法。将两个集合中的所有元素合并成一个集合，不会重复。

   set1 = {1, 2, 3}
   set2 = {3, 4, 5}
   set3 = set1 | set2
   # 或者
   set4 = set1.union(set2)
   print(set3)  # {1, 2, 3, 4, 5}
   print(set4)  # {1, 2, 3, 4, 5}
   

2. 交集：使用 & 或 intersection() 方法。返回两个集合中都包含的元素组成的集合。

   set1 = {1, 2, 3}
   set2 = {3, 4, 5}
   set3 = set1 & set2
   # 或者
   set4 = set1.intersection(set2)
   print(set3)  # {3}
   print(set4)  # {3}
   

3. 差集：使用 - 或 difference() 方法。返回第一个集合中有但第二个集合中没有的元素组成的集合。

   set1 = {1, 2, 3}
   set2 = {3, 4, 5}
   set3 = set1 - set2
   # 或者
   set4 = set1.difference(set2)
   print(set3)  # {1, 2}
   print(set4)  # {1, 2}
   

4. 补集：使用 ^ 或 symmetric_difference() 方法。返回两个集合中不同的元素组成的集合。

   set1 = {1, 2, 3}
   set2 = {3, 4, 5}
   set3 = set1 ^ set2
   # 或者
   set4 = set1.symmetric_difference(set2)
   print(set3)  # {1, 2, 4, 5}
   print(set4)  # {1, 2, 4, 5}
   

这些集合间运算都是基于集合的数学概念而来，可以方便地处理集合中的元素。

除此之外还有（<=、<、>=、>）判断子集关系或包含关系

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(x)：移除S中所有元素
• S.pop(x)：随机返回一个元素，更新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.4.集合类型应用场景

数据去重：集合类型的元素不重复，可用于去除列表等其他集合类型中的重复元素。

ls = ["p", "p", "y", "y", 123]
s = set(ls)
print(s)

lt = list(s)
print(s)

# 输出
{'p', 123, 'y'}
{'p', 123, 'y'}

其他场景还有包括：

1. 集合运算：集合类型支持包括交集、并集、差集等多种集合运算，可用于对多个集合进行操作。
2. 成员检查：集合类型支持快速的成员检查，可用于判断一个元素是否在集合中。
3. 缓存：集合类型支持快速的添加、删除、查找等操作，可用于缓存数据。
4. 数学计算：集合类型支持数学中的集合操作，如求并集、交集等。
5. 过滤数据：集合推导式可用于过滤数据，筛选满足条件的元素。

2.序列类型及操作

2.1.序列类型定义

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

• 序列是一维元素向量，元素类型可以不同
• 类似于数学元素序列
• 元素间由序号引导，通过下标访问序列的特定元素

序列是一个基类类型，不会直接使用序列类型，而是使用他的衍生类型：字符串类型、元组类型、列表类型

在Python中，序列类型的序号从0开始，表示序列中的第一个元素。例如，对于一个包含3个元素的列表，第一个元素的序号为0，第二个元素的序号为1，第三个元素的序号为2。可以使用方括号索引来获取序列中的特定元素，例如：

my_list = [1, 2, 3]
print(my_list[0])  # 输出1
print(my_list[1])  # 输出2
print(my_list[2])  # 输出3

反向从（-1）开始

2.2.序列处理函数及方法

Python中序列类型操作符包括：

1. 索引操作符（[]）：用于获取序列中指定位置的元素，索引从0开始。
2. 切片操作符（[:]）：用于获取序列中指定范围的元素，包括起始位置，但不包括结束位置。
3. 连接操作符（+）：用于连接两个序列，生成一个新的序列。
4. 重复操作符（*）：用于将序列重复多次，生成一个新的序列。
5. 成员操作符（in）：用于检查指定元素是否在序列中。
6. 长度操作符（len()）：用于获取序列的长度。

这些操作符的含义和使用方法可以根据具体的序列类型（如字符串、列表、元组等）来进行理解和应用。

序列类型中通用函数及方法：

通用函数：

1. len(seq)：返回序列的长度。
2. min(seq)：返回序列中的最小值。
3. max(seq)：返回序列中的最大值。
4. sum(seq)：返回序列中所有元素的和。
5. any(seq)：如果序列中的任意一个元素为True，则返回True；否则返回False。
6. all(seq)：如果序列中的所有元素都为True，则返回True；否则返回False。

方法：

1. seq.count(x)：返回元素x在序列中出现的次数。
2. seq.index(x)：返回元素x在序列中第一次出现的索引。
3. seq.append(x)：将元素x添加到序列的末尾。
4. seq.insert(i, x)：将元素x插入到序列中索引为i的位置。
5. seq.pop()：从序列中删除最后一个元素，并返回该元素的值。
6. seq.remove(x)：从序列中删除第一个出现的元素x。
7. seq.reverse()：将序列中的元素反转。
8. seq.sort()：将序列中的元素按照一定规则排序。

2.3.元组类型定义

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

• 元组是一种序列类型，一旦创建就不能被修改
• 使用小括号（）或tuple（）创建，元素间用逗号，分隔
• 可以使用或不适应小括号

元组类型操作：

元组继承序列类型的全部通用操作

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

2.4.列表类型及操作

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

• 列表是一种序列类型，创建后可以随意被修改
• 使用[]或者list()创建，元素间用逗号，分隔

示例：定义一个列表

ls = ["cat", "dog", "tiger", 1024]
print(ls)
lt = ls
# 输出
['cat', 'dog', 'tiger', 1024]
['cat', 'dog', 'tiger', 1024]

此时lt并没有生成一个新列表，而是给ls列表增加一个名称

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 = ["cat", "dog", "tiger", 1024]
print(ls)
ls[1:2] = [1, 2, 3, 4]
print(ls)
del ls[::3]
print(ls)
print(ls*2)
# 输出
['cat', 'dog', 'tiger', 1024]
['cat', 1, 2, 3, 4, 'tiger', 1024]
[1, 2, 4, 'tiger']
[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]
print(ls)
ls.append(1234)
print(ls)
ls.insert(3, "human")
print(ls)
ls.reverse()
print(ls)
# 输出
['cat', 'dog', 'tiger', 1024]
['cat', 'dog', 'tiger', 1024, 1234]
['cat', 'dog', 'tiger', 'human', 1024, 1234]
[1234, 1024, 'human', 'tiger', 'dog', 'cat']

2.5.序列类型应用场景

序列包括元组、列表两种重要的扩展类型

序列类型应用场景：

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

3.实例：基本统计值计算

基本统计值：

• 需求：给出一组数，对它们有个概要理解
• 该怎么做

总个数，求和，平均值，方差，中位数

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

4.字典类型及操作

4.1.字典类型定义

理解“映射”

• 映射是一种键（索引）和值（数据）的对应

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

• 键值对：键是数据索引的扩展
• 字典是键值对的集合，键值对之间无序
• 采用{}或dict()创建，键值对用：表示

d = {"中国":"北京", "美国":"华盛顿"}
print(d)
# 输出
{'中国': '北京', '美国': '华盛顿'}

4.2.字典处理函数及方法

函数及方法：

del d[k]：删除字典d中键k对应的数据值
k in d：判断键k是否在字典d中，如果在返回true，否则返回false
d.keys()：返回字典d中所有的键信息
d.values()：返回字典d中所有的值信息
d.items()：返回字典d中所有的键值对信息

示例：

d = {"中国":"北京", "美国":"华盛顿"}
print(d)
print("中国" in d)
print(d.keys())
# 输出
{'中国': '北京', '美国': '华盛顿'}
True
dict_keys(['中国', '美国'])
dict_values(['北京', '华盛顿'])

列表类型操作函数和方法：

d.get(k, )：键k存在，则返回相应值，不在则返回值
d.pop(k, )：键k存在，则取出相应值，不在则返回值
d.popitem()：随机从字典d中取出一个键值对，以元组形式返回
d.clear()：删除所有键值对

示例：

d = {"中国":"北京", "美国":"华盛顿"}
print(d.get("中国", "汉堡包"))
print(d.get("炸薯条", "汉堡包"))
# 输出
北京
汉堡包
('美国', '华盛顿')

4.3.字典类型应用场景

映射的表达：

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

5.jieba库概述

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

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

安装：在终端运行

pip install jieba

jieba分词需要依靠中文词库

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

jieba分词有三种模式

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

jieba库常用函数：

jieba.cut(s): 分词函数，将文本分成一个个词语并返回一个可迭代的generator对象。
jieba.lcut(s): 精确模式，返回一个列表，包含分词结果中的所有词语。
jieba.lcut(s,cut_all=True)：全模式，返回一个列表类型的分词结果，存在冗余
jieba.lcut_for_search(s): 适用于搜索引擎的分词函数，粒度比较细。
jieba.add_word(s): 向词典中添加新词。

6.实例：文本词频统计

文本词频统计

需求：一篇文章，出现了哪些词？哪些词出现的最多？

6.1.哈姆雷特统计

https://www.python123.io/resources/pye/hamlet.txt

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] = counts.get(word,0) + 1
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))

6.2.三国演义统计

https://www.python123.io/resources/pye/threekingdoms.txt

import jieba
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))