Return Values and String Manipulation

Summary (Notes)

Return Values

A function can produces a value to be used in further computation, i.e., as as an expression, by returning a value.
The return statement causes evaluation to return from the current function. The function call evaluates to the value that is returned.

return <expression>

A return statement causes execution of the function to end, so it does not make any sense to have additional statements after the return because they will not be executed.
In fact, all function calls are actually expressions—they just happen to also act as statements as well!
A function that does not return a value explicitly returns the unique value None of type None. None is a placeholder value that stands in for “there is no value here”.

Character Representation

In a computer, we directly represent integers using collections of bits. This is due to the electromagnetic switches that we use to store data in a computer. They can either hold a charge (1) or not hold a charge (0).
A character is represented by an integer called its character value.
To obtain the character value of a character, use the ord function, e.g., ord('a') returns 97.
To convert a character value into a character, use the chd function, e.g. chr(97) returns 'a'.

String Operations

Stringercises

In a file called stringercises.py, implement the following functions. For each function, your main function should demonstrate that the function works on a variety of inputs. Your tests should include both standard and corner cases.

indent(n): returns a string consisting of n spaces.
is_true(s): returns True iff s is the string true with any sort of case and with any amount of whitespace on either end of the string.
contains_rep(s, t): returns True iff the string s contains t or some non-zero replication of t, e.g., t, tt, ttt.
shift_char(ch, n): returns a new lowercase character that is n characters ahead of ch in the alphabet. For example shift_char('c', 5) produces 'h'. This addition operation should be performed modulo 26, i.e., the calculation should wrap from z back to a. For example shift_char('y', 3) produces 'b'. Finally, negative values of n should result in “subtracting” from ch rather than adding.
average_ch(s): returns the “average” character found in s. This character corresponds to the average of the character values of the characters found in s.
mixed_case(s): returns a string that is the result of mixing the case of s. To mix the case of a string, we make the first letter of s lowercase, the second uppercase, the third lowercase and so forth. Non-letter characters are not affected although they count with respect to the alternating case. For example, mixed_case('hello world!') returns 'hElLo wOrLd!
occurrences(s, t): returns the number of times the substring t occurs in s. For example, occurrences('mississippi', 'ss') returns 2 and occurrences('aaaaa', 'aa') returns 4.

sum_numbers(s): returns the sum of the integers found in the string s. s is a string of tokens separated by arbitrary amounts of whitespace. The function ignores any such token that is not an integer value.

intersperse(s, t): returns a new string that is the result of interspersing t among the letters of s. For example intersperse('hello world', '-') returns h-e-l-l-o- -w-o-r-l-d. Note that there is no dash after the d!
swap_at(s, n): returns a string string that is the result of swapping the substrings of s at character range (0-(n-1)] to (n-len(s)]. For example, swap_at('hello world!', 5) returns world!hello (note the space in front of the w).
evaluate(s): returns an integer that is the result of evaluating the arithmetic expression denoted by s. Assume that s is a string only containing digits and the characters + and -.