Download the JSON from API and parse the data like Unique Voting Station Name and Councillors Name
First, you should stop using Python 2, if possible. It will stop being supported in a bit over a year. Switch to Python 3, it is better in many ways.



Now, let's start with year not in range(2013,2018,4). This is a very inefficient way to do this, because in Python 2, range just generates a list and in lookup in lists is \$\mathcal{O}(n)\$. Instead use a collection for which in is \$\mathcal{O}(1)\$, like set or `dict. This is a good habit to form, even though here this list has only two elements. 

As a side note, this was such a common beginner's mistake that they made sure that the Python 3 implementation of range (which is a generator on steroids), is actually \$\mathcal{O}(1)\$.



Now, to come to the underlying problems of the code. It is currently a mix of global variables, global code, function definitions, which sometimes take arguments, but also use global variables, and all of which modify global state (even though some of hem also return something). And these functions are then called right away.

Instead, try to define pure functions, that is functions that take all they need as arguments and return their result, without modifying any global state. You can then use these functions in a main method that does all the work.

import json
import requests
CRED = '\033[91m'
CEND = '\033[0m'

URLS = {2013: "https://data.calgary.ca/resource/kqmd-3dsq.json",
        2017: "https://data.calgary.ca/resource/4wni-k3sg.json"}

WARDS = set(range(0, 14))


def ask_year():
    while True:
        try:
            year = int(raw_input("\nElection Year to Search {}:".format(sorted(URLS.keys()))))
            if year not in URLS:
                print "No data for that year!"
                continue
        except ValueError:
            print "Please enter a valid year!"
            continue
        return year


def ask_ward():
    while True:
        try:
            ward = int(raw_input("\nWard to Search:"))
            if ward not in WARDS:
                print "Ward does not exist in City of Calgary !"
                continue
        except ValueError:
            print "Invalid ward number!"
            continue
        return ward

def get_voting_stations(ward, data):
    for station in data:
        try:
            if station["wards"] == ward:
                yield station["voting_station_name"]
        except KeyError:
            continue


def print_ward_voting_stations(ward, data):
    vorting_stations = set(get_voting_stations(ward, data))
    if vorting_stations:
        print "\nThere were in total", len(vorting_stations), "unique voting stations in your ward"
        print "\nThe list of the Voting Station were as follows"
        for i, name in enumerate(vorting_stations, 1):
            print '{} {}'.format(i, name)
    else:
        print CRED, "\nCity of Calgary has no Data on voting stations for ward {} in year {}".format(ward, year), CEND


def get_councillors(ward, data):
    for ballot in data:
        if ballot["ward"] == ward and ballot["office"] == "COUNCILLOR":
            yield ballot["ballot_name"]

def print_ward_councillors(ward, data):
    councillors = set(get_councillors(ward, data))
    if councillors:
        print "\nThere were in total", len(councillors), "councillors in your ward"
        print "\nThe list of the Councillors were as follows"
        for i, name in enumerate(councillors, 1):
            print '{} {}'.format(i, name)
    else:
        print CRED, "\nCity of Calgary has no Data on this Ward for Councillors in year", year, CEND


if __name__ == "__main__":
    print " \nThis is Json Data Parser Program. \nThis program will print the Unique Voting Station Name from 2013 or 2017 City Elections from City of Calgary OpenData Portal"

    year = ask_year()
    print "You chose: {} year for Elections Results".format(year)
    ward = str(ask_ward())
    print "\nYou chose ward: {} for Elections Results".format(ward)

    data = requests.get(URLS[year]).json()
    print_ward_voting_stations(ward, data)
    print_ward_councillors(ward, data)


The major differences are: I used a dict to map from the year to the url of the json file. This automatically raises a KeyError if an undefined year is given. You also already ensure that what the user entered is a valid year, here I re-used the keys of that dictionary.

I used a set for the valid wards. Both the urls and the wards are constant, and therefore written in ALL_CAPS, as recommended by Python's official style-guide, PEP8.

I separated the filtering of the data for what you need and making it unique. For this I defined each one function for outputting a stream of the voting stations/the office the ballot was for. This is then consumed by set, which makes it unique (but removes the order, which I think is not important here). This once again removes the necessity to do e.g. i["voting_station_name"] not in wardstnresult, which is again \$\mathcal{O}(n)\$.

I also removed catching KeyboardInterrupt and EOFError. Catching these errors should be well motivated. The first one appears when the user presses Ctrl+C, which means they want to abort whatever you are doing. Ignoring that and telling them to please enter a valid year is almost passive aggressive. The same goes for the latter, which happens if the user presses Ctrl+D. This is used to denote that the input is finished (especially important for multi line input). I don't see any reason whay you would want to catch that here.

Instead I replaced these with an infinite while True loop, which continues asking the user until they enter a valid year/ward or press Ctrl+C, which kills the whole program.