11. Exercises¶

What is the result of each of the following:
1. ‘Python’[1]
2. “Strings are sequences of characters.”[5]
3. len(“wonderful”)
4. ‘Mystery’[:4]
5. ‘p’ in ‘Pineapple’
6. ‘apple’ in ‘Pineapple’
7. ‘pear’ not in ‘Pineapple’
8. ‘apple’ > ‘pineapple’
9. ‘pineapple’ < ‘Peach’
1. ‘Python’[1] = ‘y’
2. ‘Strings are sequences of characters.’[5] = ‘g’
3. len(‘wonderful’) = 9
4. ‘Mystery’[:4] = ‘Myst’
5. ‘p’ in ‘Pineapple’ = True
6. ‘apple’ in ‘Pineapple’ = True
7. ‘pear’ not in ‘Pineapple’ = True
8. ‘apple’ > ‘pineapple’ = False
9. ‘pineapple’ < ‘Peach’ = False
Write a function that will return the number of digits in an integer.

def find_num_digits(n): n_str = str(n) return len(n_str) def main(): print(find_num_digits(50)) print(find_num_digits(20000)) print(find_num_digits(1)) if __name__ == "__main__": main()
Write a function that removes the first occurrence of a string from another string.
from test import testEqual def remove(substr,original_string): # your code here testEqual(remove('an', 'banana'), 'bana') testEqual(remove('cyc', 'bicycle'), 'bile') testEqual(remove('iss', 'Mississippi'), 'Missippi') testEqual(remove('egg', 'bicycle'), 'bicycle') testEqual(remove('oo', 'Yahoohoo'), 'Yahhoo')
from test import testEqual def remove(substr,original_string): index = original_string.find(substr) if index < 0: # substr doesn't exist in original_string return original_string return_str = original_string[:index] + original_string[index+len(substr):] return return_str testEqual(remove('an', 'banana'), 'bana') testEqual(remove('cyc', 'bicycle'), 'bile') testEqual(remove('iss', 'Mississippi'), 'Missippi') testEqual(remove('egg', 'bicycle'), 'bicycle')
Write a function reverse that receives a string argument, and returns a reversed version of the string.
from test import testEqual def reverse(text): # your code here testEqual(reverse("happy"), "yppah") testEqual(reverse("Python"), "nohtyP") testEqual(reverse(""), "")
Write a function that recognizes palindromes. (Hint: use your reverse function to make this easy!).
from test import testEqual def is_palindrome(text): # your code here testEqual(is_palindrome('abba'), True) testEqual(is_palindrome('abab'), False) testEqual(is_palindrome('straw warts'), True) testEqual(is_palindrome('a'), True) testEqual(is_palindrome(''), True)
Write a function that mirrors its argument. For example, mirror('good') should return a string holding the value gooddoog. (Hint: Make use of the reverse function).
def mirror(text): # your code here def reverse(text): # your code here from test import testEqual testEqual(mirror('good'), 'gooddoog') testEqual(mirror('Python'), 'PythonnohtyP') testEqual(mirror(''), '') testEqual(mirror('a'), 'aa')
Write a function that implements a substitution cipher. In a substitution cipher one letter is substituted for another to garble the message. For example A -> Q, B -> T, C -> G etc. your function should take two parameters, the message you want to encrypt, and a string that represents the mapping of the 26 letters in the alphabet. Your function should return a string that is the encrypted version of the message.
Write a function that decrypts the message from the previous exercise. It should also take two parameters. The encrypted message, and the mixed up alphabet. The function should return a string that is the same as the original unencrypted message.

