An easy solution to this is to construct your url dynamically based on user input (you can use str.format() to do that). For example:

#!/usr/bin/env python

from requests import get
from bs4 import BeautifulSoup
import sys

v1 = sys.argv[1]
v2 = sys.argv[2]
amount = sys.argv[3]

# check if the values passed are valid
# and construct the url like so:
currency_page = 'http://www......../convert/?Amount={}&From={}&To={}'.format(amount,v1,v2)

currency = get(currency_page).text
currency_data = BeautifulSoup(currency, 'html.parser')

USD = currency_data.find('span', attrs={'class': 'uccResultUnit'})
USD_PKR = USD.text.strip()
print(USD_PKR)

Results:

$ ./test.py EUR PKR 1                           
1 EUR = 125.790 PKR

The other solution, as also mentioned in the comments, is to use

1. an API or
2. a module instead.

Code Style Improvements

• "Flat is better than nested". You can make an early exit in case of invalid input:

  import sys
  
  try:
      amount = float(input("Enter amount: "))
  except ValueError:
      print("Invalid input. Please enter only numbers.")
      sys.exit(1)
  

  That will allow you to remove the else: part and continue on the top-level. Or, you can let the user retry the input until it is valid

• on the same topic of decreasing nestedness depth - add more early exists. For instance, if input currencies are invalid, throw an error and exit. Then, remove the else: and continue with your "positive case" logic on the same level. This should improve overall readability
• define the constants, like the list of currencies, as per PEP8 - in upper case (reference)
• put the main execution logic to under if __name__ == '__main__':
• you can simplify if output_cur != '': with just if output_cur:
• I'm not sure why you are importing datetime from _datetime (with underscore). I would expect the import to be from datetime import datetime
• don't put comment for obvious parts of the code. For example, "importing required libraries" does not provide any useful information.

• organize imports per PEP8 - stdlib libraries, then a newline, third-parties, a new line and then your "local" dependencies, all sorted alphabetically:

  from datetime import datetime
  
  from babel import numbers
  import pycountry
  import requests
  

Other High-level ideas

• define custom exceptions. Instead of using the error_sev and error_inp functions where you print errors, define custom exceptions like InvalidCountryValueError. Throw it with your custom message inside
• since you are posting it on github, consider organizing the project properly - add requirements.txt with the list of dependencies, add more documentation, tests - see more at Open Sourcing a Python Project the Right Way
• on the related topic: currently, there is only one way to use your program. Consider someone who wants to use your library as an API - not going through the standard in inputs, but calling a function asking for currency rates. Thinking about your program this way may help you to re-design it a bit, apply "Extract Method" and other refactoring methods. Also, if you would try to add tests, you will quickly realize that there is no easy way to unittest the program - usually a red flag when designing clean and modular APIs

Performance notes

• I'd use a set to keep the supported list of currencies. Since you check the input currencies to be valid with in, this should have a positive impact on performance:

  CURRENCIES = {
      'USD', 'JPY', 'BGN', 'CZK', 'DKK', 'GBP', 'HUF', 'PLN', 'RON', 'SEK', 'CHF', 'NOK', 'HRK', 'RUB', 'TRY',
      'AUD', 'BRL', 'CAD', 'CNY', 'HKD', 'IDR', 'ILS', 'INR', 'KRW', 'MXN', 'MYR', 'NZD', 'PHP', 'SGD', 'THB',
      'ZAR', 'ISK'
  }
  

There is no issue with your code or the forex_python.converter library.

This is a bug with the :latest version of theforexapi which is used by the forex_python.converter, see link to raised issue:

latest/?base=EUR&symbols=USD returns base=ILS #18

The returned "base" is "ILS" instead of "EUR" as expected. This bug only occurs for latest/?base=EUR&symbols=USD. If you specify a date instead of latest, or if you use any other combination of base and symbols, the bug does not happen.

