Flyweight pattern - Memory footprint

I'm learning Python and I've thought it would be a nice excuse to refresh my pattern knowledge and in that case, the Flyweight pattern.

I created two small programs, one that is not optimized and one is implementing the Flyweight pattern. For my tests purposes, I'm creating an army of 1'000'000 Enemy objects. Each enemy can be of three types (Soldier, Ninja or Chief) and I assign a motto to each type.

What I would like to check is that, with my un-optimized program, I get 1'000'000 enemies with, for each and everyone of them, a type and a "long" string containing the motto. With the optimized code, I'd like to create only three objects (EnemyType) matching each type and containing only 3 times the motto's strings. Then, I add a member to each Enemy, pointing to the desired EnemyType.

Now the code (excerpts only) :

1. Un-optimized program

   In this version, each enemy stores its type and motto.

   enemyList = []
   enemyTypes = {'Soldier' : 'Sir, yes sir!', 'Ninja' : 'Always behind you !', 'Chief' : 'Always behind ... lot of lines '}
   for i in range(1000000):
     randomPosX = 0 # random.choice(range(1000))
     randomPosY = 0 # random.choice(range(1000))
     randomTypeIndex = 0 # random.choice(range(0,len(enemyTypes)))
     enemyType = enemyTypes.keys()[randomTypeIndex]
   
     # Here, the type and motto are parameters of EACH enemy object.
     enemyList.append(Enemy(randomPosX, randomPosY, enemyType, enemyTypes[enemyType]))
   

2. Optimized program

   In this version, each enemy has a member of an EnemyType object that stores its type and motto. Only three instances of EnemyType are created and I should see the impact in my memory footprint.

   enemyList = []
   soldierEnemy = EnemyType('Soldier', 'Sir, yes sir!')         
   ninjaEnemy = EnemyType('Ninja', 'Always behind you !')
   chiefEnemy = EnemyType('Chief', 'Always behind ... lot of lines.')
   enemyTypes = {'Soldier' : soldierEnemy, 'Ninja' : ninjaEnemy, 'Chief' : chiefEnemy}
   
   enemyCount = {}
   
   for i in range(1000000):
   randomPosX = 0 # random.choice(range(1000))
   randomPosY = 0 # random.choice(range(1000))
   randomTypeIndex = 0 #random.choice(range(0,len(enemyTypes)))
   enemyType = enemyTypes.values()[randomTypeIndex]
   
   # Here, each enemy only has a reference on its type.
   enemyList.append(Enemy(randomPosX, randomPosY, enemyType))
   

Now I'm using this to get my memory footprint (at the very last lines before my application closes itself) :

import os
import psutil
...
# return the memory usage in MB
process = psutil.Process(os.getpid())
print process.get_memory_info()[0] / float(2 ** 20)

My problem is that, I don't see any difference between the output of my two programs :

Optimized = 384.0859375 Mb
Un-optimized = 383.40234375 Mb

Is it the proper tool to get the memory footprint ? I'm new to Python so it could be a problem with my code but I checked my EnemyType objects in the second solution and I indeed have only three occurences. I therefore should have 3 motto strings instead of 1'000'000.

I've read about a tool called Heapy for Python, would it be more accurate here ?

As far as I could tell from the code in the question, in both cases you're just using references for the same small number of instances anyway.

Take the "unoptimized" version's:

enemyList.append(Enemy(randomPosX, randomPosY, enemyType, enemyTypes[enemyType]))

Indeed enemyTypes[enemyType] is a string, which might have made you think you have many instances of strings. But in reality, each of your objects has one of the three same string objects.

---

You can check this by comparing the ids of the members. Make a set of the ids, and see if it is larger than 3.