View source for Python exam help

==To get GPS coordinates and image orientation:==

<source lang="python">
from exifread import process_file
 
def degrees(j):
    return j.values[0].num + (j.values[1].num + j.values[2].den * 1.0 / j.values[2].num) / 60.0
 
tags = process_file(open("/home/sheela/Documents/Python/pics/IMG_20131019_201706.jpg"))
print tags
lat, lng = tags.get("GPS GPSLatitude"), tags.get("GPS GPSLongitude")
if lat and lng:
    print "%.4f,%.4f" % (degrees(lat), degrees(lng)),
 
# Parse datetime of the photo
timestamp = tags.get("EXIF DateTimeOriginal")
if timestamp:
    print timestamp.values,
 
# Parse image orientation
orientation = tags.get("Image Orientation")
 
if orientation:
    j, = orientation.values
    if j == 6:
        print "rotated 270 degrees",
    elif j == 8:
        print "rotated 90 degrees",
    elif j == 3:
        print "rotated 180 degrees",
 
print
</source>

==This code is to remove the exif data - metadata==

<source lang="python">
import Image
from exifread import process_file

image_file = open('/home/sheela/Documents/Python/pics/IMG_20150619_120040.jpg')
image = Image.open(image_file)

# next 3 lines strip exif
data = list(image.getdata())
image_without_exif = Image.new(image.mode, image.size)
image_without_exif.putdata(data)

image_without_exif.save('without_exif_data.jpeg')
</source>

==This code is to rotate the picture (which do not have metadata) to original view==

<source lang="python">
import Image
orig = Image.open("original.jpg")
rotated = orig.transpose(Image.ROTATE_90) # This happens only in the RAM!
rotated.save("rotated.jpg")

</source>

<source lang="python">
import Image
from exifread import process_file

#input_path, output_path = sys.argv[1:]

image_file = open('/home/sheela/Documents/Python/pics/IMG_20131019_201706.jpg')
image = Image.open(image_file)

# next 3 lines strip exif
data = list(image.getdata())
image_without_exif = Image.new(image.mode, image.size)
image_without_exif.putdata(data)

image_without_exif.save('without_exif_data.jpeg')


im = Image.open("/home/sheela/Documents/Python/pics/IMG_20131019_201706.jpg")
rotated = im.transpose(Image.ROTATE_90)
im.save("rotated.jpg")

#orig = Image.open(output_path)
#rotated = orig.transpose(Image.ROTATE_90) # This happens only in the RAM!
#rotated.save(output_path)
</source>

==dexif.py Lauri's code==

<source lang="python">
import codecs, os, sys
from exifread import process_file
from PIL import Image
from jinja2 import Template

input_path, output_path = sys.argv[1:] 
if not os.path.exists(output_path):
    os.makedirs(os.path.join(output_path, "thumbnails"))
template = Template(codecs.open("gallery.html", "r", encoding="utf-8").read())
with codecs.open("/tmp/bulid/index.html", "w", encoding="utf-8") as fh:
     fh.write(template.render(files = os.listdir(input_path)))

for filename in os.listdir(input_path):
        if not filename.endswith(".jpg"): continue 
        print filename
        tags = EXIF.process_file(open(os.path.join(input_path, filename)))
        im = Image.open(os.path.join(input_path, filname))
        rotated = im # Not roated at all
        orientation = tags.get("Image orientation") # paese image orientation
        if orientation:
            j, = orientation.values
            if j == 6:
                rotated = im.transpose(Image.ROTATE_270)
            elif j == 8:
                rotated = im.transpose(Image.ROTATE_90)
            elif j == 3:
                rotated = im.transpose(Image.ROTATE_180)
        rotated.save(os.path.join(output_path, filename))
        rotated.thumbnail((192,192), Image.ANTIALIAS)
        rotated.save(os.path.join(output_path, "thumbnails", filename))
     
</source>

==Artur code A.py==