First, there's very little point in using a class like you are here. You're essentially just using the constructor as a function to ask for input. You're also needlessly making some variables attributes of the object, like self.features, self.x, and self.d. The only use of features is to be iterated over within the constructor, and the only use of the latter two are inside of input_process. Even if this were an appropriate use of a class, that data doesn't need to be retained in the object itself. That just wastes memory.

To remedy this, I'd take everything in __init__, and move it into a regular function. To store the data, I'd use a NamedTuple returned from the function.

Your prints are also needlessly verbose. You're using print("") as a way to print newlines. Newlines can simply be added using "\n" though.

print("")
print(Fore.GREEN + "-" * 76)
print("")

Can simply be:

print("\n" + (Fore.GREEN + "-" * 76) + "\n")

And since you use (Fore.GREEN + "-" * 76) multiple times, I'd save that into a string at the top of the file:

SEPARATOR = "\n" + (Fore.GREEN + "-" * 76) + "\n"

Your loop over features is also unnecessary. It can be done simply using join:

print("\n".join(features))

Your names are also poor. c1, c2, c, x and d are very vague and give little information about what they hold. I would make those names much longer.

After making the mentioned changes, and I ended up with:

from currency_converter import CurrencyConverter
from datetime import date
from colorama import Fore
import datetime
from typing import NamedTuple, Optional, Tuple

# These are constants. They should be defined externally, and have capitalized names
FEATURES = ["1. Convert using the last available rate.", "2. Convert using specific dates."]
SEPARATOR = "\n" + (Fore.GREEN + "-" * 76) + "\n"

class ConversionInformation(NamedTuple):  # A simple class to hold information
    feature_type: str
    amount: str
    source_currency: str
    target_currency: str
    conversion_date: Optional[Tuple]

def ask_for_input() -> ConversionInformation:
    print(SEPARATOR)
    print("\n".join(FEATURES))

    feature_type = input("Select a feature: ")

    print(SEPARATOR)

    amount = input("Amount: ")
    source_cur = input("Currency1: ")
    target_cur = input("Currency2: ")

    conversion_date = None

    if feature_type == "2":
        conversion_date = (int(input("Year: ")),
                           int(input("Month: ")),
                           int(input("Day: ")))

    return ConversionInformation(feature_type, amount, source_cur, target_cur, conversion_date)

def process_input(info: ConversionInformation):
    conv = CurrencyConverter()  # This wasn't needed when asking for input

    if info.feature_type == "1":
        # Note the more descriptive names
        result = round(conv.convert(info.amount, info.source_currency, info.target_currency), 2)
        cur_date = datetime.datetime.now()

        print(f"{info.amount} {info.source_currency} is {result} {info.target_currency} on {cur_date}")

    elif info.feature_type == "2":
        result = round(conv.convert(info.amount, info.source_currency, info.target_currency,
                                    date=date(*info.conversion_date)))

        print(f"{info.amount} {info.source_currency} was {result} {info.target_currency} in" +
              "-".join(str(d) for d in info.conversion_date))

    else:
        print("Illegal Feature Type:", info.feature_type)  # Tell the user that they entered an illegal type


# Also a constant
CURRENCIES = ["USD", "SEK", "GBP", "EUR"]


if __name__ == '__main__':
    print(Fore.GREEN + f"This is a Currency converter, the main currencies are {', '.join(CURRENCIES)}")
    print(SEPARATOR)

    while True:
        info = ask_for_input()
        process_input(info)

        print(SEPARATOR)

        if input("Finished. Do another? (Y/N)\n").lower() != 'y':
            break

It's far more verbose, but I believe it's much cleaner and easier to understand.

My main issue with what I've done here is package all the data into ConversionInformation just so it can be passed into process_input. You may find that it ends up being cleaner to make this all one large function.

If i understand correctly, the user will input either "0", "1" or "2" as a input, for the convertion for dollar, euro or yen respectively. So you need to change the initial values of dollar, euro and yen. Changing that, the version with integer input will work.

dollar = 0
euro = 1
yen = 2

If the input is a string such as "dollar", "euro" or "yen", the variables need to be changed to these respective strings, so firstly you need to set the variable as:

dollar = "dollar"
euro = "euro"
yen = "yen"

