=============================
Python: Functions (Solutions)
=============================

#. Solution: the same type of the value I pass to the function!
   The function returns the value of the argument without any change.

   #. an integer.
   #. a dictionary.
   #. a list.
   #. a rational.

#. Solution: the sum, or concatenation, of the two arguments, therefore:

   #. an integer.
   #. a list.
   #. a string.

#. Solution::

    def print_even_odd(number):
        if number % 2 == 0:
            print "even"
        else:
            print "odd"

    print_even_odd(98)
    print_even_odd(99)

   Note that ``print_even_odd()`` already prints to screen, it's not necessary to write::

    print print_even_odd(99)

   otherwise Python will print::

    even
    None

   The ``None`` comes from the additional ``print``. Since ``print_even_odd()``
   doesn't have a ``return``, its result will always be ``None``. The additional ``print`` prints exactly this ``None``.

#. Solution::

    def determine_even_odd(number):
        if number % 2 == 0:
            return "even"
        else:
            return "odd"

    print determine_even_odd(98)
    print determine_even_odd(99)

   In this example, since there is no ``print`` inside ``determine_even_odd()``,
   it's necessary to add an additional ``print`` in order to print the result.

#. Solution::

    def check_alphanumeric(string):
        alphanumeric_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

        alphanumeric_flag = True
        for character in string:
            if not character.upper() in alphanumeric_chars:
                alphanumeric_flag = False

        return alphanumeric_flag

    # Let's test the function
    print check_alphanumeric("ABC123")
    print check_alphanumeric("A!%$*@")

   We can also use ``break`` to interrupt the ``for`` cycle as soon as we
   find a non-alphanumeric character (once we find a non-alphanumeric character, 
   it is impossible that ``alphanumeric_flag`` returns to ``True`` again)::

    def check_alphanumeric(string):
        alphanumeric_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

        alphanumeric_flag = True
        for character in string:
            if not character.upper() in alphanumeric_chars:
                alphanumeric_flag = False
                break # <-- exit from the cycle
        return alphanumeric_flag

    # Let's test the function
    print check_alphanumeric("ABC123")
    print check_alphanumeric("A!%$*@")

   Alternatively, since upon executing ``break`` we directly arrive to
   ``return``, we can skip a step and write directly ``return``::

    def check_alphanumeric(string):
        alphanumeric_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

        for character in string:
            if not character.upper() in alphanumeric_chars:
                # upon meetin a not alphanumeric character, 
				# we can answer False
                return False

        # we arrive to the end of the for cycle only if `return` was never executed, 
        # this happens only if the `if` condition has always been False for all characters
        # this means that all characters were alphanumeric
        # we can answer True
        return True

    # Let's test the function
    print check_alphanumeric("ABC123")
    print check_alphanumeric("A!%$*@")

#. Solution::

    def question():
        path = raw_input("write a path: ")
        print open(path).readlines()

    # Let's test the function
    question()

#. Solution::

    def wc(string):
        num_chars = len(string)
        num_newlines = string.count("\n")
        num_words = len(string.split()) # split splits upon both spaces and newlines
        return (num_chars, num_newlines, num_words)

    # Let's test the function
    print wc("I am\nan awesome\nstring")

#. Solution::

    def print_dictionary(a_dictionary):
        # here the printing order doesn't matter, 
        # we can use the natural order provided by
        # `items()`
        for key, value in a_dictionary.items():
            print key, "->", (str(value * 100.0) + "%")

    # Let's test the function

    dictionary = {
        "Arg": 0.7,
        "Lys": 0.1,
        "Cys": 0.1,
        "His": 0.1,
    }

    print_dictionary(dictionary)

#. Solution::

    def print_ordered_dictionary(a_dictionary):
        # extract and order keys
        ordered_keys = a_dictionary.keys()
        ordered_keys.sort()

        # now let's print key-value pairs in the correct order
        for key in ordered_keys:
            value = a_dictionary[key]

            print key, "->", (str(value * 100.0) + "%")

    # Let's test the function

    dictionary = {
        "Arg": 0.7,
        "Lys": 0.1,
        "Cys": 0.1,
        "His": 0.1,
    }

    print_ordered_dictionary(dictionary)

#. Solution::

    # taken from the example
    def factorial(n):
        fact = 1
        for k in range(1, n+1):
            fact = fact * k
        return fact

    def create_list_of_factorials(n):
        list_of_factorials = []
        for i in range(n):
            list_of_factorials.append(factorial(i))
        return list_of_factorials

    # Let's test the function
    print create_list_of_factorials(2)
    print create_list_of_factorials(4)
    print create_list_of_factorials(6)

   here we *reused* the function ``factorial()`` defined in a previous example.

#. Solution::

    def count_character(text, search_char):
        counts = 0
        for character in text:
            if character == search_char:
                counts += 1
        return counts

    # Let's test the function
    print count_character("abbaa", "a")
    print count_character("abbaa", "b")
    print count_character("abbaa", "?")

   or, more simply, we can use ``count()``::

    def count_character(text, search_char):
        return text.count(search_char)

    # Let's test the function
    print count_character("abbaa", "a")
    print count_character("abbaa", "b")
    print count_character("abbaa", "?")

#. Solution::

    def count_characters(text, search_chars):
        counts = {}
        for search_char in search_chars:
            counts[search_char] = count_character(text, search_char)
        return counts

    # Let's test the function
    print count_characters("abbaa", "ab?")

   Here, we reused the function defined in the previous exercise.

#. Solution::

    def distance(pair1, pair2):
        x1, y1 = pair1
        x2, y2 = pair2

        dx = x1 - x2
        dy = y1 - y2

        return (float(dx)**2 + float(dy)**2)**0.5

    # Let's test the function
    print distance((0, 0), (1, 1))
    print distance((2, 3), (3, 2))

#. Solution::

    def substring(first, second):
        return second in first

    # Let's test the function
    print substring("ACGT", "T")
    print substring("ACGT", "x")

#. Solution::

    def non_empty_substrings(input_string):
        substrings = []

        # all the possible positions to start a substring
        for start in range(len(input_string)):

            # all the possible positions to end a substring
            for end in range(start + 1, len(input_string) + 1):

                # extract the substring and update the list
                substrings.append(input_string[start:end])
        return substrings

    # Let's test the function
    print non_empty_substrings("ACTG")

#. Soluzione::

    def count_substrings(haystack, needle):
        occurrences = 0
        for start in range(len(haystack)):
            for end in range(start+1, len(haystack)+1):

                # to be sure, we print the substring 
                print start, end, ":", haystack[start:end], "==", needle, "?"

                # check whether the substring is equal to `needle`
                if haystack[start:end] == needle:
                    print "here is an occurrence!"
                    occurrences += 1

        return occurrences

    # Let's test the function
    print count_substrings("ACTGXACTG", "ACTG")

#. Solution::

    def longest_substring(string1, string2):

        # let's reuse the previous function
        substrings1 = non_empty_substrings(string1)
        substrings2 = non_empty_substrings(string2)

        # find the longest common substring 
        longest_sub = ""
        for substring1 in substrings1:
            for substring2 in substrings2:

                if substring1 == substring2 and \
                   len(substring1) > len(longest_sub):

                    # aggiorno
                    longest_sub = substring1

        return longest_sub

    # Let's test the function
    print longest_substring("ACTG", "GCTA")
    print longest_substring("", "ACTG")
    print longest_substring("ACTG", "")