asp net mvc 5 pdf viewer : Merge pdf application control cloud windows web page winforms class NaturalLanguageProcessingWithPython17-part2076

Example 4-4. Illustration of a complete docstring, consisting of a one-line summary, a more detailed
explanation, a doctest example, and epytext markup specifying the parameters, types, return type,
and exceptions.
def accuracy(reference, test):
"""
return the fraction of corresponding values that are equal.
In particular, return the fraction of indexes
{0<i<=len(test)} such that C{test[i] == reference[i]}.
0.5
@param reference: An ordered list of reference values.
@type reference: C{list}
@param test: A list of values to compare against the corresponding
reference values.
@type test: C{list}
@rtype: C{float}
@raise ValueError: If C{reference} and C{length} do not have the
same length.
"""
if len(reference) != len(test):
raise ValueError("Lists must have the same length.")
num_correct = 0
for x, y in izip(reference, test):
if x == y:
num_correct += 1
return float(num_correct) / len(reference)
4.5  Doing More with Functions
This section discusses more advanced features, which you may prefer to skip on the
first time through this chapter.
Functions As Arguments
So far the arguments we have passed into functions have been simple objects, such as
strings, or structured objects, such as lists. Python also lets us pass a function as an
argument to another function. Now we can abstract out the operation, and apply a
different operation on the same data. As the following examples show, we can pass the
built-in function 
len()
or a user-defined function 
last_letter()
as arguments to an-
other function:
>>> def extract_property(prop):
...     return [prop(word) for word in sent]
...
4.5  Doing More with Functions s | | 149
Merge pdf - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
break a pdf into multiple files; batch pdf merger online
Merge pdf - 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
merge pdf; c# merge pdf pages
>>> extract_property(len)
[4, 4, 2, 3, 5, 1, 3, 3, 6, 4, 4, 4, 2, 10, 1]
>>> def last_letter(word):
...     return word[-1]
>>> extract_property(last_letter)
The objects 
len
and 
last_letter
can be passed around like lists and dictionaries. Notice
that parentheses are used after a function name only if we are invoking the function;
when we are simply treating the function as an object, these are omitted.
Python provides us with one more way to define functions as arguments to other func-
tions, so-called lambda expressions. Supposing there was no need to use the 
last_let
ter()
function in multiple places, and thus no need to give it a name. Let’s suppose we
can equivalently write the following:
>>> extract_property(lambda w: w[-1])
Our next example illustrates passing a function to the 
sorted()
function. When we call
the latter with a single argument (the list to be sorted), it uses the built-in comparison
function 
cmp()
. However, we can supply our own sort function, e.g., to sort by de-
creasing length.
>>> sorted(sent)
>>> sorted(sent, cmp)
>>> sorted(sent, lambda x, y: cmp(len(y), len(x)))
Accumulative Functions
These functions start by initializing some storage, and iterate over input to build it up,
before returning some final object (a large structure or aggregated result). A standard
way to do this is to initialize an empty list, accumulate the material, then return the
list, as shown in function 
search1()
in Example 4-5.
Example 4-5. Accumulating output into a list.
def search1(substring, words):
result = []
for word in words:
if substring in word:
result.append(word)
return result
def search2(substring, words):
for word in words:
if substring in word:
yield word
150 | | Chapter 4: Writing Structured Programs
Online Merge PDF files. Best free online merge PDF tool.
Online Merge PDF, Multiple PDF files into one. Download Free Trial. Merge PDF, Multiple PDF files. Drag and drop your PDF or several files in the box above.
add pdf files together reader; c# merge pdf
C# WPF PDF Viewer SDK to view, annotate, convert and print PDF in
C#, C# convert PDF to HTML, C# convert PDF to Word, C# extract text from PDF, C# convert PDF to Jpeg, C# compress PDF, C# print PDF, C# merge PDF files, C# view
add pdf files together; pdf merge comments
print "search1:"
for item in search1('zz', nltk.corpus.brown.words()):
print item
print "search2:"
for item in search2('zz', nltk.corpus.brown.words()):
print item
The function 
search2()
is a generator. The first time this function is called, it gets as
far as the 
yield
statement and pauses. The calling program gets the first word and does
any necessary processing. Once the calling program is ready for another word, execu-
tion of the function is continued from where it stopped, until the next time it encounters
yield
statement. This approach is typically more efficient, as the function only gen-
erates the data as it is required by the calling program, and does not need to allocate
additional memory to store the output (see the earlier discussion of generator expres-
sions).
Here’s a more sophisticated example of a generator which produces all permutations
of a list of words. In order to force the 
permutations()
function to generate all its output,
we wrap it with a call to 
list()
.
>>> def permutations(seq):
...     if len(seq) <= 1:
...         yield seq
...     else:
...         for perm in permutations(seq[1:]):
...             for i in range(len(perm)+1):
...                 yield perm[:i] + seq[0:1] + perm[i:]
...
The 
permutations
function uses a technique called recursion, discussed
later in Section 4.7. The ability to generate permutations of a set of words
is useful for creating data to test a grammar (Chapter 8).
Higher-Order Functions
Python provides some higher-order functions that are standard features of functional
programming languages such as Haskell. We illustrate them here, alongside the equiv-
alent expression using list comprehensions.
Let’s start by defining a function 
is_content_word()
which checks whether a word is
from the open class of content words. We use this function as the first parameter of
filter()
, which applies the function to each item in the sequence contained in its
second parameter, and retains only the items for which the function returns 
True
.
4.5  Doing More with Functions s | | 151
VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to
C#, C# convert PDF to HTML, C# convert PDF to Word, C# extract text from PDF, C# convert PDF to Jpeg, C# compress PDF, C# print PDF, C# merge PDF files, C# view
pdf merger; c# combine pdf
VB.NET Create PDF from Word Library to convert docx, doc to PDF in
C#, C# convert PDF to HTML, C# convert PDF to Word, C# extract text from PDF, C# convert PDF to Jpeg, C# compress PDF, C# print PDF, C# merge PDF files, C# view
append pdf; batch pdf merger online
>>> def is_content_word(word):
>>> filter(is_content_word, sent)
>>> [w for w in sent if is_content_word(w)]
Another higher-order function is 
map()
, which applies a function to every item in a
sequence. It is a general version of the 
extract_property()
function we saw earlier in
this section. Here is a simple way to find the average length of a sentence in the news
section of the Brown Corpus, followed by an equivalent version with list comprehen-
sion calculation:
>>> sum(lengths) / len(lengths)
21.7508111616
>>> sum(lengths) / len(lengths)
21.7508111616
In the previous examples, we specified a user-defined function 
is_content_word()
and
a built-in function 
len()
. We can also provide a lambda expression. Here’s a pair of
equivalent examples that count the number of vowels in each word.
[2, 2, 1, 1, 2, 0, 1, 1, 2, 1, 2, 2, 1, 3, 0]
>>> [len([c for c in w if c.lower() in "aeiou"]) for w in sent]
[2, 2, 1, 1, 2, 0, 1, 1, 2, 1, 2, 2, 1, 3, 0]
The solutions based on list comprehensions are usually more readable than the solu-
tions based on higher-order functions, and we have favored the former approach
throughout this book.
Named Arguments
When there are a lot of parameters it is easy to get confused about the correct order.
Instead we can refer to parameters by name, and even assign them a default value just
in case one was not provided by the calling program. Now the parameters can be speci-
fied in any order, and can be omitted.
>>> def repeat(msg='<empty>', num=1):
...     return msg * num
>>> repeat(num=3)
'<empty><empty><empty>'
>>> repeat(msg='Alice')
'Alice'
>>> repeat(num=5, msg='Alice')
'AliceAliceAliceAliceAlice'
These are called keyword arguments. If we mix these two kinds of parameters, then
we must ensure that the unnamed parameters precede the named ones. It has to be this
152 | | Chapter 4: Writing Structured Programs
VB.NET PDF- HTML5 PDF Viewer for VB.NET Project
C#, C# convert PDF to HTML, C# convert PDF to Word, C# extract text from PDF, C# convert PDF to Jpeg, C# compress PDF, C# print PDF, C# merge PDF files, C# view
break pdf file into multiple files; pdf merger online
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
C#, C# convert PDF to HTML, C# convert PDF to Word, C# extract text from PDF, C# convert PDF to Jpeg, C# compress PDF, C# print PDF, C# merge PDF files, C# view
add two pdf files together; attach pdf to mail merge
way, since unnamed parameters are defined by position. We can define a function that
takes an arbitrary number of unnamed and named parameters, and access them via an
in-place list of arguments 
*args
and an in-place dictionary of keyword arguments
**kwargs
.
>>> def generic(*args, **kwargs):
...     print args
...     print kwargs
...
>>> generic(1, "African swallow", monty="python")
(1, 'African swallow')
{'monty': 'python'}
When 
*args
appears as a function parameter, it actually corresponds to all the unnamed
parameters of the function. As another illustration of this aspect of Python syntax,
consider the 
zip()
function, which operates on a variable number of arguments. We’ll
use the variable name 
*song
to demonstrate that there’s nothing special about the name
*args
.
>>> song = [['four', 'calling', 'birds'],
...         ['three', 'French', 'hens'],
...         ['two', 'turtle', 'doves']]
>>> zip(song[0], song[1], song[2])
>>> zip(*song)
It should be clear from this example that typing 
*song
is just a convenient shorthand,
and equivalent to typing out 
song[0], song[1], song[2]
.
Here’s another example of the use of keyword arguments in a function definition, along
with three equivalent ways to call the function:
>>> def freq_words(file, min=1, num=10):
...     text = open(file).read()
...     tokens = nltk.word_tokenize(text)
...     freqdist = nltk.FreqDist(t for t in tokens if len(t) >= min)
...     return freqdist.keys()[:num]
>>> fw = freq_words('ch01.rst', 4, 10)
>>> fw = freq_words('ch01.rst', min=4, num=10)
>>> fw = freq_words('ch01.rst', num=10, min=4)
A side effect of having named arguments is that they permit optionality. Thus we can
leave out any arguments where we are happy with the default value:
freq_words('ch01.rst', min=4)
freq_words('ch01.rst', 4)
. Another common use of
optional arguments is to permit a flag. Here’s a revised version of the same function
that reports its progress if a 
verbose
flag is set:
>>> def freq_words(file, min=1, num=10, verbose=False):
...     freqdist = FreqDist()
...     if trace: print "Opening", file
...     text = open(file).read()
...     if trace: print "Read in %d characters" % len(file)
...     for word in nltk.word_tokenize(text):
4.5  Doing More with Functions s | | 153
C# PDF Image Extract Library: Select, copy, paste PDF images in C#
PDF ›› C# PDF: Extract PDF Image. How to C#: Extract Image from PDF Document. Support PDF Image Extraction from a Page, a Region on a Page, and PDF Document.
apple merge pdf; split pdf into multiple files
VB.NET PDF Text Extract Library: extract text content from PDF
PDF ›› VB.NET PDF: Extract PDF Text. VB.NET PDF - Extract Text from PDF Using VB. How to Extract Text from PDF with VB.NET Sample Codes in .NET Application.
adding pdf pages together; pdf mail merge
...         if len(word) >= min:
...             freqdist.inc(word)
...             if trace and freqdist.N() % 100 == 0: print "."
...     if trace: print
...     return freqdist.keys()[:num]
Caution!
Take care not to use a mutable object as the default value of a parameter.
A series of calls to the function will use the same object, sometimes with
bizarre results, as we will see in the discussion of debugging later.
4.6  Program Development
Programming is a skill that is acquired over several years of experience with a variety
of programming languages and tasks. Key high-level abilities are algorithm design and
its manifestation in structured programming. Key low-level abilities include familiarity
with the syntactic constructs of the language, and knowledge of a variety of diagnostic
methods for trouble-shooting a program which does not exhibit the expected behavior.
This section describes the internal structure of a program module and how to organize
a multi-module program. Then it describes various kinds of error that arise during
program development, what you can do to fix them and, better still, to avoid them in
the first place.
Structure of a Python Module
The purpose of a program module is to bring logically related definitions and functions
together in order to facilitate reuse and abstraction. Python modules are nothing more
than individual .py files. For example, if you were working with a particular corpus
format, the functions to read and write the format could be kept together. Constants
used by both formats, such as field separators, or a 
EXTN = ".inf"
filename extension,
could be shared. If the format was updated, you would know that only one file needed
to be changed. Similarly, a module could contain code for creating and manipulating
a particular data structure such as syntax trees, or code for performing a particular
processing task such as plotting corpus statistics.
When you start writing Python modules, it helps to have some examples to emulate.
You can locate the code for any NLTK module on your system using the 
__file__
variable:
>>> nltk.metrics.distance.__file__
'/usr/lib/python2.5/site-packages/nltk/metrics/distance.pyc'
This returns the location of the compiled .pyc file for the module, and you’ll probably
see a different location on your machine. The file that you will need to open is the
corresponding .py source file, and this will be in the same directory as the .pyc file.
154 | | Chapter 4: Writing Structured Programs
Alternatively, you can view the latest version of this module on the Web at http://code
.google.com/p/nltk/source/browse/trunk/nltk/nltk/metrics/distance.py.
Like every other NLTK module, distance.py begins with a group of comment lines giving
a one-line title of the module and identifying the authors. (Since the code is distributed,
it also includes the URL where the code is available, a copyright statement, and license
information.) Next is the module-level docstring, a triple-quoted multiline string con-
taining information about the module that will be printed when someone types
help(nltk.metrics.distance)
.
# Natural Language Toolkit: Distance Metrics
#
# Copyright (C) 2001-2009 NLTK Project
# Author: Edward Loper <edloper@gradient.cis.upenn.edu>
        Steven Bird <sb@csse.unimelb.edu.au>
        Tom Lippincott <tom@cs.columbia.edu>
