如何计算段落中特定单词的实例数?

时间:2011-12-16 16:22:08

标签: ruby text

我想计算一组单词出现在文本文件中每个段落中的次数。我可以计算一组单词出现在整个文本中的次数。

有人向我建议我的代码真的很麻烦,所以我只想问我想做什么,如果你愿意,你可以查看我底部的代码。

因此,鉴于“frequency_count.txt”中有“apple pear grape melon kiwi”字样,我想知道“apple”在单独文件“test_essay.txt”的每一段中出现的频率,如何经常梨出现等等,然后将这些数字打印成一系列数字,每行对应一个段落。

例如:

apple, pear, grape, melon, kiwi
3,5,2,7,8
2,3,1,6,7
5,6,8,2,3

每行对应一个段落。

我对Ruby非常非常新,所以感谢您的耐心等待。

output_file = '/Users/yirenlu/Quora-Personal-Analytics/weka_input6.csv'
o = File.open(output_file, "r+")

common_words = '/Users/yirenlu/Quora-Personal-Analytics/frequency_count.txt'
c = File.open(common_words, "r")

c.each_line{|$line1|
    words1 = $line1.split
    words1.each{|w1|
        the_file = '/Users/yirenlu/Quora-Personal-Analytics/test_essay.txt'
        f = File.open(the_file, "r")
        rows = File.readlines("/Users/yirenlu/Quora-Personal-Analytics/test_essay.txt")
        text = rows.join
        paragraph = text.split(/\n\n/)
        paragraph.each{|p|
            h = Hash.new
            puts "this is each paragraph"
            p.each_line{|line|
                puts "this is each line"
                words = line.split
                words.each{|w|
                    if w1 == w
                        if h.has_key?(w)
                            h[w1] = h[w1] + 1
                        else
                            h[w1] = 1
                        end
                        $x = h[w1]
                    end
                }
            }
            o.print "#{$x},"
        }
    }
    o.print "\n"
    o.print "#{$line1}"
}

6 个答案:

答案 0 :(得分:1)

如果您习惯使用PHP或Perl,您可能会认为像$line1这样的变量是本地的,但这是一个全局变量。非常不鼓励使用它们,并且严格要求它们的实例数量非常短。在大多数情况下,您可以省略$并使用适当范围的变量。

这个例子也有几乎不可读的缩进,尽管这可能是剪切和粘贴过程的一个神器。

通常你想要的计数器是创建一个默认值为零的哈希值,然后根据需要添加它:

# Create a hash where the default values for each key is 0
counter = Hash.new(0)

# Add to the counters where required
counter['foo'] += 1
counter['bar'] += 2

puts counter['foo']
# => 1
puts counter['baz']
# => 0

你基本上拥有你需要的东西,但是一切都搞得一团糟,只需要更好地组织起来。

答案 1 :(得分:1)

这里有两个单行来计算字符串中单词的频率。

第一个更容易理解,但效果不太好:

txt.scan(/\w+/).group_by{|word| word.downcase}.map{|k,v| [k, v.size]}
# => [['word1', 1], ['word2', 5], ...]

第二个解决方案是:

txt.scan(/\w+/).inject(Hash.new(0)) { |hash, w| hash[w.downcase] += 1; hash}
# => {'word1' => 1, 'word2' => 5, ...}

答案 2 :(得分:1)

如果您使用以下内容,可能会更短,更容易阅读:

  1. CSV库。
  2. 使用地图和块的更实用的方法。
  3. require 'csv'
    
    common_words = %w(apple pear grape melon kiwi)
    text = File.open("test_essay.txt").read
    
    def word_frequency(words, text)
      words.map { |word| text.scan(/\b#{word}\b/).length }
    end
    
    CSV.open("file.csv", "wb") do |csv|
      paragraphs = text.split /\n\n/
      paragraphs.each do |para| 
        csv << word_frequency(common_words, para)
      end
    end
    

    请注意,这是区分大小写的,但如果您想要不区分大小写,那么这是一个小调整。

答案 3 :(得分:0)

计算一个单词出现在文本中的次数:

text = "word aaa word word word bbb ccc ccc"
text.scan(/\w+/).count("word") # => 4

计算一组单词:

text = "word aaa word word word bbb ccc ccc"
wlist = text.scan(/\w+/)
wset = ["word", "ccc"]
result = {}
wset.each {|word| result[word] = wlist.count(word) }
result # => {"word" => 4, "ccc" => 2}
result["ccc"] # => 2

答案 4 :(得分:0)

这个怎么样:

# Create an array of regexes to be used in `scan' in the loop.
# `\b' makes sure that `barfoobar' does not match `bar' or `foo'.
p word_list = File.open("frequency_count.txt"){|io| io.read.scan(/\w+/)}.map{|w| /\b#{w}\b/}
File.open("test_essay.txt") do |io|
    loop do
        # Add lines to `paragraph' as long as there is a continuous line
        paragraph = ""
        # A `l.chomp.empty?' becomes true at paragraph border
        while l = io.gets and !l.chomp.empty?
            paragraph << l
        end
        p word_list.map{|re| paragraph.scan(re).length}
        # The end of file has been reached when `l == nil'
        break unless l
    end
end

答案 5 :(得分:0)

这是一个替代答案,为了简洁而进行了调整(尽管不像我的其他答案那样容易阅读)。

require 'csv'

words = %w(apple pear grape melon kiwi)
text = File.open("test_essay.txt").read

CSV.open("file.csv", "wb") do |csv|
  text.split(/\n\n/).map {|p| csv << words.map {|w| p.scan(/\b#{w}\b/).length}}
end

我更喜欢稍长但更自我记录的代码,但看到它有多小可能很有趣。