<source lang="python">
import Image
import sys
from exifread import process_file

input_path, output_path = sys.argv[1:]

image_file = open(input_path)
image = Image.open(image_file)

data = list(image.getdata())
no_exif = Image.new(image.mode, image.size)
no_exif.putdata(data)

no_exif.save(output_path)

orig = Image.open(output_path)
rotated = orig.transpose(Image.ROTATE_90) # This happens only in the RAM!
rotated.save(output_path)

</source>

==To get image thumbnail==

<source lang="python">
<<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8"/>
    <title>Images</title>
    <style>
        body {
            background-color: #444;
        }

        .thumbnail {
            position: relative;
            display: inline;
            margin: 1em;
            padding: 0;
            width: 192;
            height: 192;
            box-shadow: 0px 0px 10px rgba(0,0,0,1);
        }
    </style>
  </head>
  <body>
    {% for filename in files % 
        <a href= "{{filename}}">
            <img class="thumbnail" src="thumbnails/{{filename}}"/>  
       </a>
    {% endfor %}
  </body>
</html>
</source>

==Final result all in one file==

<source lang="python">

# I need to mention my path like this - python dexif2.py /home/sheela/Documents/Python/pics /home/sheela/Documents/Python 

import codecs, os,sys
from exifread import process_file
from PIL import Image
from jinja2 import Template
 
# Grab arguments specified on the command line after: python paranoia.py <input_dir> <output_dir>
input_directory, output_directory = sys.argv[1:]
 
# Create output directories if necessary
if not os.path.exists(output_directory):
    os.makedirs(os.path.join(output_directory, "thumbnails"))
 
HEADER = """<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8"/>
    <style>
        body { background-color: #444; }
        img.thumb { position: relative; display: inline; margin: 1em;
            padding: 0; width: 192; height: 192;
            box-shadow: 0px 0px 10px rgba(0,0,0,1); }
    </style>
  </head>
  <body>
"""

# Open index.html in output diretory and write it line by line
with open(os.path.join(output_directory, "index.html"), "w") as fh:
    fh.write(HEADER)
 
    for filename in os.listdir(input_directory):        
        # Read EXIF tags
        tags = process_file(open(os.path.join(input_directory, filename)))
 
        # Read image data
        original = Image.open(os.path.join(input_directory, filename))
 
        # Rotate as necessary
        rotated = original # Not rotated at all
        orientation = tags.get("Image Orientation") # Parse image orientation        
        if orientation:
            j, = orientation.values
            if j == 6:
                rotated = original.transpose(Image.ROTATE_270)                
            elif j == 8:
                rotated = original.transpose(Image.ROTATE_90)
            elif j == 3:
                rotated = original.transpose(Image.ROTATE_180)
        rotated.save(os.path.join(output_directory, filename))
 
        # Save thumbnail        
        rotated.thumbnail((192,192), Image.ANTIALIAS)
        rotated.save(os.path.join(output_directory, "thumbnails", filename))
        fh.write("""    <a href="%s">""" % filename)
        fh.write("""<img class="thumb" src="thumbnails/%s"/>""" % filename)
        fh.write("""</a>\n""")
    fh.write("  </body>\n")
    fh.write("</html>\n")
</source>

==Exam answer==


import shutil, sys, magic, os
from mutagen.easyid3 import EasyID3
from mutagen.id3 import ID3NoHeaderError
 
db = magic.open(magic.MAGIC_MIME_TYPE)
db.load()
 
try:
    input_directory, output_directory = sys.argv[1:3]
except ValueError:
    print "Not enough arguments!"
    sys.exit(255)
 
for filename in os.listdir(input_directory):
    path = os.path.join(input_directory, filename)
    if db.file(path) not in ("application/octet-stream", "audio/mpeg"):
        continue
 
    try:
        tags = EasyID3(path)
    except ID3NoHeaderError:
        continue
 
    artist, = tags.get("artist")   # artist = tags.get("artist")[0]
    album, = tags.get("album")
    title, = tags.get("title")
    year, = tags.get("date")
    tracknumber, = tags.get("tracknumber")
 
    if "/" in tracknumber:
        tracknumber, _ = tracknumber.split("/")
 
    directory_name = "%s - %s (%s)" % (artist, album, year)
    target_name = "%02d. %s - %s.mp3" % (int(tracknumber), artist, title)
 
    if not os.path.exists(os.path.join(output_directory, directory_name)):
        os.makedirs(os.path.join(output_directory, directory_name))
    shutil.copy(path, os.path.join(output_directory, directory_name, target_name))
    print "Move from:", filename, "to:", os.path.join(directory_name, target_name)
</source>


==EXAMPLE==
<source lang="python">

SLICING

#Slice syntax forms:

	     Get elements from...
values[1:3]  Index 1 through index 3.
values[2:-1] Index 2 through index one from last.
values[:2]   Start through index 2.
values[2:]   Index 2 through end.
values[::2]  Start through end, skipping ahead 2 places each time.
...............................................................
#Python program that slices list

values = [100, 200, 300, 400, 500]
# Get elements from second index to third index.
slice = values[1:3]
print(slice)

Output

[200, 300]
....................................

#Python that creates slice object

# Create a slice object.
example = slice(1, 10, 0)
print(example.start, example.stop, example.step)

Output

1 10 0

.......................................................
#Python program that resizes list

letters = ["x", "y", "z", "a", "b"]
print(letters)

# Resize list to two elements at the start.
letters = letters[:2]
print(letters)

Output

['x', 'y', 'z', 'a', 'b']
['x', 'y']
........................................
#Python program that reduces size

values = [10, 20, 30, 40, 50]
print(values)

# Reduce size of list by 2 elements.
values = values[:-2]
print(values)

Output

[10, 20, 30, 40, 50]
[10, 20, 30]
............................................
#Python program that slices, starts and ends

values = [100, 200, 300, 400, 500]
# Slice from start to second index.
slice = values[:2]
print(slice)

# Slice from second index to end.
slice = values[2:]
print(slice)

Output

[100, 200]
[300, 400, 500]
.........................................
#Python program that slices string

word = "something"
# Get first four characters.
part = word[:4]
print(part)

Output

some
...............................................

#Python program that locates relative slices

def between(value, a, b):
    # Find and validate before-part.
    pos_a = value.find(a)
    if pos_a == -1: return ""
    # Find and validate after part.
    pos_b = value.rfind(b)
    if pos_b == -1: return ""
    # Return middle part.
    adjusted_pos_a = pos_a + len(a)
    if adjusted_pos_a >= pos_b: return ""
    return value[adjusted_pos_a:pos_b]

def before(value, a):
    # Find first part and return slice before it.
    pos_a = value.find(a)
    if pos_a == -1: return ""
    return value[0:pos_a]

def after(value, a):
    # Find and validate first part.
    pos_a = value.rfind(a)
    if pos_a == -1: return ""
    # Returns chars after the found string.
    adjusted_pos_a = pos_a + len(a)
    if adjusted_pos_a >= len(value): return ""
    return value[adjusted_pos_a:]

# Test the methods with this literal.
test = "DEFINE:A=TWO"
print(between(test, "DEFINE:", "="))
print(between(test, ":", "="))

print(before(test, ":"))
print(before(test, "="))

print(after(test, ":"))
print(after(test, "DEFINE:"))
print(after(test, "="))

Output

A
A
DEFINE
DEFINE:A
A=TWO
A=TWO
TWO

............................
#copy list

ython program that copies list

# A list:
list1 = [10, 20, 30]

# Copy list1 with slice syntax.
list2 = list1[:]

# Modify list2.
list2[0] = 0

print(list1)
print(list2)

Output

[10, 20, 30]
[0, 20, 30]

..........................
#Extend 

Python program that uses extend, copies list

list1 = [10, 20, 30]

# Create empty list, then extend it.
list2 = []
list2.extend(list1)

# The lists are separate.
list2[0] = 0

print(list1)
print(list2)

Output

[10, 20, 30]
[0, 20, 30]


....................
#slicing
ex:1
s = "abcdefghijklmnopqrs"

# Loop over some indexes.
for n in range(2, 4):
    #Print slices.
    print(n, s[n])       #(2, 'c') (3, 'd')
    print(n, s[n:n + 2])  #(2, 'cd')(3, 'de')
    print(n, s[n:n + 3]) #(2, 'cde')(3, 'def')
    print(n, s[n:n + 4:2]) #(2, 'ce')(3, 'df')
    print(n, s[n:n + 6:2]) #(2, 'ceg')(3, 'dfh')

.............
#Normally, you would just do:

s = s[:-3] + s[-2:]

The s[:-3] gives you a string up to, but not including, the comma you want removed ("this is a string") and the s[-2:] gives you another string starting one character beyond that comma (" a").

Then, joining the two strings together gives you what you were after ("this is a string a").


.....................
#ANother example.
>>> t = (2, 5, 7, 9, 10, 11, 12)
>>> t[2:4]
(7, 9)

.................
#splitting string

ex:1

x = 'blue,red,green'
x.split(",")

['blue', 'red', 'green']
>>> 

>>> a,b,c = x.split(",")

>>> a
'blue'

>>> b
'red'

>>> c
'green'

ex:2

>>> word = "This is some random text"

>>> words2 = word.split(" ")

>>> words
['This', 'is', 'some', 'random', 'text']

................
#SPILITTING ANOTHER METHOD

Following is the syntax for split() method −
str.split(str="", num=string.count(str)).

Ex:1
#!/usr/bin/python

str = "Line1-abcdef \nLine2-abc \nLine4-abcd";
print str.split( )
print str.split(' ', 1 )

output:
'Line1-abcdef', 'Line2-abc', 'Line4-abcd']
['Line1-abcdef', '\nLine2-abc \nLine4-abcd']
...................................................
#JOINING STRING 

