python

怎么统计词频？

发布时间：2024-08-30 14:14

访问量：0

来源：破盾编程

一、怎么统计词频？

方案一：借助Excel如果使用场景是偶尔统计一篇文章不长的词频，可以使用excel：（Excel 2007~2013的版本里，一个单元格最多容纳32,767个字符，也就是说目标文章不能超过32,767个字，不然就得分割开统计）（如果经常使用，可以给Excel录制宏）

步骤1：统计一个字词、两个字词、三个字词、四个字词……n个字词出现的频率

注：

B3单元格内输入的是目标文章全文

C3是全文字数（含标点符号），D3内容即是C3所用的公式

B6是序号1~序号1276

C6的公式含义为在B3里取目标字符，该目标是从第B6个字符开始，字符长度为1，D6为C6公式内容

E6为统计C6~C1281区间内，C6这个字符出现的频率

为便于显示文末部分，Excel第16行至1269行的内容已隐藏。

如果文章为英文，那更简单，可以将B3内容以空格为分列符号进行分列操作：选中B3，点击菜单[数据]-[分列]-[分隔符号]，勾选[空格]，完成。完成后单词会按“一个单词占一个单元格”形式列为1行。全选后复制、“选择性粘贴”-“转置”，即可将单词列为上图C列的效果，再同样用F列的公式统计一次即可。

步骤2：将上述统计表格以“选择性张贴”-“粘贴值”形式粘贴到第二张Sheet，对各颜色区域分别作词频降序排序（例：同时选中B4、C4，按Ctrl+Shift+L，对词频降序排序，后同）

步骤3：选中一种颜色区域，作“删除重复项”操作，其余颜色区域操作相同。工具位置见鼠标指针

步骤4：将双字词、三字词、四字词等内容进行人工删选，删去不是词语的部分，忽略词频较少的部分，汇总后即为词频统计结果。

注：由于没有词库，此部分只能人工删选。如果有词库，可以将上表结果合并成B、C两列（词语、词频两列），再在第三列D粘贴词库，第四列E再作一次countif公式，如：E5=COUNTIF(D:D,B5)，统计B5在词库中出现的次数。E列的结果只有2种：1（B列的词语存在于词库D中），0（B列的词语不存在于词库D中）。然后对E列结果作筛选，仅显示结果为“1”的内容，隐藏D列，结果就出来了。方案二，使用工具：

汉语词频统计工具

与网上流传的词频统计软件相比，这款比较简单，只能统计中文，但免费。得到统计数据后还需借用Excel排序下。.

二、vivo词频统计设置？

点击文件-项目信息-项目特性-常规-文本内容语言-中文

三、hadoop词频统计原理？

Hadoop词频统计是一种分布式处理技术，它可以帮助我们快速地统计一个文本文件中每个单词的出现次数。它的原理是：

1. 首先，将文本文件分割成多个小块，每个小块都可以被一个Hadoop节点处理。

2. 然后，每个节点从自己的小块中读取每个单词，并统计每个单词出现的次数。

3. 接着，每个节点将自己统计出来的结果发送给主节点，主节点将所有节点发送过来的结果进行汇总，得到最终的结果。

Hadoop词频统计的优点是：

1. 它可以快速地处理大量的文本文件，因为它可以将文件分割成多个小块，每个小块都可以被一个Hadoop节点处理。

2. 它可以提供高可用性和可扩展性，因为它可以添加更多的节点来处理更多的文本文件。

3. 它可以提供高性能，因为它可以利用分布式计算来提高处理速度。

Hadoop词频统计的缺点是：

1. 它可能会出现数据倾斜，因为它可能会出现某些节点处理的数据量比其他节点处理的数据量大得多的情况。

2. 它可能会出现网络延迟，因为它需要在不同的节点之间传输数据，而这种传输可能会受到网络延迟的影响。

四、excel词频统计怎么倾斜？

修改了自定义函数，可以直接统计斜体字体的单元格数量。注意，由于设置字体为斜体不会触发计算，因此这时统计的结果不会改变，需要点击单元格回车使到公式强制重新计算 Function CountFontItalic(R As Range) As Long Dim C As Range CountFontItalic = 0 For Each C In R.Cells If C.Font.Italic Then CountFontItalic = CountFontItalic + 1 Next End Function 增加自定义函数的方法说明：对准工作表标签击右键选取查看代码，弹出VBA窗口后，在左边窗口对准工作表名称，比如Sheet1 (Sheet1)，击右键，选择插入>模块，在右边窗口贴入代码。关闭VBA窗口

五、知网词频怎么统计？

词频，是一种用于情报检索与文本挖掘的常用加权技术，用以评估一个词对于一个文件或者一个语料库中的一个领域文件集的重复程度。词频统计为学术研究提供了新的方法和视野。操作如下：

