asp net mvc 5 pdf viewer : Best pdf merger application control tool html web page wpf online NaturalLanguageProcessingWithPython11-part2070

>>> 'very' - 'y'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'str' and 'str'
>>> 'very' / 2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for /: 'str' and 'int'
These error messages are another example of Python telling us that we have got our
data types in a muddle. In the first case, we are told that the operation of subtraction
(i.e., 
-
) cannot apply to objects of type 
str
(strings), while in the second, we are told
that division cannot take 
str
and 
int
as its two operands.
Printing Strings
So far, when we have wanted to look at the contents of a variable or see the result of a
calculation, we have just typed the variable name into the interpreter. We can also see
the contents of a variable using the 
print
statement:
>>> print monty
Monty Python
Notice that there are no quotation marks this time. When we inspect a variable by
typing its name in the interpreter, the interpreter prints the Python representation of
its value. Since it’s a string, the result is quoted. However, when we tell the interpreter
to 
print
the contents of the variable, we don’t see quotation characters, since there are
none inside the string.
The 
print
statement allows us to display more than one item on a line in various ways,
as shown here:
>>> grail = 'Holy Grail'
>>> print monty + grail
Monty PythonHoly Grail
>>> print monty, grail
Monty Python Holy Grail
>>> print monty, "and the", grail
Monty Python and the Holy Grail
Accessing Individual Characters
As we saw in Section 1.2 for lists, strings are indexed, starting from zero. When we
index a string, we get one of its characters (or letters). A single character is nothing
special—it’s just a string of length 
1
.
>>> monty[0]
'M'
>>> monty[3]
't'
>>> monty[5]
' '
3.2  Strings: Text Processing at the Lowest Level l | | 89
Best pdf merger - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
reader combine pdf; add pdf files together
Best pdf merger - 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
c# merge pdf pages; add pdf files together reader
As with lists, if we try to access an index that is outside of the string, we get an error:
>>> monty[20]
Traceback (most recent call last):
File "<stdin>", line 1, in ?
IndexError: string index out of range
Again as with lists, we can use negative indexes for strings, where 
-1
is the index of the
last character 
. Positive and negative indexes give us two ways to refer to any position
in a string. In this case, when the string had a length of 12, indexes 
5
and 
-7
both refer
to the same character (a space). (Notice that 
5 = len(monty) - 7
.)
>>> monty[-1] 
'n'
>>> monty[5]
' '
>>> monty[-7]
' '
We can write 
for
loops to iterate over the characters in strings. This 
print
statement
ends with a trailing comma, which is how we tell Python not to print a newline at the
end.
>>> sent = 'colorless green ideas sleep furiously'
>>> for char in sent:
...     print char,
...
We can count individual characters as well. We should ignore the case distinction by
normalizing everything to lowercase, and filter out non-alphabetic characters:
>>> from nltk.corpus import gutenberg
>>> raw = gutenberg.raw('melville-moby_dick.txt')
>>> fdist = nltk.FreqDist(ch.lower() for ch in raw if ch.isalpha())
>>> fdist.keys()
This gives us the letters of the alphabet, with the most frequently occurring letters listed
first (this is quite complicated and we’ll explain it more carefully later). You might like
to visualize the distribution using 
fdist.plot()
. The relative character frequencies of
a text can be used in automatically identifying the language of the text.
Accessing Substrings
A substring is any continuous section of a string that we want to pull out for further
processing. We can easily access substrings using the same slice notation we used for
lists (see Figure 3-2). For example, the following code accesses the substring starting
at index 
6
, up to (but not including) index 
10
:
>>> monty[6:10]
'Pyth'
90 | | Chapter 3: Processing Raw Text
VB.NET TIFF: Merge and Split TIFF Documents with RasterEdge .NET
processing SDK will give the best solutions for Besides TIFF document merger and splitter, RasterEdge still & profession imaging controls, PDF document, tiff
add two pdf files together; how to combine pdf files
VB.NET PowerPoint: Merge and Split PowerPoint Document(s) with PPT
looking for - RasterEdge VB.NET PPT Document Merger and Splitter Then the best way to reach this target is to If you want to see more PDF processing functions
add pdf files together online; c# pdf merge
Here we see the characters are 
'P'
'y'
't'
, and 
'h'
, which correspond to 
monty[6]
...
monty[9]
but not 
monty[10]
. This is because a slice starts at the first index but finishes
one before the end index.
We can also slice with negative indexes—the same basic rule of starting from the start
index and stopping one before the end index applies; here we stop before the space
character.
>>> monty[-12:-7]
'Monty'
As with list slices, if we omit the first value, the substring begins at the start of the string.
If we omit the second value, the substring continues to the end of the string:
>>> monty[:5]
'Monty'
>>> monty[6:]
'Python'
We test if a string contains a particular substring using the 
in
operator, as follows:
>>> phrase = 'And now for something completely different'
>>> if 'thing' in phrase:
...     print 'found "thing"'
found "thing"
We can also find the position of a substring within a string, using 
find()
:
>>> monty.find('Python')
6
Your Turn: Make up a sentence and assign it to a variable, e.g., 
sent =
'my sentence...'
. Now write slice expressions to pull out individual
words. (This is obviously not a convenient way to process the words of
a text!)
Figure 3-2. String slicing: The string Monty Python is shown along with its positive and negative
indexes; two substrings are selected using “slice” notation. The slice [m,n] contains the characters
from position m through n-1.
3.2  Strings: Text Processing at the Lowest Level l | | 91
More Operations on Strings
Python has comprehensive support for processing strings. A summary, including some
operations we haven’t seen yet, is shown in Table 3-2. For more information on strings,
type 
help(str)
at the Python prompt.
Table 3-2. Useful string methods: Operations on strings in addition to the string tests shown in
Table 1-4; all methods produce a new string or list
Method
Functionality
s.find(t)
Index of first instance of string 
t
inside 
s
(
-1
if not found)
s.rfind(t)
Index of last instance of string 
t
inside 
s
(
-1
if not found)
s.index(t)
Like 
s.find(t)
, except it raises 
ValueError
if not found
s.rindex(t)
Like 
s.rfind(t)
, except it raises 
ValueError
if not found
s.join(text)
Combine the words of the text into a string using 
s
as the glue
s.split(t)
Split 
s
into a list wherever a 
t
is found (whitespace by default)
s.splitlines()
Split 
s
into a list of strings, one per line
s.lower()
A lowercased version of the string 
s
s.upper()
An uppercased version of the string 
s
s.titlecase()
A titlecased version of the string 
s
s.strip()
A copy of 
s
without leading or trailing whitespace
s.replace(t, u)
Replace instances of 
t
with 
u
inside 
s
The Difference Between Lists and Strings
Strings and lists are both kinds of sequence. We can pull them apart by indexing and
slicing them, and we can join them together by concatenating them. However, we can-
not join strings and lists:
>>> query = 'Who knows?'
>>> query[2]
'o'
>>> beatles[2]
'George'
>>> query[:2]
'Wh'
>>> beatles[:2]
['John', 'Paul']
>>> query + " I don't"
"Who knows? I don't"
>>> beatles + 'Brian'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only concatenate list (not "str") to list
>>> beatles + ['Brian']
92 | | Chapter 3: Processing Raw Text
When we open a file for reading into a Python program, we get a string corresponding
to the contents of the whole file. If we use a 
for
loop to process the elements of this
string, all we can pick out are the individual characters—we don’t get to choose the
granularity. By contrast, the elements of a list can be as big or small as we like: for
example, they could be paragraphs, sentences, phrases, words, characters. So lists have
the advantage that we can be flexible about the elements they contain, and corre-
spondingly flexible about any downstream processing. Consequently, one of the first
things we are likely to do in a piece of NLP code is tokenize a string into a list of strings
(Section 3.7). Conversely, when we want to write our results to a file, or to a terminal,
we will usually format them as a string (Section 3.9).
Lists and strings do not have exactly the same functionality. Lists have the added power
that you can change their elements:
>>> beatles[0] = "John Lennon"
>>> del beatles[-1]
>>> beatles
['John Lennon', 'Paul', 'George']
On the other hand, if we try to do that with a string—changing the 0th character in
query
to 
'F'
—we get:
>>> query[0] = 'F'
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: object does not support item assignment
This is because strings are immutable: you can’t change a string once you have created
it. However, lists are mutable, and their contents can be modified at any time. As a
result, lists support operations that modify the original value rather than producing a
new value.
Your Turn: Consolidate your knowledge of strings by trying some of
the exercises on strings at the end of this chapter.
3.3  Text Processing with Unicode
Our programs will often need to deal with different languages, and different character
sets. The concept of “plain text” is a fiction. If you live in the English-speaking world
you probably use ASCII, possibly without realizing it. If you live in Europe you might
use one of the extended Latin character sets, containing such characters as “ø” for
Danish and Norwegian, “ő” for Hungarian, “ñ” for Spanish and Breton, and “ň” for
Czech and Slovak. In this section, we will give an overview of how to use Unicode for
processing texts that use non-ASCII character sets.
3.3  Text Processing with Unicode e | | 93
What Is Unicode?
Unicode supports over a million characters. Each character is assigned a number, called
code point. In Python, code points are written in the form 
\u
XXXX, where XXXX
is the number in four-digit hexadecimal form.
Within a program, we can manipulate Unicode strings just like normal strings. How-
ever, when Unicode characters are stored in files or displayed on a terminal, they must
be encoded as a stream of bytes. Some encodings (such as ASCII and Latin-2) use a
single byte per code point, so they can support only a small subset of Unicode, enough
for a single language. Other encodings (such as UTF-8) use multiple bytes and can
represent the full range of Unicode characters.
Text in files will be in a particular encoding, so we need some mechanism for translating
it into Unicode—translation into Unicode is called decoding. Conversely, to write out
Unicode to a file or a terminal, we first need to translate it into a suitable encoding—
this translation out of Unicode is called encoding, and is illustrated in Figure 3-3.
Figure 3-3. Unicode decoding and encoding.
From a Unicode perspective, characters are abstract entities that can be realized as one
or more glyphs. Only glyphs can appear on a screen or be printed on paper. A font is
a mapping from characters to glyphs.
Extracting Encoded Text from Files
Let’s assume that we have a small text file, and that we know how it is encoded. For
example, polish-lat2.txt, as the name suggests, is a snippet of Polish text (from the Polish
Wikipedia; see http://pl.wikipedia.org/wiki/Biblioteka_Pruska). This file is encoded as
Latin-2, also known as ISO-8859-2. The function 
nltk.data.find()
locates the file for
us.
94 | | Chapter 3: Processing Raw Text
The Python 
codecs
module provides functions to read encoded data into Unicode
strings, and to write out Unicode strings in encoded form. The 
codecs.open()
function
takes an encoding parameter to specify the encoding of the file being read or written.
So let’s import the 
codecs
module, and call it with the encoding 
'latin2'
to open our
Polish file as Unicode:
>>> import codecs
>>> f = codecs.open(path, encoding='latin2')
For a list of encoding parameters allowed by 
codecs
, see http://docs.python.org/lib/
standard-encodings.html. Note that we can write Unicode-encoded data to a file using
f = codecs.open(path, 'w', encoding='utf-8')
.
Text read from the file object 
f
will be returned in Unicode. As we pointed out earlier,
in order to view this text on a terminal, we need to encode it, using a suitable encoding.
The Python-specific encoding 
unicode_escape
is a dummy encoding that converts all
non-ASCII characters into their 
\u
XXXX representations. Code points above the ASCII
0–127 range but below 256 are represented in the two-digit form 
\x
XX.
>>> for line in f:
...     line = line.strip()
...     print line.encode('unicode_escape')
"Berlinka" to skarb kultury i sztuki niemieckiej. Przewiezione przez
odnalezione po 1945 r. na terytorium Polski. Trafi\u0142y do Biblioteki
archiwali\xf3w, m.in. manuskrypty Goethego, Mozarta, Beethovena, Bacha.
The first line in this output illustrates a Unicode escape string preceded by the 
\u
escape
string, namely 
\u0144
. The relevant Unicode character will be displayed on the screen
as the glyph ń. In the third line of the preceding example, we see 
\xf3
, which corre-
sponds to the glyph ó, and is within the 128–255 range.
In Python, a Unicode string literal can be specified by preceding an ordinary string
literal with a 
u
, as in 
u'hello'
. Arbitrary Unicode characters are defined using the
\u
XXXX escape sequence inside a Unicode string literal. We find the integer ordinal
of a character using 
ord()
. For example:
>>> ord('a')
97
The hexadecimal four-digit notation for 97 is 0061, so we can define a Unicode string
literal with the appropriate escape sequence:
>>> a = u'\u0061'
>>> a
u'a'
>>> print a
a
3.3  Text Processing with Unicode e | | 95
Notice that the Python 
print
statement is assuming a default encoding of the Unicode
character, namely ASCII. However, ń is outside the ASCII range, so cannot be printed
unless we specify an encoding. In the following example, we have specified that
print
should use the 
repr()
of the string, which outputs the UTF-8 escape sequences
(of the form 
\x
XX) rather than trying to render the glyphs.
>>> nacute = u'\u0144'
>>> nacute
u'\u0144'
>>> nacute_utf = nacute.encode('utf8')
>>> print repr(nacute_utf)
'\xc5\x84'
If your operating system and locale are set up to render UTF-8 encoded characters, you
ought to be able to give the Python command 
print nacute_utf
and see ń on your
screen.
There are many factors determining what glyphs are rendered on your
screen. If you are sure that you have the correct encoding, but your
Python code is still failing to produce the glyphs you expected, you
should also check that you have the necessary fonts installed on your
system.
The module 
unicodedata
lets us inspect the properties of Unicode characters. In the
following example, we select all characters in the third line of our Polish text outside
the ASCII range and print their UTF-8 escaped value, followed by their code point
integer using the standard Unicode convention (i.e., prefixing the hex digits with 
U+
),
followed by their Unicode name.
>>> import unicodedata
>>> lines = codecs.open(path, encoding='latin2').readlines()
>>> line = lines[2]
>>> print line.encode('unicode_escape')
>>> for c in line:
...     if ord(c) > 127:
'\xc3\xb3' U+00f3 LATIN SMALL LETTER O WITH ACUTE
'\xc5\x9b' U+015b LATIN SMALL LETTER S WITH ACUTE
'\xc5\x9a' U+015a LATIN CAPITAL LETTER S WITH ACUTE
'\xc4\x85' U+0105 LATIN SMALL LETTER A WITH OGONEK
'\xc5\x82' U+0142 LATIN SMALL LETTER L WITH STROKE
If you replace the 
%r
(which yields the 
repr()
value) by 
%s
in the format string of the
preceding code sample, and if your system supports UTF-8, you should see an output
like the following:
ó U+00f3 LATIN SMALL LETTER O WITH ACUTE
ś U+015b LATIN SMALL LETTER S WITH ACUTE
Ś U+015a LATIN CAPITAL LETTER S WITH ACUTE
96 | | Chapter 3: Processing Raw Text
ą U+0105 LATIN SMALL LETTER A WITH OGONEK
ł U+0142 LATIN SMALL LETTER L WITH STROKE
Alternatively, you may need to replace the encoding 
'utf8'
in the example by
'latin2'
, again depending on the details of your system.
The next examples illustrate how Python string methods and the 
re
module accept
Unicode strings.
>>> line.find(u'zosta\u0142y')
54
>>> line = line.lower()
>>> print line.encode('unicode_escape')
>>> import re
>>> m = re.search(u'\u015b\w*', line)
>>> m.group()
u'\u015bwiatowej'
NLTK tokenizers allow Unicode strings as input, and correspondingly yield Unicode
strings as output.
>>> nltk.word_tokenize(line)  
Using Your Local Encoding in Python
If you are used to working with characters in a particular local encoding, you probably
want to be able to use your standard methods for inputting and editing strings in a
Python file. In order to do this, you need to include the string 
'# -*- coding: <coding>
-*-'
as the first or second line of your file. Note that 
<coding>
has to be a string like
'latin-1'
'big5'
, or 
'utf-8'
(see Figure 3-4).
Figure 3-4 also illustrates how regular expressions can use encoded strings.
3.4  Regular Expressions for Detecting Word Patterns
Many linguistic processing tasks involve pattern matching. For example, we can find
words ending with ed using 
endswith('ed')
. We saw a variety of such “word tests” in
Table 1-4. Regular expressions give us a more powerful and flexible method for de-
scribing the character patterns we are interested in.
There are many other published introductions to regular expressions,
organized around the syntax of regular expressions and applied to
searching text files. Instead of doing this again, we focus on the use of
regular expressions at different stages of linguistic processing. As usual,
we’ll adopt a problem-based approach and present new features only as
they are needed to solve practical problems. In our discussion we will
mark regular expressions using chevrons like this: «
patt
».
3.4  Regular Expressions for Detecting Word Patterns s | | 97
To use regular expressions in Python, we need to import the 
re
library using: 
import
re
. We also need a list of words to search; we’ll use the Words Corpus again (Sec-
tion 2.4). We will preprocess it to remove any proper names.
>>> import re
Using Basic Metacharacters
Let’s find words ending with ed using the regular expression «
ed$
». We will use the
re.search(p, s)
function to check whether the pattern 
p
can be found somewhere
inside the string 
s
. We need to specify the characters of interest, and use the dollar sign,
which has a special behavior in the context of regular expressions in that it matches the
end of the word:
>>> [w for w in wordlist if re.search('ed$', w)]
The 
.
wildcard symbol matches any single character. Suppose we have room in a
crossword puzzle for an eight-letter word, with j as its third letter and t as its sixth letter.
In place of each blank cell we use a period:
>>> [w for w in wordlist if re.search('^..j..t..$', w)]
Figure 3-4. Unicode and IDLE: UTF-8 encoded string literals in the IDLE editor; this requires that
an appropriate font is set in IDLE’s preferences; here we have chosen Courier CE.
98 | | Chapter 3: Processing Raw Text
Documents you may be interested
Documents you may be interested