convert pdf to image asp.net c#: Convert locked pdf to word online application software tool html windows wpf online O'Reilly%20-%20Python%20Cookbook12-part1437

3.8 Filtering a String for a Set of Characters

Credit: Jürgen Hermann, Nick Perkins

3.8.1 Problem

Given a set of characters to keep, you need to build a filtering functor (a function-like, callable

object). The specific functor you need to build is one that, applied to any string

, returns a copy

that contains only characters in the set.

3.8.2 Solution

The

string.maketrans

function and

translate

method of string objects are fast and

handy for all tasks of this ilk:

import string

# Make a reusable string of all characters

_allchars = string.maketrans('', '')

def makefilter(keep):

""" Return a functor that takes a string and returns a

partial copy of that

string consisting of only the characters in 'keep'.

"""

# Make a string of all characters that are not in 'keep'

delchars = _allchars.translate(_allchars, keep)

# Return the functor, binding the two strings as default

args

return lambda s, a=_allchars, d=delchars: s.translate(a,

def canonicform(keep):

""" Given a string, considered as a set of characters,

return the

string's characters as a canonic-form string:

alphabetized

and without duplicates.

"""

return makefilter(keep)(_allchars)

if _ _name_ _ == '_ _main_ _':

identifier = makefilter(string.letters + string.digits +

'_')

print identifier(_allchars)

3.8.3 Discussion

The key to understanding this recipe lies in the definitions of the

translate

and

maketrans

functions in the

string

module.

translate

takes a string and replaces each

character in it with the corresponding character in the translation table passed in as the second

Convert locked pdf to word online - C# PDF Digital Signature Library: add, remove, update PDF digital signatures in C#.net, ASP.NET, MVC, WPF

Help to Improve the Security of Your PDF File by Adding Digital Signatures

change security settings pdf reader; change pdf security settings reader

Convert locked pdf to word online - VB.NET PDF Digital Signature Library: add, remove, update PDF digital signatures in vb.net, ASP.NET, MVC, WPF

Guide VB.NET Programmers to Improve the Security of Your PDF File by Adding Digital Signatures

pdf security; pdf secure signature

argument, deleting the characters specified in the third argument.

maketrans

is a utility routine

that helps create the translation tables.

Efficiency is vastly improved by splitting the filtering task into preparation and execution phases.

The string of all characters is clearly reusable, so we build it once and for all when this module is

imported. That way, we ensure that each filtering functor has a reference to the same string of all

characters, not wasting any memory. The string of characters to delete depends on the set of

characters to keep, so we build it in the

makefilter

factory function. This is done quite

rapidly using the

translate

method to delete the characters to keep from the string of all

characters. The

translate

method is very fast, as are the construction and execution of these

useful little functors. The solution also supplies an extremely simple function to put any set of

characters, originally an arbitrary string, into canonic-string form (alphabetically sorted, without

duplicates). The same trick encapsulated in the

canonicform

function is also explicitly used

in the test code that is executed when this runs as a script.

Of course, you don't have to use

lambda

(here or anywhere else). A named function local to the

factory function will do just as well. In other words, this recipe works fine if you change

makefilter

return

statement into the following two statements:

def filter(s, a=_allchars, d=delchars): return s.translate(a,

return filter

Many Pythonistas would consider this clearer and more readable.

This isn't a big issue, but remember that

lambda

is never necessary. In any case in which you

find yourself straining to fit code into a

lambda

's limitations (i.e., just an expression, with no

statements allowed), you can and should always use a local named function instead, to avoid all

the limitations and problems.

With Python 2.2, or Python 2.1 and a

from _ _future_ _ import

nested_scopes

, you get lexically nested scopes, so that if you want to, you can avoid

binding

_allchars

and

delchars

as default values for arguments in the returned functor.

However, it is (marginally) faster to use this binding anyway: local variables are the fastest kind to

access, and arguments are nothing but prebound local variables. Globals and names from nested

scopes require a little more effort from the interpreter (and sometimes, perhaps more significantly,

from a human being who is reading the code). This is why we bind

_allchars

as argument

here despite the fact that, in any release of Python, we could have just accessed it as a global

variable.

3.8.4 See Also

Documentation for the

maketrans

function in the

string

module in the Library Reference.

C# PDF Page Extract Library: copy, paste, cut PDF pages in C#.net

though they are using different types of word processors. Besides, the capacity to be locked against editing or processing by others makes PDF file become

pdf encryption; copy locked pdf

C# Word - Extract or Copy Pages from Word File in C#.NET

C#.NET convert PDF to text, C#.NET convert PDF to images VB.NET How-to, VB.NET PDF, VB.NET Word Besides, the capacity to be locked against editing or processing

pdf security; secure pdf file

3.9 Controlling Case

Credit: Luther Blissett

3.9.1 Problem

You need to convert a string from uppercase to lowercase, or vice versa.

3.9.2 Solution

That's what the

upper

and

lower

methods of string objects are for. Each takes no arguments

and returns a copy of the string in which each letter has been changed to upper- or lowercase,

respectively.

big = little.upper( )

little = big.lower( )

s.capitalize

is similar to

s[:1].upper()+s[1:].lower( )

. The first character

is changed to uppercase, and all others are changed to lowercase.

s.title

is similar, but it

uppercases the first letter of each word:

>>> print 'one two three'.capitalize( )

One two three

>>> print 'one two three'.title( )

One Two Three

3.9.3 Discussion

Case manipulation of strings is a very frequent need. Because of this, several string methods let

you produce case-altered copies of strings. Moreover, you can also check if a string object is

already in a given case form with the methods

isupper

islower

, and

istitle

, which all

return

if the string is nonempty and already meets the uppercase, lowercase, or titlecase

constraints. There is no

iscapitalized

method, but we can code it as a function:

def iscapitalized(s):

return s[:1].isupper() and s[1:].islower( )

This may not be exactly what you want, because each of the

methods returns

for an empty

string, and the three case-checking ones also return

for strings that, while not empty, contain no

letters at all. This

iscapitalized

function does not quite match these semantics; rather, it

accepts a string

only if

starts with an uppercase letter, followed by at least one more character,

including at least one more letter somewhere, and all letters except the first one are lowercase.

Here's an alternative whose semantics may be easier to understand:

def iscapitalized(s):

return s == s.capitalize( )

However, this version deviates from the boundary-case semantics of the methods by accepting

strings that are empty or contain no letters. Depending on your exact needs for boundary cases,

you may of course implement precisely those checks you want to perform.

PDF, VB.NET delete PDF pages, VB.NET convert PDF to SVG. VB.NET How-to, VB.NET PDF, VB.NET Word Besides, the capacity to be locked against editing or processing

create pdf the security level is set to high; creating a secure pdf document

VB.NET Word: Extract Text from Microsoft Word Document in VB.NET

Word documents are often locked as static images and the through VB.NET programming, convert Word document to & profession imaging controls, PDF document, tiff

pdf password security; convert locked pdf to word

The Library Reference section on string methods; Perl Cookbook Recipe 1.9.

C# Excel - Extract or Copy Excel Pages to Excel File in C#.NET

C#.NET convert PDF to text, C#.NET convert PDF to images VB.NET How-to, VB.NET PDF, VB.NET Word Besides, the capacity to be locked against editing or processing

decrypt pdf password; pdf unlock

3.10 Reversing a String by Words or Characters

Credit: Alex Martelli

3.10.1 Problem

You want to reverse the characters or words in a string.

3.10.2 Solution

Strings are immutable, so we need to make a copy. A list is the right intermediate data structure,

since it has a

reverse

method that does just what we want and works in place:

revchars = list(astring) # string -> list of chars

revchars.reverse( ) # reverse the list in place

revchars = ''.join(revchars) # list of strings -> string

To flip words, we just work with a list of words instead of a list of characters:

revwords = astring.split( ) # string -> list of words

revwords.reverse( ) # reverse the list in

place

revwords = ' '.join(revwords) # list of strings ->

string

Note that we use a

' '

(space) joiner for the list of words, but a

(empty string) joiner for the

list of characters.

If you need to reverse by words while preserving untouched the intermediate whitespace, regular-

expression splitting can be useful:

import re

revwords = re.split(r'(\s+)', astring) # separators too

since '(...)'

revwords.reverse( ) # reverse the

list in place

revwords = ''.join(revwords) # list of strings

-> string

Note that the joiner becomes the empty string again in this case, because the whitespace separators

are kept in the

revwords

list by using

re.split

with a regular expression that includes a

parenthesized group.

3.10.3 Discussion

The snippets in this recipe are fast, readable, and Pythonic. However, some people have an

inexplicable fetish for one-liners. If you are one of those people, you need an auxiliary function

(you can stick it in your built-ins from sitecustomize.py) like this:

def reverse(alist):

temp = alist[:]

temp.reverse( )

return temp

or maybe this, which is messier and slower:

def reverse_alternative(alist):

return [alist[i-1] for i in range(len(alist), 0, -1)]

This is, indeed, in-lineable, but not worth it in my opinion.

Anyway, armed with such an almost-built-in, you can now do brave new one-liners, such as:

revchars = ''.join(reverse(list(astring)))

revwords = ' '.join(reverse(astring.split( )))

In the end, Python does not twist your arm to make you choose the obviously right approach:

Python gives you the right tools, but it's up to you to use them.

3.10.4 See Also

The Library Reference section on sequence types; Perl Cookbook Recipe 1.6.

3.11 Accessing Substrings

Credit: Alex Martelli

3.11.1 Problem

You want to access portions of a string. For example, you've read a fixed-width record and want to

extract the record's fields.

3.11.2 Solution

Slicing is great, of course, but it only does one field at a time:

afield = theline[3:8]

If you need to think in terms of field length,

struct.unpack

may be appropriate. Here's an

example of getting a five-byte string, skipping three bytes, getting two eight-byte strings, and then

getting the rest:

import struct

# Get a 5-byte string, skip 3, get two 8-byte strings, then

all the rest:

baseformat = "5s 3x 8s 8s"

numremain = len(theline)-struct.calcsize(baseformat)

format = "%s %ds" % (baseformat, numremain)

leading, s1, s2, trailing = struct.unpack(format, theline)

If you need to split at five-byte boundaries, here's how you could do it:

numfives, therest = divmod(len(theline), 5)

form5 = "%s %dx" % ("5s "*numfives, therest)

fivers = struct.unpack(form5, theline)

Chopping a string into individual characters is of course easier:

chars = list(theline)

If you prefer to think of your data as being cut up at specific columns, slicing within list

comprehensions may be handier:

cuts = [8,14,20,26,30]

pieces = [ theline[i:j] for i, j in zip([0]+cuts,

cuts+[sys.maxint]) ]

3.11.3 Discussion

This recipe was inspired by Recipe 1.1 in the Perl Cookbook. Python's slicing takes the place of

Perl's

substr

. Perl's built-in

unpack

and Python's

struct.unpack

are similar. Perl's is

slightly handier, as it accepts a field length of

for the last field to mean all the rest. In Python,

we have to compute and insert the exact length for either extraction or skipping. This isn't a major

issue, because such extraction tasks will usually be encapsulated into small, probably local

functions. Memoizing, or automatic caching, may help with performance if the function is called

repeatedly, since it allows you to avoid redoing the preparation of the format for the struct

unpacking. See also Recipe 17.8

In a purely Python context, the point of this recipe is to remind you that

struct.unpack

often viable, and sometimes preferable, as an alternative to string slicing (not quite as often as

unpack

versus

substr

in Perl, given the lack of a

-valued field length, but often enough to

be worth keeping in mind).

Each of these snippets is, of course, best encapsulated in a function. Among other advantages,

encapsulation ensures we don't have to work out the computation of the last field's length on each

and every use. This function is the equivalent of the first snippet in the solution:

def fields(baseformat, theline, lastfield=None):

numremain = len(theline)-struct.calcsize(baseformat)

format = "%s %d%s" % (baseformat, numremain, lastfield

and "s" or "x")

return struct.unpack(format, theline)

If this function is called in a loop, caching with a key of

(baseformat,

len(theline),

lastfield)

may be useful here because it can offer an easy speed-up.

The function equivalent of the second snippet in the solution is:

def split_by(theline, n, lastfield=None):

numblocks, therest = divmod(len(theline), n)

baseblock = "%d%s"%(n, lastfield and "s" or "x")

format = "%s %dx"%(baseblock*numblocks, therest)

And for the third snippet:

def split_at(theline, cuts, lastfield=None):

pieces = [ theline[i:j] for i, j in zip([0]+cuts, cuts) ]

if lastfield:

pieces.append(theline(cuts[-1:]))

return pieces

In each of these functions, a decision worth noticing (and, perhaps, worth criticizing) is that of

having a

lastfield=None

optional parameter. This reflects the observation that while we

often want to skip the last, unknown-length subfield, sometimes we want to retain it instead. The

use of

lastfield

in the expression

lastfield and

"s" or "x"

(equivalent to C's

lastfield?'s':'c'

) saves an

if/else

, but it's unclear whether the saving is worth it.

"sx"[not lastfield]

and other similar alternatives are roughly equivalent in this respect;

see Recipe 17.6

. When

lastfield

is false, applying

struct.unpack

to just a prefix of

theline

(specifically,

theline[:struct.calcsize(format)]

) is an alternative,

but it's not easy to merge with the case of

lastfield

being true, when the format does need a

supplementary field for

len(theline)-struct.calcsize(format)

3.11.4 See Also

Recipe 17.6

and Recipe 17.8

; Perl Cookbook Recipe 1.1.

3.12 Changing the Indentation of a Multiline String

Credit: Tom Good

3.12.1 Problem

You have a string made up of multiple lines, and you need to build another string from it, adding

or removing leading spaces on each line so that the indentation of each line is some absolute

number of spaces.

3.12.2 Solution

We don't need

for this. The

string

module (or string methods, in Python 2.0 and later) is

quite sufficient:

import string

def reindent(s, numSpaces):

s = string.split(s, '\n')

s = [(numSpaces * ' ') + string.lstrip(line) for line in

s = string.join(s, '\n')

return s

3.12.3 Discussion

When working with text, it may be necessary to change the indentation level of a block. This

recipe's code takes a multiline string and adds or removes leading spaces on each line so that the

indentation level of each line of the block matches some absolute number of spaces. For example:

>>> x = """line one

... line two

... and line three

... """

>>> print x

line one

line two

and line three

>>> print reindent(x, 8)

line one

line two

and line three

Even if the lines in

are initially indented differently, this recipe makes their indentation

homogeneous. This is sometimes what we want, and sometimes not. A frequent need is to adjust

the amount of leading spaces in each line, so that the relative indentation of each line in the block

is preserved. This is not hard either, for either positive or negative values of the adjustment.

However, negative values need a check to ensure that no nonspaces are snipped from the start of

the lines. Thus, we may as well split the functionality into two functions to perform the

transformations, plus one to measure the number of leading spaces of each line and return the

result as a list:

def addSpaces(s, numAdd):

white = " "*numAdd

return white + white.join(s.splitlines(1))

def delSpaces(s, numDel):

def aux(line, numDel=numDel, white=" "*numDel):

if line[:numDel] != white:

raise ValueError, "removing more spaces than

there are!"

return line[numDel:]

return ''.join(map(aux, s.splitlines(1)))

def numSpaces(s):

return [len(line)-len(line.lstrip()) for line in

s.splitlines( )]

This alternative approach relies on the string method

splitlines

(and so requires Python 2.0

or later, like any other recipe using string methods and/or list comprehensions), which is similar to

a split on

'\n'

, with the extra ability to leave the trailing newline on each line when called with

a true argument. This is not often crucial (the last statement in

delSpaces

, for example, might

just as easily return

'\n'.join(map(aux, s.split('\n')))

), but sometimes it

turns out to be (

addSpaces

could not be quite as short and sweet without this ability of the

splitlines

string method).

For example, here's how we can combine these functions to build another function that deletes

enough leading spaces from each line to ensure that the least-indented line of the block becomes

flush-left, while preserving the relative indentations of all the other lines:

def unIndentBlock(s):

return delSpaces(s, min(numSpaces(s)))

3.12.4 See Also

The Library Reference section on sequence types.

Documents you may be interested

convert pdf to image asp.net c# : Convert locked pdf to word online application software tool html windows wpf online O'Reilly%20-%20Python%20Cookbook12-part1437