python计算机二级相关操作

python计算机二级的操作题感觉考查的第一个点是对python中各种数据结构的熟练使用，例如列表、集合、元组、字典、字符串以及各种数据结构组合之后的使用，常见的为for循环中进行遍历列表、字典、元组等可迭代类型，还有就是对列表、字典的使用lambda表达式对其进行由小到大进行排序或者是由大到小进行排序，使用字典对字符或者数字进行计数等等，反正主要是常见数据结构的使用，一般不会涉及算法。for循环遍历会经常结合range函数，range函数可以产生一个长度为k的int类型的列表，所以使用for i in 遍历range函数产生的数字列表时候相当于是为循环确定遍历的范围，并且一般遍历列表、字典也是使用for ..... in ()，其中（）为可迭代的各种数据类型，一般为列表、字符串、字典这些。

考查的第二个点是能够使用turtle库绘制几何图形，其实这个是操作题中最简单的题目，就是几个例如前进、顺时钟旋转或者是逆时钟旋转一定角度方法的使用，掌握计算正n边形内角和公式即可：（n - 2）* 180 // n即可计算出每一次旋转的角度

考查的第三个点是能够使用第三方分词jieba库对文本文件（文本文件对应的字符串）进行分词，经常使用到的一个方法是jieba.lcut(line)，其中line为字符串类型，lcut方法分词之后得到的是列表类型，并且分词之后一般需要将词语写入到另一个txt文件中或者是输出到控制台中，使用"".join()方法连接列表中的每一个词语得到对应的字符串，而且分词之后还会涉及到文件的读取与写入操作（涉及到读取与写入文件的各种文件模式：a,w,b...），读取的方法包括：整行读取使用readline()，方法返回值为str字符串类型，整个文件读取使用read()和readlines()方法，read方法返回值为str字符串类型，readlines()方法返回的是包含文件中每一行字符串内容的列表类型。写入文件的方法使用逐行写入的write(s)方法，s为要写入的字符串，writelines()方法用于向文件中写入一个序列的字符串，这一序列字符串可以是由迭代对象产生的，如一个字符串列表。

并且在调用各个方法的时候需要注意的一个点是需要明白当前方法调用的返回值是list列表呢，还是str字符串呢还是其他的数据类型，只有明确这一点才可以对返回值进行进一步的操作（切片操作等）

简单应用：

python计算机二级常见的画图操作为绘制各种常见的几何图形，例如正方形、等边三角形、菱形等图形，这个时候就需要使用到python中的一个库：turtle，里面有几个比较常用的方法：turtle.left(),turtle.right(),turtle.fd(),turtle.seth()，其中turtle.left(),turtle.right()是用来向左、向右来旋转一定角度，并且这个角度是相对的，是相对于当前海龟的前进方向的角度，turtle.fd()表示前进一段距离，turtle.seth()也是用来旋转一定角度但是他是相对于海龟一开始的前进方向的，相当于是绝对角度，海龟一开始的前进方向为：---------------------->,下面是使用这几个方法画出的图形：其中在绘制图形的时候需要计算多边形每个内角的度数，这个时候就需要利用到多边形每个内角计算公式：（n - 2）* 180  // n，已知多边形内角角度那么就可以确定每一次转动的角度

菱形：

import turtle
if __name__ == '__main__':
    turtle.right(-30)
    turtle.fd(200)
    turtle.right(60)
    turtle.fd(200)
    turtle.right(120)
    turtle.fd(200)
    turtle.right(60)
    turtle.fd(200)
    turtle.right(120)

等边三角形：

import turtle as t
if __name__ == '__main__':
    for i in range(3):
        # turtle函数库中的seth设置一个旋转角度
        t.seth(i * 120)
        t.fd(200)

正五边形：

import turtle
if __name__ == '__main__':
    turtle.pensize(2)
    d = 0
    for i in range(1, 6):
        turtle.fd(100)
        d += 72
        turtle.seth(d)

正十二边形：首先是需要计算出正十二每个内角的度数：（12 - 2） * 180 // 12 = 150，所以每次转动的角度为30，可以使用turtle.seth(30)，而每次转动的角度是一样的在循环中每次转动30度即可

import turtle
if __name__ == '__main__':
    turtle.pensize(2)
    # 首先计算出正十二边形的内角的角度
    d = 0
    for i in range(1, 13):
        turtle.fd(40)
        d += 30
        turtle.seth(d)

选举问题：

1. 使用字典和列表型变量完成村长选举。某村有40名有选举权和被选举权村民,名单由考生文件夹下文件name.txt给出,从这40名村民中选出一人当长,40人的投票信息由考生文件夹下文件vote.txt给出,每行是一张选票的信息。有效票中得票最多的村民当选。

问题1：请从vote.txt中筛选出无效票写入文件vote1.txt。有效票的含义是:选票中只有一个名字且该名字在name.txt文件列表中,不是有效票的票称为无效票.

问题2：给出当选村长的名字及其得票数.