Following is the syntax for join() method:

str.join(sequence)

Example1:
he following example shows the usage of join() method.

#!/usr/bin/python

s = "-";
seq = ("a", "b", "c"); # This is sequence of strings.
print s.join( seq )

When we run above program, it produces following result −

a-b-c

.............................
#String Formatting

String formatting with %

ex:1
x = 'apple'
y = 'lemon'
z = "The items in the basket are %s and %s" % (x,y)

................................

#String formatting using { }
ex:1
fname = "Joe"
lname = "Who"
age = "24"

#Example of how to use the format() method:
print "{} {} is {} years ".format(fname, lname, age)

Another really cool thing is that we don't have to provide the inputs in the same order, if we number the place-holders.
print "{0} {1} is {2} years".format(fname, lname, age)

...............................
#Python program that gets one-character substring

value = "web"

# Loop over every index in string.
for index in range(0, len(value)):

    # Get one-character substring.
    char = value[index]

    # Display substring.
    print(char)

    # Test substring.
    if char == "w":
        print(True)

Output:

w
True
e
b
...................
#Python program that takes substrings

string = "abcdefgh"

# Two-character substring.
two = string[0:2]

# Three-character substring.
three = string[0:3]

# Four-character substring.
four = string[0:4]

# Five-character substring.
five = string[0:5]

