The authors provide additional materials for each chapter via the NLTK website at:
http://www.nltk.org/
To comment or ask technical questions about this book, send email to:
bookquestions@oreilly.com
For more information about our books, conferences, Resource Centers, and the
O’Reilly Network, see our website at:
http://www.oreilly.com
Acknowledgments
The authors are indebted to the following people for feedback on earlier drafts of this
book: Doug Arnold, Michaela Atterer, Greg Aumann, Kenneth Beesley, Steven Bethard,
Ondrej Bojar, Chris Cieri, Robin Cooper, Grev Corbett, James Curran, Dan Garrette,
Jean Mark Gawron, Doug Hellmann, Nitin Indurkhya, Mark Liberman, Peter Ljunglöf,
Stefan Müller, Robin Munn, Joel Nothman, Adam Przepiorkowski, Brandon Rhodes,
Stuart Robinson, Jussi Salmela, Kyle Schlansker, Rob Speer, and Richard Sproat. We
are thankful to many students and colleagues for their comments on the class materials
that evolved into these chapters, including participants at NLP and linguistics summer
schools in Brazil, India, and the USA. This book would not exist without the members
of the 
nltk-dev
developer community, named on the NLTK website, who have given
so freely of their time and expertise in building and extending NLTK.
We are grateful to the U.S. National Science Foundation, the Linguistic Data Consor-
tium, an Edward Clarence Dyason Fellowship, and the Universities of Pennsylvania,
Edinburgh, and Melbourne for supporting our work on this book.
We thank Julie Steele, Abby Fox, Loranah Dimant, and the rest of the O’Reilly team,
for organizing comprehensive reviews of our drafts from people across the NLP and
Python communities, for cheerfully customizing O’Reilly’s production tools to accom-
modate our needs, and for meticulous copyediting work.
Finally, we owe a huge debt of gratitude to our partners, Kay, Mimo, and Jee, for their
love, patience, and support over the many years that we worked on this book. We hope
that our children—Andrew, Alison, Kirsten, Leonie, and Maaike—catch our enthusi-
asm for language and computation from these pages.
Royalties
Royalties from the sale of this book are being used to support the development of the
Natural Language Toolkit.
Preface | xix
Add pdf together one file - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
attach pdf to mail merge in word; add pdf pages together
Add pdf together one file - VB.NET PDF File Merge Library: Merge, append PDF files in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET Guide and Sample Codes to Merge PDF Documents in .NET Project
add pdf together one file; acrobat reader merge pdf files
Figure P-1. Edward Loper, Ewan Klein, and Steven Bird, Stanford, July 2007
xx | | Preface
C# Word - Merge Word Documents in C#.NET
C# DLLs: Merge Word File. Add references: Combine and Merge Multiple Word Files into One Using C#. You may also combine more Word documents together.
acrobat merge pdf files; reader merge pdf
C# PowerPoint - Merge PowerPoint Documents in C#.NET
can easily merge and append one PowerPoint document to can be merged and appended together according to Add necessary XDoc.PowerPoint DLL libraries into your
combine pdfs online; pdf mail merge plug in
CHAPTER 1
Language Processing and Python
It is easy to get our hands on millions of words of text. What can we do with it, assuming
we can write some simple programs? In this chapter, we’ll address the following
questions:
1.What can we achieve by combining simple programming techniques with large
quantities of text?
2.How can we automatically extract key words and phrases that sum up the style
and content of a text?
3.What tools and techniques does the Python programming language provide for
such work?
4.What are some of the interesting challenges of natural language processing?
This chapter is divided into sections that skip between two quite different styles. In the
“computing with language” sections, we will take on some linguistically motivated
programming tasks without necessarily explaining how they work. In the “closer look
at Python” sections we will systematically review key programming concepts. We’ll
flag the two styles in the section titles, but later chapters will mix both styles without
being so up-front about it. We hope this style of introduction gives you an authentic
taste of what will come later, while covering a range of elementary concepts in linguis-
tics and computer science. If you have basic familiarity with both areas, you can skip
to Section 1.5; we will repeat any important points in later chapters, and if you miss
anything you can easily consult the online reference material at http://www.nltk.org/. If
the material is completely new to you, this chapter will raise more questions than it
answers, questions that are addressed in the rest of this book.
1.1  Computing with Language: Texts and Words
We’re all very familiar with text, since we read and write it every day. Here we will treat
text as raw data for the programs we write, programs that manipulate and analyze it in
a variety of interesting ways. But before we can do this, we have to get started with the
Python interpreter.
1
VB.NET Word: How to Process MS Word in VB.NET Library in .NET
MSWordDocx.dll", which, when used together with other online tutorial on how to add & insert one powerful & profession imaging controls, PDF document, image to
pdf combine; combine pdf
C# Excel - Merge Excel Documents in C#.NET
SDK, C# developers can easily merge and append one Excel document to Excel documents can be merged and appended together according to Add necessary references:
pdf mail merge; pdf merger
Getting Started with Python
One of the friendly things about Python is that it allows you to type directly into the
interactive interpreter—the program that will be running your Python programs. You
can access the Python interpreter using a simple graphical interface called the In-
teractive DeveLopment Environment (IDLE). On a Mac you can find this under Ap-
plications→MacPython, and on Windows under All Programs→Python. Under Unix
you can run Python from the shell by typing 
idle
(if this is not installed, try typing
python
). The interpreter will print a blurb about your Python version; simply check that
you are running Python 2.4 or 2.5 (here it is 2.5.1):
Python 2.5.1 (r251:54863, Apr 15 2008, 22:57:26)
[GCC 4.0.1 (Apple Inc. build 5465)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>
If you are unable to run the Python interpreter, you probably don’t have
Python installed correctly. Please visit http://python.org/ for detailed in-
structions.
The 
>>>
prompt indicates that the Python interpreter is now waiting for input. When
copying examples from this book, don’t type the “
>>>
” yourself. Now, let’s begin by
using Python as a calculator:
>>> 1 + 5 * 2 - 3
8
>>>
Once the interpreter has finished calculating the answer and displaying it, the prompt
reappears. This means the Python interpreter is waiting for another instruction.
Your Turn: Enter a few more expressions of your own. You can use
asterisk (
*
) for multiplication and slash (
/
) for division, and parentheses
for bracketing expressions. Note that division doesn’t always behave as
you might expect—it does integer division (with rounding of fractions
downwards) when you type 
1/3
and “floating-point” (or decimal) divi-
sion when you type 
1.0/3.0
. In order to get the expected behavior of
division (standard in Python 3.0), you need to type: 
from __future__
import division
.
The preceding examples demonstrate how you can work interactively with the Python
interpreter, experimenting with various expressions in the language to see what they
do. Now let’s try a non-sensical expression to see how the interpreter handles it:
2 | | Chapter 1: Language Processing and Python
C# PDF Convert to Text SDK: Convert PDF to txt files in C#.net
PDF document layout and all the paragraphs are joining together, our C# RasterEdge.XDoc.PDF.dll. RasterEdge.Imaging.Basic' or any other assembly or one of
acrobat split pdf into multiple files; scan multiple pages into one pdf
VB.NET Image: VB.NET ISSN Barcode Reader & Scanner; Decode Barcode
be integrated and used in VB.NET class application together. VB.NET ISSN barcode scanner control add-on can barcode recognition from one page PDF file works in
add pdf files together online; acrobat merge pdf files
>>> 1 +
File "<stdin>", line 1
1 +
^
SyntaxError: invalid syntax
>>>
This produced a syntax error. In Python, it doesn’t make sense to end an instruction
with a plus sign. The Python interpreter indicates the line where the problem occurred
(line 1 of 
<stdin>
, which stands for “standard input”).
Now that we can use the Python interpreter, we’re ready to start working with language
data.
Getting Started with NLTK
Before going further you should install NLTK, downloadable for free from http://www
.nltk.org/. Follow the instructions there to download the version required for your
platform.
Once you’ve installed NLTK, start up the Python interpreter as before, and install the
data required for the book by typing the following two commands at the Python
prompt, then selecting the 
book
collection as shown in Figure 1-1.
>>> import nltk
>>> nltk.download()
Figure 1-1. Downloading the NLTK Book Collection: Browse the available packages using
nltk.download(). The Collections tab on the downloader shows how the packages are grouped into
sets, and you should select the line labeled book to obtain all data required for the examples and
exercises in this book. It consists of about 30 compressed files requiring about 100Mb disk space. The
full collection of data (i.e., all in the downloader) is about five times this size (at the time of writing)
and continues to expand.
Once the data is downloaded to your machine, you can load some of it using the Python
interpreter. The first step is to type a special command at the Python prompt, which
1.1  Computing with Language: Texts and Words s | | 3
C# Image: Document Image Processing SDK Programming in C#.NET
RasterEdge.Imaging.MSWordDocx.dll; RasterEdge.Imaging.PDF.dll; Before you use any programming add-ons from your C#.NET project, usually together with integrated
batch pdf merger online; c# pdf merge
C# PowerPoint: C# Codes to Combine & Split PowerPoint Documents
or a list of PowerPoint documents together and create a String doc in dirs) { docList.Add(doc); } PPTXDocument & profession imaging controls, PDF document, tiff
asp.net merge pdf files; add pdf files together reader
tells the interpreter to load some texts for us to explore: 
from nltk.book import *
. This
says “from NLTK’s 
book
module, load all items.” The 
book
module contains all the data
you will need as you read this chapter. After printing a welcome message, it loads the
text of several books (this will take a few seconds). Here’s the command again, together
with the output that you will see. Take care to get spelling and punctuation right, and
remember that you don’t type the 
>>>
.
>>> from nltk.book import *
*** Introductory Examples for the NLTK Book ***
Loading text1, ..., text9 and sent1, ..., sent9
Type the name of the text or sentence to view it.
Type: 'texts()' or 'sents()' to list the materials.
text1: Moby Dick by Herman Melville 1851
text2: Sense and Sensibility by Jane Austen 1811
text3: The Book of Genesis
text4: Inaugural Address Corpus
text5: Chat Corpus
text6: Monty Python and the Holy Grail
text7: Wall Street Journal
text8: Personals Corpus
text9: The Man Who Was Thursday by G . K . Chesterton 1908
>>>
Any time we want to find out about these texts, we just have to enter their names at
the Python prompt:
>>> text1
<Text: Moby Dick by Herman Melville 1851>
>>> text2
<Text: Sense and Sensibility by Jane Austen 1811>
>>>
Now that we can use the Python interpreter, and have some data to work with, we’re
ready to get started.
Searching Text
There are many ways to examine the context of a text apart from simply reading it. A
concordance view shows us every occurrence of a given word, together with some
context. Here we look up the word monstrous in Moby Dick by entering 
text1
followed
by a period, then the term 
concordance
, and then placing 
"monstrous"
in parentheses:
>>> text1.concordance("monstrous")
Building index...
Displaying 11 of 11 matches:
4 | | Chapter 1: Language Processing and Python
>>>
Your Turn: Try searching for other words; to save re-typing, you might
be able to use up-arrow, Ctrl-up-arrow, or Alt-p to access the previous
command and modify the word being searched. You can also try search-
es on some of the other texts we have included. For example, search
Sense and Sensibility for the word affection, using 
text2.concord
ance("affection")
. Search the book of Genesis to find out how long
some people lived, using: 
text3.concordance("lived")
. You could look
at 
text4
, the Inaugural Address Corpus, to see examples of English going
back to 1789, and search for words like nation, terrorgod to see how
these words have been used differently over time. We’ve also included
text5
, the NPS Chat Corpus: search this for unconventional words like
imurlol. (Note that this corpus is uncensored!)
Once you’ve spent a little while examining these texts, we hope you have a new sense
of the richness and diversity of language. In the next chapter you will learn how to
access a broader range of text, including text in languages other than English.
A concordance permits us to see words in context. For example, we saw that mon-
strous occurred in contexts such as the ___ pictures and the ___ size. What other words
appear in a similar range of contexts? We can find out by appending the term
similar
to the name of the text in question, then inserting the relevant word in
parentheses:
>>> text1.similar("monstrous")
Building word-context index...
subtly impalpable pitiable curious imperial perilous trustworthy
abundant untoward singular lamentable few maddens horrible loving lazy
mystifying christian exasperate puzzled
>>> text2.similar("monstrous")
Building word-context index...
very exceedingly so heartily a great good amazingly as sweet
remarkably extremely vast
>>>
Observe that we get different results for different texts. Austen uses this word quite
differently from Melville; for her, monstrous has positive connotations, and sometimes
functions as an intensifier like the word very.
The term 
common_contexts
allows us to examine just the contexts that are shared by
two or more words, such as monstrous and very. We have to enclose these words by
square brackets as well as parentheses, and separate them with a comma:
>>> text2.common_contexts(["monstrous", "very"])
be_glad am_glad a_pretty is_pretty a_lucky
>>>
1.1  Computing with Language: Texts and Words s | | 5
Your Turn: Pick another pair of words and compare their usage in two
different texts, using the 
similar()
and 
common_contexts()
functions.
It is one thing to automatically detect that a particular word occurs in a text, and to
display some words that appear in the same context. However, we can also determine
the location of a word in the text: how many words from the beginning it appears. This
positional information can be displayed using a dispersion plot. Each stripe represents
an instance of a word, and each row represents the entire text. In Figure 1-2 we see
some striking patterns of word usage over the last 220 years (in an artificial text con-
structed by joining the texts of the Inaugural Address Corpus end-to-end). You can
produce this plot as shown below. You might like to try more words (e.g., liberty,
constitution) and different texts. Can you predict the dispersion of a word before you
view it? As before, take care to get the quotes, commas, brackets, and parentheses
exactly right.
>>>
Important: You need to have Python’s NumPy and Matplotlib pack-
ages installed in order to produce the graphical plots used in this book.
Please see http://www.nltk.org/ for installation instructions.
Now, just for fun, let’s try generating some random text in the various styles we have
just seen. To do this, we type the name of the text followed by the term 
generate
. (We
need to include the parentheses, but there’s nothing that goes between them.)
Figure 1-2. Lexical dispersion plot for words in U.S. Presidential Inaugural Addresses: This can be
used to investigate changes in language use over time.
6 | | Chapter 1: Language Processing and Python
>>> text3.generate()
In the beginning of his brother is a hairy man , whose top may reach
unto heaven ; and ye shall sow the land of Egypt there was no bread in
all that he was taken out of the month , upon the earth . So shall thy
wages be ? And they made their father ; and Isaac was old , and kissed
him : and Laban with his cattle in the midst of the hands of Esau thy
first born , and Phichol the chief butler unto his son Isaac , she
>>>
Note that the first time you run this command, it is slow because it gathers statistics
about word sequences. Each time you run it, you will get different output text. Now
try generating random text in the style of an inaugural address or an Internet chat room.
Although the text is random, it reuses common words and phrases from the source text
and gives us a sense of its style and content. (What is lacking in this randomly generated
text?)
When 
generate
produces its output, punctuation is split off from the
preceding word. While this is not correct formatting for English text,
we do it to make clear that words and punctuation are independent of
one another. You will learn more about this in Chapter 3.
Counting Vocabulary
The most obvious fact about texts that emerges from the preceding examples is that
they differ in the vocabulary they use. In this section, we will see how to use the com-
puter to count the words in a text in a variety of useful ways. As before, you will jump
right in and experiment with the Python interpreter, even though you may not have
studied Python systematically yet. Test your understanding by modifying the examples,
and trying the exercises at the end of the chapter.
Let’s begin by finding out the length of a text from start to finish, in terms of the words
and punctuation symbols that appear. We use the term 
len
to get the length of some-
thing, which we’ll apply here to the book of Genesis:
>>> len(text3)
44764
>>>
So Genesis has 44,764 words and punctuation symbols, or “tokens.” A token is the
technical name for a sequence of characters—such as 
hairy
his
, or 
:)
—that we want
to treat as a group. When we count the number of tokens in a text, say, the phrase to
be or not to be, we are counting occurrences of these sequences. Thus, in our example
phrase there are two occurrences of to, two of be, and one each of or and not. But there
are only four distinct vocabulary items in this phrase. How many distinct words does
the book of Genesis contain? To work this out in Python, we have to pose the question
slightly differently. The vocabulary of a text is just the set of tokens that it uses, since
in a set, all duplicates are collapsed together. In Python we can obtain the vocabulary
1.1  Computing with Language: Texts and Words s | | 7
items of 
text3
with the command: 
set(text3)
. When you do this, many screens of
words will fly past. Now try the following:
>>> sorted(set(text3)) 
>>> len(set(text3)) 
2789
>>>
By wrapping 
sorted()
around the Python expression 
set(text3)
, we obtain a sorted
list of vocabulary items, beginning with various punctuation symbols and continuing
with words starting with A. All capitalized words precede lowercase words. We dis-
cover the size of the vocabulary indirectly, by asking for the number of items in the set,
and again we can use 
len
to obtain this number 
. Although it has 44,764 tokens, this
book has only 2,789 distinct words, or “word types.” A word type is the form or
spelling of the word independently of its specific occurrences in a text—that is, the
word considered as a unique item of vocabulary. Our count of 2,789 items will include
punctuation symbols, so we will generally call these unique items types instead of word
types.
Now, let’s calculate a measure of the lexical richness of the text. The next example
shows us that each word is used 16 times on average (we need to make sure Python
uses floating-point division):
>>> from __future__ import division
>>> len(text3) / len(set(text3))
16.050197203298673
>>>
Next, let’s focus on particular words. We can count how often a word occurs in a text,
and compute what percentage of the text is taken up by a specific word:
>>> text3.count("smote")
5
>>> 100 * text4.count('a') / len(text4)
1.4643016433938312
>>>
Your Turn: How many times does the word lol appear in 
text5
? How
much is this as a percentage of the total number of words in this text?
You may want to repeat such calculations on several texts, but it is tedious to keep
retyping the formula. Instead, you can come up with your own name for a task, like
“lexical_diversity” or “percentage”, and associate it with a block of code. Now you
only have to type a short name instead of one or more complete lines of Python code,
and you can reuse it as often as you like. The block of code that does a task for us is
8 | | Chapter 1: Language Processing and Python
Documents you may be interested
Documents you may be interested