def encrypt(message, cipher): alphabet = "abcdefghijklmnopqrstuvwxyz" encrypted = '' for char in message: if char == ' ': encrypted = encrypted + ' ' else: pos = alphabet.index(char) encrypted = encrypted + cipher[pos] return encrypted def decrypt(encrypted, cipher): alphabet = "abcdefghijklmnopqrstuvwxyz" decrypted = '' for char in encrypted: if char == ' ': decrypted = decrypted + ' ' else: pos = cipher.index(char) decrypted = decrypted + alphabet[pos] return decrypted cipher = "badcfehgjilknmporqtsvuxwzy" encrypted = encrypt('hello world', cipher) print(encrypted) decrypted = decrypt(encrypted, cipher) print(decrypted)
Write a function called rot13 that uses the Caesar cipher to encrypt a message. The Caesar cipher works like a substitution cipher but each character is replaced by the character 13 characters to “its right” in the alphabet. So for example the letter “a” becomes the letter “n”. If a letter is past the middle of the alphabet then the counting wraps around to the letter “a” again, so “n” becomes “a”, “o” becomes “b” and so on. Hint: Whenever you talk about things wrapping around its a good idea to think of modulo arithmetic (using the remainder operator).
def rot13(mess): # Your code here def main(): print(rot13('abcde')) print(rot13('nopqr')) print(rot13(rot13('since rot thirteen is symmetric you should see this message'))) if __name__ == "__main__": main()
def rot13(mess): alphabet = 'abcdefghijklmnopqrstuvwxyz' encrypted = '' for char in mess: if char == ' ': encrypted = encrypted + ' ' else: rotated_index = alphabet.index(char) + 13 if rotated_index < 26: encrypted = encrypted + alphabet[rotated_index] else: encrypted = encrypted + alphabet[rotated_index % 26] return encrypted def main(): print(rot13('abcde')) print(rot13('nopqr')) print(rot13(rot13('since rot thirteen is symmetric you should see this message'))) if __name__ == "__main__": main()

Graded Lesson Assignment¶

Write a function analyze_text that receives a string as input. Your function should count the number of alphabetic characters (a through z, or A through Z) in the text and also keep track of how many are the letter 'e' (upper or lowercase).

Your function should return an analysis of the text in the form of a string phrased exactly like this:

“The text contains 240 alphabetic characters, of which 105 (43.75%) are ‘e’.”

You will need to make use of the isalpha function, which can be used like this

"a".isalpha() # => evaluates to True
"3".isalpha() # => evaluates to False
"&".isalpha() # => False
" ".isalpha() # => False

mystr = "Q"
mystr.isalpha() # => True

def analyze_text(text):
    # Your code here

# Note that depending on whether you use str.format or string concatenation
# your code will pass different tests. As long as your code passes either
# tests 1-3 OR tests 4-6, yo'll be okay. See below for more details.
from test import testEqual

# Tests 1-3: solutions using string concatenation should pass these
text1 = "Eeeee"
answer1 = "The text contains 5 alphabetic characters, of which 5 (100.0%) are 'e'."
testEqual(analyze_text(text1), answer1)

text2 = "Blueberries are tasteee!"
answer2 = "The text contains 21 alphabetic characters, of which 7 (33.3333333333%) are 'e'."
testEqual(analyze_text(text2), answer2)

text3 = "Wright's book, Gadsby, contains a total of 0 of that most common symbol ;)"
answer3 = "The text contains 55 alphabetic characters, of which 0 (0.0%) are 'e'."
testEqual(analyze_text(text3), answer3)

# Tests 4-6: solutions using str.format should pass these
text4 = "Eeeee"
answer4 = "The text contains 5 alphabetic characters, of which 5 (100%) are 'e'."
testEqual(analyze_text(text4), answer4)

text5 = "Blueberries are tasteee!"
answer5 = "The text contains 21 alphabetic characters, of which 7 (33.33333333333333%) are 'e'."
testEqual(analyze_text(text5), answer5)

text6 = "Wright's book, Gadsby, contains a total of 0 of that most common symbol ;)"
answer6 = "The text contains 55 alphabetic characters, of which 0 (0%) are 'e'."
testEqual(analyze_text(text6), answer6)

Ready to submit your code? Time to fork, and submit a Pull Request to: this Github Repository.