在考生文件夹下给出了程序框架文件PY202.py,补充代码完成程序。

对于问题1直接使用readlines()读取vote.txt与name.txt文件，readlines()方法返回值为包含每一行字符串内容的列表，然后遍历这个列表并且判断当前遍历的元素是否在name.txt中，存在则进行计数，对于问题2，那么就需要在遍历的时候使用字典进行计数（字典的一个强大的功能就是映射与计数的作用），然后对将字典转换为列表（列表中每一个元素为元组类型）进行排序，最后输出列表中第一个元素也即对应元组中的两个值即可

简单应用中经常会使用到字典中出现的最大次数中对应的键值对，这个时候就需要将字典转换为列表进行排序，而不是直接对字典进行排序，转换为列表进行排序的好处是排序之后能够使用下标来访问列表中的第一个元素，列表中每个元素类型为元组类型，排序之后就可以直接输出下标为0的元素对应的就是最大次数对应的键值对，下面是经常会使用到的对字典排序的几句代码：

li = list(d.items())

li.sort(key=lambda x: x[1], reverse=True)  # 使用lambda表达式对列表进行排序，x[1]为列表中元组中的第二个元素，整个意思是按照列表中元组中的第二个元素由大到小进行排序，sort函数会直接修改原来的列表

print(li[0][0], li[0][1])    # 因为列表的元素为元组类型，所以li[0]表示列表中的第一个元素，li[0][0]表示列表中第一个元素中元组中的第一个值

if __name__ == '__main__':
    f = open("name.txt")
    names = f.readlines()
    f.close()
    f = open("vote.txt")
    votes = f.readlines()
    f.close()
    f = open("vote1.txt", "w")
    D = {}
    NUM = 0
    for vote in votes:
        num = len(vote.split())
        if num == 1 and vote in names:
            D[vote[:-1]] = D.get(vote[:-1], 0) + 1
            NUM += 1
        else:
            f.write(vote)
    f.close()
    # 将字典转化为列表这样排序之后才可以使用下标进行访问第一个元素内容
    l = list(D.items())
    # 使用lambda表达式式进行排序
    l.sort(key=lambda s: s[1], reverse=True)
    name = l[0][0]
    score = l[0][1]
    print("有效票数为：{} 当选村长村民为:{},票数为：{}".format(NUM, name, score))

综合应用：

使用字典对文件中的字符进行计数，并且对字典中的键值对使用lambda表达式进行排序：

1. 考生文件夹下存在3个Python源文件,分别对应3个问题,1个文本文件,作为本题目输入数据,请按照源文件内部说明修改代码,实现以下功能
《命运》是著名科幻作家倪匡的作品。这里给出《命运》的一个网络版本文件,文件名为“命运.txt“。
问题1(5分)：在PY301-1.py文件中修改代码,对“命运.txt“文件进行字符频次统计,输出频次最高的中文字符(不包含标点符号)及其频次,字符与频次之间采用英文冒号“:“分隔,示例格式如下:
理:224.

问题2(5分)：在PY301-2.py文件中修改代码,对“命运.txt“文件进行字符频次统计,按照频次由高到低,屏幕输出前10个频次最高的字符,不包含回车符,字符之间无间隔,连续输出,示例格式如下:
理斯卫…(后略,共10个字)

问题3(10分)：在PY301-3.py文件中修改代码,对“命运.txt“文件进行字符频次统计,将所有字符按照频次从高到低排序,字符包括中文、标点、英文等符号,但不包合空格和回车。将排序后的字符及频次输出到考生文件夹下,文件名为“命运-频次排序.txt。字符与频次之间采用英文冒号“:“分隔,各字符之间采用英文逗号“,“分隔,参考CSV格式,最后无逗号,文件内部示例格式如下:
理:224,斯:120,卫:100
提示：建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序。

问题1：

if __name__ == '__main__':
    # 打开文件
    f = open("命运.txt", "r+")
    # 读取文件, 返回整个文件对应的字符串内容
    txt = f.read()
    # 使用字典记录词频
    d = {}
    for i in txt:
        if i not in "，。？！《》【】“”；‘’":
            d[i] = d.get(i, 0) + 1
    # 将字典转换为列表,列表中每个元素为元组类型,转换为列表排序之后就可以使用列表中的索引进行访问
    ls = list(d.items())
    # x[1]表示按照列表元素中的第二个元素进行排序, reverse=True表示按照由大到小进行排序
    ls.sort(key=lambda x: x[1], reverse=True)
    #ls[0]表示列表中的第一个元素, ls[0][0]表示列表中第一个元素对应元组中的第一个值
    print("{}:{}".format(ls[0][0], ls[0][1]))

问题2：

if __name__ == '__main__':
    f = open("命运.txt", "r+")
    # read方法返回值为str
    txt = f.read()
    d = {}
    for i in txt:
        if i not in " \n":
            d[i] = d.get(i, 0) + 1
    ls = list(d.items())
    ls.sort(key=lambda x: x[1], reverse=True)  # 此行可以按照词频由高到低排序
    for k in range(10):
        print(ls[k][0], end="")

