Python - ayuda automata celular

nueva_cadena=primer_celda+nueva_cadena+ultima_celda

import sys

# Imprimir resultado con el formato establecido: 0=blanco, 1=*.

#  Entrada: cadena

#  Salida: cadena con formato establecido (anexa guiones al principio y al final)

def imprime_resultado(cadena):

	resultado_formato = ''

	for caracter in cadena:

		if caracter == '1':

			resultado_formato = resultado_formato + 'x'

		else:

			resultado_formato = resultado_formato + '-'

        print (resultado_formato + "")

# Aplicar la regla con la ventana recibida.

#  Entrada: Ventana (coleccion de tres celdas, la central y dos vecinos a los lados)

#  Salida: 0 o 1, dependiendo de la regla utilizada

#  Regla 165: Vecinos con el mismo color=1, de otra manera=0

def procesa_ventana(ventana):

    if ventana[0] == ventana[2]:

        resultado = '1'

    else:

        resultado = '0'

    return resultado

# Generar una nueva cadena de acuerdo a una regla (0-255)

# Entrada: cadena actual (t=i)

# Salida: cadena nueva (t=i+1)

def recorre_cadena(cadena):

    nueva_cadena = ''

    for i in range(0,len(cadena)-2): #Es como un for(i=0;i<cadena.length;i++) en Java

        n = len(cadena)

        ventana = cadena[i:i+3]

        nueva_cadena = nueva_cadena+str(procesa_ventana(ventana))

        ultima_ventana = cadena[len(cadena)-2]+cadena[len(cadena)-1]+cadena[0]

        primera_ventana = cadena[len(cadena)-1]+cadena[0]+cadena[1]

        ultima_celda = str(procesa_ventana(ultima_ventana))

        primer_celda = str(procesa_ventana(primera_ventana))

        nueva_cadena = primer_celda+nueva_cadena+ultima_celda;

    return nueva_cadena

#-------------------------------------------------------------

# Main (parte principal del programa)

# Cadenas de prueba

#mi_cadena = "0000000000000000000000000000000000100000000000000000000000000000000000"

#mi_cadena="0010101110"

mi_cadena="01010111"

# Toma la cantidad de iteraciones como argumento de la linea de comando

iteraciones = 3 #sys.argv[1]

# Por la cantidad fijada de iteraciones:

#   Imprime la cadena actual

#   Genera una nueva cadena de acuerdo a la regla

#   Reemplaza la cadena actual por esta nueva cadena

for i in range(0,int(iteraciones)):

    imprime_resultado(mi_cadena)

    nueva_cadena = recorre_cadena(mi_cadena)

    mi_cadena = nueva_cadena

import sys

def imprime_resultado(cadena):

        resultado_formato="_"

        for caracter in cadena:

                if caracter=="1":

                        resultado_formato=resultado_formato + "+"

                        print resultado_formato+'_'

                else:

                        resultado_formato=resultado_formato + "o"

                        print resultado_formato+'_'

def recorre_cadena(cadena):

        nueva_cadena=''

        for i in range(0,len(cadena)-2):

                n=len(cadena)

                ventana=cadena[i:i+3]

                nueva_cadena=procesa_ventana(ventana)

                ultima_ventana=cadena[n-2] + cadena[n-1] + cadena[0]

                primera_ventana=cadena[n-1] + cadena[0] + cadena[1]

                ultima_celda=procesa_ventana(ultima_ventana)

                primer_celda=procesa_ventana(primera_ventana)

                nueva_cadena=primer_celda+nueva_cadena+ultima_celda

        return nueva_cadena

def procesa_ventana(ventana):

        if ventana[0]==ventana[2]:

                resultado="1"

                return resultado

        else:

                resultado="0"

                return resultado

iteraciones=sys.argv[0]

mi_cadena="0000000000000000000000000000000000100000000000000000000000000000000000"

for i in range(0,len(iteraciones)):

        nueva_cadena=''

        imprime_resultado(mi_cadena)

        mi_cadena=nueva_cadena + recorre_cadena(mi_cadena)

        mi_cadena=nueva_cadena

#!/usr/bin/python

import sys

try:

  import Image

except:

  print "You need python-imaging package"

  sys.exit()

import cStringIO

class Automaton:

  vector = []

  def __init__(self,rulesInput,initSize=256,defaultState='0',initialVector=None):

    self.numberRule = rulesInput

    n = Denary2Binary(rulesInput)

    self.createRule((8-len(n))*'0' + n)

    if initialVector == None:

      self.defaultState = defaultState

      self.size = initSize

      self.vector = [self.defaultState]*self.size

    else:

      self.vector = initialVector

      self.size = len(initialVector)

  def createRule(self,binary):

     self.rules = {"000": binary[7],"001":binary[6],"010":binary[5],"011":binary[4],

                    "100":binary[3],"101":binary[2],"110":binary[1],"111":binary[0]}

  def changeState(self):

    nextStep = self.vector[:]

    for i in xrange(self.size-1):

      nextStep[i] = str(self.rules[self.vector[i-1]+self.vector[i]+self.vector[i+1]])

    nextStep[-1] = str(self.rules[self.vector[-2]+self.vector[-1]+self.vector[0]])

    self.vector = nextStep

def Denary2Binary(n):

  if n == 0: return ''

  return Denary2Binary(n>>1) + str(n % 2)

class AutomatonImage:

  buffer = cStringIO.StringIO()

  width = 0

  height = 0

  def __init__(self,autoObj=None,iter=None):

    if autoObj != None and iter != None:

      self.name = "automata-rule%s.jpg" % autoObj.numberRule

      for i in xrange(iter):

       self.writeVector(autoObj.vector)

       autoObj.changeState()

      self.saveImage()

  def writeVector(self,vector):

    self.height = self.height + 1

    self.width = len(vector)

    for i in xrange(len(vector)):

      self.writePixel(vector[i])

  def writePixel(self,value):

    if value == '0':

      self.buffer.write('\xff\xff\xff')

    else:

      self.buffer.write('\x00\x00\x00')

  def saveImage(self):

    imagen = Image.fromstring("RGB",(self.width,self.height),self.buffer.getvalue())

    imagen.save(self.name,"JPEG")

if __name__ == "__main__":

  # Default size of the initial automata

  size = 500

  mVector = (' '.join('0'*size)).split()

  # The midle of the vector must be 1

  mVector[(size/2)+1]='1'

  if len(sys.argv) > 1:

    try:

      n = int(sys.argv[1])

    except:

      print "Second parameter must be an integer"

      sys.exit()

  else:

    n = raw_input("Rule number: ")

    try:

      n = int(n)

    except:

      print "Must be an integer"

      sys.exit()

  myAutom = Automaton(n,initialVector=mVector)

  AutomatonImage(myAutom,(size/2))