Then change the input type for raw_input, as python requires this type of input to recognize a String input. So change convert_to to:

convert_to = raw_input ("What currency do you want to convert to? ")

If you try to pass a string to a input variable it will always return 0. And since the initial values for all the variable are 0, the if statements returns true when comparing convert_to to dollar , euro or yen. Because the comparsion to the dollar is hapening first, it always goes to that case. These are the changes necessary for the code to run.

Extra: You also don't need the variables in this case, since you're only using them in one field. So on your if statements, you can just compare them to the specific strings, as:

if convert_to == "dollars":
    amount *= 1.3
elif convert_to == "euros":
     amount *=  1.17
elif convert_to == "yen":
    amount *= 133.66
else:
    print "You must pick either dollar, euro or yen." 

Hope it helps.

Sorry to hear that; at a first glance the code looks okay, naming and splitting into functionality looks good, as well as the use of appropriate libraries, but there's a number of things that could be improved too.

For starters, on the GitHub README.md you're listing a couple of libraries that have to be installed - so it would be easy enough to add a requirements.txt for pip to install them (or an equivalent setup via virtualenv etc.). As an interviewer the smoother the whole thing goes, from downloading to seeing the expected result, the better! Consider next time how someone else runs your project, make it as easy as possible for them, while not going overboard (like, unless you're going to provide a Docker image for them (which is obviously an option ...) for a Python project: Requiring them to have Python 3.X installed is okay, same for pip, but the specific libraries not; give them a Makefile perhaps such that make dependencies runs pip install -r requirements.txt or so).

Next, the README.md says Run a main.py file..., but instead you're using __main__.py, so the documentation should be updated; like I'd rather have it say "Run PYTHONPATH=. python3 -m pyapi." since I might not be familiar with all variants of how Python programs can be invoked (e.g. I had to play with a few different variants till I figured out how to run it ... an interviewer likely has less patience and time than me.)

Okay, so I run pyapi, then curl the examples from the description page (not yours mind you, it'd be a good idea to have it all on your repository too so it doesn't depend on someone else's files!), the first example fails, the second one looks okayish:

0 ~ % curl "http://localhost:5000/currency_converter?amount=0.9&input_currency=¥&output_currency=AUD"
Currency not recognized%
0 ~ % curl "http://localhost:5000/currency_converter?amount=10.92&input_currency=£"
{
    "input": {
        "amount": 10.92,
        "currency": "\u00c2\u00a3"
    },
    "output": {
        "ALL": null
    }
}%

Though, well, the output is empty. Can't really tell why except it looks like I'm inputting the wrong currencies? Using EUR actually works and gives me output:

0 ~ % curl "http://localhost:5000/currency_converter?amount=10.92&input_currency=EUR"
{
    "input": {
        "amount": 10.92,
        "currency": "EUR"
    },
    "output": {
        "ALL": 1380.78
    }
}%

Now CLI, much better, first example works out of the box, second and third don't, same problem, the currency unit isn't converted somehow. Though if I do it myself it works (JPY/GBP). Ah, right, there's some where the currency unit isn't unique, that's fine I guess.

However, if the output currency isn't specified I read the problem statement such that it should then return the conversion to all other currencies ("if output_currency param is missing, convert to all known currencies"), but that's not what's happening:

0 kiwi-currencies % PYTHONPATH=. python3 -m pycli --amount 10.92 --input_currency EUR
INFO: FUNC: create_currencies_dict
INFO: FUNC: sign_to_abbreviation parameters: curr:EUR
INFO: FUNC: sign_to_abbreviation parameters: curr:None
INFO: FUNC: create_json parameters: inp:EUR out:None am=10.92
INFO: FUNC: convert parameters: inp:EUR out:ALL am=10.92
INFO: FUNC: contact_api parameters: inp:EUR out:ALL
INFO: FUNC: contact_api Loading from CACHE: True
INFO: FUNC: convert rate: {'EUR_ALL': 126.445488}
{
    "input": {
        "amount": 10.92,
        "currency": "EUR"
    },
    "output": {
        "ALL": 1380.78
    }
}

What does ALL mean, "Albanian Leak"?

Now to the actual code, both of the __main__.py look mostly okay to me, but, this isn't production quality code: There are no error checks or fallbacks. If an expected argument is missing e.g. the HTTP API crashes (the CLI is better since the command line argument parser checks for it).

test.py looks pretty good! Though I'd suggest not to use assert like this. It could trivially be disabled when optimisations are turned on:

0 kiwi-currencies % python3 test.py
INFO: FUNC: create_currencies_dict
INFO: TEST: test_contact_api <MagicMock name='contact_api' id='140590866107192'>
INFO: TEST: simple_contact_api
.INFO: TEST: test_sign_to_abbreviation
INFO: FUNC: sign_to_abbreviation parameters: curr:€
INFO: FUNC: sign_to_abbreviation parameters: curr:£
.INFO: TEST: test_unknown_input
INFO: FUNC: convert parameters: inp:USD out:EgUR am=45.2
test.py:54: DeprecationWarning: Please use assertEqual instead.
  "Currency not recognized")
