Calculating all prime palindromes from 0 to 1000 and printing the largest I have often read about how important clear and efficient code is. Also often people talk and write about 'beautiful' code. Some hints and critic from experienced developers for the following code would be extremely helpful to me. Another question that I often ask myself is about list comprehensions: I feel that in the first specific code (about prime palindromes), especially the second function that verifies palindrome characteristics could be expressed on one line in a list comprehension - how would that work, and would it even be an advantage of some sort?

The code calculates all the prime palindromes from 0 to 1000 and prints the largest.

#My solution to codeval challenge Prime Palindrome. AUTHOR: S.Spiess
#initial count
counting_list = [x for x in range(0,1001)]

#prime number check. make list prime_list containing only primes from 0 to 1000
def prime_check(a_list):
    prime_list = []
    for k in a_list:
        count = 2.0
        d_test = 0
        while count &lt; k:
            if k % count == 0:
                d_test += 1
                count += 1
            else:
                count += 1
        if d_test &lt; 1 and k &gt; 1:
            prime_list.append(k)

    return prime_list

#check prime numbers from previous function for palindrome characteristic. append in new list.
def palindrome_check(num_list):
    palindrome_list = []
    for i in num_list:
        temp = str(i)
        if temp == temp[::-1]:
            palindrome_list.append(i)

    return palindrome_list

#print biggest palindrome prime from 0 to 1000
print max(palindrome_check(prime_check(counting_list)))


Here is another sample of code I wrote. It contains two functions that can change the base of a number.

def to_mod20(any_num):
    a_list = []

    if any_num &lt; 20 and any_num &gt;= 1:
        a_list.append(int(any_num))

    while any_num &gt;= 20:
        a_list.append(any_num % 20)
        if any_num / 20 &lt; 20:
            a_list.append(any_num / 20)
        any_num = any_num / 20
    #invert list for proper output
    return a_list[::-1]


def decimal_mod20(any_dec):
    count = 0
    a_list = []
    while any_dec &lt; 1 and count &lt; 4:
        a_list.append(int(any_dec * 17.0))
        any_dec = any_dec * 17.0 - int(any_dec * 17.0)
        count += 1
        #print any_dec

    return a_list
The list comprehension [x for x in range(0,1001)] is redundant, as range already returns a list in Python 2. In Python 3 one can use list(range(1001))
Write a docstring instead of a comment to describe a function.
Why is count a float (2.0) in prime_check? Should be an int.
Prefer for loops to while loops when they do the same thing. Eg. use for count in xrange(2, k) in prime_check.
if any_num &lt; 20 and any_num &gt;= 1: can be written as if 1 &lt;= any_num &lt; 20:
You may want to look for more efficient algorithms for generating primes.