u4-script-functions

Question 1

What’s the difference between positional and keyword arguments in Python functions?

Answer 1

Positional arguments are passed by position, while keyword arguments are passed by name. Example:

def my_divide(numerator=1.0, divisor=1.0):
    return numerator / divisor
		
my_divide(6, 2)  # positional

my_divide(numerator=6, divisor=2)  # keyword

Question 2

How do you set default values for function parameters?

Answer 2

Add an equals sign and default value in the function definition. Example:

def my_divide(numerator=1.0, divisor=1.0):
    return numerator / divisor
		
my_divide()  # uses defaults: 1.0/1.0

Question 3

How can you modify a list in-place within a function?

Answer 3

Lists are mutable, so changes made to the list inside the function affect the original list. Example:

def append_sum(lst):
    lst.append(lst[-2] + lst[-1])

numbers = [1, 2, 3]

append_sum(numbers)  # numbers is modified

Question 4

What’s the difference between returning a new list vs modifying in-place?

Answer 4

Returning a new list preserves the original, while in-place modification changes the original. Example:

def new_list(lst): 
    return lst + [sum(lst)]  # original unchanged

def in_place(lst): 
    lst.append(sum(lst))     # original modified```

Question 5

How do you access the last elements of a list in Python?

Answer 5

Use negative indices: -1 for last element, -2 for second-to-last, etc. Example:

lst = [1, 2, 3, 4]
last = lst[-1]      # 4
second_last = lst[-2]  # 3

Question 6

What’s the purpose of None as a default parameter value?

Answer 6

None is commonly used to create mutable default values safely. Example:

def func(ignored_values=None):
    if ignored_values is None:
        ignored_values = {-1, -2, -3}

Question 7

How do you combine elements from two lists into tuples?

Answer 7

You can iterate through both lists up to the length of the shorter list. Example:

def zip_lists(list1, list2):
    result = []
    for i in range(min(len(list1), len(list2))):
        result.append((list1[i], list2[i]))
    return result

Question 8

What’s the difference between pop() and remove() for lists?

Answer 8

pop() removes by index and returns the removed item, while remove() removes by value. Example:

lst = [1, 2, 3]
lst.pop(0)     # removes and returns first item
lst.remove(2)  # removes first occurrence of 2

Question 9

How do you iterate through a sequence without using its values?

Answer 9

Use underscore () as a placeholder variable when you only need the count. Example:

def my_len(iterable):
    length = 0
    for _ in iterable:  # values not used
        length += 1
    return length```

Question 10

What is type hinting in Python functions?

Answer 10

Type hints suggest the expected types of parameters and return values. Example:

def filter_numbers(numbers: list, inplace: bool = False) -> list:
    # function body here```

Question 11

How do you handle optional parameters with mutable default values?

Answer 11

Never use mutable objects as default values, instead use None and create the object inside the function. Example:

def func(ignored_values=None):  # Good
    if ignored_values is None:
        ignored_values = {-1, -2, -3}

Question 12

What’s the difference between list slicing and direct assignment?

Answer 12

List slicing [:] modifies the list in-place, while direct assignment creates a new reference. Example:

nums = [1, 2, 3]
nums[:] = [4, 5, 6]  # modifies original
nums = [4, 5, 6]     # creates new reference```

Question 13

How do you iterate through a list while modifying it?

Answer 13

Use a while loop with an index counter when removing elements to avoid skipping items. Example:

i = 0
while i < len(numbers):
    if should_remove(numbers[i]):
        numbers.pop(i)
    else:
        i += 1```