print(two)
print(three)
print(four)
print(five)

Output:

ab
abc
abcd
abcde
......................................................
#Python program that uses offset

string = "abcdefgh"

# Three characters starting at index 2.
offset = 2
length = 3
sliced = string[offset:offset+length]
print(sliced)

Output

cde
........................
#Python program that omits start index

value = "google"

# Omitting the start means start at 0.
test1 = value[:2]
test2 = value[0:2]

print(test1)
print(test2)

Output

go
go
..............................
#Python program that gets last two characters

value = "apple"

# Get last two characters.
end = value[-2:]
print(end)

Output

le
...........................
#Python that causes error

value = "dotperls"
value[3] = " net " # Does not work.
print(value)

Output

Traceback (most recent call last):
  File "...\file.py", line 6, in <module>
    value[3:] = " net "
TypeError: 'str' object does not support item assignment
......................................................
#Python that uses slice, gets first words

def first_words(input, words):
    for i in range(0, len(input)):
        # Count spaces in the string.
        if input[i] == ' ':
            words -= 1
        if words == 0:
            # Return the slice up to this point.
            return input[0:i]
    return ""

# Test our method.
test = "Stately, plump Buck Mulligan came from the stairhead."
result = first_words(test, 4)
print(result)

Output

Stately, plump Buck Mulligan
..........................................................
#Python program that truncates string

