### Or Currency Conversion using Python

I love to travel and one of my favorite programming languages is Python. Sometimes when I travel I like to make things a bit more difficult and instead of just asking Google to convert currency for me, I like to have a script on my computer that requires me to know the conversion rate and then calculate my needs. But seriously, let’s use a currency converter to help explain some neat reasons why Object Oriented Programming is awesome.

### Money Money Money

First let’s build a currency class.

``class Currency(object):    def __init__(self, country, value):        self.country = country        self.value = float(value)``

OK, neato. Here’s a currency class. Let’s break this down. In Python every class has an __init__ method. This is how we build an instance of a class. If I call Currency(), it’s going to break because our class also happens to require two arguments. self is not required to be passed. In order to create an instance of currency we just use Currency(‘Canada’, 1.41) and we’ve now got a Canadian instance of our currency class.

``def from_usd(self, dollars):    """If you provide USD it will convert to     foreign currency    """    return self.value * int(dollars)def to_usd(self, dollars):    """If you provide foreign currency it will convert to     USD    """    return int(dollars) / self.value``

Again, self isn’t needed by us to use the methods but needs to be passed to every method in our class. self is our instance. In some cases self will refer to our Canadian instance but if we were to create a new instance Currency(‘Mexico’, 18.45) self can now also refer to our Mexican instance.

Fun. We’ve got some awesome methods that help me do math without me having to think. How does this help us? Well, we don’t have to write new methods for each country. This way, as currency rates change, we can update the changes rather quickly and also deal with many countries at once. Conversion between USD and foreign currency is all done the same way. We don’t need to change the math based on the country we’re planning on visiting, we only need to change the value of the currency relative to USD.

I’m an American so I used USD because that’s the currency I’d be converting to and from most often. But if I wanted, I could have named them from_home_country and to_home_country.

Now how does this work? Well, if I wanted to run this script I’d just do this:

``````again = True

while again:
country = raw_input('What country are you going to?n')
value = float(raw_input('How many of their dollars equal 1 US dollarn'))

foreign_country = Currency(country, value)

convert = raw_input('What would you like to convert?n1. To USDn2. To %s dollarsn' % country)
dollars = raw_input('How many dollars would you like to convert?n')

if( convert == '1' ):
print dollars + ' ' + country + ' dollars are worth ' + str(foreign_country.to_usd(dollars)) + ' US dollarsn'
elif( convert == '2' ):
print dollars + ' US dollars are worth ' + str(foreign_country.from_usd(dollars)) + dollars + ' ' + country

again = raw_input('nnnWant to go again? (Y/N)n')

if( again == 'y' or again == 'Y' ):
again = True
elif( again == 'n' or again == 'N' ):
again = False``````

**I’m still using Python 2 so if you’re using Python 3 you’ll want to change those raw_inputs to just input.

This way we can convert as much currency as we want between USD and any country! I can now travel the world feeling comfortable that if I can’t access the Internet and I happen to have my computer nearby and I am at a bank or the hotel lobby staring at the exchange rate board, I’ll be able to convert currency with ease without having to remember which way converts my money to USD and which way converts USD to Canadian dollars.

Object-oriented programming allows us to create objects that all behave in the same way but store different values, like a blue car, red car, or green car. The cars all behave the same way but they are all described differently. They might all have different MPG but the way we calculate their MPG is the same. They all have four wheels and an engine. While it can be harder to build your program with object oriented design in mind, it definitely helps with maintainability in the long run.