Could anyone help me on a Python programming assignment?

def decoder(filename):
    infile = open(filename, "r")
    cypher = dict()
    count = 0
    for line in infile:
        parts = line.split() 
        count += 1
        plain = parts[0]
        code_b = parts[1]
        cypher[plain] = code_b
    infile.close()
    return cypher
    
def replace_all(filename):
    infile = open(filename, "r")
    for i in infile:
        decyrpted = infile.replace(plain, code_b)
    infile.close()
    return decrypted
    
code_break = decoder("key.txt")
new_code = replace_all("encrypted.txt")
outfile = open("decrypted.txt", "w")
for line in outfile:
    outfile.write(line + "\n" )
outfile.close()

#Your program should decode the "encrypted.txt" file using "key.txt" and write the plaintext to "decrypted.txt".

# count doesn't do anything, removed.
# looks like your decoder function worked.
def decoder(filename):
    cypher = dict()
    with open(filename, "r") as infile:   # use the with context statement.  Automatically closes the file.
        for line in infile:
            parts = line.split()
            plain = parts[0]
            code_b = parts[1]
            cypher[plain] = code_b
    return cypher




def decrypt_character(c,cypher):
    # your code needs to handle characters that are not in the cypher dictionary
    # as well as those that are in the cypher dictionary.
    return the_decrypted_character




def replace_all(text,cypher):
    t = list(text)
    for (i,c) in enumerate(t):
        t[i] = decrypt_character(c,cypher)
    return ''.join(t)

code_break = decoder("key.txt")

with open('encrypted.txt','r') as infile:
    et = infile.read()                    # et is the entire encrypted text

dc = replace_all(et,code_break)           # replace all needs the cypher dictionary!

with open('decrypted.txt','w') as outfile:
    outfile.write(dc)

class Decode(object):
    def decoder(filename):
        cypher = dict()
        infile = open(filename, "r")
        for line in infile:
            parts = line.split()
            plain = parts[0]
            code_b = parts[1]
            cypher[plain] = code_b
        infile.close()
        return cypher
        
    def replace_all(filename, cypher):
        infile = open(filename, "r")
        decrypted = ""
        for i in infile:
            for plain in cypher:
                decrypted += i.replace(plain, cypher[plain])
        infile.close()
        return decrypted
    
    code_break = decoder("key.txt")
    outfile = open("decrypted.txt", "w")
    new_code = replace_all("encrypted.txt", code_break)
    outfile.write(new_code + "\n" )
    outfile.close()

class Decode(object):
    def decoder(filename):

>>> class c:
...  def f():
...   pass
... 
>>> c().f()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() takes no arguments (1 given)
>>> 

#! python3

'''
  Your program needs to decode an encrypted text file called
  "encrypted.txt". The person who wrote it used a cipher specified in
  "key.txt". This key file would look similar to the following:

  The left column represents the plaintext letter, and the right
  column represents the corresponding ciphertext.

  Your program should decode the "encrypted.txt" file using "key.txt"
  and write the plaintext to "decrypted.txt".
'''

import sys

class TomMixError(ValueError):
    pass

class TomMixCodeRing(object):

    '''
        TomMixCodeRing(file_object)
        file_object has three characters per line,
        the plain text character, a space character, and the cipher character.

        The constructor loads the secret code.

        >>> import sys
        >>> if sys.version[0] < '3':
        ...     raise TomMixError('This docstring test requires python2')
        >>> import io
        >>> code = TomMixCodeRing(io.StringIO('a e'))
        >>> code.encode('bat')
        'bet'
        >>> code.encode('beat')
        'beet'
        >>> code.decode('beet')             # non-cyclic ciphers fail.
        'baat'
    '''

    def __init__(self,keyfile):
        '''
            build the translation dictionaries, and save them in this object
        '''
        encode = {}
        decode = {}
        try:
            for line in keyfile:
                (plain,cipher) = line.split()
                encode[plain] = cipher
                decode[cipher] = plain
        except:
            raise TomMixError(self.__class__.__doc__)
        self.en = encode
        self.de = decode

    def decode(self,encryption):
        return self.replace_all(encryption,self.de)

    def encode(self,plaintext):
        return self.replace_all(plaintext,self.en)

    @staticmethod      # the object is NOT passed as first argument
    def replace_all(s,d):
        '''
            using replace_all avoids duplicate code
        '''
        L = []
        append = L.append
        for c in s:
            if c in d: # I meant this by "handle characters not given by your code
                c = d[c]
            append(c)
        return ''.join(L)