问题3：

if __name__ == '__main__':
    f = open("命运.txt", "r+")
    fi = open("命运-频次.txt", "w")
    # read方法返回值为str
    txt = f.read()
    d = {}
    for i in txt:
        if i not in "\n":
            d[i] = d.get(i, 0) + 1
    ls = list(d.items())
    ls.sort(key=lambda x: x[1], reverse=True)  # 此行可以按照词频由高到低排序
    s = ""
    for k in ls:
        s += "{}:{}".format(k[0], k[1]) + ","
    fi.write(s[:-1])
    f.close()
    fi.close()

2. 读取文件将符合要求的内容写入到文件中：其中readlines()方法中读取的是整个文件的内容，返回的是一个包含每一行字符串内容的一维列表，我们通过遍历的得到的每一行的字符串对其进行分割，并且需要注意在判断的时候需要去除空格或者是在earpa001前加上空格进行判断这样才可以将编号为earpa001的传感器通过write方法以字符串的形式写入到earpa001.txt文件中

考生文件夹下存在两个Python源文件,分别对应两个问题,请按照文件内说明修改代码,实现以下功能：
下面所示为一套由公司职员随身佩戴的位置传感器采集的数据,文件名称为“sensor-txt，其内容示例如下:
2016/5/310:05,vawelon001,1,1
2016/5/310:20,earpa001,1,1
2016/5/312:26,earpa001,1,6
(....略)
第一列是传感器获取数据的时间,第二列是传感器的编号,第三列是传感器所在的楼层,第四列是传感器所在的位置区域编号.
问题1(10分)：在PY301-1.py文件中修改代码,读入sensor.txt文件中的数据,提取出传感器编号为earpa001的所有数据,将结果输出保存到"earpa001.txt"文件。输出文件格式要求:原数据文件中的每行记录写入新文件中,行尾无空格,无空行。参考格式如下:

2016/5/31 7:11, earpa001,2,4

2016/5/31 8:02, earpa001,3,4

20161/5/31 9:22, earpa001,3,4

…略)

问题2(10分)：在PY301-2.py文件中修改代码,读入"earpa001.txt"文件中的数据,统计earpa001对应的职员在各楼层和区域出现的次数,保存到"earpa001_count.txt"文件,每条记录一行,位置信息和出现的次数之间用英文半角逗号隔开,行尾无空格,无空行。参考格式如下。
1-15
1-43
…略)
含义如下:
第1行1-1,5中1-1表示1楼1号区域,5表示出现5次:
第2行1-4,3中1-4表示1楼4号区域,3表示出现3次:
提示建议使用本机提供的Python集成开发环境IDLE编写、调试及验证程序.

if __name__ == '__main__':
    f = open("sensor.txt", "r", encoding="UTF-8")
    fo = open("earpa001.txt", "w")
    txt = f.readlines()
    for line in txt:
        # strip的返回值是一个字符串, split函数返回值为一个字符串列表
        t = line.strip("\n").split(",")
        # 输出t的内容可以查看到列表中存在换行符
        # print(t[1])
        # 注意文本文件中某些字符串之间存在空格
        if t[1].strip(" ") == "earpa001":
            fo.write('{},{},{},{}\n'.format(t[0], t[1], t[2], t[3]))
    f.close()
    fo.close()

问题2：首先是使用readlines方法读取整个文件得到包含每一行字符串内容，使用split方法对其进行分割，然后楼层与区域拼接的字符串，使用字典进行记录字符串出现的次数即可，最后字典中的内容通过write方法写入到文件中

if __name__ == '__main__':
    f = open("earpa001.txt", "r", encoding="UTF-8")
    fo = open("earpa001_count.txt", "w")
    d = {}
    txt = f.readlines()
    for i in txt:
        # 使用strip方法去除换行符, split方法返回的是一个列表
        cur = i.strip("\n").split(",")
        # 拼接字符串
        t = cur[2] + "-" + cur[3]
        d[t] = d.get(t, 0) + 1
    ls = list(d.items())
    ls.sort(key=lambda x: x[1], reverse=True)  # 该语句用于排序
    for i in ls:
        fo.write("{},{}\n".format(i[0], i[1]))
    f.close()
    fo.close()

3. 使用jieba库对读取的文件中的字符串进行分词（使用jieba.lcut方法进行分词），并且将分词之后的词语写入到txt文件中，使用字典统计某个词语出现的次数

《三国演义》是中国古典四大名著之一，曹操是其中主要人物,考生文件夹文件"data.txt"给出《三国演义》简介。
问题1：请编写程序,用Python语言中文分词第三方库jieba对文件"data.txt"行分词,并将结果写入文件out.txt每行一个词例如:
内容简介
整个
故事
在
东汉
在考生文件夹下给出了程序框架文件PY301-1.py补充代码完成程序(10分)
问题2：对文件out.txt进行分析,打印输出曹操出现次数.
在考生文件夹下给出了程序框架文件PY301-2.py,补充代码完成程序(10分)

