Вопрос по коду

with open(file_name, 'r') as f:
  content = f.read()
words = content.split(' ')
count = {}
for word in words:
  if word not in count.keys():
    count[word] = 0
  count[word]++

#!/usr/bin/python3
import re
from collections import Counter

data = open('bigtestfile.txt').read().lower()
c = Counter(re.findall(r'\w+-?\w+', data))

for word,n in c.most_common():
    suf = 'а'  if n%10 in [2,3,4] and n%100 not in [12,13,14]  else  ''
    print('%s встречается %i раз%s' % (word.rjust(20), n, suf))

#include <string>
#include <iostream>
#include <fstream>
#include <list>
#include <map>
#include <sys/time.h>

int main() {
	struct timeval initTime;
	gettimeofday(&initTime, NULL);
	int initMinis = initTime.tv_sec * 1000 + initTime.tv_usec / 1000;

	std::ifstream file;
	file.open("bigtestfile.txt");
	std::list<std::string> words;
	std::string word;
	while (file >> word) {
		words.push_back(word);
	}
	file.close();
	
	struct timeval readedTime;
	gettimeofday(&readedTime, NULL);
	int readedMinis = readedTime.tv_sec * 1000 + readedTime.tv_usec / 1000;

	std::cout << "Readed\n";
	std::map<std::string, int> counts;
	for (std::list<std::string>::iterator it = words.begin(); it != words.end(); it++) {
		std::string word = *it;
		if (counts.find(word) == counts.end()) {
			std::cout << word << "\n";
			counts.insert(std::pair<std::string, int>(word, 0));
		}
		counts[word]++;
	}
	
	struct timeval readyTime;
	gettimeofday(&readyTime, NULL);
	int readyMinis = readyTime.tv_sec * 1000 + readyTime.tv_usec / 1000;

	for (std::map<std::string, int>::iterator it = counts.begin(); it != counts.end(); it++) {
		std::cout << it->first << " " << it->second << "\n";
	}

	std::cout << "Read time : " << readedMinis - initMinis << " ms\nCount time : " << readyMinis - readedMinis << " ms\n";
}

Read time : 1874 ms
Count time : 4293 ms

grep -Poi '[a-zа-я]+' bigtestfile.txt | sort | uniq -c > bigresult.txt

if word in counts

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>

//////////////////////////////////
#define WORD_TAB_SIZE 1024
#define WORD_MAX_LENGTH 1024
#define ISALNUM(c) (isalpha (c) || (c) == '_')

typedef struct word_st {
    struct word_st *next;
    int   counter;
    char  str[];
}word_t;

word_t *words[WORD_TAB_SIZE] = {0};
///////////////////////////////////////////////////////////
unsigned str_hash (char *str)
{
    unsigned int idx = 0;

    while (*str) {
        idx = (idx * 31) + (unsigned int) *str++;
    }
    return (idx % WORD_TAB_SIZE);
}

word_t *word_new (char *str)
{
    int len = strlen (str) + 1;
    word_t *w;

    w = malloc (sizeof (word_t) + len);
    strcpy (w->str, str);
    w->counter = 1;
    w->next = NULL;
    return w;
}

void word_count (char *str)
{
    int idx = str_hash (str);
    word_t *prev, *cur;
    int cmp;

    for (prev = NULL, cur = words[idx];
         cur != NULL;
         prev = cur, cur = cur->next) {

        cmp = strcmp (cur->str, str);
        if (cmp < 0)
            break;
        if (cmp == 0) {
            cur->counter++;
            return;
        }
    }
    cur = word_new (str);
    if (prev != NULL) {
        cur->next = prev->next;
        prev->next = cur;
    } else {
        cur->next = words[idx];
        words[idx] = cur;
    }
}

void words_report ()
{
    word_t *w;
    int i;

    for (i = 0; i < WORD_TAB_SIZE; i++) {

        for (w = words[i]; w != NULL; w = w->next) {
            printf ("%20s\t%d\n", w->str, w->counter);
        }
    }
}

int main ()
{
    char word[WORD_MAX_LENGTH];
    enum { STATE_INIT, STATE_WORD} state = STATE_INIT;
    int c, idx;

    idx = 0;
    while ((c = fgetc (stdin)) != EOF) {
        
        switch (state) {
            case STATE_INIT:
                if (ISALNUM (c)) {
                    word[idx++] = tolower (c);
                    state = STATE_WORD;
                }
                break;

            case STATE_WORD:
                if (!ISALNUM (c)) {
                    word[idx] = 0;
                    word_count (word);
                    idx = 0;
                    state = STATE_INIT;
                } else if (idx < WORD_MAX_LENGTH - 1) {
                    word[idx++] = tolower (c);
                }
                break;
        }
    }

    if (state == STATE_WORD) {
        word[idx] = 0;
        word_count (word);
    }
    words_report ();
    return 0;
}

<dictionary-keyiterator object at 0x7f4a9b6b7940>
Without: 41
<listiterator object at 0x7f4a9b7ab450>
With.keys():  424051

$ python -V
Python 3.5.2

<dict_keyiterator object at 0x7f1679f34908>
Without: 51
<dict_keyiterator object at 0x7f1679f34908>
With.keys():  51