called a function, and we define a short name for our function with the keyword 
def
.
The next example shows how to define two new functions, 
lexical_diversity()
and
percentage()
:
>>> def lexical_diversity(text): 
...     return len(text) / len(set(text)) 
...
>>> def percentage(count, total): 
...     return 100 * count / total
...
Caution!
The Python interpreter changes the prompt from 
>>>
to 
...
after en-
countering the colon at the end of the first line. The 
...
prompt indicates
that Python expects an indented code block to appear next. It is up to
you to do the indentation, by typing four spaces or hitting the Tab key.
To finish the indented block, just enter a blank line.
In the definition of 
lexical diversity()
, we specify a parameter labeled 
text
. This
parameter is a “placeholder” for the actual text whose lexical diversity we want to
compute, and reoccurs in the block of code that will run when the function is used, in
line 
. Similarly, 
percentage()
is defined to take two parameters, labeled 
count
and
total
.
Once Python knows that 
lexical_diversity()
and 
percentage()
are the names for spe-
cific blocks of code, we can go ahead and use these functions:
>>> lexical_diversity(text3)
16.050197203298673
>>> lexical_diversity(text5)
7.4200461589185629
>>> percentage(4, 5)
80.0
>>> percentage(text4.count('a'), len(text4))
1.4643016433938312
>>>
To recap, we use or call a function such as 
lexical_diversity()
by typing its name,
followed by an open parenthesis, the name of the text, and then a close parenthesis.
These parentheses will show up often; their role is to separate the name of a task—such
as 
lexical_diversity()
—from the data that the task is to be performed on—such as
text3
. The data value that we place in the parentheses when we call a function is an
argument to the function.
You have already encountered several functions in this chapter, such as 
len()
set()
,
and 
sorted()
. By convention, we will always add an empty pair of parentheses after a
function name, as in 
len()
, just to make clear that what we are talking about is a func-
tion rather than some other kind of Python expression. Functions are an important
concept in programming, and we only mention them at the outset to give newcomers
1.1  Computing with Language: Texts and Words s | | 9
Combine pdf files - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
pdf combine pages; pdf combine
Combine pdf files - 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; pdf merger
a sense of the power and creativity of programming. Don’t worry if you find it a bit
confusing right now.
Later we’ll see how to use functions when tabulating data, as in Table 1-1. Each row
of the table will involve the same computation but with different data, and we’ll do this
repetitive work using a function.
Table 1-1. Lexical diversity of various genres in the Brown Corpus
Genre
Tokens
Types
Lexical diversity
skill and hobbies s 82345
11935 6.9
humor
21695
5017
4.3
fiction: science
14470
3233
4.5
press: reportage
100554 14394 4 7.0
fiction: romance
70022
8452
8.3
religion
39399
6373
6.2
1.2  A Closer Look at Python: Texts as Lists of Words
You’ve seen some important elements of the Python programming language. Let’s take
a few moments to review them systematically.
Lists
What is a text? At one level, it is a sequence of symbols on a page such as this one. At
another level, it is a sequence of chapters, made up of a sequence of sections, where
each section is a sequence of paragraphs, and so on. However, for our purposes, we
will think of a text as nothing more than a sequence of words and punctuation. Here’s
how we represent text in Python, in this case the opening sentence of Moby Dick:
>>> sent1 = ['Call', 'me', 'Ishmael', '.']
>>>
After the prompt we’ve given a name we made up, 
sent1
, followed by the equals sign,
and then some quoted words, separated with commas, and surrounded with brackets.
This bracketed material is known as a list in Python: it is how we store a text. We can
inspect it by typing the name 
. We can ask for its length 
. We can even apply our
own 
lexical_diversity()
function to it 
.
>>> sent1 
['Call', 'me', 'Ishmael', '.']
>>> len(sent1) 
4
>>> lexical_diversity(sent1) 
1.0
>>>
10 | | Chapter 1: Language Processing and Python
Online Merge PDF files. Best free online merge PDF tool.
RasterEdge C#.NET PDF document merging toolkit (XDoc.PDF) is designed to help .NET developers combine PDF document files created by different users to one PDF
break a pdf into multiple files; pdf combine files online
C# Word - Merge Word Documents in C#.NET
RasterEdge C#.NET Word document merging toolkit (XDoc.Word) is designed to help .NET developers combine Word document files created by different users to one
break pdf into multiple files; merge pdf online
Some more lists have been defined for you, one for the opening sentence of each of our
texts, 
sent2
… 
sent9
. We inspect two of them here; you can see the rest for yourself
using the Python interpreter (if you get an error saying that 
sent2
is not defined, you
need to first type 
from nltk.book import *
).
>>> sent2
'been', 'settled', 'in', 'Sussex', '.']
>>> sent3
'heaven', 'and', 'the', 'earth', '.']
>>>
Your Turn: Make up a few sentences of your own, by typing a name,
equals sign, and a list of words, like this: 
ex1 = ['Monty', 'Python',
'and', 'the', 'Holy', 'Grail']
. Repeat some of the other Python op-
erations we saw earlier in Section 1.1, e.g., 
sorted(ex1)
len(set(ex1))
,
ex1.count('the')
.
A pleasant surprise is that we can use Python’s addition operator on lists. Adding two
lists 
creates a new list with everything from the first list, followed by everything from
the second list:
This special use of the addition operation is called concatenation; it
combines the lists together into a single list. We can concatenate sen-
tences to build up a text.
We don’t have to literally type the lists either; we can use short names that refer to pre-
defined lists.
>>> sent4 + sent1
>>>
What if we want to add a single item to a list? This is known as appending. When we
append()
to a list, the list itself is updated as a result of the operation.
>>> sent1.append("Some")
>>> sent1
['Call', 'me', 'Ishmael', '.', 'Some']
>>>
1.2  A Closer Look at Python: Texts as Lists of Words s | | 11
C# PowerPoint - Merge PowerPoint Documents in C#.NET
RasterEdge C#.NET PowerPoint document merging toolkit (XDoc.PowerPoint) is designed to help .NET developers combine PowerPoint document files created by
c# merge pdf; add pdf together one file
C# PDF: C#.NET PDF Document Merging & Splitting Control SDK
C#.NET PDF Merger to Combine PDF Files. Using following C#.NET PDF document merging APIs, you can easily merge two or more independent PDF files to create a
pdf merge files; add pdf files together
Indexing Lists
As we have seen, a text in Python is a list of words, represented using a combination
of brackets and quotes. Just as with an ordinary page of text, we can count up the total
number of words in 
text1
with 
len(text1)
, and count the occurrences in a text of a
particular word—say, heaven—using 
text1.count('heaven')
.
With some patience, we can pick out the 1st, 173rd, or even 14,278th word in a printed
text. Analogously, we can identify the elements of a Python list by their order of oc-
currence in the list. The number that represents this position is the item’s index. We
instruct Python to show us the item that occurs at an index such as 
173
in a text by
writing the name of the text followed by the index inside square brackets:
>>> text4[173]
'awaken'
>>>
We can do the converse; given a word, find the index of when it first occurs:
>>> text4.index('awaken')
173
>>>
Indexes are a common way to access the words of a text, or, more generally, the ele-
ments of any list. Python permits us to access sublists as well, extracting manageable
pieces of language from large texts, a technique known as slicing.
>>> text5[16715:16735]
'buying', 'it']
>>> text6[1600:1625]
'officer', 'for', 'the', 'week']
>>>
Indexes have some subtleties, and we’ll explore these with the help of an artificial
sentence:
>>> sent[0]
'word1'
>>> sent[9]
'word10'
>>>
Notice that our indexes start from zero: 
sent
element zero, written 
sent[0]
, is the first
word, 
'word1'
, whereas 
sent
element 9 is 
'word10'
. The reason is simple: the moment
Python accesses the content of a list from the computer’s memory, it is already at the
first element; we have to tell it how many elements forward to go. Thus, zero steps
forward leaves it at the first element.
12 | | Chapter 1: Language Processing and Python
C# PDF File Split Library: Split, seperate PDF into multiple files
Split PDF document by PDF bookmark and outlines. Also able to combine generated split PDF document files with other PDF files to form a new PDF file.
c# merge pdf pages; best pdf merger
VB.NET Word: Merge Multiple Word Files & Split Word Document
As List(Of DOCXDocument), destnPath As [String]) DOCXDocument.Combine(docList, destnPath) End imaging controls, PDF document, image to pdf files and components
pdf mail merge plug in; c# pdf merge
This practice of counting from zero is initially confusing, but typical of
modern programming languages. You’ll quickly get the hang of it if
you’ve mastered the system of counting centuries where 19XY is a year
in the 20th century, or if you live in a country where the floors of a
building are numbered from 1, and so walking up n-1 flights of stairs
takes you to level n.
Now, if we accidentally use an index that is too large, we get an error:
>>> sent[10]
Traceback (most recent call last):
File "<stdin>", line 1, in ?
IndexError: list index out of range
>>>
This time it is not a syntax error, because the program fragment is syntactically correct.
Instead, it is a runtime error, and it produces a 
Traceback
message that shows the
context of the error, followed by the name of the error, 
IndexError
, and a brief
explanation.
Let’s take a closer look at slicing, using our artificial sentence again. Here we verify that
the slice 
5:8
includes 
sent
elements at indexes 5, 6, and 7:
>>> sent[5:8]
['word6', 'word7', 'word8']
>>> sent[5]
'word6'
>>> sent[6]
'word7'
>>> sent[7]
'word8'
>>>
By convention, 
m:n
means elements mn-1. As the next example shows, we can omit
the first number if the slice begins at the start of the list 
, and we can omit the second
number if the slice goes to the end 
:
>>> sent[:3] 
['word1', 'word2', 'word3']
>>> text2[141525:] 
'THE', 'END']
>>>
We can modify an element of a list by assigning to one of its index values. In the next
example, we put 
sent[0]
on the left of the equals sign 
. We can also replace an entire
slice with new material 
. A consequence of this last change is that the list only has
four elements, and accessing a later value generates an error 
.
1.2  A Closer Look at Python: Texts as Lists of Words s | | 13
VB.NET TIFF: Merge and Split TIFF Documents with RasterEdge .NET
String], docList As [String]()) TIFFDocument.Combine(filePath, docList powerful & profession imaging controls, PDF document, tiff files and components
pdf split and merge; pdf merge documents
VB.NET TIFF: .NET TIFF Merger SDK to Combine TIFF Files
VB.NET TIFF merging API only allows developers to combine two source powerful & profession imaging controls, PDF document, image to pdf files and components
add pdf pages together; acrobat merge pdf
>>> sent[0] = 'First' 
>>> sent[9] = 'Last'
>>> len(sent)
10
>>> sent[1:9] = ['Second', 'Third'] 
>>> sent
['First', 'Second', 'Third', 'Last']
>>> sent[9] 
Traceback (most recent call last):
File "<stdin>", line 1, in ?
IndexError: list index out of range
>>>
Your Turn: Take a few minutes to define a sentence of your own and
modify individual words and groups of words (slices) using the same
methods used earlier. Check your understanding by trying the exercises
on lists at the end of this chapter.
Variables
From the start of Section 1.1, you have had access to texts called 
text1
text2
, and so
on. It saved a lot of typing to be able to refer to a 250,000-word book with a short name
like this! In general, we can make up names for anything we care to calculate. We did
this ourselves in the previous sections, e.g., defining a variable 
sent1
, as follows:
>>> sent1 = ['Call', 'me', 'Ishmael', '.']
>>>
Such lines have the form: variable = expression. Python will evaluate the expression,
and save its result to the variable. This process is called assignment. It does not gen-
erate any output; you have to type the variable on a line of its own to inspect its contents.
The equals sign is slightly misleading, since information is moving from the right side
to the left. It might help to think of it as a left-arrow. The name of the variable can be
anything you like, e.g., 
my_sent
sentence
xyzzy
. It must start with a letter, and can
include numbers and underscores. Here are some examples of variables and
assignments:
... 'forth', 'from', 'Camelot', '.']
>>> noun_phrase = my_sent[1:4]
>>> noun_phrase
['bold', 'Sir', 'Robin']
>>> wOrDs = sorted(noun_phrase)
>>> wOrDs
['Robin', 'Sir', 'bold']
>>>
Remember that capitalized words appear before lowercase words in sorted lists.
14 | | Chapter 1: Language Processing and Python
Notice in the previous example that we split the definition of 
my_sent
over two lines. Python expressions can be split across multiple lines, so
long as this happens within any kind of brackets. Python uses the 
...
prompt to indicate that more input is expected. It doesn’t matter how
much indentation is used in these continuation lines, but some inden-
tation usually makes them easier to read.
It is good to choose meaningful variable names to remind you—and to help anyone
else who reads your Python code—what your code is meant to do. Python does not try
to make sense of the names; it blindly follows your instructions, and does not object if
you do something confusing, such as 
one = 'two'
or 
two = 3
. The only restriction is
that a variable name cannot be any of Python’s reserved words, such as 
def
if
not
,
and 
import
. If you use a reserved word, Python will produce a syntax error:
>>> not = 'Camelot'
File "<stdin>", line 1
not = 'Camelot'
^
SyntaxError: invalid syntax
>>>
We will often use variables to hold intermediate steps of a computation, especially
when this makes the code easier to follow. Thus 
len(set(text1))
could also be written:
>>> vocab = set(text1)
>>> vocab_size = len(vocab)
>>> vocab_size
19317
>>>
Caution!
Take care with your choice of names (or identifiers) for Python varia-
bles. First, you should start the name with a letter, optionally followed
by digits (
0
to 
9
) or letters. Thus, 
abc23
is fine, but 
23abc
will cause a
syntax error. Names are case-sensitive, which means that 
myVar
and
myvar
are distinct variables. Variable names cannot contain whitespace,
but you can separate words using an underscore, e.g., 
my_var
. Be careful
not to insert a hyphen instead of an underscore: 
my-var
is wrong, since
Python interprets the 
-
as a minus sign.
Strings
Some of the methods we used to access the elements of a list also work with individual
words, or strings. For example, we can assign a string to a variable 
, index a string
, and slice a string 
.
1.2  A Closer Look at Python: Texts as Lists of Words s | | 15
>>> name = 'Monty' 
>>> name[0] 
'M'
>>> name[:4] 
'Mont'
>>>
We can also perform multiplication and addition with strings:
>>> name * 2
'MontyMonty'
>>> name + '!'
'Monty!'
>>>
We can join the words of a list to make a single string, or split a string into a list, as
follows:
>>> ' '.join(['Monty', 'Python'])
'Monty Python'
>>> 'Monty Python'.split()
['Monty', 'Python']
>>>
We will come back to the topic of strings in Chapter 3. For the time being, we have
two important building blocks—lists and strings—and are ready to get back to some
language analysis.
1.3  Computing with Language: Simple Statistics
Let’s return to our exploration of the ways we can bring our computational resources
to bear on large quantities of text. We began this discussion in Section 1.1, and saw
how to search for words in context, how to compile the vocabulary of a text, how to
generate random text in the same style, and so on.
In this section, we pick up the question of what makes a text distinct, and use automatic
methods to find characteristic words and expressions of a text. As in Section 1.1, you
can try new features of the Python language by copying them into the interpreter, and
you’ll learn about these features systematically in the following section.
Before continuing further, you might like to check your understanding of the last sec-
tion by predicting the output of the following code. You can use the interpreter to check
whether you got it right. If you’re not sure how to do this task, it would be a good idea
to review the previous section before continuing further.
>>> tokens = set(saying)
>>> tokens = sorted(tokens)
>>> tokens[-2:]
what output do you expect here?
>>>
16 | | Chapter 1: Language Processing and Python
Frequency Distributions
How can we automatically identify the words of a text that are most informative about
the topic and genre of the text? Imagine how you might go about finding the 50 most
frequent words of a book. One method would be to keep a tally for each vocabulary
item, like that shown in Figure 1-3. The tally would need thousands of rows, and it
would be an exceedingly laborious process—so laborious that we would rather assign
the task to a machine.
Figure 1-3. Counting words appearing in a text (a frequency distribution).
The table in Figure 1-3 is known as a frequency distribution , and it tells us the
frequency of each vocabulary item in the text. (In general, it could count any kind of
observable event.) It is a “distribution” since it tells us how the total number of word
tokens in the text are distributed across the vocabulary items. Since we often need
frequency distributions in language processing, NLTK provides built-in support for
them. Let’s use a 
FreqDist
to find the 50 most frequent words of Moby Dick. Try to
work out what is going on here, then read the explanation that follows.
>>> fdist1 = FreqDist(text1) 
>>> fdist1 
<FreqDist with 260819 outcomes>
>>> vocabulary1 = fdist1.keys() 
>>> vocabulary1[:50] 
'now', 'which', '?', 'me', 'like']
>>> fdist1['whale']
906
>>>
When we first invoke 
FreqDist
, we pass the name of the text as an argument 
. We
can inspect the total number of words (“outcomes”) that have been counted up 
260,819 in the case of Moby Dick. The expression 
keys()
gives us a list of all the distinct
types in the text 
, and we can look at the first 50 of these by slicing the list 
.
1.3  Computing with Language: Simple Statistics s | | 17
Your Turn: Try the preceding frequency distribution example for your-
self, for 
text2
. Be careful to use the correct parentheses and uppercase
letters. If you get an error message 
NameError: name 'FreqDist' is not
defined
, you need to start your work with 
from nltk.book import *
.
Do any words produced in the last example help us grasp the topic or genre of this text?
Only one word, whale, is slightly informative! It occurs over 900 times. The rest of the
words tell us nothing about the text; they’re just English “plumbing.” What proportion
of the text is taken up with such words? We can generate a cumulative frequency plot
for these words, using 
fdist1.plot(50, cumulative=True)
, to produce the graph in
Figure 1-4. These 50 words account for nearly half the book!
Figure 1-4. Cumulative frequency plot for the 50 most frequently used words in Moby Dick, which
account for nearly half of the tokens.
18 | | Chapter 1: Language Processing and Python
Documents you may be interested
Documents you may be interested