a few newbie questions

#setup variable named var 
var = 'some value'

#if nothing is passed to chnage new = new value.
def change(new = 'new value'):
	#set local variable to global
	global var
	var = new
	return var

#chnage value	
change()

#print var variable
print var

def mode(numbers):
    b = 0
    highs = ([], [])  #number, count
    numbers.sort()
    while b < (len(numbers)):
        c = numbers.count(numbers[b])
        if c > 1:
            highs[0].append(numbers[b])
            highs[1].append(c)
        b += c
    b = ([0],[0])   #number, count
    for c in range(len(highs[0])):
        if highs[1][c] > b[1][0]:
            b[1][0] = highs[1][c]
            b[0][0] = highs[0][c]
            continue
        if highs[1][c] == b[1][0]:
            b[0].append(highs[0][c])
        if b[0][0] == '':
            b[0][0] = "none"
    return b        # returns in the format ([modes], [highest # of occurences])

def multoutbinomial(eq, n):
    i, holder = 1, (["empty"],[0],[0]) # no letter on the nj coefficient.
    eq = cleaner(eq,0)
    eq = eq.split(" ")
    parts = [0],[0],[0],[0] # nj coefficient, a, b, multiplied result
    
    for i in range(1,(n+1)):  # put the things into arrays
        if i == 1:
            parts[0].append(i)
        else:
            parts[0].append(((n-i+1)*parts[0][i-1])/(i-1))
        parts[1].append(eq[0] + "**" + str(n-i))
        parts[2].append(eq[1] + "**" + str(i-1))
    print parts    # only for testing!
    for b in range(1,3):    # store letters in parallel thingy
        for i in range(1,n+1):
            current = str(parts[b][i])
            letter = re.findall("[a-zA-Z]", current)
            holder[b].append(letter[0] + "^" + str(n-i+1) or "")

multoutbinomial("2x - 3", 6)

def cleaner(eq, split = 1):    # breaks the equation into coefficients and x-values
    eq = re.sub("\s\-\s", " -", eq)
    eq = re.sub("\s\+\s", " ", eq)
    if split == 1:
        eq = eq.split(" = ")
    return eq

def line(list = []):
	for num in xrange(len(list)):
		print list[num] + 'is number:' + num

exec("var = 2 * 2")

import re
def summation(eq="x**2",n=2,k=0):
    sum = 0
    if re.findall("-\.?\d+", eq):        
        eq = re.sub("-", "(-", eq)
        eq = re.sub("\*\*", ")**", eq)
    eq = re.sub(alpha, "x", eq)
    while k <= n:
        x = k
        sum += eval(eq)
        k += 1
    return(sum)

from re import sub, findall
from math import sqrt
global alpha; alpha = re.compile("[a-zA-Z]")
global s; s = re.sub
global f; f = re.findall

def cleaner(eq, splittype = "equal"):
    """ Separates an equation into array elements based on splittype """
    eq = s("\s\-\s", " -", eq)
    eq = s("\s\+\s", " ", eq)
    if splittype == "equal":
        eq = eq.split(" = ")
    if splittype == "space":
        eq = eq.split()
    else:
        eq = eq.split(", ")
    return eq


def pascalsTri(n):
    """ Finds the row of Pascal's Triangle that corresponds
        to the nth term of a binomial expansion """
    init = [1]
    for i in range(0,n):
        init.append((n-i) * init[i] / (i+1))
    return init  


def multoutbinomial(eq="5x + 3y", n=5): # add support for (ax^b + cy^d)^n
    """ Multiplies out a binomial of the form (ax + by) to the nth term. """
    i, holder, sol = 1, (["empty"],[0],[0]), "" # no letter in the nj coefficient.
    eq = cleaner(eq,"space")
    parts = [0],[0],[0],[0] # nj coefficient, a, b, multiplied result
    pascal = pascalsTri(n)

    for i in pascal: parts[0].append(i)  # puts the nj coefficients into an array
    for i in range(1,n+2):  # put the things into arrays & do x and y
        parts[1].append(eq[0] + "**" + str(n-i+1)) # does the powers
        parts[2].append(eq[1] + "**" + str(i-1))
    for b in range(1,3):    # store letters in parallel truple
        for i in range(1,n+2): # sort through each element
            current = str(parts[b][i])
            if f(alpha, current): # is the current element a letter?
                letter = f(alpha, current) # find the letter
                if (n-i+1) != 1:
                    holder[b].append((letter[0]) + "^" + str(n-i+1)) 
                elif (n-i+1) == 1: # so there isn't x^1
                    holder[b].append(letter[0])
                if f("[a-z]\^0", str(holder[b][-1])):
                    holder[b][-1] = 0 # removes x^0 to maintain intended holder[] functionality
                current = s(alpha, "", current) # removes letter from coefficient
            else:
                holder[b].append(0) # if there is no letter, put a 0 instead
            if f("-", current):
                current = s("-", "(-", current) # (-a)^n is not the same as -a^n
                current = s("\*\*", ")**", current)
            if f("^\*\*\d+", current) or f("^\(-\)\*\*\d+", current):
                current = s("(?:\W*)\*\*", "1**", current) # fixed the (-)**n weirdness
            parts[b][i] = current

    for i in range(1,n+1):  # multiply the coefficients
        parts[3].append(parts[0][i] * eval(parts[1][i]) * eval(parts[2][i]))

    if holder[2][1] != 0: # unreverses the secondary letter array
        holder[2].reverse(); holder[2].pop(); holder[2].insert(0, 0)

    for i in range(1,n+1): # puts everything together, cosmetics
        current = str(parts[3][i]) # go through each element of the solution array
        if f("-", current) and i != 1: # makes "-a" " - a", only if not [1]
            current = s("-", "- ", current)
        elif i != 1: # makes "a" into " + a", only if not [1]
            current = s("^", "+ ", current)
        for b in range(1,3):
            if holder[b][i] != 0: # does the corresponding letter array element have a letter?
                current += str(holder[b][i])
        sol += " " + current
    current = str(eval(parts[2][-1])) # evaluate the last coefficient
    if f("-", current):
        current = s("-", " - ", current)
    else:
        current = " + " + current  # clean up this last coefficient
    sol += current
    if holder[2][-1] != 0: sol += holder[2][-1] # tack on the last variable, if there is one
    return sol

if i != 0: var = i

string_or_variable.replace('string to be replaces', 'with').

string_or_variable.find('string to be found')