How to get domain of words using WordNet in Python?

As @alvas suggests, you can use WordNetDomains. You have to download both WordNet2.0 (in its current status WordNetDomains does not support the sense inventory of WordNet3.0, which is the default version of WordNet used by NLTK) and WordNetDomains.

• WordNet2.0 can be downloaded from here

• WordNetDomains can be downloaded from here (after having being granted permission).

I have created a very simple Python API that loads both resources in Python3.x and provides some common routines you might need (such as getting a set of domains linked to a given term, or to a given synset, etc.). The data load of WordNetDomains is from @alvas.

This is how it looks like (with most comments omitted):

from collections import defaultdict
from nltk.corpus import WordNetCorpusReader
from os.path import exists


class WordNetDomains:
    def __init__(self, wordnet_home):
        #This class assumes you have downloaded WordNet2.0 and WordNetDomains and that they are on the same data home.
        assert exists(f'{wordnet_home}/WordNet-2.0'), f'error: missing WordNet-2.0 in {wordnet_home}'
        assert exists(f'{wordnet_home}/wn-domains-3.2'), f'error: missing WordNetDomains in {wordnet_home}'

        # load WordNet2.0
        self.wn = WordNetCorpusReader(f'{wordnet_home}/WordNet-2.0/dict', 'WordNet-2.0/dict')

        # load WordNetDomains (based on https://stackoverflow.com/a/21904027/8759307)
        self.domain2synsets = defaultdict(list)
        self.synset2domains = defaultdict(list)
        for i in open(f'{wordnet_home}/wn-domains-3.2/wn-domains-3.2-20070223', 'r'):
            ssid, doms = i.strip().split('t')
            doms = doms.split()
            self.synset2domains[ssid] = doms
            for d in doms:
                self.domain2synsets[d].append(ssid)

    def get_domains(self, word, pos=None):
        word_synsets = self.wn.synsets(word, pos=pos)
        domains = []
        for synset in word_synsets:
            domains.extend(self.get_domains_from_synset(synset))
        return set(domains)

    def get_domains_from_synset(self, synset):
        return self.synset2domains.get(self._askey_from_synset(synset), set())

    def get_synsets(self, domain):
        return [self._synset_from_key(key) for key in self.domain2synsets.get(domain, [])]

    def get_all_domains(self):
        return set(self.domain2synsets.keys())

    def _synset_from_key(self, key):
        offset, pos = key.split('-')
        return self.wn.synset_from_pos_and_offset(pos, int(offset))

    def _askey_from_synset(self, synset):
        return self._askey_from_offset_pos(synset.offset(), synset.pos())

    def _askey_from_offset_pos(self, offset, pos):
        return str(offset).zfill(8) + "-" + pos

I think that you can use the spacy library as well see code below:

Code is taken from this official spacy-wordnet website https://pypi.org/project/spacy-wordnet/:

import spacy

from spacy_wordnet.wordnet_annotator import WordnetAnnotator 

# Load an spacy model (supported models are "es" and "en")  nlp = spacy.load('en') nlp.add_pipe(WordnetAnnotator(nlp.lang), after='tagger') token = nlp('prices')[0]

# wordnet object link spacy token with nltk wordnet interface by giving acces to
# synsets and lemmas  token._.wordnet.synsets() token._.wordnet.lemmas()

# And automatically tags with wordnet domains token._.wordnet.wordnet_domains()

# Imagine we want to enrich the following sentence with synonyms sentence = nlp('I want to withdraw 5,000 euros')

# spaCy WordNet lets you find synonyms by domain of interest
# for example economy economy_domains = ['finance', 'banking'] enriched_sentence = []

# For each token in the sentence for token in sentence:
    # We get those synsets within the desired domains
    synsets = token._.wordnet.wordnet_synsets_for_domain(economy_domains)
    if synsets:
        lemmas_for_synset = []
        for s in synsets:
            # If we found a synset in the economy domains
            # we get the variants and add them to the enriched sentence
            lemmas_for_synset.extend(s.lemma_names())
            enriched_sentence.append('({})'.format('|'.join(set(lemmas_for_synset))))
    else:
        enriched_sentence.append(token.text)

# Let's see our enriched sentence print(' '.join(enriched_sentence))
# >> I (need|want|require) to (draw|withdraw|draw_off|take_out) 5,000 euros

Branching off of @sel’s answer, I used spacy_wordnet (which uses nltk.wordnet under the hood).

import spacy
from spacy_wordnet.wordnet_annotator import WordnetAnnotator  # must be imported for pipe creation

nlp = spacy.load("en_core_web_md")  # I was using medium, but may be able to get away with small

# this adds `wordnet` capabilities to your tokens when processed by the `nlp` pipeline
nlp.add_pipe("spacy_wordnet", after="tagger", config={"lang": nlp.lang})

# your words
words = ["transaction", "Demand Draft", "cheque", "passbook"]

for word in words:
    # process text with spacy
    doc: spacy.tokens.Doc = nlp(word)
    
    for token in doc:
        # get all wordnet domains for token
        token_wordnet_domains = token._.wordnet.wordnet_domains()
        print(token, token_wordnet_domains)

As an example for the word "transaction", this will print out:

transaction ['social', 'diplomacy', 'book_keeping', 'money', 'finance', 'industry', 'economy', 'telephony', 'tax', 'exchange', 'betting', 'law', 'commerce', 'insurance', 'banking', 'enterprise']

You can check if "banking" is in the domains with a conditional:

for word in words:
    # convert each word into a spacy.tokens.Doc
    doc: spacy.tokens.Doc = nlp(word)
    
    for token in doc:
        # get all wordnet domains for token
        token_wordnet_domains = token._.wordnet.wordnet_domains()
        # print(token, token_wordnet_domains)
        print(token, "banking" in token_wordnet_domains)

Output:

transaction True
Demand True
Draft True
cheque True
passbook True