问题1：

import jieba
if __name__ == '__main__':
    f = open("data.txt", "r")
    lines = f.readlines()
    f.close()
    f = open("out.txt", "w")
    for line in lines:
        # 删除每一行可能出现的空格
        line = line.strip()
        # 对每一行内容进行分词, lcut方法返回的是一个list列表
        wordList = jieba.lcut(line)
        f.writelines("\n".join(wordList))

问题2：

if __name__ == '__main__':
    f = open('out.txt', 'r')  # 以读的方式打开文件
    words = f.readlines()
    f.close()
    D = {}
    for w in words:  # 词频统计
        D[w[:-1]] = D.get(w[:-1], 0) + 1
    print("曹操出现次数为:{}  ".format(D["曹操"]))

4. 根据用户的输入输出对应的内容，主要是读取文件和遍历文件，在遍历文件每一行内容的过程中匹配相应的内容进行输出

考生文件夹下存在三个Python源文件,分别对应三个问题,请按照文件内说明修改代码,实现以下功能:
二十多年前希腊的天文学家希巴克斯命名十二星座,它们是水瓶座、双鱼座、白羊座、金牛座、双子座、巨融座、狮子座、处女座、天秤座、天蝠座、射手座、摩羯座。给出一个CSV文件(PY301-Sunsign.csv),内容示例如下:
序号,星座开始月日,结束月日,Unicode
1,水瓶座.120,218,9810
2,双色座,219,320,9811
3,白羊座,321,419,9800
4,金牛座420,520,9801
5,双子座,521,621,9802
...(略)
以第1行为例.120表示1月20日,218表示2月18日,9810是Unicode码。
问题1(5分)：在PY301-1.py文件中修改代码,读入CSV文件中数据,获得用户输入。根据用户输入的星座名称,输出此星座的出生日期范围.
参考输入和输出示例格式如下:
请输入星座中文名称(例如,双子座):双子座
双子座的生日位于521-621之间
问题2(10分)：在PY301-2.py文件中修改代码,读入CSV文件中数据,获得用户输入。用户键盘输入一组范围是1-12的整数作为序号,序号间采用空格分隔,以回车结束。
屏幕输出这些序号对应的星座的名称、字符编码以及出生日期范围,每个星座的信息一行。本次屏幕显示完成后,重新回到输入序号的状态.
参考输入和输出示例格式如下:
请输入星座序号(例如,5):5 10
双子座(9802)的生日是5月21日至6月21日之间
天蝎座(9807)的生日是10月24日至11月22日之间
请输入星座序号(例如,5):
问题3(5分)：在问题2的基础上,在PY301-3.py文件中修改代码,对键盘输入的每个序号做合法性处理。如果输入的数字不台法,请输出“输入星座编号有误！继续输出
后续信息,然后重新回到输入序号的状态。
参考输入和输出示例格式如下:
请输入星座序号(例如,5):5 14 11
双子座(9802)的生日是5月21日至6月21日之间
输入星座序号有误!
射手座(9808)的生日是11月23日至12月21日之间
请输入星座序号(例如,5):

问题1：

if __name__ == '__main__':
    sunSign = input("请输入星座中文名称(例如, 双子座): ")
    f = open("PY301-SunSign.csv", "r")
    # 可以直接遍历f对象
    csv = f.readlines()
    for line in csv:
        # 注意csv文件按照逗号进行分割
        cur = line.strip("\n").split(",")
        if sunSign == cur[1]:
            print("{}的生日位于{}-{}之间".format(cur[1], cur[2], cur[3]))
            f.close()
            break

问题2：

if __name__ == '__main__':
    f = open("PY301-SunSign.csv", "r")
    ls = []
    ls = f.readlines()
    while True:
        s = input("请输入星座序号(例如, 5): ")
        for i in s.split():
            for line in ls:
                it = line.strip("\n").split(",")
                if i == it[0]:
                    # 这里主要是使用了负数索引进行切片操作, [-2:]-2表示从倒数第二个元素开始一直到结尾
                    print("{}({})的生日是{}月{}日至{}月{}日之间".format(it[1], it[4], it[2][:-2], it[2][-2:], it[3][:-2], it[3][-2:]))

问题3：

if __name__ == '__main__':
    f = open("PY301-SunSign.csv", "r")
    ls = []
    ls = f.readlines()
    while True:
        s = input("请输入星座序号(例如, 5): ")
        for i in s.split():
            if 0 < int(i) <= 12:
                flag = False
            else:
                flag = True
            for line in ls:
                it = line.strip("\n").split(",")
                if i == it[0]:
                    # 这里主要是使用了负数索引进行切片操作
                    print("{}({})的生日是{}月{}日至{}月{}日之间".format(it[1], it[4], it[2][:-2], it[2][-2:], it[3][:-2], it[3][-2:]))
                    break
            if flag:
                print("输入星座序号有误!")

