Number to Roman Numerals in Python
Welcome to Code Review!

Most of my suggestions are stylistic, but still something to care about in the Python world.  (PEP8 Style Guide)  I did catch a fairly major bug since you are only accepting 1 - 3999 as valid numbers, so we fix that too.



Redundant Parentheses

Unlike in C or C++ (or even Java to some level) you don't have to wrap conditionals in parentheses typically.  There are some cases where you would need to, but your if conditions are not complex enough to need that.



BUG: If an integer less than 0 is passed, there is no warning about being too small a number

Therefore, if a negative number is passed in at runtime, it outputs nothing and no errors.  We can fix this in one line of code - we just change your == check to a &lt;= check (less than or equal to):

if num &lt;= 0:
    return "Number too small"




Descriptive Parameters

Normally, you should name an parameter for a function in a more descriptive way.  While n can be assumed to be a number, it would be better to have num instead of n as an parameter name for getRomanNumerals to better describe what that is.

My two cents, of course, but in more complex functions where n could lose meaning, you'd be better off with a more descriptive parameter name so you don't lose track of what n does.



Rogue Semicolon!

On line 47, you have a rogue trailing semicolon.  While this doesn't affect running of your program, such semicolons are not necessary.



Style: Function names should be lowercase; multiword names separated with underscores

From the PEP8 (linked above):


  Function names should be lowercase, with words separated by underscores as necessary to improve readability.
  
  mixedCase is allowed only in contexts where that's already the prevailing style (e.g. threading.py), to retain backwards compatibility.


Therefore, your function names should be renamed as follows:


digitToRomanSym becomes digit_to_roman_sym
getRomanNumerals becomes get_roman_numerals




Style: Parameter variable names usually are lowercase

While not explicitly defined in PEP8 as far as I can tell, most of the time, arguments within a function (for example, symList in digitToRomanSym in your code) tend to be lowercase and if multiword, are underscore-separated.



Style: Local variable names should be lowercase, multiword separated with underscores

Just like function definitions, local variables should be lowercase.  That is, variables within the scope of a single function.





Your code after my changes:

(Filename: int2roman.py)

import sys

symbols1 =     [(1,   "I"), (5,   "V"), (10,   "X")]
symbols10 =    [(10,  "X"), (50,  "L"), (100,  "C")]
symbols100 =   [(100, "C"), (500, "D"), (1000, "M")]

symList = [symbols1, symbols10, symbols100]

def digit_to_roman_sym (digit, sym_list):
    """ Converts a single digit into its roman symbols """
    one =  sym_list[0][1]
    five = sym_list[1][1]
    ten =  sym_list[2][1]

    switcher = {
        1: one,
        2: one + one,
        3: one + one + one,
        4: one + five,
        5: five,
        6: five + one,
        7: five + one + one,
        8: five + one + one + one,
        9: one + ten,
    }
    return switcher.get(digit, "")

def get_roman_numerals(num):
    """ Converts a num between 1 and 3999 into Roman numerals """
    max_number = symList[-1][-1][0] * 4 - 1 # A symbol can be repeated max 3 times e.g. MMM for 3000

    if num &gt; max_number:
        return "Number too big"

    if num &lt;= 0:
        return "Number too small"

    i = 0
    roman_str = ""
    while num &gt; 0 and i &lt; len(symList):
        roman_str = digit_to_roman_sym(num % 10, symList[i]) + roman_str
        num /= 10
        i += 1

    if num &gt; 0:
        biggest_symbol = symList[-1][-1][1]
        roman_str = (num * biggest_symbol) + roman_str

    return roman_str

if len(sys.argv) == 2:
    number = int(sys.argv[1])
    print(get_roman_numerals(number))
else:
    print("Wrong number of arguments")