Python Data Types and Functions Quiz

Data Types and Expressions

• 'cat' in L evaluates to False because the list L does not contain the string 'cat', only the characters 'c', 'a', and 't'.
• len(L) == len('cat') evaluates to True because both L and 'cat' have a length of 3.
• d == {2: 6, 3: 9, 1: 3} evaluates to True due to the dictionary comprehension assignment where each element x in the list [1, 2, 3] is mapped to x * 3.
• d evaluates to {1: 3, 2: 6, 3: 9} because dictionaries are unordered.
• min(numbers_list) evaluates to 5 as numbers_list contains numbers from 5 to 49.
• max(numbers_list) evaluates to 49 as numbers_list contains numbers from 5 to 49.
• str.upper(gl) evaluates to 'GOOD LUCK, WE'RE ROOTING FOR YOU!' because the upper() method converts all characters in the string to uppercase.
• 'good' in gl evaluates to True as the substring 'good' is present in the string gl.

Function Basics

• f1(4) evaluates to 8 due to the function definition f1(x: int) -> int: return x * 2.
• f1(2) + f1(1) evaluates to 6 because f1(2) returns 4 and f1(1) returns 2, summing to 6.
• f1(x + 1) evaluates to 10 because x is 4, so x + 1 is 5, and f1(5) returns 10.
• x still evaluates to 4 as the function f1 does not modify the global variable x.
• f2(3, 2) evaluates to True because f1(3) returns 6, 6 % 2 is 0, and r == 0 is True.
• r is undefined in this context as it is a local variable within the f2 function.

Symbolic Logic and Python Translation

• All cute animals are fluffy: ∀a ∈ A, IsCute(a) ⇒ IsFluffy(a)
• At least one cute animal is fluffy: ∃a ∈ A, IsCute(a) ∧ IsFluffy(a)
• (¬(¬p)) ⇔ p: (not (not p)) == p
• ((p ∨ q) ∧ ¬p) ⇒ q: ((p or q) and not p) == q

Filtering Collections and String Methods

• def get_uppercase(lst: list[str]) -> list[str]:
  • return sorted([s for s in lst if s.isupper()])

If Statements

• def check_scores(scores: list[int]) -> str:
  • check_all = all([score >= 100 for score in scores])
  • check_at_least_one = any([score >= 100 for score in scores])
  • if check_all:
    • return 'Great work'
  • elif check_at_least_one:
    • return 'Good work'
  • else:
    • return 'Better luck next time'

Function Design Recipe - get_common_numbers

• def get_common_numbers(L1: list[int], L2: list[int]) -> set[int]:
  • """Return a set containing the common numbers in L1 and L2 (i.e., those numbers present in both lists).
  • >>> L1 = [10, 20, 30, 40, 50]
  • >>> L2 = [60, 70, 80, 30, 10]
  • >>> numbers = get_common_numbers(L1, L2)
  • >>> numbers == {10, 30}
  • True
  • >>> L1 = [10, 20, 30, 40, 50]
  • >>> L2 = [60, 70, 80]
  • >>> get_common_numbers(L1, L2)
  • set()
  • """
  • return set(L1) & set(L2)

Debugging and Testing - is_fibonacci

• def test_is_fibonacci_error() -> None:
  • """A test case for is_fibonacci that reveals an error in the given implementation.If we ran this test with pytest and the current implementation, we would expect
  • this test to *fail* because of the error in the function body."""
  • actual = is_fibonacci([0, 1, 1, 2, 3, 5, 8, 13, 21, 34])
  • expected = False
  • assert actual == expected
• Error: The original implementation fails to validate the first two elements of the list.
• def is_fibonacci(s: list[int]) -> bool:
  • """Return whether list s contains the Fibonacci sequence of length len(s).The Fibonacci sequence of length n is the sequence of n numbers
  • 0, 1, 1, 2, 3, 5, 8, 13,...Every number after the second is the sum of the previous two numbers.The first number must be 0 and the second number must be 1.Preconditions:
  • - len(s) > 2
  • >>> is_fibonacci([0, 1, 1, 2, 3, 5, 8, 13, 21])
  • True
  • >>> is_fibonacci([0, 1, 4, 9, 16, 25, 36, 49, 64, 81])
  • False
  • """
  • return s[0] == 0 and s[1] == 1 and all([s[i + 2] == s[i] + s[i + 1] for i in range(0, len(s) - 2)])

Proofs

• Statement (1) rewritten: ∃k ∈ Z, n = k * n
• Proof: To prove the statement, we need to show that there exists an integer k for any integer n such that n = k * n.
  • Choosing k = 1, we get: n = 1 * n which holds true for any integer n.
  • Therefore, the statement ∀n ∈ Z, n | n2 + n is proven.