<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def is_confusable(string, greedy=False, preferred_aliases=[]):
 """Checks if ``string`` contains characters which might be confusable with characters from ``preferred_aliases``. If ``greedy=False``, it will only return the first confusable character found without looking at the rest of the string, ``greedy=True`` returns all of them. ``preferred_aliases=[]`` can take an array of unicode block aliases to be considered as your 'base' unicode blocks: - considering ``paρa``, - with ``preferred_aliases=['latin']``, the 3rd character ``ρ`` would be returned because this greek letter can be confused with latin ``p``. - with ``preferred_aliases=['greek']``, the 1st character ``p`` would be returned because this latin letter can be confused with greek ``ρ``. - with ``preferred_aliases=[]`` and ``greedy=True``, you'll discover the 29 characters that can be confused with ``p``, the 23 characters that look like ``a``, and the one that looks like ``ρ`` (which is, of course, *p* aka *LATIN SMALL LETTER P*). 'ρ' 'p' False False False False [{'homoglyphs': [{'c': 'p', 'n': 'LATIN SMALL LETTER P'}], 'alias': 'GREEK', 'character': 'ρ'}] :param string: A unicode string :type string: str :param greedy: Don't stop on finding one confusable character - find all of them. :type greedy: bool :param preferred_aliases: Script blocks aliases which we don't want ``string``'s characters to be confused with. :type preferred_aliases: list(str) :return: False if not confusable, all confusable characters and with what they are confusable otherwise. :rtype: bool or list """

    preferred_aliases = [a.upper() for a in preferred_aliases]
    outputs = []
    checked = set()
    for char in string:
        if char in checked:
            continue
        checked.add(char)
        char_alias = alias(char)
        if char_alias in preferred_aliases:
            # it's safe if the character might be confusable with homoglyphs from other
            # categories than our preferred categories (=aliases)
            continue
        found = confusables_data.get(char, False)
        if found is False:
            continue
        # character λ is considered confusable if λ can be confused with a character from
        # preferred_aliases, e.g. if 'LATIN', 'ρ' is confusable with 'p' from LATIN.
        # if 'LATIN', 'Γ' is not confusable because in all the characters confusable with Γ,
        # none of them is LATIN.
        if preferred_aliases:
            potentially_confusable = []
            try:
                for d in found:
                    aliases = [alias(glyph) for glyph in d['c']]
                    for a in aliases:
                        if a in preferred_aliases:
                            potentially_confusable = found
                            raise Found()
            except Found:
                pass
        else:
            potentially_confusable = found
        if potentially_confusable:  # we found homoglyphs
            output = {
                'character': char,
                'alias': char_alias,
                'homoglyphs': potentially_confusable,
            }
            if not greedy:
                return [output]
            outputs.append(output)

    return outputs or False