0

So I was going though nltk and saw this code

entities = nltk.chunk.ne_chunk(tagged)

Now my question is that how do you people know which method to use when and what is the order of method calls?

Another strange code I saw was 

nltk.corpus.words.words('en')

Now how would one interpret .words followed by .words? Why did we call words method twice here & how do I know when I need to call a method twice?

I just finished "Udacity - Intro. to CS (with Python)" but this "nltk" is getting way too confusing. Please help, have been struggling to get the logic of all these since couple of days.

Improve this question
4
  • 7
    how do you people know which method to use when? we check the documentation, try to understand the types involved, write some code and fail a few times. Then we eventually learn how to use a lib. Commented Aug 26, 2013 at 12:14
  • 4
    nltk.corpus.words.words('en') sounds like poor naming on someone's part. The first words isn't a method call - note the parentheses after the second on and not the first. It might be a variable or module. Commented Aug 26, 2013 at 12:14
  • 1
    It's not poor naming. It's very poor naming. Commented Aug 26, 2013 at 12:17
  • nltk.corpus.words.words('en') taken from section 3.4 of nltk.org/book/ch03.html Commented Aug 26, 2013 at 12:22

2 Answers 2

Reset to default
8

You are not calling words twice. You are calling the words method of words module. It's all about namespaces and modules. Read more about Python modules.

:)

Improve this answer
Sign up to request clarification or add additional context in comments.

7 Comments

Followed that chapter. So according to section 6.4 its nltk/corpus/words/words.py being called/accessed as nltk.corpus.words.words , am I right ? So I have to be aware of this directory structure and modules in each subdirectory/directory & their function in order to access them ?
No. Module nltk/corpus/words has defined (poorly) a method called "words". You can play with namespaces like this: import nltk.corpus.words as words_module and after that, just simple call "words" method with words_module.words(...)
This is what I tried : - 1.] import nltk.corpus as nc ("WORKS"), 2.] import nltk.corpus.words.words as ncw ( "ImportError: No module named words.words") , 3.] import nltk.corpus.words as ncw ("ImportError: No module named words") Why these different behaviors ?
So this is what I found out: "nltk.corpus.words" is an object from "WordListCorpusReader" class. That is the reason you cannot import it. That class is defined in nltk.corpus.reader.wordlist, and you can see the code here -> nltk.org/_modules/nltk/corpus/reader/wordlist.html. So with the whole dotted notation, you are accessing to "words" method definded inside WordListCorpusReader class, referenced by "words" object defined inside "nltk.corpus" package.
You can get all he info typing: >>> dir(nltk.corpus) # Extensive package info >>> nltk.corpus.words.__class__ #<class 'nltk.corpus.reader.wordlist.WordListCorpusReader' >>>> nltk.corpus.WordListCorpusReader.__class__ <type 'type'>
|
3

The . character in Python is not only for accessing methods. It denotes attribute access in some object. What exactly that means may depend on what the object is.

In your examples, nltk.chunk and nltk.corpus.words are both names of modules. nltk is a package which is a special kind of module that can contain other modules. So is nltk.corpus. (And actually, nltk.chunk is also a package, but you're using it as a regular module, rather than accessing another module within it.)

In nltk.chunk.ne_chunk(tagged), the dots access the chunk attribute in the nltk module, then the ne_chunk attribute within the nltk.chunk module. That happens to be a function, which gets called.

In nltk.corpus.words.words('en'), the third dot looks up the words attribute within the nltk.corpus.words module.

Improve this answer

4 Comments

Technically, . is used only for attribute access. A method is simply a callable attribute.
Cud u help me understnd stepwise 1.]import nltk 2.]from nltk.corpus import words 3.]nltk.corpus.words <WordListCorpusReader in '.../corpora/words' (not loaded yet)> 4.]nltk.corpus.words.words <bound method WordListCorpusReader.words of <WordListCorpusReader in '~/nltk_data/corpora/words'>> Question is,how do I even know when to use nltk.corpus.words & when use nlt.corpus.words.words? Shall I memorize it? Do coders memorize such stuff? If no then,how do u people know (& from where) about these arrangements,that whether it should be x.foo.bar.blah OR x.blah.foo.hush? Pls,Im totally confused
@vinita: I think you're being thrown off by the fact that nltk.corpus.words.words has words twice. That's a design decision by the library designers (and as a bunch of other commenters have said, it may be a bad design). There are no rules about how deep a given thing will be, it depends on the design of the modules and packages in question. As for needing to memorize locations, I think that's optional. If you don't remember a function's exact location, you can always check the docs for a refresher. You'll probably learn the locations of things you use often, just by repeated use.
Hmm thanks,BTW I found that this interactivepython.org/runestone/static/thinkcspy/PythonModules/… addresses my question. Heres a line from the link "But what if no one had told us about turtle? How would we know that it exists. How would we know what it can do for us?". It addresses my questions and confusion.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.