1、选择要统计词频的文本。

2、打开文本并读取文本open("文件名.txt","r")，这里是txt=open("命运.txt","r").read()。

3、使用循环依次读取文本中的每个字符，并且替换掉文本中的换行符。

4、创建字典类型，对字符出现的次数进行累加。

5、字典中出现的字符按照【值】的大小进行排序。

6、输出需要统计的词频的数目即可。

六、emeditor 如何快速统计词频？

试试看DiVoMiner吧，excel导入平台，用统计分析做词云图，一秒出图，还可以编辑词。

具体方法见下：

如何制作词云图？ - DiVoMiner 支援中心

七、如何做词频统计？

题目：

第0步：输出某个英文文本文件中 26 字母出现的频率，由高到低排列，并显示字母出现的百分比，精确到小数点后面两位。

第1步：输出单个文件中的前 N 个最常出现的英语单词。作用：一个用于统计文本文件中的英语单词出现频率。

设计思想：首先是统计字母，我们应该先把要统计的文件读取，遍历统计字母出现的次数，将大写字母转换为小写字母；统计单词也需要将大写字母转换为小写，只要遇到空格则记为一个单词，遍历一遍统计单词个数。

 import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Scanner;
import java.awt.List;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.io.FileOutputStream;  
import java.io.PrintStream;
import java.text.NumberFormat;
public class tongji {
public static void main(String[] args) {
    File src =new File("c:/Harry Potter and the Sorcerer's Stone.txt");
    InputStream is=null;
   try {
    is=new FileInputStream(src);
    int temp;
    int[] p=new int[56];
    while((temp=is.read())!=-1)//当数据为不存在时，返回-1
    {
        char t=(char)temp;
        if(t=='a'||t=='A')
        {
            p[0]++;
        }
        if(t=='b'||t=='B')
        {
            p[1]++;
        }
        if(t=='c'||t=='C')
        {
            p[2]++;
        }
        if(t=='d'||t=='D')
        {
            p[3]++;
        }
        if(t=='e'||t=='E')
        {
            p[4]++;
        }
        if(t=='f'||t=='F')
        {
            p[5]++;
        }
        if(t=='g'||t=='G')
        {
            p[6]++;
        }
        if(t=='h'||t=='H')
        {
            p[7]++;
        }
        if(t=='i'||t=='I')
        {
            p[8]++;
        }
        if(t=='j'||t=='J')
        {
            p[9]++;
        }
        if(t=='k'||t=='K')
        {
            p[10]++;
        }
        if(t=='l'||t=='L')
        {
            p[11]++;
        }
        if(t=='m'||t=='M')
        {
            p[12]++;
        }
        if(t=='n'||t=='N')
        {
            p[13]++;
        }
        if(t=='o'||t=='O')
        {
            p[14]++;
        }
        if(t=='P'||t=='p')
        {
            p[15]++;
        }
        if(t=='q'||t=='Q')
        {
            p[16]++;
        }
        if(t=='r'||t=='R')
        {
            p[17]++;
        }
        if(t=='S'||t=='s')
        {
            p[18]++;
        }
        if(t=='t'||t=='T')
        {
            p[19]++;
        }
        if(t=='u'||t=='U')
        {
            p[20]++;
        }
        if(t=='v'||t=='V')
        {
            p[21]++;
        }
        if(t=='w'||t=='W')
        {
            p[22]++;
        }
        if(t=='X'||t=='x')
        {
            p[23]++;
        }
        if(t=='Y'||t=='y')
        {
            p[24]++;
        }
        if(t=='z'||t=='Z')
        {
            p[25]++;
        }
                        }
    int[] y=new int[26];
    for(int r=0;r<26;r++)
    {
        y[r]=p[r];
    }
    
    int templ=0;
    for(int i=0;i<26;i++) 
    {
    templ+=p[i];
    }
    float qq=(float)templ;
    int te;
    //冒泡排序
    for(int g=0;g<24;g++)
    {
    for(int f=0;f<24-g;f++) 
    {
        if(p[f]<p[f+1])
        {
            te=p[f];
            p[f]=p[f+1];
            p[f+1]=te;
        }
    }}
    for(int j=0;j<26;j++) {
        NumberFormat nt = NumberFormat.getPercentInstance();//获取百分数实例
        nt.setMinimumFractionDigits(2);//保留百分数后两位
        char w=' ';
        for(int b=0;b<26;b++) {
            if(p[j]==y[b]) {
                switch (b) {
                case 0:
                    w='a';
                    break;
                case 1:
                    w='b';
                    break;
                case 2:
                    w='c';
                    break;
                case 3:
                    w='d';
                    break;
                case 4:
                    w='e';
                    break;
                case 5:
                    w='f';
                    break;
                case 6:
                    w='g';
                    break;
                case 7:
                    w='h';
                    break;
                case 8:
                    w='i';
                    break;
                case 9:
                    w='j';
                    break;
                case 10:
                    w='k';
                    break;
                case 11:
                    w='l';
                    break;
                case 12:
                    w='m';
                    break;
                case 13:
                    w='n';
                    break;
                case 14:
                    w='o';
                    break;
                case 15:
                    w='p';
                    break;
                case 16:
                    w='q';
                    break;
                case 17:
                    w='r';
                    break;
                case 18:
                    w='s';
                    break;
                case 19:
                    w='t';
                    break;
                case 20:
                    w='u';
                    break;
                case 21:
                    w='v';
                    break;
                case 22:
                    w='w';
                    break;
                case 23:
                    w='x';
                    break;
                case 24:
                    w='y';
                    break;
                case 25:
                    w='z';
                    break;
                default:
                    break;
                }
            }
            }
        
        float q=(float)p[j];
        System.out.println(w+"---"+nt.format(q/qq));
        //System.out.println(p[j]/templ);
    }
    //System.out.println(templ);
    //System.out.println(p[0]);
} catch (FileNotFoundException e) {
    e.printStackTrace();
} catch (IOException e) {
    
    e.printStackTrace();
}finally {
    try {
        is.close();
    } catch (IOException e) {
        e.printStackTrace();
    }}    }}

