itextsharp pdf to image c# example : Cannot save pdf form in reader SDK application service wpf html windows dnn Automate%20the%20Boring%20Stuff%20with%20Python%20(2015)18-part1606

Pattern Matching with Regular Expressions
157
previous curly bracket example returns 
'HaHaHaHaHa'
instead of the shorter 
possibilities. After all, 
'HaHaHa'
and 
'HaHaHaHa'
are also valid matches of the 
regular expression 
(Ha){3,5}
.
Python’s regular expressions are greedy by default, which means that in 
ambiguous situations they will match the longest string possible. The non-
greedy version of the curly brackets, which matches the shortest string pos-
sible, has the closing curly bracket followed by a question mark.
Enter the following into the interactive shell, and notice the dif-
ference between the greedy and nongreedy forms of the curly brackets 
searching the same string:
>>> greedyHaRegex = re.compile(r'(Ha){3,5}')
>>> mo1 = greedyHaRegex.search('HaHaHaHaHa')
>>> mo1.group()
'HaHaHaHaHa'
>>> nongreedyHaRegex = re.compile(r'(Ha){3,5}?')
>>> mo2 = nongreedyHaRegex.search('HaHaHaHaHa')
>>> mo2.group()
'HaHaHa'
Note that the question mark can have two meanings in regular expres-
sions: declaring a nongreedy match or flagging an optional group. These 
meanings are entirely unrelated.
the findall() method
In addition to the 
search()
method, 
Regex
objects also have a 
findall()
method. While 
search()
will return a 
Match
object of the first matched text 
in the searched string, the 
findall()
method will return the strings of every 
match in the searched string. To see how 
search()
returns a 
Match
object 
only on the first instance of matching text, enter the following into the 
interactive shell:
>>> phoneNumRegex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d')
>>> mo = phoneNumRegex.search('Cell: 415-555-9999 Work: 212-555-0000')
>>> mo.group()
'415-555-9999'
On the other hand, 
findall()
will not return a 
Match
object but a list of 
strings—as long as there are no groups in the regular expression. Each string in 
the list is a piece of the searched text that matched the regular expression. 
Enter the following into the interactive shell:
>>> phoneNumRegex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d') # has no groups
>>> phoneNumRegex.findall('Cell: 415-555-9999 Work: 212-555-0000')
['415-555-9999', '212-555-0000']
If there are groups in the regular expression, then 
findall()
will return 
a list of tuples. Each tuple represents a found match, and its items are the 
Cannot save pdf form in reader - C# PDF Field Edit Library: insert, delete, update pdf form field in C#.net, ASP.NET, MVC, Ajax, WPF
Online C# Tutorial to Insert, Delete and Update Fields in PDF Document
create pdf forms; add fillable fields to pdf online
Cannot save pdf form in reader - VB.NET PDF Field Edit library: insert, delete, update pdf form field in vb.net, ASP.NET, MVC, Ajax, WPF
How to Insert, Delete and Update Fields in PDF Document with VB.NET Demo Code
edit pdf form; add date to pdf form
158   
Chapter 7
matched strings for each group in the regex. To see 
findall()
in action, enter 
the following into the interactive shell (notice that the regular expression 
being compiled now has groups in parentheses):
>>> phoneNumRegex = re.compile(r'(\d\d\d)-(\d\d\d)-(\d\d\d\d)') # has groups
>>> phoneNumRegex.findall('Cell: 415-555-9999 Work: 212-555-0000')
[('415', '555', '1122'), ('212', '555', '0000')]
To summarize what the 
findall()
method returns, remember the 
following:
1.  When called on a regex with no groups, such as 
\d\d\d-\d\d\d-\d\d\d\d
the method 
findall()
returns a list of string matches, such as 
['415-555-
9999', '212-555-0000']
.
2.  When called on a regex that has groups, such as 
(\d\d\d)-(\d\d\d)-(\d\
d\d\d)
, the method 
findall()
returns a list of tuples of strings (one string 
for each group), such as 
[('415', '555', '1122'), ('212', '555', '0000')]
.
Character Classes
In the earlier phone number regex example, you learned that 
\d
could 
stand for any numeric digit. That is, 
\d
is shorthand for the regular expres-
sion 
(0|1|2|3|4|5|6|7|8|9)
. There are many such shorthand character classes, as 
shown in Table 7-1.
Table 7-1: Shorthand Codes for Common Character Classes
Shorthand character class
Represents
\d
Any numeric digit from 0 to 9.
\D
Any character that is not a numeric digit from 0 to 9.
\w
Any letter, numeric digit, or the underscore character. 
(Think of this as matching “word” characters.)
\W
Any character that is not a letter, numeric digit, or the 
underscore character.
\s
Any space, tab, or newline character. (Think of this as 
matching “space” characters.)
\S
Any character that is not a space, tab, or newline.
Character classes are nice for shortening regular expressions. The char-
acter class 
[0-5]
will match only the numbers 
0
to 
5
; this is much shorter 
than typing 
(0|1|2|3|4|5)
.
For example, enter the following into the interactive shell:
>>> xmasRegex = re.compile(r'\d+\s\w+')
>>> xmasRegex.findall('12 drummers, 11 pipers, 10 lords, 9 ladies, 8 maids, 7 
swans, 6 geese, 5 rings, 4 birds, 3 hens, 2 doves, 1 partridge')
['12 drummers', '11 pipers', '10 lords', '9 ladies', '8 maids', '7 swans', '6 
geese', '5 rings', '4 birds', '3 hens', '2 doves', '1 partridge']
C# PDF: PDF Document Viewer & Reader SDK for Windows Forms
SaveFile(String filePath): Save PDF document file to a specified path in a file dialog and load your PDF document in will be a pop-up window "cannot open your
add form fields to pdf; pdf form creation
VB.NET Create PDF Library SDK to convert PDF from other file
because you can make sure that the PDF file cannot be altered pages Dim doc As PDFDocument = PDFDocument.Create(2) ' Save the new created PDF document into
adding text to a pdf form; add image field to pdf form
Pattern Matching with Regular Expressions
159
The regular expression 
\d+\s\w+
will match text that has one or more 
numeric digits (
\d+
), followed by a whitespace character (
\s
), followed by 
one or more letter/digit/underscore characters (
\w+
). The 
findall()
method 
returns all matching strings of the regex pattern in a list.
making your own character classes
There are times when you want to match a set of characters but the short-
hand character classes (
\d
\w
\s
, and so on) are too broad. You can define 
your own character class using square brackets. For example, the character 
class 
[aeiouAEIOU]
will match any vowel, both lowercase and uppercase. Enter 
the following into the interactive shell:
>>> vowelRegex = re.compile(r'[aeiouAEIOU]')
>>> vowelRegex.findall('RoboCop eats baby food. BABY FOOD.')
['o', 'o', 'o', 'e', 'a', 'a', 'o', 'o', 'A', 'O', 'O']
You can also include ranges of letters or numbers by using a hyphen. 
For example, the character class 
[a-zA-Z0-9]
will match all lowercase letters, 
uppercase letters, and numbers.
Note that inside the square brackets, the normal regular expression 
symbols are not interpreted as such. This means you do not need to escape 
the 
.
*
?
, or 
()
characters with a preceding backslash. For example, the 
character class 
[0-5.]
will match digits 
0
to 
5
and a period. You do not need 
to write it as 
[0-5\.]
.
By placing a caret character (
^
) just after the character class’s opening 
bracket, you can make a negative character class. A negative character class 
will match all the characters that are not in the character class. For example, 
enter the following into the interactive shell:
>>> consonantRegex = re.compile(r'[^aeiouAEIOU]')
>>> consonantRegex.findall('RoboCop eats baby food. BABY FOOD.')
['R', 'b', 'c', 'p', ' ', 't', 's', ' ', 'b', 'b', 'y', ' ', 'f', 'd', '.', ' 
', 'B', 'B', 'Y', ' ', 'F', 'D', '.']
Now, instead of matching every vowel, we’re matching every character 
that isn’t a vowel.
the caret and dollar Sign characters
You can also use the caret symbol (
^
) at the start of a regex to indicate that 
a match must occur at the beginning of the searched text. Likewise, you can 
put a dollar sign (
$
) at the end of the regex to indicate the string must end 
with this regex pattern. And you can use the 
^
and 
$
together to indicate 
that the entire string must match the regex—that is, it’s not enough for a 
match to be made on some subset of the string. 
C# Image: How to Use C# Code to Capture Document from Scanning
installed on the client as browsers cannot interface directly Save a the customized multi-page document to a a multi-page document (including PDF, TIFF, Word
changing font size in a pdf form; add image to pdf form
VB.NET Image: VB.NET Code to Add Rubber Stamp Annotation to Image
designed image and document, then you cannot miss RasterEdge image or document files; Able to save created rubber Suitable for VB.NET PDF, Word & TIFF document
change font size in pdf form; create a fillable pdf form from a word document
160   
Chapter 7
For example, the 
r'^Hello'
regular expression string matches strings 
that begin with 
'Hello'
. Enter the following into the interactive shell:
>>> beginsWithHello = re.compile(r'^Hello')
>>> beginsWithHello.search('Hello world!')
<_sre.SRE_Match object; span=(0, 5), match='Hello'>
>>> beginsWithHello.search('He said hello.') == None
True
The 
r'\d$'
regular expression string matches strings that end with a 
numeric character from 0 to 9. Enter the following into the interactive shell:
>>> endsWithNumber = re.compile(r'\d$')
>>> endsWithNumber.search('Your number is 42')
<_sre.SRE_Match object; span=(16, 17), match='2'>
>>> endsWithNumber.search('Your number is forty two.') == None
True
The 
r'^\d+$'
regular expression string matches strings that both begin 
and end with one or more numeric characters. Enter the following into the 
interactive shell:
>>> wholeStringIsNum = re.compile(r'^\d+$')
>>> wholeStringIsNum.search('1234567890')
<_sre.SRE_Match object; span=(0, 10), match='1234567890'>
>>> wholeStringIsNum.search('12345xyz67890') == None
True
>>> wholeStringIsNum.search('12  34567890') == None
True
The last two 
search()
calls in the previous interactive shell example dem-
onstrate how the entire string must match the regex if 
^
and 
$
are used.
I always confuse the meanings of these two symbols, so I use the mne-
monic “Carrots cost dollars” to remind myself that the caret comes first and 
the dollar sign comes last.
the wildcard character
The 
.
(or dot) character in a regular expression is called a wildcard and will 
match any character except for a newline. For example, enter the following 
into the interactive shell:
>>> atRegex = re.compile(r'.at')
>>> atRegex.findall('The cat in the hat sat on the flat mat.')
['cat', 'hat', 'sat', 'lat', 'mat']
VB.NET TIFF: VB.NET Sample Codes to Add Watermark in a TIFF Image
would not be obscured and cannot be removed for TIFF watermark embedding; Easily save updated TIFF powerful & profession imaging controls, PDF document, image
android edit pdf forms; create a pdf form online
VB.NET Word: .NET Project for Merging Two or More Microsoft Word
REDocument), fileNameMerged, New DOCXEncoder()) 'save new word Unfortunately, it cannot be used in commercial profession imaging controls, PDF document, image
change font in pdf form; create a pdf form in word
Pattern Matching with Regular Expressions
161
Remember that the dot character will match just one character, which 
is why the match for the text 
flat
in the previous example matched only 
lat
To match an actual dot, escape the dot with a backslash: 
\.
.
Matching Everything with Dot-Star
Sometimes you will want to match everything and anything. For example, 
say you want to match the string 
'First Name:'
, followed by any and all text, 
followed by 
'Last Name:'
, and then followed by anything again. You can 
use the dot-star (
.*
) to stand in for that “anything.” Remember that the 
dot character means “any single character except the newline,” and the 
star character means “zero or more of the preceding character.”
Enter the following into the interactive shell:
>>> nameRegex = re.compile(r'First Name: (.*) Last Name: (.*)')
>>> mo = nameRegex.search('First Name: Al Last Name: Sweigart')
>>> mo.group(1)
'Al'
>>> mo.group(2)
'Sweigart'
The dot-star uses greedy mode: It will always try to match as much text as 
possible. To match any and all text in a nongreedy fashion, use the dot, star, 
and question mark (
.*?
). Like with curly brackets, the question mark tells 
Python to match in a nongreedy way.
Enter the following into the interactive shell to see the difference 
between the greedy and nongreedy versions:
>>> nongreedyRegex = re.compile(r'<.*?>')
>>> mo = nongreedyRegex.search('<To serve man> for dinner.>')
>>> mo.group()
'<To serve man>'
>>> greedyRegex = re.compile(r'<.*>')
>>> mo = greedyRegex.search('<To serve man> for dinner.>')
>>> mo.group()
'<To serve man> for dinner.>'
Both regexes roughly translate to “Match an opening angle bracket, 
followed by anything, followed by a closing angle bracket.” But the string 
'<To serve man> for dinner.>'
has two possible matches for the closing angle 
bracket. In the nongreedy version of the regex, Python matches the shortest 
possible string: 
'<To serve man>'
. In the greedy version, Python matches the 
longest possible string: 
'<To serve man> for dinner.>'
.
C# TIFF: C#.NET Code to Create Windows TIFF Viewer | Online
document annotating support; Simple to save and output would be an notice with "cannot open your file powerful & profession imaging controls, PDF document, image
add an image to a pdf form; change font on pdf form
C# Image: Create C#.NET Windows Document Image Viewer | Online
viewing multiple document & image formats (PDF, MS Word SaveFile(String filePath): Save loaded file to a specified there will prompt a window "cannot open your
create a form in pdf; add editable fields to pdf
162   
Chapter 7
Matching Newlines with the Dot Character
The dot-star will match everything except a newline. By passing 
re.DOTALL
as 
the second argument to 
re.compile()
, you can make the dot character match 
all characters, including the newline character.
Enter the following into the interactive shell:
>>> noNewlineRegex = re.compile('.*')
>>> noNewlineRegex.search('Serve the public trust.\nProtect the innocent. 
\nUphold the law.').group()
'Serve the public trust.'
>>> newlineRegex = re.compile('.*', re.DOTALL)
>>> newlineRegex.search('Serve the public trust.\nProtect the innocent. 
\nUphold the law.').group()
'Serve the public trust.\nProtect the innocent.\nUphold the law.'
The regex 
noNewlineRegex
, which did not have 
re.DOTALL
passed to the 
re.compile()
call that created it, will match everything only up to the first 
newline character, whereas 
newlineRegex
, which did have 
re.DOTALL
passed to 
re.compile()
, matches everything. This is why the 
newlineRegex.search()
call 
matches the full string, including its newline characters.
review of regex Symbols
This chapter covered a lot of notation, so here’s a quick review of what 
you learned:
•  The 
?
matches zero or one of the preceding group.
•  The 
*
matches zero or more of the preceding group.
•  The 
+
matches one or more of the preceding group.
•  The 
{n}
matches exactly n of the preceding group.
•  The 
{n,}
matches n or more of the preceding group.
•  The 
{,m}
matches 0 to m of the preceding group.
•  The 
{n,m}
matches at least n and at most m of the preceding group.
• 
{n,m}?
or 
*?
or 
+?
performs a nongreedy match of the preceding group.
• 
^spam
means the string must begin with spam.
• 
spam$
means the string must end with spam.
•  The 
.
matches any character, except newline characters.
• 
\d
\w
, and 
\s
match a digit, word, or space character, respectively.
• 
\D
\W
, and 
\S
match anything except a digit, word, or space character, 
respectively.
• 
[abc]
matches any character between the brackets (such as a, b, or c).
• 
[^abc]
matches any character that isn’t between the brackets.
C# Excel: View Excel File in Window Document Viewer Control
Easy to view, edit, annotate and save Excel (.xlsx there will prompt a window "cannot open your file powerful & profession imaging controls, PDF document, image
cannot save pdf form in reader; change pdf to fillable form
C# PowerPoint: Document Viewer Creating in Windows Forms Project
C#.NET users to edit, annotate and save PowerPoint document NET tutorial, we will take a blank form as an control, there will prompt a window "cannot open your
add picture to pdf form; add fields to pdf
Pattern Matching with Regular Expressions
163
case-insensitive matching
Normally, regular expressions match text with the exact casing you specify. 
For example, the following regexes match completely different strings:
>>> regex1 = re.compile('RoboCop')
>>> regex2 = re.compile('ROBOCOP')
>>> regex3 = re.compile('robOcop')
>>> regex4 = re.compile('RobocOp')
But sometimes you care only about matching the letters without worry-
ing whether they’re uppercase or lowercase. To make your regex case-insen-
sitive, you can pass 
re.IGNORECASE
or 
re.I
as a second argument to 
re.compile()
Enter the following into the interactive shell:
>>> robocop = re.compile(r'robocop', re.I)
>>> robocop.search('RoboCop is part man, part machine, all cop.').group()
'RoboCop'
>>> robocop.search('ROBOCOP protects the innocent.').group()
'ROBOCOP'
>>> robocop.search('Al, why does your programming book talk about robocop so much?').group()
'robocop'
Substituting Strings with the sub() method
Regular expressions can not only find text patterns but can also substitute 
new text in place of those patterns. The 
sub()
method for 
Regex
objects is 
passed two arguments. The first argument is a string to replace any matches. 
The second is the string for the regular expression. The 
sub()
method returns 
a string with the substitutions applied.
For example, enter the following into the interactive shell:
>>> namesRegex = re.compile(r'Agent \w+')
>>> namesRegex.sub('CENSORED', 'Agent Alice gave the secret documents to Agent Bob.')
'CENSORED gave the secret documents to CENSORED.'
Sometimes you may need to use the matched text itself as part of the 
substitution. In the first argument to 
sub()
, you can type 
\1
\2
\3
, and so 
on, to mean “Enter the text of group 
1
2
3
, and so on, in the substitution.”
For example, say you want to censor the names of the secret agents by 
showing just the first letters of their names. To do this, you could use the 
regex 
Agent (\w)\w*
and pass 
r'\1****'
as the first argument to 
sub()
. The 
\1
in that string will be replaced by whatever text was matched by group 
1
that is, the 
(\w)
group of the regular expression.
164   
Chapter 7
>>> agentNamesRegex = re.compile(r'Agent (\w)\w*')
>>> agentNamesRegex.sub(r'\1****', 'Agent Alice told Agent Carol that Agent 
Eve knew Agent Bob was a double agent.')
A**** told C**** that E**** knew B**** was a double agent.'
managing complex regexes
Regular expressions are fine if the text pattern you need to match is simple. 
But matching complicated text patterns might require long, convoluted reg-
ular expressions. You can mitigate this by telling the 
re.compile()
function 
to ignore whitespace and comments inside the regular expression string. 
This “verbose mode” can be enabled by passing the variable 
re.VERBOSE
as 
the second argument to 
re.compile()
.
Now instead of a hard-to-read regular expression like this:
phoneRegex = re.compile(r'((\d{3}|\(\d{3}\))?(\s|-|\.)?\d{3}(\s|-|\.)\d{4}
(\s*(ext|x|ext.)\s*\d{2,5})?)')
you can spread the regular expression over multiple lines with comments 
like this:
phoneRegex = re.compile(r'''(
(\d{3}|\(\d{3}\))?            # area code
(\s|-|\.)?                    # separator
\d{3}                         # first 3 digits
(\s|-|\.)                     # separator
\d{4}                         # last 4 digits
(\s*(ext|x|ext.)\s*\d{2,5})?  # extension
)''', re.VERBOSE)
Note how the previous example uses the triple-quote syntax (
'''
) to 
create a multiline string so that you can spread the regular expression defi-
nition over many lines, making it much more legible.
The comment rules inside the regular expression string are the same as 
regular Python code: The 
#
symbol and everything after it to the end of the 
line are ignored. Also, the extra spaces inside the multiline string for the reg-
ular expression are not considered part of the text pattern to be matched. 
This lets you organize the regular expression so it’s easier to read.
combining re.ignorecASe, re.dotAll, and re.VerBoSe
What if you want to use 
re.VERBOSE
to write comments in your regular expres-
sion but also want to use 
re.IGNORECASE
to ignore capitalization? Unfortunately, 
the 
re.compile()
function takes only a single value as its second argument. You 
can get around this limitation by combining the 
re.IGNORECASE
re.DOTALL
, and 
re.VERBOSE
variables using the pipe character (
|
), which in this context is 
known as the bitwise or operator.
Pattern Matching with Regular Expressions
165
So if you want a regular expression that’s case-insensitive and includes 
newlines to match the dot character, you would form your 
re.compile()
call 
like this:
>>> someRegexValue = re.compile('foo', re.IGNORECASE | re.DOTALL)
All three options for the second argument will look like this:
>>> someRegexValue = re.compile('foo', re.IGNORECASE | re.DOTALL | re.VERBOSE)
This syntax is a little old-fashioned and originates from early versions 
of Python. The details of the bitwise operators are beyond the scope of this 
book, but check out the resources at http://nostarch.com/automatestuff/ for 
more information. You can also pass other options for the second argument; 
they’re uncommon, but you can read more about them in the resources, too.
Project: Phone number and email Address extractor
Say you have the boring task of finding every phone number and email 
address in a long web page or document. If you manually scroll through 
the page, you might end up searching for a long time. But if you had a pro-
gram that could search the text in your clipboard for phone numbers and 
email addresses, you could simply press 
ctrl
-A to select all the text, press 
ctrl
-c to copy it to the clipboard, and then run your program. It could 
replace the text on the clipboard with just the phone numbers and email 
addresses it finds.
Whenever you’re tackling a new project, it can be tempting to dive right 
into writing code. But more often than not, it’s best to take a step back and 
consider the bigger picture. I recommend first drawing up a high-level plan 
for what your program needs to do. Don’t think about the actual code yet—
you can worry about that later. Right now, stick to broad strokes.
For example, your phone and email address extractor will need to do 
the following:
•  Get the text off the clipboard.
•  Find all phone numbers and email addresses in the text.
•  Paste them onto the clipboard.
Now you can start thinking about how this might work in code. The 
code will need to do the following:
•  Use the 
pyperclip
module to copy and paste strings.
•  Create two regexes, one for matching phone numbers and the other for 
matching email addresses.
•  Find all matches, not just the first match, of both regexes.
•  Neatly format the matched strings into a single string to paste.
•  Display some kind of message if no matches were found in the text.
166   
Chapter 7
This list is like a road map for the project. As you write the code, you 
can focus on each of these steps separately. Each step is fairly manageable 
and expressed in terms of things you already know how to do in Python.
Step 1: Create a Regex for Phone Numbers
First, you have to create a regular expression to search for phone numbers. 
Create a new file, enter the following, and save it as phoneAndEmail.py:
#! python3
# phoneAndEmail.py - Finds phone numbers and email addresses on the clipboard.
import pyperclip, re
phoneRegex = re.compile(r'''(
(\d{3}|\(\d{3}\))?                # area code
(\s|-|\.)?                        # separator
(\d{3})                           # first 3 digits
(\s|-|\.)                         # separator
(\d{4})                           # last 4 digits
(\s*(ext|x|ext.)\s*(\d{2,5}))?    # extension
)''', re.VERBOSE)
# TODO: Create email regex.
# TODO: Find matches in clipboard text.
# TODO: Copy results to the clipboard.
The 
TODO
comments are just a skeleton for the program. They’ll be 
replaced as you write the actual code.
The phone number begins with an optional area code, so the area code 
group is followed with a question mark. Since the area code can be just 
three digits (that is, 
\d{3}
) or three digits within parentheses (that is, 
\(\d{3}\)
), 
you should have a pipe joining those parts. You can add the regex comment 
# Area code
to this part of the multiline string to help you remember what 
(\d{3}|\(\d{3}\))?
is supposed to match.
The phone number separator character can be a space (
\s
), hyphen (
-
), 
or period (
.
), so these parts should also be joined by pipes. The next few 
parts of the regular expression are straightforward: three digits, followed 
by another separator, followed by four digits. The last part is an optional 
extension made up of any number of spaces followed by 
ext
x
, or 
ext.
, fol-
lowed by two to five digits. 
Step 2: Create a Regex for Email Addresses
You will also need a regular expression that can match email addresses. 
Make your program look like the following:
#! python3
# phoneAndEmail.py - Finds phone numbers and email addresses on the clipboard.
Documents you may be interested
Documents you may be interested