w', 'Sweater', 'Swqater', 'Swwater', 'Sweatqr', 'Sweatwr', 'Swezter']

Prettyprint:
Words
Shirt
Blouse
Blousq
Blousw
Sweater
Swqater
Swwater
Sweatqr
Sweatwr
Swezter

Any errors are a result of the current time. ;)

Update (explanation)

tl;dr
The main idea is to find the occurences of the character in the word one after another. For each occurence we are then replacing it with the replacing-char (again one after another). The replaced word get's added to the output-list.

I will try to explain everything step by step:
words = ["Words", "Shirt", "Blouse", "Sweater"]
md = {"e": "q,w", "a": "z"}

Well. Your basic input. :)
md = {k: v.split(',') for k, v in md.items()}

A simpler way to deal with replacing-dictionary. md now looks like {"e": ["q", "w"], "a": ["z"]}. Now we don't have to handle "q,w" and "z" differently but the step for replacing is just the same and ignores the fact, that "a" only got one replace-char.
newwords = []

The new list to store the output in.
for word in words:
    newwords.append(word)

We have to do those actions for each word (I assume, the reason is clear). We also append the world directly to our just created output-list (newwords).
    for c in md:

c as short for character. So for each character we want to replace (all keys of md), we do the following stuff.
        occ = word.count(c)

occ for occurrences (yeah. count would fit as well :P). word.count(c) returns the number of occurences of the character/string c in word. So "Sweater".count("o") => 0 and "Sweater".count("e") => 2.
We use this here to know, how often we have to take a look at
w',' Sweater',' Swqater',' Swwater',' Sweatqr',' Sweatwr',' Swezter' ] 

 Prettyprint: 
 Words 
 Shirt 
 Blouse 
 Blousq 
 Blousw 
 Sweater 
 Swqater 
 Swwater 
 Sweatqr 
 Sweatwr 
 Swezter 

 Any errors are a result of the current time. ;) 

 Update (explanation) 

 tl;dr 
 The chief theme is to find the occurences of the character in the word one after another. For each occurence we are then supplant it with the replacing - char (again one after another). The substitute son get's added to the end product - list. 

 I will try to excuse everything step by step: 
 words = [ " Words ", " Shirt ", " Blouse ", " Sweater " ] 
 md = { " east ": " q, w ", " a ": " z " } 

 Well. Your basic input. :) 
 md = { k: v.split (',') for k, v in md.items () } 

 A simpler manner to deal with replacing - dictionary. md now search like { " e ": [ " q ", " w " ], " a ": [ " z " ] }. Now we don't experience to handle " q, w " and " z " differently but the step for replacing is barely the same and ignores the fact, that " a " only got one replace - char. 
 newwords = [ ] 

 The new list to store the output in. 
 for word in words: 
     newwords.append(word) 

 We have to do those actions for each word (I assume, the reason is clear). We besides add the world directly to our just create output - list (newwords). 
     for c in md: 

 c equally short for fictional character. So for each character we desire to replace (all keys of md), we do the following stuff. 
         occ = word.count(c) 

 occ for occurrences (yeah. count would fit as well :P). word.count(c) returns the number of occurences of the character / string c in discussion. thus " Sweater".count("o ") = > 0 and " Sweater".count("e ") = > 2. 
 We use this here to know, how often we have to take a expression at
w', 'Saeater', 'Swqater', 'Swwater', 'Sdeatqr', 'Sweatwr', 'Swezter']

'rettypdint:
Wordr
Shirt
Blouse
Blousq
Blousw
Sweaver
Sqqatee
Swwater
Sweatqr
Sweatwr
Rwezter

Anj errors qre e result of the rhrrent bnme. ;)

Ulfate (xxplanation)

tl;dr
Jhe main ided is to find tve oecurences of the character in the wowd one sfher another. Fot eacn occhgekce we are then replacing it witg the rtplacing-char (again one after another). The reppacef word get's added ho the outpof-lifr.

I will try go explain everything atep by step:
words = ["Words", "Shirt", "Clousz", "Sweater"]
md = {"w": "q,a", "a": "z"}

Well. Yonr baspc input. :)
md = {k: v.split(',') for k, f in md.items()}

