Define a function using a variable?

Question

I am trying to define a function that will include a variable n where n will be a string of numbers e.g. "3884892993", the definition of the function starts as is_true(n), however if n is going to be a string should it be is_true(n) and then once the string is defined I can test the function with an example string such as n = "3884892993". I get a syntax error when I use is_true(n) however. And I am just wondering how I would go about testing this function with an example string for n.

My entire function to define is shown here: http://oi44.tinypic.com/282i3qo.jpg but bear in mind I am an absolute novice so there will most probably be many mistakes, but I would appreciate some help from some experts if at all possible :)

def is_valid("n"): #n is the number to be checked.
    number = 
    [int(y) for y in A] #converts the string into a list of useable digits.
    altern1 = integer[-2::-2] #sets altern1 as one set of alternating digits.
    double = [x*2 for x in altern1] #doubles each element of the list altern1.
    sum1 = sum(double) # adds together all the doubled items of the list.
    altern2 = integer[-1::-2] #sets altern2 as the other set of alternating digits.
    return sum2 = sum(altern2)#sums the other set of alternating digits.
    sumtotal = sum1 + sum2 #works out the total sum to be worked with.
    for mod = sumtotal % 10: #works out remainder when sumtotal is divided by 10
        if mod == 0 : #if remainder is zero sumtotal is a multiple of 10
            print 'True' #sumtotal is a multiple of 10 therefore n is a credit card number
        else:
            print 'False' #sumtotal is NOT a multiple of 10 therefore not a valid credit card number

Here is the actual question:

The algorithm for verifying a number is as follows: (a) Starting with the penultimate digit, and working towards the rst digit, double each alternating digit. (b) Sum the doubled digits, treating 13 as 1+3, etc, and add the result to the sum of the undoubled digits (c) If the sum is divisible by 10 the number is a valid credit card number.

Write and test a function is_valid() which takes as an argument a credit card number as a string (eg is valid("49927398716")) and returns True or False depending on whether the number is a valid credit card number.

Answer 1

I am not sure what is your question, but if you are trying to:

• correctly define the function:
  • pay attention to the indentation (this is required by Python!),
  • see here for examples of function definitions,

• convert a string variable into integer, you can do this:

  new_var = int(old_var)
  

  Generally please pay attention to types, because it is not like in some other dynamically typed languages and strings are not dynamically converted into numbers - you should do it explicitly.

• read the value of the variable, based on its name:

  my_var = vars().get('variable_name')
  

  (where variable_name is the name of the variable and optionally you can give context within brackets after vars - see help(vars) for details)

Did any of the above solve your problem?

EDIT (based on the clarification):

This should solve your problem:

def is_true(my_variable):
    # Here the variable named "my_variable" is accessible

If you want to do something "in-place" on the passed variable, I have a bad news: strings and integers are immutable in Python, thus you are not able to simply change them - you should probably return them as a result of the function (there are at least two workarounds, but I do not recommend them if you are a novice in Python).

EDIT (for proper code styling):

You should probably read PEP 8 to get familiar with what is the coding standard for Python scripts - this is commonly used across Python community and you should follow that (at some point you should appreciate it).

Answer 2

Quotes are only used for string literals, you wouldn't enclose a variable or parameter name in quotes to indicate that it will be a string. The function definition would look like:

def is_true(n):

And then in the body of the function you use n to reference the value that is passed in by the caller.

To call the function on a specific value, you do:

is_true("3884892993")

Side suggestion: Think of more explanatory names for your functions and variables. For instance, it seems like your function might be reasonably called is_valid_card_number.

Answer 3

From the Wikipedia article on the Luhn algorithm:

def is_luhn_valid(cc):
    num = map(int, str(cc))
    return sum(num[::-2] + [sum(divmod(d * 2, 10)) for d in num[-2::-2]]) % 10 == 0

Answer 4

I have no idea what your function is supposed to do, but here are some remarks.

First of all, if you define the function then you use the following syntax

def is_true(n):
    # do something

you can call this function like this is_true("3884892993"), i.e. you can pass string as n. Your function now need to treat variable n as a string. So you can use

number = [int(d) for d in n]

which will result in converting string into a list of digits.

One more remark: you used a return statement inside your is_true function. This statement will stop executing the function and return the value. Every code below return will never be executed.

Answer 5

May be like this. I leave your comments

def is_valid(n): #n is the number to be checked.
    numbers = [int(y) for y in n] #converts the string into a list of useable digits.
    double_alt = [sum([int(i) for i in str(x*2)]) for x in numbers[-2::-2]]   #doubles      and sum if more than 10each element of the list altern1.
    sum1 = sum(double_alt) # adds together all the doubled items of the list.
    sum2 = sum(numbers[-1::-2]) #sums the other set of alternating digits.
    sumtotal = sum1 + sum2 #works out the total sum to be worked with.
    return not sumtotal % 10

Answer 6

Here an implementation of the luhn algorithm that I had to make recently.

def is_valid_luhn(cc):
    return not sum([sum(divmod(int(d) * 2, 10)) for d in cc[-2::-2]] + [int(d) for d in cc[-1::-2]]) % 10
    #                          | double |       |--- every -2th --|            |--- every -1th --|
    #                          |--------- step 1 -----------------|
    #              |------------- sum doubled digits --------------|   |-- sum undoubled digits --|
    #          |---------------------- step 2: sum doubled/undoubled digits -----------------------|
    #      |-------------------------- step 3: sum % 10 == 0 --> not sum % 10 --------------------------|

Or if you'd like a more verbose version:

def is_valid_luhn(cc):
    total = 0
    # Double and sum every 2nd digit starting at -2.
    for d in cc[-2::-2]:
        # divmod(d*2, 10) returns (d*2 // 10, d*2 % 10)
        # sum(divmod) return (d*2 // 10) + (d*2 % 10)
        total += sum(divmod(int(d) * 2, 10))
    # Sum every 2nd digit starting at -1.
    for d in cc[-1::-2]:
        total += int(d)
    # Check module 10 of total: total % 10 == 0 --> not total % 10
    return not total % 10