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 line before my application closes) :

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 a 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.