# use the power of regular expressions # bite the bullet and review the regular expression syntax import re # lets say you have created the next search engine # your search engine extracts the contents of # the <title></title> tags theString = """ <lots of garbage and # what not and this title is going to be cool> <myTitle> will be awesome. And once you get <title>the title is here</title> and then there is the end """ # you compile a regular expression to search # for the contents of the title tag # (this is where the regular expression syntax http://docs.python.org/library/re.html#regular-expression-syntax # comes in handy) # the one thing to certainly notice is that there are # parenthesis surrounding the contents of the title tag. # These are called backreferences. Once we've run the search # we'll be able to reference these. p = re.compile('<title>(.+)<\/title>') # now search theString m = re.search(p, theString) # you can test whether or not your # regular expression was successfull if m: print "regular expression search successfull!" # referencing group #1 references the first backreference print "the title contents are:", m.group(1) # group # 0 is the entire regular expression result print "the entire regular expression returned:", m.group(0) else: print "regular expression search returns no results" #output: # regular expression search successfull! # the title contents are: the title is here # the entire regular expression returned: <title>the title is here</title>
A python example based blog that shows how to accomplish python goals and how to correct python errors.
Wednesday, September 30, 2009
Python - regular expression backreference example
Labels:
backreference,
compile,
group,
python,
re,
regular expressions,
search
Python - using yaml for configuration files
import yaml # checkout and download yaml for python # you should probably put this config in a seperate file # but for this example it is just a multi-line string yamlConfigFile = """ cars: car0: type: toyota hp: 129 mpg: city: 30 highway: 35 cost: 15,000 car1: type: gm hp: 225 mpg: city: 20 highway: 25 cost: 20,000 car2: type: chevy hp: 220 mpg: city: 22 highway: 24 cost: 21,000 """ # the yaml file will be converted to a dict # for sub sections the dict will nest dicts theDict = yaml.load(yamlConfigFile) print theDict # output (I added some tabs and what not so you # could see the nested dict structure): # {'cars': # {'car2': # {'mpg': {'city': 22, 'highway': 24}, # 'hp': 220, # 'cost': '21,000', # 'type': 'chevy'}, # 'car0': # {'mpg': {'city': 30, 'highway': 35}, # 'hp': 129, # 'cost': '15,000', # 'type': 'toyota'}, # 'car1': # {'mpg': {'city': 20, 'highway': 25}, # 'hp': 225, # 'cost': '20,000', # 'type': 'gm'} # } #} # to list the car types (like car1, car2, etc print theDict['cars'].keys() # output: # ['car2', 'car0', 'car1'] # to display the type and cost of the vehicles for c in theDict['cars'].keys(): print theDict['cars'][c]['type'], "cost:", theDict['cars'][c]['cost'] # output: # chevy cost: 21,000 # toyota cost: 15,000 # gm cost: 20,000 # update the cost of toyota theDict['cars']['car0']['cost'] = '25,000' # the update is now in the dict representation of the yaml file # to dump the yaml dict back to a file # or in our case a multi-line string use the dump command # which you could write to a file print yaml.dump(theDict) # output: # cars: # car0: # cost: 25,000 # hp: 129 # mpg: {city: 30, highway: 35} # type: toyota # car1: # cost: 20,000 # hp: 225 # mpg: {city: 20, highway: 25} # type: gm # car2: # cost: 21,000 # hp: 220 # mpg: {city: 22, highway: 24} # type: chevy
Tuesday, September 29, 2009
Python - simple regular expression examples
# regular expressions are extremely powerful # here are some simple examples to get you started import re text = "Some example text to manipulate with regular expressions." # find the location of all the vowels # iterate through all vowels # here I've used the finditer method to return and # and iterator through the results for i in re.finditer('[aeiouy]', text): print "location:", i.start(), " to ", i.end() print " found text was: ", text[i.start():i.end()] # output: #location: 1 to 2 # found text was: o #location: 3 to 4 # found text was: e # # SNIP -- there are lots of vowels # #location: 49 to 50 # found text was: e #location: 52 to 53 # found text was: i #location: 53 to 54 # found text was: o # use regular expressions to split your sentence into words sentence = "This is my example sentence" for word in re.split(' ', sentence): print word #Output: # This # is # my # example # sentence # search and replace regular expression functionality # replace 'regular expression' with 're' text = "regular expression text goes here" newText = re.sub('regular expression', 're', text) print newText #Outputs: # re text goes here
Python - generate double dutch
# this example is similar # to the double dutch generator def createDoubleDutch(word): ''' create and return a double dutch version of word ''' for v in ("a", "e", "i", "o", "u", "y"): # double dutch-ize each vowel word = word.replace(v, v+"b"+v) return word if __name__ == '__main__': ddSentence = "" for w in "My sample sentence for double dutch".split(' '): ddSentence += createDoubleDutch(w) + " " print ddSentence.strip() #output: # Myby sabamplebe sebentebencebe fobor doboubublebe dubutch
Monday, September 28, 2009
Python - pig latin generator
def makePigLatin(word): """ convert one word into pig latin """ m = len(word) vowels = "a", "e", "i", "o", "u", "y" # short words are not converted if m<3 or word=="the": return word else: for i in vowels: if word.find(i) < m and word.find(i) != -1: m = word.find(i) if m==0: return word+"way" else: return word[m:]+word[:m]+"ay" sentence = "Hooray for pig latin" pigLatinSentence = "" # iterate through words in sentence for w in sentence.split(' '): pigLatinSentence += makePigLatin(w) + " " print pigLatinSentence.strip() # output: # oorayHay orfay igpay atinlay
python - split paragraph into sentences with regular expressions
# split up a paragraph into sentences # using regular expressions def splitParagraphIntoSentences(paragraph): ''' break a paragraph into sentences and return a list ''' import re # to split by multile characters # regular expressions are easiest (and fastest) sentenceEnders = re.compile('[.!?]') sentenceList = sentenceEnders.split(paragraph) return sentenceList if __name__ == '__main__': p = """This is a sentence. This is an excited sentence! And do you think this is a question?""" sentences = splitParagraphIntoSentences(p) for s in sentences: print s.strip() #output: # This is a sentence # This is an excited sentence # And do you think this is a question
Python - detect and label objects in images
Image to be analyzed
Detected Objects have now been outlined
from PIL import Image # you'll need to get PIL # some other (shorter) scripts # that use PIL: # create a thumbnail with PIL # find the average image RGB # replace image colors with PIL # # this script is based on the # find the sun script class TheOutliner(object): ''' takes a dict of xy points and draws a rectangle around them ''' def __init__(self): self.outlineColor = 0, 255, 255 self.pic = None self.picn = None self.minX = 0 self.minY = 0 self.maxX = 0 self.maxY = 0 def doEverything(self, imgPath, dictPoints, theoutfile): self.loadImage(imgPath) self.loadBrightPoints(dictPoints) self.drawBox() self.saveImg(theoutfile) def loadImage(self, imgPath): self.pic = Image.open(imgPath) self.picn = self.pic.load() def loadBrightPoints(self, dictPoints): '''iterate through all points and gather max/min x/y ''' # an x from the pool (the max/min # must be from dictPoints) self.minX = dictPoints.keys()[0][0] self.maxX = self.minX self.minY = dictPoints.keys()[0][1] self.maxY = self.minY for point in dictPoints.keys(): if point[0] < self.minX: self.minX = point[0] elif point[0] > self.maxX: self.maxX = point[0] if point[1]< self.minY: self.minY = point[1] elif point[1] > self.maxY: self.maxY = point[1] def drawBox(self): # drop box around bright points for x in xrange(self.minX, self.maxX): # top bar self.picn[x, self.minY] = self.outlineColor # bottom bar self.picn[x, self.maxY] = self.outlineColor for y in xrange(self.minY, self.maxY): # left bar self.picn[self.minX, y] = self.outlineColor # right bar self.picn[self.maxX, y] = self.outlineColor def saveImg(self, theoutfile): self.pic.save(theoutfile, "JPEG") #class CollectBrightPoints(object): # # def __init__(self): # self.brightThreshold = 240, 240, 240 # self.pic = None # self.picn = None # self.brightDict = {} # def loadImage(self, imgPath): # self.pic = Image.open(imgPath) # self.picn = self.pic.load() # def collectBrightPoints(self): # for x in xrange(self.pic.size[0]): # for y in xrange(self.pic.size[1]): # r,g,b = self.picn[x,y] # if r > self.brightThreshold[0] and \ # g > self.brightThreshold[1] and \ # b > self.brightThreshold[2]: # # then it is brighter than our threshold # self.brightDict[x,y] = r,g,b class ObjectDetector(object): ''' returns a list of dicts representing all the objects in the image ''' def __init__(self): self.detail = 4 self.objects = [] self.size = 1000 self.no = 255 self.close = 100 self.pic = None self.picn = None self.brightDict = {} def loadImage(self, imgPath): self.pic = Image.open(imgPath) self.picn = self.pic.load() self.picSize = self.pic.size self.detail = (self.picSize[0] + self.picSize[1])/2000 self.size = (self.picSize[0] + self.picSize[1])/8 # each must be at least 1 -- and the larger # the self.detail is the faster the analyzation will be self.detail += 1 self.size += 1 def getSurroundingPoints(self, xy): ''' returns list of adjoining point ''' x = xy[0] y = xy[1] plist = ( (x-self.detail, y-self.detail), (x, y-self.detail), (x+self.detail, y-self.detail), (x-self.detail, y),(x+self.detail, y), (x-self.detail, y+self.detail),(x, y+self.detail),(x+self.detail,y+self.detail) ) return (plist) def getRGBFor(self, x, y): try: return self.picn[x,y] except IndexError as e: return 255,255,255 def readyToBeEvaluated(self, xy): try: r,g,b = self.picn[xy[0],xy[1]] if r==255 and g==255 and b==255: return False except: return False return True def markEvaluated(self, xy): try: self.picn[xy[0],xy[1]] = self.no, self.no, self.no except: pass def collectAllObjectPoints(self): for x in xrange(self.pic.size[0]): if x % self.detail == 0: for y in xrange(self.pic.size[1]): if y % self.detail == 0: r,g,b = self.picn[x,y] if r == self.no and \ g == self.no and \ b == self.no: # then no more pass else: ol = {} ol[x,y] = "go" pp = [] pp.append((x,y)) stillLooking = True while stillLooking: if len(pp) > 0: xe, ye = pp.pop() # look for adjoining points for p in self.getSurroundingPoints((xe,ye)): if self.readyToBeEvaluated((p[0], p[1])): r2,g2,b2 = self.getRGBFor(p[0], p[1]) if abs(r-r2) < self.close and \ abs(g-g2) < self.close and \ abs(b-b2) < self.close: # then its close enough ol[p[0],p[1]] = "go" pp.append((p[0],p[1])) self.markEvaluated((p[0],p[1])) self.markEvaluated((xe,ye)) else: # done expanding that point stillLooking = False if len(ol) > self.size: self.objects.append(ol) if __name__ == "__main__": print "Start Process"; # assumes that the .jpg files are in # working directory theFile = "3.jpg" theOutFile = "3.output.jpg" import os os.listdir('.') for f in os.listdir('.'): if f.find(".jpg") > 0: theFile = f print "working on " + theFile + "..." theOutFile = theFile + ".out.jpg" bbb = ObjectDetector() bbb.loadImage(theFile) print " analyzing.." print " file dimensions: " + str(bbb.picSize) print " this files object weight: " + str(bbb.size) print " this files analyzation detail: " + str(bbb.detail) bbb.collectAllObjectPoints() print " objects detected: " +str(len(bbb.objects)) drawer = TheOutliner() print " loading and drawing rectangles.." drawer.loadImage(theFile) for o in bbb.objects: drawer.loadBrightPoints(o) drawer.drawBox() print "saving image..." drawer.saveImg(theOutFile) print "Process complete" #output #Start Process #working on A Good Book to Have on Your Shelf.jpg... # analyzing.. # file dimensions: (500, 667) # this files object weight: 146 # this files analyzation detail: 1 # objects detected: 6 # loading and drawing rectangles.. #saving image... #Process complete #working on bamboo-forest.jpg... # analyzing.. # file dimensions: (640, 480) # this files object weight: 141 # this files analyzation detail: 1 # objects detected: 68 # loading and drawing rectangles.. #saving image... # # .............. SNIP .... (I had 20 jpeg files in the dir) # #working on Family_Photo.jpg... # analyzing.. # file dimensions: (4200, 3300) # this files object weight: 938 # this files analyzation detail: 4 # objects detected: 20 # loading and drawing rectangles.. #saving image... #Process complete
Saturday, September 26, 2009
Python - sun image detector - outline objects in an image
The input:
Where oh where is the sun?
Where oh where is the sun?
from PIL import Image # find brightest region of image # and visually identify the region class TheOutliner(object): def __init__(self): self.outlineColor = 0, 255, 255 self.pic = None self.picn = None self.minX = 0 self.minY = 0 self.maxX = 0 self.maxY = 0 def doEverything(self, imgPath, dictPoints, theoutfile): self.loadImage(imgPath) self.loadBrightPoints(dictPoints) self.drawBox() self.saveImg(theoutfile) def loadImage(self, imgPath): self.pic = Image.open(imgPath) self.picn = self.pic.load() def loadBrightPoints(self, dictPoints): # iterate through all points and # gather max/min x/y # an x from the pool (the max/min # must be from dictPoints) self.minX = dictPoints.keys()[0][0] self.maxX = self.minX self.minY = dictPoints.keys()[0][1] self.maxY = self.minY for point in dictPoints.keys(): if point[0] < self.minX: self.minX = point[0] elif point[0] > self.maxX: self.maxX = point[0] if point[1] < self.minY: self.minY = point[1] elif point[1] > self.maxY: self.maxY = point[1] def drawBox(self): # drop box around bright points for x in xrange(self.minX, self.maxX): # top bar self.picn[x, self.minY] = self.outlineColor # bottom bar self.picn[x, self.maxY] = self.outlineColor for y in xrange(self.minY, self.maxY): # left bar self.picn[self.minX, y] = self.outlineColor # right bar self.picn[self.maxX, y] = self.outlineColor def saveImg(self, theoutfile): self.pic.save(theoutfile, "JPEG") class CollectBrightPoints(object): def __init__(self): self.brightThreshold = 240, 240, 240 self.pic = None self.picn = None self.brightDict = {} def loadImage(self, imgPath): self.pic = Image.open(imgPath) self.picn = self.pic.load() def collectBrightPoints(self): for x in xrange(self.pic.size[0]): for y in xrange(self.pic.size[1]): r,g,b = self.picn[x,y] if r>self.brightThreshold[0] and \ g > self.brightThreshold[1] and \ b > self.brightThreshold[2]: # then it is brighter than our threshold self.brightDict[x,y] = r,g,b if __name__ == "__main__": print "Start Process"; # assumes that the test.jpg is in the # working directory theFile = "four.jpg" theOutFile = "four.output.jpg" cbp = CollectBrightPoints() cbp.loadImage(theFile) cbp.collectBrightPoints() brightDict = cbp.brightDict drawer = TheOutliner() drawer.doEverything(theFile, brightDict, theOutFile) print "Process complete"
The output: The sun has been detected!
Friday, September 25, 2009
Python - replace or remove colors from an image
from PIL import Image # this script assumes that 'test.jpg' # is in the current working directory http://pythonicprose.blogspot.com/2009/09/python-os-module-and-working-directory.html n = Image.open('test.jpg') m = n.load() # get x,y size s = n.size # iterate through x and y (every pixel) for x in xrange(s[0]): for y in xrange(s[1]): r,g,b = m[x,y] # remove red from the pic m[x,y] = 0,g,b # save the doctored image n.save('sans_red.jpg', "JPEG") # removing all the red from a photo # makes for a creepy greenish blue (duh..with no red) # try it out!
Wednesday, September 23, 2009
Python - pure python ping using raw sockets
# I've searched the web far and wide. I've written my own
# os.popen() version to ride an operating system's ping.
# I finally found a pure raw ping implementation in python
# that seems to work!
#
# I copied the entire page from:
# http://svn.pylucid.net/pylucid/CodeSnippets/ping.py
#########################################################
#!/usr/bin/env python
"""
A pure python ping implementation using raw socket.
Note that ICMP messages can only be sent from processes running as root.
Derived from ping.c distributed in Linux's netkit. That code is
copyright (c) 1989 by The Regents of the University of California.
That code is in turn derived from code written by Mike Muuss of the
US Army Ballistic Research Laboratory in December, 1983 and
placed in the public domain. They have my thanks.
Bugs are naturally mine. I'd be glad to hear about them. There are
certainly word - size dependenceies here.
Copyright (c) Matthew Dixon Cowles, <http://www.visi.com/~mdc/>.
Distributable under the terms of the GNU General Public License
version 2. Provided with no warranties of any sort.
Original Version from Matthew Dixon Cowles:
-> ftp://ftp.visi.com/users/mdc/ping.py
Rewrite by Jens Diemer:
-> http://www.python-forum.de/post-69122.html#69122
Revision history
~~~~~~~~~~~~~~~~
May 30, 2007
little rewrite by Jens Diemer:
- change socket asterisk import to a normal import
- replace time.time() with time.clock()
- delete "return None" (or change to "return" only)
- in checksum() rename "str" to "source_string"
November 22, 1997
Initial hack. Doesn't do much, but rather than try to guess
what features I (or others) will want in the future, I've only
put in what I need now.
December 16, 1997
For some reason, the checksum bytes are in the wrong order when
this is run under Solaris 2.X for SPARC but it works right under
Linux x86. Since I don't know just what's wrong, I'll swap the
bytes always and then do an htons().
December 4, 2000
Changed the struct.pack() calls to pack the checksum and ID as
unsigned. My thanks to Jerome Poincheval for the fix.
Last commit info:
~~~~~~~~~~~~~~~~~
$LastChangedDate: $
$Rev: $
$Author: $
"""
import os, sys, socket, struct, select, time
# From /usr/include/linux/icmp.h; your milage may vary.
ICMP_ECHO_REQUEST = 8 # Seems to be the same on Solaris.
def checksum(source_string):
"""
I'm not too confident that this is right but testing seems
to suggest that it gives the same answers as in_cksum in ping.c
"""
sum = 0
countTo = (len(source_string)/2)*2
count = 0
while count<countTo:
thisVal = ord(source_string[count + 1])*256 + ord(source_string[count])
sum = sum + thisVal
sum = sum & 0xffffffff # Necessary?
count = count + 2
if countTo<len(source_string):
sum = sum + ord(source_string[len(source_string) - 1])
sum = sum & 0xffffffff # Necessary?
sum = (sum >> 16) + (sum & 0xffff)
sum = sum + (sum >> 16)
answer = ~sum
answer = answer & 0xffff
# Swap bytes. Bugger me if I know why.
answer = answer >> 8 | (answer << 8 & 0xff00)
return answer
def receive_one_ping(my_socket, ID, timeout):
"""
receive the ping from the socket.
"""
timeLeft = timeout
while True:
startedSelect = time.clock()
whatReady = select.select([my_socket], [], [], timeLeft)
howLongInSelect = (time.clock() - startedSelect)
if whatReady[0] == []: # Timeout
return
timeReceived = time.clock()
recPacket, addr = my_socket.recvfrom(1024)
icmpHeader = recPacket[20:28]
type, code, checksum, packetID, sequence = struct.unpack(
"bbHHh", icmpHeader
)
if packetID == ID:
bytesInDouble = struct.calcsize("d")
timeSent = struct.unpack("d", recPacket[28:28 + bytesInDouble])[0]
return timeReceived - timeSent
timeLeft = timeLeft - howLongInSelect
if timeLeft <= 0:
return
def send_one_ping(my_socket, dest_addr, ID):
"""
Send one ping to the given >dest_addr<.
"""
dest_addr = socket.gethostbyname(dest_addr)
# Header is type (8), code (8), checksum (16), id (16), sequence (16)
my_checksum = 0
# Make a dummy heder with a 0 checksum.
header = struct.pack("bbHHh", ICMP_ECHO_REQUEST, 0, my_checksum, ID, 1)
bytesInDouble = struct.calcsize("d")
data = (192 - bytesInDouble) * "Q"
data = struct.pack("d", time.clock()) + data
# Calculate the checksum on the data and the dummy header.
my_checksum = checksum(header + data)
# Now that we have the right checksum, we put that in. It's just easier
# to make up a new header than to stuff it into the dummy.
header = struct.pack(
"bbHHh", ICMP_ECHO_REQUEST, 0, socket.htons(my_checksum), ID, 1
)
packet = header + data
my_socket.sendto(packet, (dest_addr, 1)) # Don't know about the 1
def do_one(dest_addr, timeout):
"""
Returns either the delay (in seconds) or none on timeout.
"""
icmp = socket.getprotobyname("icmp")
try:
my_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp)
except socket.error, (errno, msg):
if errno == 1:
# Operation not permitted
msg = msg + (
" - Note that ICMP messages can only be sent from processes"
" running as root."
)
raise socket.error(msg)
raise # raise the original error
my_ID = os.getpid() & 0xFFFF
send_one_ping(my_socket, dest_addr, my_ID)
delay = receive_one_ping(my_socket, my_ID, timeout)
my_socket.close()
return delay
def verbose_ping(dest_addr, timeout = 2, count = 4):
"""
Send >count< ping to >dest_addr< with the given >timeout< and display
the result.
"""
for i in xrange(count):
print "ping %s..." % dest_addr,
try:
delay = do_one(dest_addr, timeout)
except socket.gaierror, e:
print "failed. (socket error: '%s')" % e[1]
break
if delay == None:
print "failed. (timeout within %ssec.)" % timeout
else:
delay = delay * 1000
print "get ping in %0.4fms" % delay
print
if __name__ == '__main__':
verbose_ping("heise.de")
verbose_ping("google.com")
verbose_ping("a-test-url-taht-is-not-available.com")
verbose_ping("192.168.1.1")
#output (for me):
## ping heise.de... get ping in 161.5423ms
## ping heise.de... get ping in 161.8938ms
## ping heise.de... get ping in 161.8139ms
## ping heise.de... get ping in 161.0677ms
##
## ping google.com... get ping in 55.2157ms
## ping google.com... get ping in 54.8570ms
## ping google.com... get ping in 54.9019ms
## ping google.com... get ping in 54.7282ms
##
## ping a-test-url-taht-is-not-available.com... failed. (socket error: 'getaddrinfo failed')
##
## ping 192.168.1.1... get ping in 2.6651ms
## ping 192.168.1.1... get ping in 3.4502ms
## ping 192.168.1.1... get ping in 2.0416ms
## ping 192.168.1.1... get ping in 1.9452ms
python - copy images (or any file) from the web to local machine
# copy images off of the web to your local machine
# (this should work for any files off the web...not just images)
import urllib
import os
url_of_file = "http://www.example.com/images/example_image.jpg"
local_file = "local_copy.jpg"
# retrieve from web and put in local_file
urllib.urlretrieve(url_of_file, local_file)
# now proof that the file was copied
# just listing all files in working directory
print os.listdir('.')
Labels:
listdir,
os,
python,
urllib,
urlretrieve
Tuesday, September 22, 2009
Python - find the average rgb color for an image
# iterate through each pixel in an image and
# determine the average rgb color
# you will need to install the PIL module
from PIL import Image
class PixelCounter(object):
''' loop through each pixel and average rgb '''
def __init__(self, imageName):
self.pic = Image.open(imageName)
# load image data
self.imgData = self.pic.load()
def averagePixels(self):
r, g, b = 0, 0, 0
count = 0
for x in xrange(self.pic.size[0]):
for y in xrange(self.pic.size[1]):
tempr,tempg,tempb = self.imgData[x,y]
r += tempr
g += tempg
b += tempb
count += 1
# calculate averages
return (r/count), (g/count), (b/count), count
if __name__ == '__main__':
# assumes you have a test.jpg in the working directory!
pc = PixelCounter('test.jpg')
print "(red, green, blue, total_pixel_count)"
print pc.averagePixels()
# for my picture the ouput rgb values are:
# (red, green, blue, total_pixel_count)
# (135, 122, 107, 10077696)
#
# you can see that my image had 10,077,696 pixels and python/PIL
# still churned right through it!
python - while loop specified time frame
import time
def looper(timeCount):
start = time.time()
keepLooping = True
while keepLooping:
if time.time()-start > timeCount:
keepLooping = False
else:
print time.time()-start
time.sleep(0.1)
if __name__ == '__main__':
looper(10.0)
python - create thumbnail with PIL
#PIL is the python image library
# learn more about pil
from PIL import Image
# the size of thumbnail you would like to create
# NOTE: you may get from the 100,100 that the image is ... or will be square
# PIL takes care of this and keeps the proper aspect ratio
# the values you enter here are the max
thumbSize = 100, 100
# assumes you have a file called 'test.jpg' in
# the current directory
# how to tell where python's current directory
pic = Image.open("test.jpg")
# PIL makes thumbnails easy with the thumbnail method
pic.thumbnail(thumbSize, Image.ANTIALIAS)
# save to file and choose save type
pic.save("test.small.jpg", "JPEG")
python - os module and working directory
import os
# curdir attribute lists the current directory
# which is always '.' .... which means...right here
print os.curdir
#output:
# .
# to see what the path to the curdir
print os.path.abspath(os.path.curdir)
#output
# C:\Documents and Settings\steve\My Documents\python
# and then to see what files are in the curdir
print os.listdir(os.curdir)
#or
print os.listdir(os.path.abspath(os.path.curdir))
# output for either listdir
#['colormaker.py', 'createThumbnail.py', 'strFunctions.py', 'pycolor.py']
Subscribe to:
Posts (Atom)