# URL: <http://www.nltk.org/>
# For license information, see LICENSE.TXT
#
"""
Distance Metrics.
Compute the distance between two items (usually strings).
As metrics, they must satisfy the following three requirements:
1. d(a, a) = 0
2. d(a, b) >= 0
3. d(a, c) <= d(a, b) + d(b, c)
"""
After this comes all the import statements required for the module, then any global
variables, followed by a series of function definitions that make up most of the module.
Other modules define “classes,” the main building blocks of object-oriented program-
ming, which falls outside the scope of this book. (Most NLTK modules also include a
demo()
function, which can be used to see examples of the module in use.)
Some module variables and functions are only used within the module.
These should have names beginning with an underscore, e.g.,
_helper()
, since this will hide the name. If another module imports this
one, using the idiom: 
from module import *
, these names will not be
imported. You can optionally list the externally accessible names of a
module using a special built-in variable like this: 
__all__ = ['edit_dis
tance', 'jaccard_distance']
.
Multimodule Programs
Some programs bring together a diverse range of tasks, such as loading data from a
corpus, performing some analysis tasks on the data, then visualizing it. We may already
4.6  Program Development t | | 155
have stable modules that take care of loading data and producing visualizations. Our
work might involve coding up the analysis task, and just invoking functions from the
existing modules. This scenario is depicted in Figure 4-2.
Figure 4-2. Structure of a multimodule program: The main program my_program.py imports
functions from two other modules; unique analysis tasks are localized to the main program, while
common loading and visualization tasks are kept apart to facilitate reuse and abstraction.
By dividing our work into several modules and using 
import
statements to access func-
tions defined elsewhere, we can keep the individual modules simple and easy to main-
tain. This approach will also result in a growing collection of modules, and make it
possible for us to build sophisticated systems involving a hierarchy of modules. De-
signing such systems well is a complex software engineering task, and beyond the scope
of this book.
Sources of Error
Mastery of programming depends on having a variety of problem-solving skills to draw
upon when the program doesn’t work as expected. Something as trivial as a misplaced
symbol might cause the program to behave very differently. We call these “bugs” be-
cause they are tiny in comparison to the damage they can cause. They creep into our
code unnoticed, and it’s only much later when we’re running the program on some
new data that their presence is detected. Sometimes, fixing one bug only reveals an-
other, and we get the distinct impression that the bug is on the move. The only reas-
surance we have is that bugs are spontaneous and not the fault of the programmer.
156 | | Chapter 4: Writing Structured Programs
Flippancy aside, debugging code is hard because there are so many ways for it to be
faulty. Our understanding of the input data, the algorithm, or even the programming
language, may be at fault. Let’s look at examples of each of these.
First, the input data may contain some unexpected characters. For example, WordNet
synset names have the form 
tree.n.01
, with three components separated using periods.
The NLTK WordNet module initially decomposed these names using 
split('.')
.
However, this method broke when someone tried to look up the word PhD, which has
the synset name 
ph.d..n.01
, containing four periods instead of the expected two. The
solution was to use 
rsplit('.', 2)
to do at most two splits, using the rightmost in-
stances of the period, and leaving the 
ph.d.
string intact. Although several people had
tested the module before it was released, it was some weeks before someone detected
the problem (see http://code.google.com/p/nltk/issues/detail?id=297).
Second, a supplied function might not behave as expected. For example, while testing
NLTK’s interface to WordNet, one of the authors noticed that no synsets had any
antonyms defined, even though the underlying database provided a large quantity of
antonym information. What looked like a bug in the WordNet interface turned out to
be a misunderstanding about WordNet itself: antonyms are defined for lemmas, not
for synsets. The only “bug” was a misunderstanding of the interface (see http://code
.google.com/p/nltk/issues/detail?id=98).
Third, our understanding of Python’s semantics may be at fault. It is easy to make the
wrong assumption about the relative scope of two operators. For example, 
"%s.%s.
%02d" % "ph.d.", "n", 1
produces a runtime error 
TypeError: not enough arguments
for format string
. This is because the percent operator has higher precedence than
the comma operator. The fix is to add parentheses in order to force the required scope.
As another example, suppose we are defining a function to collect all tokens of a text
having a given length. The function has parameters for the text and the word length,
and an extra parameter that allows the initial value of the result to be given as a
parameter:
>>> def find_words(text, wordlength, result=[]):
...     for word in text:
...         if len(word) == wordlength:
...             result.append(word)
...     return result
['omg', 'teh', 'teh', 'mat']
['ur', 'on']
The first time we call 
find_words()
, we get all three-letter words as expected. The
second time we specify an initial value for the result, a one-element list 
['ur']
, and as
expected, the result has this word along with the other two-letter word in our text.
Now, the next time we call 
find_words()
we use the same parameters as in 
, but
we get a different result! Each time we call 
find_words()
with no third parameter, the
4.6  Program Development t | | 157
result will simply extend the result of the previous call, rather than start with the empty
result list as specified in the function definition. The program’s behavior is not as ex-
pected because we incorrectly assumed that the default value was created at the time
the function was invoked. However, it is created just once, at the time the Python
interpreter loads the function. This one list object is used whenever no explicit value
is provided to the function.
Debugging Techniques
Since most code errors result from the programmer making incorrect assumptions, the
first thing to do when you detect a bug is to check your assumptions. Localize the prob-
lem by adding 
print
statements to the program, showing the value of important vari-
ables, and showing how far the program has progressed.
If the program produced an “exception”—a runtime error—the interpreter will print
stack trace, pinpointing the location of program execution at the time of the error.
If the program depends on input data, try to reduce this to the smallest size while still
producing the error.
Once you have localized the problem to a particular function or to a line of code, you
need to work out what is going wrong. It is often helpful to recreate the situation using
the interactive command line. Define some variables, and then copy-paste the offending
line of code into the session and see what happens. Check your understanding of the
code by reading some documentation and examining other code samples that purport
to do the same thing that you are trying to do. Try explaining your code to someone
else, in case she can see where things are going wrong.
Python provides a debugger which allows you to monitor the execution of your pro-
gram, specify line numbers where execution will stop (i.e., breakpoints), and step
through sections of code and inspect the value of variables. You can invoke the debug-
ger on your code as follows:
>>> import pdb
>>> import mymodule
>>> pdb.run('mymodule.myfunction()')
It will present you with a prompt 
(Pdb)
where you can type instructions to the debugger.
Type 
help
to see the full list of commands. Typing 
step
(or just 
s
) will execute the
current line and stop. If the current line calls a function, it will enter the function and
stop at the first line. Typing 
next
(or just 
n
) is similar, but it stops execution at the next
line in the current function. The 
break
(or 
b
) command can be used to create or list
breakpoints. Type 
continue
(or 
c
) to continue execution as far as the next breakpoint.
Type the name of any variable to inspect its value.
We can use the Python debugger to locate the problem in our 
find_words()
function.
Remember that the problem arose the second time the function was called. We’ll start
by calling the function without using the debugger 
, using the smallest possible input.
The second time, we’ll call it with the debugger 
.
158 | | Chapter 4: Writing Structured Programs
Documents you may be interested
Documents you may be interested