5. 使用jieba库对文件中的内容进行分词，并且将符合条件的词语写入到文件中，要求词语不重复那么就需要在分词之后统计曾经出现过的词语，可以使用列表或者是字典记录进行记录

考生文件夹下的文件data.txt是一个来源于网上的技术信息资料.
问题1：(10分)在考生文件夹下给出了程序框架文件PY301-1.py,补充代码完成程序。用Python语言中文分词第三方库jieba对文件data.txt进行分词,并选择长度大于等于3个字符的关键词,写入文件out1.txt,每行一个关键间,各行的关键词不重复,输出顺序不做要求,例如:
人工智能
科幻小说
问题2：(10分)在考生文件夹下给出了程序框架文件PY301-2.py,补充代码完成程序。对文件data.txt进行分词,对长度不少于3个字符的关键词,统计出现的次数,按照出现次数由大到小的顺序输出到文件out2.txt,每行一个关键词及其出现次数,例如:
科学家:2
达特茅斯:1
问题1：

import jieba
if __name__ == '__main__':
    f = open("data.txt", "r")
    lines = f.readlines()
    f.close()
    d = []
    for line in lines:
        wordList = jieba.lcut(line)
        for word in wordList:
            if len(word) >= 3 and word not in d:
                d.append(word)
    f = open("out1.txt", "w")
    # writelines方法写入一个可迭代对象
    f.writelines("\n".join(d))

问题2：

import jieba
if __name__ == '__main__':
    f = open("data.txt", "r")
    lines = f.readlines()
    f.close()
    d = {}
    for line in lines:
        line = jieba.lcut(line)
        for word in line:
            if len(word) >= 3:
                d[word] = d.get(word, 0) + 1
    # 对字典进行排序, 使用sorted函数对字典进行排序之后得到的是一个列表, 列表中的元素为元组类型
    d = sorted(d.items(), key=lambda x: x[1], reverse=True)
    res = list()
    for cur in d:
        # 使用format函数格式化字符串添加到列表中也可以
        res.append(cur[0] + ":" + str(cur[1]))
    f = open("out2.txt", "w")
    f.writelines("\n".join(res))

6. 某班学生评选一等奖学金,学生的10门主干课成绩存在考生文件夹下文件score.txt中,每行为一个学生的信息,分别记录了学生学号、姓名以及10门课成绩格式如下:
1820161043 郑珉镐 68 66 83 77 56 73 61 69 66 78
1820161044 沈红伟 91 70 81 91 96 80 78 91 89 94
从这些学生中选出奖学金候选人,条件是:1)总成绩排名在前10名;2)全部课程及格(成绩大于等于60)
问题1：给出按总成绩从高到低排序的前10名学生名单,并写入文件candidate0.txt,每行记录一个学生的信息,分别为学生学号、姓名以及10门课成绩、补充考生文件夹下文件PY301-1.py,完成这一功能。
问题2：读取文件candidate0.txt,从中选出候选人,并将学号和姓名写入文件candidate.txt格式如下:
1010112161722张三
1010112161728李四
补充考生文件夹下文件PY301-2.py.完成这一功能。

问题1：根据代码中给出的提示框架：L.sort(key=lambda x: x[-1], reverse=True)中x[-1]可以知道我们需要在读取文件的过程中计算每一位学生的总成绩并且加入到列表的末尾，最后根据这个总成绩由高到低对学生进行排序（排序的是二维列表，列表元素为每一位学生的信息，x[-1]表示按照学生的总成绩进行排序），问题2：读取文件的过程中遍历每位学生的分数，这里需要设置一个标志用来记录在遍历的过程中是否存在不及格的分数，当遍历每一行的循环结束通过这个标志根据成绩是否合格决定是否将当前的学生信息写入到文件中

问题1：

if __name__ == '__main__':
    fi = open("score.txt", "r")
    fo = open("candicate0.txt", "w")
    L = []  # L中的元素是学生原始成绩和总成绩
    D = []
    # 直接遍历文件中的每一行
    for line in fi:
        # 每个学生的总成绩
        s = 0
        D = line.strip("\n").split()
        for i in D[2:]:
            s += int(i)
        D.append(s)
        L.append(D)
    # 对学生按照总分由小到达进行排序(根据对L排序的参数可以知道需要将总分加入遍历的列表中)
    L.sort(key=lambda x: x[-1], reverse=True)  # 按学生总成绩从大到小排序
    # 将排名前10的学生写入到文件中
    for k in range(10):
        fo.write(" ".join(L[k][:-1]) + "\n")
    fi.close()
    fo.close()

问题2：