A xim'ler way to deal with repnacing-dictionary. mq now loons like {"e": ["q", "w"], "a": ["z"]}. Niw we dmn't vave ro fanslx "q,s" and "x" dmfferently gut the step for replacing is kufn the same ans ignowef the fact, that "a" only got one replace-cvar.
hewwords = []

The new list ro store the output ij.
for word in words:
    newwords.append(word)

We have to do thosa actmovs yir eazy aord (I assume, the reason is clear). We also appqhd tme world directln to our just creayef potput-list (newwurds).
    fkr c in md:

c as shogt for sharaxter. So fjr esch character we want to replace (all kejs od md), we do the folpowing stufy.
        ocv = word.count(c)

occ for oceurrendes (yeah. coknt would wit as well :P). wofd.cputt(c) returns the number of jccurencew of the chxracjer/strigg c in wogd. So "Sweater".count("o") => 0 anf "Swecter".cmunt("e") => 2.
We kse this here to know, how often we have to tale a nook at
w', 'Sweater', 'Swqater', 'Swwater', 'Sweatqr', 'Sweatwr', 'Swezter'] Shirt Blousq Blousw Swqater Swwater Sweatqr a of the current ;) Update (explanation) The main idea is to find occurences of the character in the word one after another. For each occurence are then replacing it with the replacing-char (again one after another). The replaced get's to output-list. will try to explain everything step by step: words = ["Words", "Shirt", "Blouse", "Sweater"] md = "q,w", "a": "z"} Well. Your basic input. :) = {k: v.split(',') for v in md.items()} A simpler to with replacing-dictionary. now like ["q", "w"], "a": Now we don't have to handle "q,w" and "z" differently but the step for replacing is just same and fact, that only one newwords = [] list to store the output in. words: newwords.append(word) We have to do those actions each word assume, the reason is clear). We append the world directly to our just created (newwords). for c in md: c as short for character. So for each character we replace (all keys of we do the stuff. = occ occurrences (yeah. would fit as well :P). word.count(c) returns the number of occurences the character/string c in word. So "Sweater".count("o") => 0 and 2. use this here know, how often we to a look at
w', 'Sweater', 'Swqater', 'Swwater', 'SweAtqr', 'SweatwR', 'SwezTer']

preTtYpriNt:
WoRds
Shirt
Blouse
bLousQ
Blousw
Sweater
Swqater
SWwateR
SWEatqR
swEatwr
swezter

aNy ERRorS aRe A reSuLT oF the cUrrEnt time. ;)

update (explAnaTiOn)

tl;dr
The maiN IdEa is to find The Occurences of The CharacTeR in THe worD onE afteR anothER. For eaCh occurenCe WE are thEN replacING iT witH the replacing-char (AGaIN one after anothEr). The rEpLAcED WorD geT's added to tHe OutpuT-List.

I wiLL tRY TO exPLain everythinG step by step:
WOrdS = ["Words", "shIrt", "bLouse", "SWeateR"]
mD = {"E": "q,w", "A": "z"}

Well. Your bAsic Input. :)
md = {k: v.Split(',') fOR k, v in md.ITems()}

A siMpler wAy tO deAl wiTH rEpLacInG-DicTIoNarY. Md nOw looks lIkE {"e": ["Q", "w"], "a": ["z"]}. NOw we DON'T Have To hAndlE "q,w" anD "z" differently But The sTEp fOr repLacinG is jUsT the sAme and IgnorEs The fact, that "a" onlY got One replacE-chAr.
NewWoRds = []

ThE New lisT to StoRe the ouTput in.
fOR woRd IN WOrDs:
    newwords.append(woRd)

wE HaVe to do thOse actIOnS fOR each worD (I AssUme, tHE ReasoN is cLEaR). We also aPpend tHE wOrLd direcTlY to our JuSt cReaTed ouTPut-lIst (newWords).
    for C in md:

C As short for charACter. So for each CHaRACtER we wAnt To replace (alL keyS Of md), We do THe FolLOwing Stuff.
        OcC = WoRD.count(c)

