============================= 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", "")