if __name__ == '__main__':
    fi = open("candicate0.txt", "r")
    fo = open("candicate.txt", "w")
    for line in fi:
        cur = line.split()
        flag = 1
        for i in cur[2:]:
            if int(i) < 60:
                flag = 0
                break
        if flag:
            # 使用切片操作获取每一行的前面两个元素并且使用空格进行分割
            fo.write(" ".join(cur[:2]) + "\n")
    fi.close()
    fo.close()

7. 提取网页中的内容，并且写入到txt文件中，主要是读取文件判断文件中当前行是否存在目标内容，然后根据网页文件内容使用split函数对其进行分割获取对应的学校名称即可（需要分析网页内容的结构）

考生文件夹下的文件data.txt是教育部中国大学MOOC平台的某个HTML页面源文件,里面包含了我国参与MOOC建设的一批大学或机构列表。
问题1：请编写程序,从data.txt中提取大学或机构名称列表,将结果写入文件univ.txt,每行一个大学或机构名称,按照大学或机构在data.txt出现的先后顺序输出,样例如下:
北京理工大学
北京师范大学
提示:所有大学名称在data.txt文件中以alt=“北京理工大学“形式存在。在考生文件夹下给出了程序框架文件PY301-1.py,补充代码完成程序(10分)
问题2：请编写程序,从univ.txt文件中提取大学名称,大学名称以出现“大学“或“学院“字样为参考,但不包括“大学生“等字样,将所有大学名称在屏幕上输出,大学各行之间没有空行,最后给出名称中包含“大学“和“学院“的名称数量,同时包括“大学“和“学院“的名称以结尾的词作为其类型。样例如下(样例中数量不是真实结果):
北京理工大学
长沙师范学院
包含大学的名称数量是10
包含学院的名称数量是10
在考生文件夹下给出了程序框架文件PY301-2.py,补充代码完成程序(10分)
问题1：

if __name__ == '__main__':
    f = open("data.txt", "r")
    lines = f.readlines()
    f.close()
    f = open("unix.txt", "w")
    for line in lines:
        if "alt" in line:
            # -1表示倒数第一个元素
            dx = line.split("alt=")[-1].split('"')[1]
            f.write("{}\n".format(dx))
            # f.write(dx + "\n")
    f.close()

问题2：

if __name__ == '__main__':
    f = open("unix.txt", "r")
    lines = f.readlines()
    n, m = 0, 0
    f.close()
    for line in lines:
        if "大学生" in line: continue
        elif "大学" in line:
            print("{}".format(line), end="")
            n += 1
        elif "学院" in line:
            print("{}".format(line), end="")
            m += 1
    print("包含大学的名称数量{}".format(n))
    print("包含学院的名称数量{}".format(m))

8. 使用jieba库进行分词，统计出现次数最多的前10个词语，统计两个文件中出现的共有词语与各自的特有词语，对于问题1可以先使用read方法读取整个文件，得到整个文件对应的字符串然后使用jieba.lcut方法进行分词，遍历lcut方法分词之后得到的列表使用字典统计各个词语出现的次数，最后将字典转为列表之后进行排序，输出排序之后列表的前10个词语即可，对于问题2我们可以先得到两个文件中排名前10的词语，然后使用两层循环找出出现次数前10的词语中的共有词语，然后不在共有词语的说明它就是特有的词语，循环中进行判断即可。

考生文件夹下存在2个Python源文件和2个文本文件。其中,2个python源文件对应2个问题,2个文本文件分别摘自2019年和2018年的政府工作报告。请分别补充2个
Python源文件,实现以下功能.
问题1(10分)：数据统计。要求:修改PY301-1.py文件中代码,分别统计两个文件中出现次数最多的10词语,作为主题词,要求词语不少于2个字符,打印输出在屏幕上,输出示例如下：示例词语非答案)
2019:改革:10,企业:9..,(略),深化:2
2018:改革:11,效益:7..,(略),深化:1
注意:输出格式采用英文冒号和英文逗号,标点符号前后无空格,各词语间用逗号分隔,最后一个词语后无逗号。
问题2(10分):数据关联、要求:修改PY301-2.py文件中代码,对比两组主题词的差异,输出两组的共有词语和分别的特有词语、输出示例如下:(示例词语非答案)
共有词语:改革,...(略)深化
2019特有:企业,...(略)加强
2018特有效益,...(略)创新
注意:输出格式采用英文冒号和英文逗号,标点符号前后无空格,各词语间用逗号分隔,最后一个间语后无逗号。

问题1：

import jieba


# 因为都是读取两个文件所以使用一个方法进行处理
def textProcess(path, year):
    f = open(path, "r")
    # read方法返回值为str
    data = f.read()
    words = jieba.lcut(data)  # lcut函数返回的是一个列表
    # 使用字典对词语进行记录
    d = {}
    for word in words:
        if len(word) == 1:
            continue  # 长度为1的词语略过
        else:
            d[word] = d.get(word, 0) + 1
    # 将字典转换为列表
    d = list(d.items())
    d.sort(key=lambda x: x[1], reverse=True)
    print(year + ":", end="")
    for i in range(10):
        # 因为最后一行是没有逗号的所以需要提前判断一下, d[i]表示列表中的第i个元素
        if i < 9:
            print("{}:{}".format(d[i][0], d[i][1]), end=",")
        else:
            print("{}:{}".format(d[i][0], d[i][1]))


