Python3 - Functions

Question 1

Pure Functions

Answer 1

Have no side effects.

output of a pure functions is determined entirely by input, and do not modify any state outside of itself (even print modifies the state of the console).

comprehensible, easier to reason, debug and parallelize (execute multiple at the same time)

def square (x): return x * x

Question 2

Higher-Order Functions

Answer 2

take one or more function as an argument, or return one or more function as a result.

list ( map ( lambda x: x * x, [1, 2, 3]))

Question 3

Recursion

Answer 3

Programming technique where function calls itself.

takes base case (case where recursion finishes) and recursive case (reason to call itself)

def factorial(n):

if n == 1:
return 1
else:
return n * factorial(n-1)

Question 4

Nested Function

Answer 4

function inside function.

helps encapsulate code to be easier to read and maintain, but can be harder to understand if overused.

creates closures, comprehensions and decorators

Question 5

Closure

Answer 5

creates functions with access to variables in surrounding scope. creates reusable functions that work with different data

(generators, decorators, higher order functions.

def make_multiplier(factor):
def multiplier(number):
return number * factor
return multiplier

Question 6

Enclosing

Answer 6

Ability of a nested function to access variables defined in enclosing function (surrounding scope)

Question 7

Nonlocal Variable

Answer 7

variable set to be accessible beyond current scope (nested function variable defined with nonlocal keyword)

Question 8

*args and **kwargs

Answer 8

permit variable number of arguments as parameters.
kwargs permits key-value pairs.

def print_args(*args):
for arg in args:
print(arg)

def prints_kwargs( **kwargs):
for key, value in kwargs.items():
print(key, value)

Question 9

lambda functions

Answer 9

one-lined function defined using lambda keyword.

“anonymous” function, quick and compact. takes a single expresison and any number of arguments, ad returns the result of the expression, per argument. good for map, filter and reduce.

squares = (lambda x: x * x, numbers_list)

Question 10

Comprehensions

Answer 10

concise way to make lists, sets, dictionaries and generators.

used to create new sequences from existing sequences.

squares_list = [x * x for x in range(1, 11) ]
even_numbers_set = { x for x in range(1, 11) if x % 2 == 0 }

squares_dict = {x: x * x for x in range(10)}
evens_only_squares_dict = {x: x * x for x in range(10) if x % 2 == 0}

> > > evens_only_squares_dict
{0: 0, 4: 16, 8: 64}

Question 11

Decorators

Answer 11

function that returns another function as an argument, returns a modified version of the function. efined using @symbol.

@make_pretty
def ordinary():
print(something”)

Question 12

built-in functions:
Map
Filter
reduce

Answer 12

numbers = [1, 2, 3, 4, 5]

squared_numbers = map(lambda x: x * x, numbers)
# Output: [1, 4, 9, 16, 25]

even_numbers = filter(lambda x: x % 2 == 0, numbers)
# Output: [2, 4]

product_of_numbers = reduce(lambda x, y: x * y, numbers)
# Output: 120

Question 13

What is the difference between “expression” and “statement”

Answer 13

expression is a combination of variables the evaluates to a single value,

but a statement has a side effect (x = 2 * 2 vs 2 * 2)

Question 14

When should you use lambda, when should you not?

Answer 14

yes for one-off functions. NOT for loops.

Question 15

Write a program to remove specific words from a given list using lambda

Answer 15

def remove_words(lst, remove_from_list):
return list(filter(lambda word: word not in remove_from_list, lst))

my_list = [“Python”, “C”, “BashScript”, “JavaScript”, “COBOL”, “Java”]
remove_list = [“COBOL”, “Java”]

filtered_list = remove_words(my_list, remove_list)

Question 16

Write a program to sort a list of strings(numbers) numerically. use lambda

Answer 16

def sort_list_and_convert_to_int(lst):
return [int(x) for x in sorted(lst, key=lambda x: int(x))]

num_string_list = [“5”, “1”, “3”, “2”, “4”]
sorted_list = sort_list_and_convert_to_int(num_string_list)

Question 17

Write a program to calculate the sum of the positive and nevative numbers of a given list of numbers sing lambda function

Answer 17

def calculate_sum(numbers):
pos_sum = sum(filter(lambda x: x > 0, numbers))
neg_sum = sum(filter(lambda x: x < 0, numbers))
return pos_sum, neg_sum

Question 18

Using list comprehension, construct a list from the squares of each element in the given list

Answer 18

def sqrt_even_elements(numbers):
return [x ** 2 for x in numbers if x % 2 == 0]

Question 19

Write a function that receives the dictionary with the names of products and their prices and returns the dictionary with 10% sale price

Answer 19

def sale_pricing(products, discount_percentage):
return {product: price * (1 - (discount_percentage / 100)) for product, price in products.items()}

Question 20

Gematria Function reminder

Answer 20

def validate_credit_card(num):
# Convert the number to a list of digits
digits = [int(digit) for digit in str(num)]

# Double every other digit starting from the second-to-last digit
doubled_digits = [2 * digit if idx % 2 == len(digits) % 2 else digit for idx, digit in enumerate(digits[::-1])][::-1]

# Subtract 9 from doubled digits greater than 9
summed_digits = [digit - 9 if digit > 9 else digit for digit in doubled_digits]

# Calculate the total sum of all digits
total_sum = sum(summed_digits)

# Check if the total sum is divisible by 10
return total_sum % 10 == 0

Question 21

Linux Boot Process

Answer 21

BIOS:
-performs POST, checking CPU, memory and disk drives functional, and compatible with OS
- searches for Boot Loader in MBR (special area in hard drive that stores boot loaders)

Boot Loader:
- loads kernel into memory (Kernel is core of the OS. manages hardware, starts processes and and loads file systems)

Kernel initializes hardware
-configures hardware
-loads necessary drivers
-kernel mounts the file systems (so OS can access files)
-starts init (daemon responsible for starting over processes and managing system resources)

Init:
- runs startup scripts (scripts in /etc/init.d that start services and loading drivers. The drivers not required up until now.)
- efffectively starts the Shell, GUI, and and services needed to start OS

Question 22

rename files in a directory. in bash

Answer 22

newname=”toot_”

for file in $1
do
if [ -f “$file” ]
then
mv “$file” “${newname}_${file}”
fi
done

Question 23

return copy of string (yes I’m borrowing Caesar’s answer sorry he’s a great coder)

Answer 23

char *StringDup(char *str, char *copy_str);

int main()
{
char *str = “Hello”;
char *copy_str = malloc(sizeof(char) * strlen(str) + 1);
copy_str = StringDup(str, copy_str);

printf("Original String is: %s\n", str);
printf("Duplicated string is %s\n", copy_str);

free(copy_str);
return 0; }

char *StringDup(char *str, char *copy_str)
{
size_t i;

for(i = 0; i < strlen(str); ++i)
{
	copy_str[i] = str[i];
}

return copy_str; }

Question 24

C Build Process

Answer 24

Preprocessor: takes .C file, outputs .i file
- removes comments, expands macros, runs #includes,

Compiler: takes .i file, outputs .asm file.
-parsing (breaks code down to sequence of tokens, to generate sequence of instructions pushq etc.)