title: How to make a gif of mandelbrot fractal zoom (Python)?
body: <p>I have made a Mandelbrot fractal using PIL module in Python.
  Now, I want to make a GIF of zooming into one point. I have watched other code on-line, but needless to say, I didn't understand it, since the pattern I'm using is a bit different (I'm using classes). </p>
  
  <p>I know that to zoom in I need to change scale... But I plainly don't know how to implement it. </p>
  
  <pre><code>from PIL import Image
  import random
  
  
  class Fractal:
      """Fractal class."""
  
      def __init__(self, size, scale, computation):
          """Constructor.
  
          Arguments:
          size -- the size of the image as a tuple (x, y)
          scale -- the scale of x and y as a list of 2-tuple
                   [(minimum_x, minimum_y), (maximum_x, maximum_y)]
          computation -- the function used for computing pixel values as a function
          """
          self.size = size
          self.scale = scale
          self.computation = computation
          self.img = Image.new("RGB", (size[0], size[1]))
  
      def compute(self):
          """
          Create the fractal by computing every pixel value.
          """
          for y in range(self.size[1]):
              for x in range(self.size[0]):
                  i = self.pixel_value((x, y))
                  r = i % 8 * 32
                  g = i % 16 * 16
                  b = i % 32 * 8
                  self.img.putpixel((x, y), (r, g, b))
  
      def pixel_value(self, pixel):
          """
          Return the number of iterations it took for the pixel to go out of bounds.
  
          Arguments:
          pixel -- the pixel coordinate (x, y)
  
          Returns:
          the number of iterations of computation it took to go out of bounds as integer.
          """
          # x = pixel[0] * (self.scale[1][0] - self.scale[0][0]) / self.size[0] + self.scale[0][0]
          # y = pixel[1] * (self.scale[1][1] - self.scale[0][1]) / self.size[1] + self.scale[0][1]
          x = (pixel[0] / self.size[0]) * (self.scale[1][0] - self.scale[0][0]) + self.scale[0][0]
          y = (pixel[1] / self.size[1]) * (self.scale[1][1] - self.scale[0][1]) + self.scale[0][1]
  
          return self.computation((x, y))
  
      def save_image(self, filename):
          """
          Save the image to hard drive.
  
          Arguments:
          filename -- the file name to save the file to as a string.
          """
          self.img.save(filename, "PNG")
  
  if __name__ == "__main__":
      def mandelbrot_computation(pixel):
          """Return integer -&gt; how many iterations it takes for the pixel to escape the mandelbrot set."""
          c = complex(pixel[0], pixel[1])  # Complex number: A + Bi  (A is real number, B is imaginary number).
          z = 0  # We are assuming the starting z value for each square is 0.
          iterations = 0  # Will count how many iterations it takes for a pixel to escape the mandelbrot set.
  
          for i in range(255):  # The more iterations, the more detailed the mandelbrot set will be.
              if abs(z) &gt;= 2.0:  # Checks, if pixel escapes the mandelbrot set. Same as square root of pix[0] and pix[1].
                  break
              z = z**2 + c
              iterations += 1
  
          return iterations
  
      mandelbrot = Fractal((1000, 1000), [(-2, -2), (2, 2)], mandelbrot_computation())
      mandelbrot.compute()
      mandelbrot.save_image("mandelbrot.png")
  </code></pre>