if __name__ == '__main__':
    textProcess("data2019.txt", "2019")
    textProcess("data2018.txt", "2018")

问题2：

import jieba


# 一个方法用来记录两个文件中出现次数最多的十个词语
def textProcess(path):
    f = open(path, "r")
    data = f.read()
    words = jieba.lcut(data)
    d = {}
    for word in words:
        if len(word) == 1:
            continue
        else:
            d[word] = d.get(word, 0) + 1
    d = list(d.items())
    d.sort(key=lambda x: x[1], reverse=True)
    return d


if __name__ == '__main__':
    data_2019 = textProcess("data2019.txt")
    data_2018 = textProcess("data2018.txt")
    da, db = {}, {}
    for i in range(10):
        da[i] = data_2019[i][0]
        db[i] = data_2018[i][0]
    common = "共有词语:"
    for i in range(10):
        flag = 0
        for j in range(10):
            if da[i] == db[j]:
                flag = 1
                break
        if flag: common += da[i] + ","
    # -1表示输出到倒数第二个元素, 也就是不输出逗号
    print(common[:-1])
    p = "2019特有:"
    for i in range(10):
        if da[i] not in common:
            p += da[i] + ","
    print(p[:-1])
    p = "2018特有:"
    for i in range(10):
        if db[i] not in common:
            p += db[i] + ","
    print(p[:-1])

9.  对于问题1可以使用read方法读取整个文件，read返回整个文件对应的字符串，然后遍历这个字符串，判断当前的字符是否是需要清理的字符如果不是那么拼接在需要写入到另外一个文件的字符串变量中，问题2可以使用jieba进行分词，然后遍历lcut方法得到的分词列表判断词语长度大于等于3的那么记录到字典中

考生文件夹下,存在2个Python源文件和1个文本文件。其中,2个Python源文件对应2个问题,文本文件“data.txt中包含一篇从互联网上下载的关于“德国工业4.0战略规划实施建议摘要“的文章。请分别补充2个Python源文件,完成以下功能。
问题1(10分)：文件内容清洗。要求:在文件PY301-1.py中补充代码,对文件data.txt的内容进行清理,去除中文标点符号,只保留中文、英文、数字、英文标点符号等字符,将结果输出到文件clean.txt中。示例如下:
德国工业4.0战略计划实施建议摘缉机械工业信息研究院战略与规化研究所一德国实施工业…(略)
问题2(10分)：提取主题词及其出现频次。要求:在文件PY301-2.py中补充代码,提取clean.txt文件中长度不少于3个字符的词语并统计词频,将词频最高的10个词语作为主题词,并将主题词及其频次输出到屏幕。示例如下:
4.0:10,制造业:9..(略)
注意.输出格式采用英文冒号和英文逗号,标点符号前后无空格,各词语中间用逗号分隔,最后一个间语后无逗号。

问题1：

if __name__ == '__main__':
    f = open("data.txt", "r", encoding="UTF-8")
    # 使用read方法读取整个文件
    txt = f.read()
    f.close()
    f = open("clean.txt", "w")
    s = ""
    for c in txt:
        if c not in "（）【】！。￥‘’“”？，《》\n：、 ；-":
            s += c
    f.write(s)
    f.close()

问题2：

import jieba
if __name__ == '__main__':
    f = open("clean.txt", "r")
    data = f.read()
    l = jieba.lcut(data)
    d = {}
    for i in l:
        if len(l) >= 3:
            d[i] = d.get(i, 0) + 1
    It = list(d.items())
    It.sort(key=lambda x: x[1], reverse=True)
    # sep属性规定输出的多个对象之间的连接符
    for i in It[:9]:
        print(i[0], ":", i[1], end=",", sep="")
    print(It[9][0], ":", It[9][1], sep="")

10. 主要是读取文件、剔除文件中的停用词，统计词频

考生文件夹下存在2个文本文件,文本文件“红楼梦.txt“中包含了《红楼梦》小说前20章内容,“停用词.txt“包含了需要排除的词语。请修改模板,实现以下功能
1. 对“红楼梦.txt“中文本进行分词,并对人物名称进行归-化处理,仅归一化以下内容:
凤姐、凤姐儿、凤丫头归-为凤姐
宝玉、二爷、宝二爷归-为宝玉
黛玉、智儿、林姊妹、黛玉道归-为黛玉
宝钗、宝丫头归一为宝钗
贾母、老祖宗归-为贾母
袭人、袭人道当一为袭人
贾政、贾政道归一为贾政
贾链、琏二爷归一为贾球
2. 不统计“停用词.txt文件中包含词语的词频.
3. 提取出场次数不少于40次的人物名称,将人物名称及其出场次数按照递减排序,保存到result.csv文件中,出场次数相同的.则按照人物名称的字符顺序排序.
输出示例：
宝玉,597
凤姐,296
一个,279
如今,132
黛玉,113
一面,112