value = "one two three"

# Truncate the string to 3 characters.
first = value[0:3]
print(first + ".")

# Truncate the string to 7 characters.
second = value[0:7]
print(second + ".")

Output

one.
one two.
..........................................
#Python program that uses short truncation syntax

letters = "abcdef"

# Omit the first 0 in the slice syntax.
# ... This truncates the string.
first_part = letters[:3]
print(first_part)

Output

abc
...............................

#LIST MANIPULATING 

 first we need an example list:
x = [1,6,3,2,6,1,2,6,7]
# lets add something.
# we can do .append, which will add something to the end of the list, like:
x.append(55)
print(x)

Above, we took a list, and added to the end of the list with .append. Remember append with files? Same thing, .append() will add to the end of a list.
.......

x.insert(2,33)
print(x)
Here we say that we want to insert, at the index of 2, the number 33. The reason that went in the 3rd place, again, is because we start at the zero element, then go 1, 2...etc with lists.
.........

x.remove(6)
print(x)
Now we can remove things. .remove() will remove the first instance of the value in the list. If it doesn't exist, there will be an error:

...........
Next, remember how we can reference an item by index in a list? like:

print(x[5])
................

Well, we can also search for this index, like so:

print(x.index(1))

.............
Now here, we can see that it actually returned a 0, meaning the first element was a 1... when we knew there was another with an index of 5. So, instead we might want to know before-hand how many examples there are.

print(x.count(1))

We see there are actually 2 of them

We can also sort the list:

x.sort()
print(x)

What if these were strings? like:

y = ['Jan','Dan','Bob','Alice','Jon','Jack']
y.sort()
print(y)
y.reverse()
print(y)
.......................................

#DICT
To access dictionary elements, you can use the familiar square brackets along with the key to obtain its value. Following is a simple example −

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

print "dict['Name']: ", dict['Name']
print "dict['Age']: ", dict['Age']

When the above code is executed, it produces the following result −

dict['Name']:  Zara
dict['Age']:  7
...............................

#Updating Dictionary

You can update a dictionary by adding a new entry or a key-value pair, modifying an existing entry, or deleting an existing entry as shown below in the simple example −

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School"; # Add new entry


print "dict['Age']: ", dict['Age']
print "dict['School']: ", dict['School']

When the above code is executed, it produces the following result −

dict['Age']:  8
dict['School']:  DPS School

.....................................
#Example Dict value

The following example shows the usage of values() method.

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7}

print "Value : %s" %  dict.values()

When we run above program, it produces following result −

Value : [7, 'Zara']

..........................
#Dict default key 

dict.setdefault(key, default=None)

he following example shows the usage of setdefault() method.

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7}

print "Value : %s" %  dict.setdefault('Age', None)
print "Value : %s" %  dict.setdefault('Sex', None)

When we run above program, it produces following result −

Value : 7
Value : None

Dict items

The following example shows the usage of items() method.

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7}

print "Value : %s" %  dict.items()

When we run above program, it produces following result −

Value : [('Age', 7), ('Name', 'Zara')]



</source>