.
----------------------------------------------------------------------
Ran 3 tests in 0.007s

OK

0 kiwi-currencies % python3 -O test.py
INFO: FUNC: create_currencies_dict
INFO: TEST: test_contact_api <MagicMock name='contact_api' id='139676823006232'>
.INFO: TEST: test_sign_to_abbreviation
.INFO: TEST: test_unknown_input
INFO: FUNC: convert parameters: inp:USD out:EgUR am=45.2
test.py:54: DeprecationWarning: Please use assertEqual instead.
  "Currency not recognized")
.
----------------------------------------------------------------------
Ran 3 tests in 0.018s

OK

Notice how the second run doesn't exercise some of the tests!

Now for service.py.

• You have comments, good, though I also imagine having some of those as docstrings (contact_api) might be nicer.
• Logging is on, great, that's helpful once you've read the code.
• sign_to_abbreviation, the for loop should be a dictionary lookup? Also the assignment to curr can be removed and directly returned.
• create_json, dict = {} is overwritten immediately after. Same with dict["output"] = {}. Also not x == y should be x != y.
• create_currencies_dict, it might make sense to check for the inverse and return early to keep the indendation shorter, e.g. if currencies_symbols: return and if response.status_code != 200: return None. else: pass at the end of the loop can also be omitted.
• return None can also be omitted in general, or even just return. If you want to be explicit that's fine though.

So overall there are priorities: make it work, show the user how (not just by test cases, by writing down the exact invocation for them to use), then make it nicer. You're on the right way though!

Probably more elegant ways to do this, but it works.

currency_in = 'USD'
currency_out = 'NOK'
import urllib2
req = urllib2.urlopen('http://finance.yahoo.com/d/quotes.csv?e=.csv&f=sl1d1t1&s='+currency_in+currency_out+'=X')
result = req.read()
# result = "USDNOK=X",5.9423,"5/3/2010","12:39pm"

Then you can split() the result for the modifier.

You are taking the currency input in a wrong way. Replace with this code:

amount = int(input("Please enter an amount to convert"))

if con=='a':
    print(amount,'converts to ',amount*0.57)

Also, to add more currency types, instead of typing everything, just put them in an array in this way:

currencies = [['CAD','GBP'],['CAD','USD'],['CAD','JPY'],['CAD','EUR']]
for i in range(len(currencies)):
    print(i+1,' ',currencies[i][0],' to' ,currencies[i][1])
    #change alphabet to integers