import jieba
if __name__ == '__main__':
    txt = jieba.lcut(open("红楼梦.txt", "r", encoding="UTF-8").read())
    stop_words = list()
    with open("停用词.txt", "r", encoding="UTF-8") as f:
        # splitlines函数按照\n \r进行分割
        for i in f.read().splitlines():
            # 将停用词追加到列表中
            stop_words.append(i)
    # 剔除停用词
    txt0 = [x for x in txt if x not in stop_words]
    # 统计词频
    counts = {}
    # 归一化处理
    for word in txt0:
        if len(word) == 1: continue
        elif word == "凤姐儿" or word == "风丫头":
            rword = "凤姐"
        elif word == "二爷" or word  == "宝二爷":
            rword = "宝玉"
        elif word == "颦儿" or word == "林妹妹" or word == "黛玉道":
            rword = "黛玉"
        elif word == "宝丫头":
            rword = "宝钗"
        elif word == "老祖宗":
            rword = "贾母"
        elif word == "袭人道":
            rword = "袭人"
        elif word == "贾政道":
            rword = "贾政"
        elif word == "琏二爷":
            rword = "贾琏"
        else:
            rword = word
        counts[rword] = counts.get(rword, 0) + 1
    li = list(counts.items())
    li.sort(key=lambda x: x[1], reverse=True)
    with open("result.csv", "a", encoding="gbk") as f:
        for i in li:
            key, value = i
            if value < 40:
                break
            f.write(key + "," + str(value) + "\n")
            print(key + "," + str(value))

11. 读取文件将对应章节的内容写入到文件中，感觉这是一道比较好的文件处理题目，问题1：主要是食堂readlines读取整个文件，依次遍历readlines返回每一行内容的列表，然后根据split分割之后的内容判断当前行是否是题目如果是那么写入文件即可，对于问题2可以可以先找出每一章的标题，然后记录下每一章标题对应的行号，通过遍历readlines方法得到的每一行，将之前记录的行号将相邻两个章节的行号通过空串进行拼接然后使用lcut方法进行分词，通过遍历分词结果将词语出现的次数记录在字典中，最后将字典转换为列表进行排序，输出列表中第一个元素内容即可，表示每一章出现的最多次数最多的词语是什么

请按照源文件内部说明修改代码,实现以下功能
附件中保存1个文本文件,分别对应2个问题
其中,文本文件"八十天环游地球.txt"是法国作家儒勒.凡尔纳《八十天环游地球》长篇小说的网络版本,请修改源文件实现以下功能.
问题1：提取章节题目并输出到文件。
要求:在模板中补充代码,提取“八十天环游地球.txt中所有章节的题目,并且将提取后的题目输出到"八十天环游地球-章节.txt"文件中,每行一一个标题,示例如下-
第一章 斐利亚福克和路路通建立主仆关系
第二章 路路通认为他总算找到了理想的工作
第三章 一场可能使福克先生破财的争论
第四章 斐利亚-福克把路路通吓得目瞪口呆
第五章 伦敦市场上出现了一种新的股票
问题2：统计每章节的高频词并打印输出。
要求:在模板补充代码,统计“八十天环游地球.txt“中每一章的标题和内容中,出现次数最多的词语(词语长度不少于2个字符及其次数,输出格式为章节名、词语及其出现次数,以空格分隔,示例如下:
问题1：

if __name__ == '__main__':
    f = open("八十天环游地球.txt", "r", encoding="UTF-8")
    fi = open("八十天环游地球-章节.txt", "w", encoding="UTF-8")
    for i in f:
        # 取出分割之后的第一个元素
        txt = i.split()[0]
        if txt[0] == "第" and txt[-1] == "章":
            fi.write("{}\n".format(i.strip("\n")))
    fi.close()

问题2：

import jieba
if __name__ == '__main__':
    f = open("八十天环游地球.txt", "r", encoding="UTF-8")
    datas = f.readlines()
    l = list()
    # 计算出每一章开始时的行数后面就可以通过拼接每一章的行数直接的内容进行分词了
    for i in range(len(datas)):
        line = datas[i].split()
        if line[0][0] == "第" and line[0][-1] == "章":
            l.append(i)
    for i in range(len(l)):
        if i != len(l) - 1:
            data = "".join(datas[l[i]:l[i + 1]])
        else:
            data = "".join(datas[l[i]:])
        s = data.split()[0]
        words = jieba.lcut(data)
        d = {}
        for word in words:
            if len(word) >= 2:
                d[word] = d.get(word, 0) + 1
        lis = list(d.items())
        lis.sort(key=lambda x: x[1], reverse=True)
        # 输出每一行中出现次数最多的词语
        print(s, lis[0][0], lis[0][1])
    f.close()