结果：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.file.NoSuchFileException;
import java.util.*;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class danci{
    public static void main(String[] args) throws IOException{
        ArrayList<String> AL = new ArrayList<String>();
        try {
            FileInputStream IS = new FileInputStream("c:/Harry Potter and the Sorcerer's Stone.txt");
            Scanner S = new Scanner(IS);
            while(S.hasNextLine()){ 
                StringTokenizer st = new StringTokenizer(StringFunc(S.nextLine()));
                while(st.hasMoreTokens()) {
                    AL.add(st.nextToken());
                }
            }
            IS.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        HashFunc(AL);
    }
    
    //handle the string
    public static String StringFunc(String Str) {
        Str = Str.toLowerCase();
        Str = Pattern.compile("[^A-Za-z]+").matcher(Str).replaceAll(" ");
        return Str;
    }
    
    //put elements in a hashtable and count how many times they appear
    public static void HashFunc(ArrayList<String> AL) {
        HashMap<String, Integer> Hmap = new LinkedHashMap<>();
        Collections.sort(AL);
        for (String temp : AL) {
            Integer count = Hmap.get(temp);
            Hmap.put(temp, (count == null) ? 1 : count + 1);
        }
        Iterator iter = Hmap.entrySet().iterator();
        while (iter.hasNext()) {
            Map.Entry entry = (Map.Entry) iter.next();
            Object key = entry.getKey();
            Object val = entry.getValue();
            System.out.println(val + " " + key);
        }    
    }
}

八、词频统计切词的方法？

根据统计出的词频信息作为字典，反过来切词。切词用的算法是正向最大匹配的方法。

九、anaconda如何做词频统计？

File.open("docment") do |f| str=f.read.downcase.split " " a={} str.each do |s| a[s]=str.count(s) if !(a.include? s) end a.sort_by do |s| s[1] end.each |s| puts "#{s[0]} : #{s[1]}" end end 大致这个意思吧，没有考虑把It's等价于It is之类，简单从小到大排序并打印到STDOUT

十、有哪些好用的词频统计软件？

文皮皮

这是一款国产的在线词频统计软件。我上班经常用，很便捷快速。10万字的文章，只需要40秒。实测《十四五规划》63000+字量用了31秒

上一篇：so咖啡

下一篇：c4d泛光灯

热点信息

1
python中怎么查看函数的用法？

在Python中，要查看函数的用法，可以使用以下方法： 1. 使用内置函数help()：在Python交互式环境中，可以直接输入help(函数名)来获取函数的帮助文档。例如，...
2
java 连接数据库

一、java 连接数据库在当今信息时代，Java 是一种广泛应用的编程语言，尤其在与数据库进行交互的过程中发挥着重要作用。无论是在企业级应用开发还是...
3
idea连接mysql数据库

一、idea连接mysql数据库 php connect_error) { die("连接失败: " . $conn->connect_error);}echo "成功连接到MySQL数据库！";// 关闭连接$conn->close();?> 二、idea连接mysql数据库连...
4
python如何安装modbus-tk？

要在Python中安装modbus-tk库，您可以按照以下步骤进行操作： 1. 确保您已经安装了Python解释器。您可以从Python官方网站(https://www.python.org)下载和安装最新版本...