con = int(input("Please select the type of conversion"))
if con == 1:
    print(amount,' ',currencies[i-1][0], converts to ',currencies[i-1][1],amount*0.57)

    

You might not have realised it yet, but all your unimplemented methods will very much look like real_to_dollar:

• ask the user how much of the original currency he wants converted;
• apply a specific conversion rate;
• tell the user the result of the conversion in the desired currency.

So that should be a single function, parametrized by the elements that differ between various calls: name of the origin currency, name of the converted currency, exchange rate.

def convert_currency(from, to, rate):
    user_value = raw_input("How many {}? ".format(from))
    amount = float(user_value)
    conversion = amount * rate
    print " {} {} is equal to {} {}.".format(user_value, from, conversion, to)

Also note the use of format to simplify building a string with numbers.

You would then call it convert_currency("reais", "dollars", 0.26) or convert_currency(" dollars", "reias", 3.85).

However, having to use a bunch of ifs to know what parameters to use (like you would have used a bunch of ifs to know which function to call) is not that great and can be a burden to maintain and expand. You could use a second dictionary to map couples of currencies to exchange rates:

RATES = {
    ("BRL", "USD"): 0.26,
    ("USD", "BRL"): 3.85,
    # Expand as necessary
}

And just have to get the rate using RATES[(user_choice1, user_choice2)].

Never assume that your user doesn't make mistakes. I ran your program with no arguments ... error message, fine. I ran it with a single argument of 4 ... error message, fine. I ran it with two arguments, 4 and 5 ...:

Traceback (most recent call last):
  File "test.py", line 17, in <module>
    rate = checker(args.curency_for_convert, args.curency_converted_to)
  File "test.py", line 9, in checker
    rate = content["rates"][symbol.upper()]
KeyError: 'rates'

For debugging purposes, I put print content above that line and ran again:

{'error': 'Invalid base'}

If I run the program with a valid base, but an invalid symbol:

Traceback (most recent call last):
  File "test.py", line 16, in <module>
    rate = checker(args.curency_for_convert, args.curency_converted_to)
  File "test.py", line 8, in checker
    rate = content["rates"][symbol.upper()]
KeyError: '8'

You should catch these errors and display something that is a little more user-friendly.

I would recommend that you read PEP 8, the Python style guide. There are a couple things you aren't following:

Imports should usually be on separate lines, e.g.:

Yes:

import os
import sys

No:

import sys, os

It's okay to say this though:

from subprocess import Popen, PIPE

Don't use spaces around the = sign when used to indicate a keyword argument or a default parameter value.

Your whitespace is a little strange. I would have at least one blank line above and below the function definition. I would also put one after the if block and maybe even before it too. You have " =", " = ", and "=" used in just three lines. PEP 8 says that A Foolish Consistency is the Hobgoblin of Little Minds, but that doesn't mean never be consistent. It is only the foolish consitency which is a hobgoblin. In this case, you have nothing to lose.

Your naming is a little strange. n even shows up in the help messages. One-letter variable names are generally not recommended because they give very little idea of what the variable is for. curency_for_convert and curency_converted_to, besides mis-spelling "currency", are ungrammatical. You could say "for conversion" or "to convert", but "for convert"? I would suggest "convert_from" and "convert_to".

if len(sys.argv) > 3:
    parser.add_argument("n", type =int, help = "Amount of curency_for_convert", default=1)

Instead of manually parsing an argument, make it optional with nargs='?'

print rate if len(sys.argv) <= 3 else rate*args.n

Since our argument will always be present (either with the default of 1 or with a user-supplied number), we can now do print rate * args.n.

Full Program

#!/usr/bin/env python
import argparse
import ast
import requests
import sys

def checker(base, symbol):
    url = "http://api.fixer.io/latest?base=%s" % base.upper()
    r = requests.get(url)
    content = ast.literal_eval(r.content)
    rate = content["rates"][symbol.upper()]
    return rate

parser = argparse.ArgumentParser(description=
    "Currency converter. For instance: to convert 100 USD to RUB, it would be "
    "100 USD RUB. If you need only the rate: USD RUB"
)

parser.add_argument("amount", type=int, help="Amount of currency to convert", default=1, nargs='?')
parser.add_argument('convert_from', type=str, help="Currency to convert")
parser.add_argument('convert_to', type=str, help = "Currency of converted")

args = parser.parse_args()

try:
    rate = checker(args.convert_from, args.convert_to)
except KeyError:
    print "Invalid argument(s)"
else:
    print rate*args.amount