# a. Define variables
x = complex(5.2, 3.4)
y = -17
z = 0.02

# b. Compute and print specified quantities
print(f"x + y = {x + y}")
print(f"xyz = {x*y*z:.1f}")
print(f"4x^3 - 8xy + 6y^2 = {4*x**3 - 8*x*y + 6*y**2:.1f}")

# c. Compute and print further specified quantities
print(f"|x| = {abs(x)}") # Built-in abs() function
print(f"conj xy = {(x*y).conjugate()}")
print(f"Re(x) = {x.real}")

# a. Define list l
l = [4, -12, 6, -14, 8, -16]

# b. Print first and last elements
print(f"First element: {l[0]}")
print(f"Last element: {l[-1]}")

# c. First three elements
print(f"First 3 elements: {l[0:3]}")

# d. Last three elements
print(f"Last 3 elements: {l[-3:]}")

# e. Every other element
print(f"Every other element: {l[0::2]}")

# f. Length
print(f"Length: {len(l)}")

# g. Sum
print(f"sum: {sum(l)}")

# a. Define list l
l = [32, 41, 58, 34, 24, 53, 46, 41]

# b. Mean
m = sum(l)/len(l)
print(f"Mean: {m}")

# c. Max and min
max_ = max(l)
min_ = min(l)
print(f"Max: {max_}; Min: {min_}")

# d. Indices of max and min
# Note: If there is duplication of max or min, the first index is found
print(f"Max Index (first): {l.index(max_)}")
print(f"Min Index (first): {l.index(min_)}")

# e. Sort
l.sort() # Mutates l itself (returns None)
print(f"Sorted: {l}")

def which_number(x):
    """Identifies which type of number the argument is.

    Args:
        x: A number
        
    Returns:
        A string "int", "float", or "complex", or None.
    """
    t = type(x)
    if t == int:
        return "int"
    elif t == float:
        return "float"
    elif t == complex:
        return "complex"
    else:
        return None

# Test which_number()
test_args = [42, 3.92, complex(2, -3), "3.92", [2, 0]]
for arg in test_args:
    r = which_number(arg)
    # Print with repr() so that strings are displayed quoted
    print(f"which_number({repr(arg)}) => {repr(r)}")

def capital_only(l):
    """Return a list with only the strings from l that begin with
    capital letters.

    Args:
        l: A list of strings
    
    Returns:
        A new list of strings sans non-capitalized elements of l
        
    Raises:
        ValueError: If not all elements of l are strings
    """
    r = [] # Initialize return list
    for li in l:
        if type(li) == str:
            letter_start = li[0].isalpha() # First character is letter
            capitalized = li[0].capitalize() == li[0] # First is cap
            if letter_start and capitalized:
                    r.append(li)
        else:
            raise ValueError("All elements must be strings")
    return r

# Test capital_only()
test_args = [
    ["Foo", "Bar", "Baz"],
    ["Foo", "bar", "Baz"],
    ["Foo", 0, 1, "Bar", 2],
]
for arg in test_args:
    try:
        r = capital_only(arg)
        print(f"capital_only({repr(arg)}) => {repr(r)}")
    except ValueError as e: # Handle ValueError exception
        print(f"capital_only({repr(arg)}) => {type(e)}: {e}")

def float_list(l):
    """Return a list with all elements converted to floats.

    Args:
        l: A list
    
    Returns:
        New list with elements of l that could be converted to floats
    """
    if type(l) != list:
        return []
    r = [] # Initialize return list
    for li in l:
        if type(li) == float or type(li) == complex:
            r.append(li)
        else:
            try: # converting to a float
                li_float = float(li) # If this throws exception then
                r.append(li_float)   # ... this will not execute
            except:
                continue
    return r

# Test float_list()
test_args = [
    [1.1, 0.2, 4.2, -30.2],
    [3, 42, -32, 0, 3],
    [1-3j, 2, 0.3],
    ["1.2", "8", "-3.9"],
    ["0.4", "dog", None, 8],
    3.4,
]
for arg in test_args:
    r = float_list(arg)
    print(f"float_list({repr(arg)}) => {repr(r)}")