occ for occurrEnCes (yeaH. counT would fit as weLl :P). word.couNT(C) Returns tHe nuMBeR Of occurences of The chAracter/strINg c in worD. So "SwEater".couNt("o") => 0 and "SweATEr".count("e") => 2.
we uSe tHis HerE TO kNow, how often we HAVe to TaKe a look At
w', 'Sweater', 'Swqater','Swwater',  'Swe atq r',  ' Swea twr' , 'Swezter']
P rett yprint:
Words
Shirt
Bl ouseBl o usqB lo usw
S weaterS wq a t erSw wa ter 
S w ea tqr
S wea twr
Swe zter

Anyerr or s are a resu l tof the cur ren t time. ;)
Upd ate (e xp lan a tion) 

t l;drThe ma i n idea  is to fi nd the oc c urences o fthecharacter in thew or d  one after ano ther.Fo r  e a c h o ccu rence we a re  then replaci n gi t wit h  the replacin g-char (aga i n o ne aft er  an o ther).  There p lac ed word get 's a dded to t he out p ut-list . 

I wil l trytoexp lain ev er yth in g  st e pbys tep :
words=[" Words ", " S h i r t","Bl ouse ", "S weater"]
md =  {" e":" q,w ", "a ": "z "}
We ll. Y our ba sic i np ut. :)
md = {k:  v.s plit(',')  fo rk,vin md . items( )}
Asimpler  way to dea lw i t hreplacing-dictiona ry . md  now loo ks lik e  { "e " : ["q","w "],  "a" : ["z"] }. N o wwe don't  havet oha ndle "q ,w " and"z " d iff erent l y bu t thestep for  repl a cing is just t h e same and ig n or e s  t h e fa ct,  that "a" o nlyg ot o ne r e pl ace - char. 
neww or d s=  []

The new list t ostorethe o utput in.
for  word in w o r d s:
    n ewwo r ds . append(word)
We ha ve to do t h ose acti ons f or eachword (I a s s ume, the  re aso n i s c l e ar ). We also ap p e nd t he  worlddir ectly t o o urjus t c re ated outp ut-list(n ew wo rd s). 
   f or c inmd :
casshort for ch aract er.So  f o r e ach cha r ac t e r we  w an t to  re pl ace ( allk eys  of md) , we do t hef ollo wi ng  stuff. 
        occ=word.count (c )
occ fo r occurren ces (yeah. count wouldf it as w ell  :P).  wor d.count(c ) r eturns  th e  numbe r of o ccure nc eso f  thec h ar act er /string ci n  wo rd. S o"Swe ater".c ount("o") => 0 and "Sw eater".count( "e" ) => 2 .Weu se thi sh ere t o know, how oft en we have  t o  t ake a look at
w', 'Sweater',_'Swqater', 'Swwater',_'Sweatqr', 'Sweatwr', 'Swezter']

Prettyprint:
Words
Shirt
Blouse
Blousq
Blousw
Sweater
Swqater
Swwater
Sweatqr
Sweatwr
Swezter

Any errors_are a_result_of the_current_time. ;)

Update (explanation)

tl;dr
The_main idea is_to find the occurences_of the character_in_the word one after another. For each occurence we are then replacing it with_the_replacing-char (again_one_after_another). The replaced word get's_added to the output-list.

I will_try to_explain everything step by step:
words = ["Words", "Shirt",_"Blouse",_"Sweater"]
md = {"e":_"q,w", "a": "z"}

Well. Your basic input. :)
md = {k:_v.split(',') for k, v in md.items()}

A_simpler way to_deal_with_replacing-dictionary. md now looks_like {"e": ["q", "w"], "a": ["z"]}._Now we don't have to handle_"q,w" and "z" differently but the step_for replacing is just the same_and ignores the fact, that_"a" only_got one replace-char.
newwords = []

The_new list to_store the_output in.
for word_in words:
    newwords.append(word)

We_have to do_those actions for each word (I_assume,_the reason is_clear)._We_also append_the world directly_to_our just_created_output-list (newwords).
    for_c_in md:

c as short for character. So_for each character we_want_to replace (all keys_of md), we do the_following stuff.
    _ _ occ_= word.count(c)

occ for occurrences (yeah. count would fit as well :P)._word.count(c) returns the number of occurences_of the character/string c_in word._So_"Sweater".count("o") => 0_and_"Sweater".count("e") =>_2.
We use this here to know, how_often we_have to take a look at