c# display pdf in browser : Add page numbers to pdf using preview control Library system azure .net winforms console Python.3.Object.Oriented.Programming.Dusty.Phillips.201015-part402

When to Use Object-oriented Programming
[
138 
]
As an example, we'll write a program that does a find and replace action for text files 
stored in a compressed ZIP file. We'll need objects to represent the ZIP file and each 
individual text file (luckily, we don't have to write these classes, they're available in 
three steps occur in order:
1. Unzipping the compressed file.
2. Performing the find and replace action.
3. Zipping up the new files.
The class is initialized with the 
.zip
filename and search and replace strings. We 
create a temporary directory to store the unzipped files in, so that the folder stays 
individual filename inside that directory:
import sys
import os
import shutil
import zipfile
class ZipReplace:
def __init__(self, filename, search_string,
replace_string):
self.filename = filename
self.search_string = search_string
self.replace_string = replace_string
self.temp_directory = "unzipped-{}".format(
filename)
def _full_filename(self, filename):
return os.path.join(self.temp_directory, filename)
several advantages to separating the three steps:
Readability: The code for each step is in a self-contained unit that is easy to 
read and understand. The method names describe what the method does, 
Extensibility: If a subclass wanted to use compressed TAR files instead of 
ZIP files, it could override the 
zip
and 
unzip
methods without having to 
duplicate the 
find_replace
method.
Add page numbers to pdf using preview - insert pages into PDF file in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Guide C# Users to Insert (Empty) PDF Page or Pages from a Supported File Format
adding page numbers in pdf file; add blank page to pdf
Add page numbers to pdf using preview - VB.NET PDF Page Insert Library: insert pages into PDF file in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Easy to Use VB.NET APIs to Add a New Blank Page to PDF Document
add page numbers to pdf preview; adding page numbers pdf file
Chapter 5
[
139 
]
Partitioning: An external class could create an instance of this class and call 
the find and replace method directly on some folder without having to 
zip
the content.
The delegation method is the first in the code below; the rest of the methods are 
included for completeness:
def zip_find_replace(self):
self.unzip_files()
self.find_replace()
self.zip_files()
def unzip_files(self):
os.mkdir(self.temp_directory)
zip = zipfile.ZipFile(self.filename)
try:
zip.extractall(self.temp_directory)
finally:
zip.close()
def find_replace(self):
for filename in os.listdir(self.temp_directory):
with open(self._full_filename(filename)) as file:
contents = file.read()
contents = contents.replace(
self.search_string, self.replace_string)
with open(
self._full_filename(filename), "w") as file:
file.write(contents)
def zip_files(self):
file = zipfile.ZipFile(self.filename, 'w')
for filename in os.listdir(self.temp_directory):
file.write(
self._full_filename(filename), filename)
shutil.rmtree(self.temp_directory)
if __name__ == "__main__":
ZipReplace(*sys.argv[1:4]).zip_find_replace()
For brevity, the code for zipping and unzipping files is sparsely documented. Our 
of the 
zipfile
module, refer to the documentation in the standard library, either 
online at 
http://docs.python.org/library/zipfile.html
or by typing 
import
zipfile
;
help(zipfile)
into your interactive interpreter. Note that this example 
only searches the top-level files in a ZIP file; if there are any folders in the unzipped 
content, they will not be scanned, nor will any files inside those folders.
C# Create PDF Library SDK to convert PDF from other file formats
them the ability to count the page numbers of generated PDF document in C#.NET using this PDF document creating toolkit, if you need to add some text
adding page numbers to pdf in; add pdf pages to word document
C# PowerPoint - PowerPoint Creating in C#.NET
them the ability to count the page numbers of generated a PowerPoint document in C#.NET using this PowerPoint creating toolkit, if you need to add some text
add a page to a pdf in reader; adding a page to a pdf in reader
When to Use Object-oriented Programming
[
140 
]
passing the zIP filename, search string, and replace string as arguments:
python zipsearch.py hello.zip hello hi
imported from another module (to perform batch ZIP file processing) or accessed as 
do with ZIP files (for example to retrieve them from an FTP server or back them up 
to an external disk).
As programs become more and more complex, the objects being modeled  
well-defined behaviors.
Removing duplicate code
Often the code in management style classes such as 
ZipReplace
is quite generic 
Before we look at any examples of this, let's discuss a tiny bit of theory. Specifically: 
why is duplicate code a bad thing?
than figure out how to extract the overlapping functionality.
code should always be written to be readable first.
C# Word - Word Creating in C#.NET
offer them the ability to count the page numbers of generated creating a Word document in C#.NET using this Word creating toolkit, if you need to add some text
add page numbers pdf files; adding a page to a pdf
C# Word - Word Create or Build in C#.NET
also offer them the ability to count the page numbers of generated using this Word document adding control, you can add some additional Create Word From PDF.
add pages to pdf online; add page number pdf
Chapter 5
[
141 
]
I once had to try to understand someone's code that had three identical 
copies of the same three hundred lines of very poorly written code. I 
had been working with the code for a month before I realized that the 
were also obvious areas where someone had updated a calculation in 
one function without updating the other two. The number of subtle, 
incomprehensible bugs in the code could not be counted.
usually manifest themselves as, "but I fixed that already, why is it still happening?"
had written the code in a non-repetitive manner in the first place. It's even more 
copy-pasting existing code is lost the very first time we have to maintain it. Code is 
Comprehensible code should always be paramount.
elegant code more than average), follow what is known as the Don't Repeat 
Yourself, or DRY principle. DRY code is maintainable code. My advice to beginning 
intermediate programmers, I suggest they think thrice before they hit Ctrl + C.
sufficient. For example, if we have two pieces of code that unzip a ZIP file into two 
slightly more difficult to read, but a good function name and docstring can easily 
to write. 
C# Excel - Excel Creating in C#.NET
also offer them the ability to count the page numbers of generated a Excel document in C#.NET using this Excel creating toolkit, if you need to add some text
add page numbers to a pdf document; add page numbers to a pdf
When to Use Object-oriented Programming
[
142 
]
In practice
strings in a ZIP file full of text files, we are later contracted to scale all the images in a 
ZIP file to 640x480. Looks like we could use a very similar paradigm to what we used 
in 
ZipReplace
. The first impulse, obviously, would be to save a copy of that file and 
change the 
find_replace
method to 
scale_image
or something similar. But, that's 
open TAR files? Or maybe we want to use a guaranteed unique directory name for 
temporary files. In either case, we'd have to change it in two different places!
we'll modify our original 
ZipReplace
class into a superclass for processing generic 
ZIP files:
import os
import shutil
import zipfile
class ZipProcessor:
def __init__(self, zipname):
self.zipname = zipname
self.temp_directory = "unzipped-{}".format(
zipname[:-4])
def _full_filename(self, filename):
return os.path.join(self.temp_directory, filename)
def process_zip(self):
self.unzip_files()
self.process_files()
self.zip_files()
def unzip_files(self):
os.mkdir(self.temp_directory)
zip = zipfile.ZipFile(self.zipname)
try:
zip.extractall(self.temp_directory)
finally:
zip.close()
def zip_files(self):
file = zipfile.ZipFile(self.zipname, 'w')
for filename in os.listdir(self.temp_directory):
file.write(self._full_filename(
filename), filename)
shutil.rmtree(self.temp_directory)
Chapter 5
[
143 
]
We changed the 
filename
property to 
zipfile
to avoid confusion with the 
filename
parameters to 
__init__
(
search_string
and 
replace_string
) that were specific to 
ZipReplace
. Then we renamed the 
zip_find_replace
method to 
process_zip
and 
made it call an (as yet undefined) 
process_files
method instead of 
find_replace
Notice that we have removed the 
find_replace
method altogether; that code is 
specific to 
ZipReplace
and has no business here.
This new 
ZipProcessor
class doesn't actually define a 
process_files
method; so if 
Now, before we move on to our image processing app, let's fix up our original 
zipsearch
to make use of this parent class:
from zip_processor import ZipProcessor
import sys
import os
class ZipReplace(ZipProcessor):
def __init__(self, filename, search_string,
replace_string):
super().__init__(filename)
self.search_string = search_string
self.replace_string = replace_string
def process_files(self):
'''perform a search and replace on all files
in the temporary directory'''
for filename in os.listdir(self.temp_directory):
with open(self._full_filename(filename)) as file:
contents = file.read()
contents = contents.replace(
self.search_string, self.replace_string)
with open(
self._full_filename(filename), "w") as file:
file.write(contents)
if __name__ == "__main__":
ZipReplace(*sys.argv[1:4]).process_zip()
When to Use Object-oriented Programming
[
144 
]
zIP processing 
abilities from the parent class. We first import the base class we just wrote and make 
ZipReplace
extend that class. Then we use 
super()
to initialize the parent class. 
The 
find_replace
method is still here, but we renamed it to 
process_files
so 
added a docstring to describe what it is doing.
work, it is now much easier for us to write other classes that operate on files in a 
z
functionality, we can do it for all classes by changing only the one 
ZipProcessor
base class. Maintenance will be much more effective.
ZipProcessor
functionality. (Note: this class requires the third-party pygame library 
to be installed. You can download it from 
http://www.pygame.org/
.)
from zip_processor import ZipProcessor
import os
import sys
from pygame import image
from pygame.transform import scale
class ScaleZip(ZipProcessor):
def process_files(self):
'''Scale each image in the directory to 640x480'''
for filename in os.listdir(self.temp_directory):
im = image.load(self._full_filename(filename))
scaled = scale(im, (640,480))
image.save(scaled, self._full_filename(filename))
if __name__ == "__main__":
ScaleZip(*sys.argv[1:4]).process_zip()
each file (assuming that it is an image; it will unceremoniously crash if the file cannot 
be opened), scale it, and save it back. The 
ZipProcessor
takes care of the zipping 
and unzipping without any extra work on our part.
Chapter 5
[
145 
]
Or we can use composition
only have to make a minor modification to our 
ZipProcessor
class:
import os
import shutil
import zipfile
class ZipProcessor:
def __init__(self, zipname, processor):
self.zipname = zipname
self.temp_directory = "unzipped-{}".format(
zipname[:-4])
self.processor = processor
def _full_filename(self, filename):
return os.path.join(self.temp_directory, filename)
def process_zip(self):
self.unzip_files()
self.processor.process(self)
self.zip_files()
def unzip_files(self):
os.mkdir(self.temp_directory)
zip = zipfile.ZipFile(self.zipname)
try:
zip.extractall(self.temp_directory)
finally:
zip.close()
def zip_files(self):
file = zipfile.ZipFile(self.zipname, 'w')
for filename in os.listdir(self.temp_directory):
file.write(self._full_filename(filename), filename)
shutil.rmtree(self.temp_directory)
When to Use Object-oriented Programming
[
146 
]
All we did was change the initializer to accept a 
processor
object. The 
process_zip
function now calls a method on that 
processor
object; the method called accepts a 
reference to the 
ZipProcessor
itself. Now we can change our 
ZipReplace
class to be 
a suitable 
processor
object that no longer uses inheritance:
from zip_processor import ZipProcessor
import sys
import os
class ZipReplace:
def __init__(self, search_string,
replace_string):
self.search_string = search_string
self.replace_string = replace_string
def process(self, zipprocessor):
'''perform a search and replace on all files in the
temporary directory'''
for filename in os.listdir(
zipprocessor.temp_directory):
with open(
zipprocessor._full_filename(filename)) as file:
contents = file.read()
contents = contents.replace(
self.search_string, self.replace_string)
with open(zipprocessor._full_filename(
filename), "w") as file:
file.write(contents)
if __name__ == "__main__":
zipreplace = ZipReplace(*sys.argv[2:4])
ZipProcessor(sys.argv[1], zipreplace).process_zip()
We didn't actually change much here; the class no longer inherits from 
ZipProcessor
, and when we process the files, we accept a 
zipprocessor
object that 
gives us the function to calculate 
__full_filename
. In the bottom two lines, when 
we run from the command line, we first construct a 
ZipReplace
object. This is then 
passed into the 
ZipProcessor
constructor so the two objects can communicate.
This design is a terrific separation of interests. Now we have a 
ZipProcessor
that 
can accept any object that has a 
process
method to do the actual processing. Further, 
we have a 
ZipReplace
that can be passed to any method, function, or object that 
wants to call its 
process
function; it is no longer tied to the zIP processing code 
local or network filesystem, for example, or to a different kind of compressed file 
such as a RAR archive.
Chapter 5
[
147 
]
modeled as inheritance.
Case study
For this case study, we'll try to delve further into the question, "when should I choose 
an object versus a built-in type?" We'll be modeling a 
Document
class that might be 
it have? 
We might start with a 
str
for the 
Document
contents, but strings aren't mutable. A 
mutable object is one that can be changed; but a 
str
is immutable, we can't insert 
leaving a lot of 
str
objects for Python's garbage collector to clean up behind us. 
addition, a 
Document
would need to know the current cursor position within the list, 
and should also store a filename for the document.
and behavior, so it makes sense to put all this stuff into its own 
Document
class. 
such as 
str
filenames, 
int
cursor positions, and a 
list
of characters? Or should 
some or all of those things be specially defined objects in their own right? What 
Document
class first and see what it can do:
class Document:
def __init__(self):
self.characters = []
self.cursor = 0
self.filename = ''
def insert(self, character):
self.characters.insert(self.cursor, character)
self.cursor += 1
def delete(self):
Documents you may be interested
Documents you may be interested