Mastering Python

  #my_list = [i for i in range(10)]
  my_list = list(range(10))
  my_list

  my_list_as_strs = list(map(str, my_list))
  my_list_as_strs

  another_list = list(range(5))
  times_two_list = list(map(lambda x: 2*x, another_list))
  times_two_list

  another_list = list(range(20))
  odd_lists = list(filter(lambda x: x%2==1, another_list))
  odd_lists

  another_list = list(range(20))
  odd_lists_minus_one = list(map(lambda x:-1 if x%2==1 else x, another_list))
  odd_lists_minus_one

  list_ints = list(range(15))
  bool_list = list(map(lambda x: True if x != 0 else False, list_ints))
  bool_list

  import random
  random.seed(4)
  def create_n_by_n_list(n):
	return [[random.randint(0,n) for i in range(n)] for i in list(range(0,n))]
  def normalise_list(l, n):
	import numpy
	return numpy.array(l) / n
  my_list = create_n_by_n_list(6)
  norm_list = normalise_list(my_list, 6)
  print(norm_list)

  import numpy
  print(sum(numpy.diag(norm_list)))

  new_list = list(range(-5, 4))
  tuple_list = filter(lambda t: t[1] != 0, enumerate(new_list)) # filter correct tuples
  out_list = [e[0] for e in tuple_list] # construct list of indices
  out_list

  out_list.reverse() # no return value for this
  print(out_list)
  print(new_list) # defined in the last q
  print(reversed(new_list)) # returns an iterator object
  print(list(reversed(new_list)))

  x = 6
  a = 7
  b = 8
  var_list = [x, a, b]
  print(f"var_list: {var_list}")
  stable_list = var_list[::-1]
  question_list = list(reversed(var_list))
  x = 1
  a = 2
  b = 3
  unstable_list = list(reversed(var_list))
  print(question_list)
  print(unstable_list)
  print(stable_list)

  x = [6]
  a = [7]
  b = [8]
  var_list = [x, a, b]
  print(f"var_list: {var_list}")
  stable_list = var_list[::-1]
  question_list = list(reversed(var_list))
  x.append(1)
  a.append(2)
  b.append(3)
  unstable_list = list(reversed(var_list))
  print(f"question_list: {question_list}")
  print(f"unstable_list: {unstable_list}")
  print(f"stable_list: {stable_list}")

  import copy
  stable_list = copy.deepcopy(var_list)
  print(f"stable_list: {stable_list}")
  # and now, even if you mutate the lists, stable_list does not change but unstable_list will:
  x.pop()
  print(f"unstable_list: {unstable_list}")
  print(f"still stable: {stable_list}")

  l = np.array(range(12))
  print(l.reshape(2, -1))

  l = list(range(12))
  x = [l[x:x+int(len(l)/2)] for x in range(0, len(l), int(len(l)/2))]
  print(x)

  import random
  random.seed(4)
  n = 5
  l = [ [random.randint(0,n-1) for i in range(n)] for i in range(n)]
  print(l)

  import numpy
  m = numpy.random.randint(5, size=(5,5))
  print(m)

import timeit

# Setup code for the list-comprehension approach
setup1 = """
import random
random.seed(4)
n = 5
"""

# The statement we want to time repeatedly
stmt1 = """
l = [[random.randint(0, n - 1) for i in range(n)] for j in range(n)]
"""

# Setup code for the NumPy approach
setup2 = """
import numpy
"""

# The statement we want to time repeatedly
stmt2 = """
m = numpy.random.randint(5, size=(5, 5))
"""

# Number of iterations to run timeit
iterations = 1_000_000

time1 = timeit.timeit(stmt=stmt1, setup=setup1, number=iterations)
time2 = timeit.timeit(stmt=stmt2, setup=setup2, number=iterations)

print(f"List comprehension approach: {time1:.6f} seconds")
print(f"NumPy approach:              {time2:.6f} seconds")

max(max(l))

max(range(15))

numpy.amax(l)

  import random
  random.seed(3)
  print([[1 if random.random() > 0.5 else 0 for _ in range(3)] for _ in range(3)])

  top_n_idx = lambda x,n: list(list(zip(*sorted(enumerate(x), key=lambda x:x[1], reverse=True)))[0][:n:])
  print(top_n_idx([1, 2, 6, 4], 3))

  mean_cols = lambda l: [sum(l[i]) / len(l) for i in range(len(l))]
  n = 5
  d2_list = [[random.randint(0,10) for _ in range(n)] for _ in range(n)]
  print(mean_cols(d2_list))

  mean_cols = lambda l: [sum(row[i] for row in l) / len(l) for i in range(len(l))]
  n = 5
  d2_list = [[random.randint(0,10) for _ in range(n)] for _ in range(n)]
  print(mean_cols(d2_list))

  random.seed(4)
  mean_cols = lambda l: [
	[l[r][c] / sum(l[i][c] for i in range(len(l[r])))
	 for c in range(len(l[r]))]
	for r in range(len(l))
    ]
  n = 5
  d2_list = [[random.randint(0,10) for _ in range(n)] for _ in range(n)]
  print("original matrix:", d2_list)
  print(mean_cols(d2_list))

  l1 = list(range(5))
  l2 = ['a', 'b', 'string']
  l1.extend(l2)
  print(l1)

  import random
  n = 3
  sort_rows = lambda l: [sorted(row) for row in l]
  print(sort_rows([[random.randint(0,n) for _ in range(n)] for _ in range(n)]))

  my_list = [random.randint(0,n) for _ in range(n)]
  check_nonzero = lambda l: True if len(list(filter(lambda x: x == 0, l))) == 0 else False
  print(my_list)
  print(check_nonzero(my_list))

  my_list = [random.randint(0,n) for _ in range(n)]
  check_nonzero = lambda l: all(l)
  print(my_list)
  print(check_nonzero(my_list))

  my_list = [[random.randint(0,n+2) for _ in range(n)] for _ in range(n)]
  max_idx_rows_as_list = lambda l: list(map(lambda x: x.index(max(x)), l))
  print(my_list)
  print(max_idx_rows_as_list(my_list))

  my_list = [[random.randint(0,n+2) for _ in range(n)] for _ in range(n)]
  max_idx_rows_as_list = lambda l: list(map(lambda x: x.index(max(x)), l))
  print(my_list)
  print(max_idx_rows_as_list(my_list))

  import math
  matrix = [[1, float('nan'), 3], [4, 5, float('nan')], [7, 8, 9]]
  #row_means = [sum(x for x in row if not math.isnan(x)) / sum(1 for x in row if not math.isnan(x)) for row in matrix]
  row_means = list(map(lambda x: sum(i for i in x if not math.isnan(i)) / sum(1 for i in x if not math.isnan(i)) , matrix))
  print(row_means)

  import random
  random.seed(3)
  n = 10
  my_list = [ [random.randint(0,n) for _ in range(n) ] for _ in range(n)]
  diag_2d = lambda l: sum(l[i][i] for i in range(n))
  print(my_list)
  print(diag_2d(my_list))

  import math
  convert_list = [1, 2, 0.5, 0.25]
  rad_2_deg = lambda x: [y*180/math.pi for y in x]
  #rad_2_deg = lambda x: list(map(lambda y: y*180/math.pi, x))
  print(rad_2_deg(convert_list))

  import math
  first_list = [1, 2, 0.5, 0.25]
  second_list = list(range(4))
  pairwise_euc = lambda x, y: [abs(i[0] - i[1]) for i in zip(x,y)]
  print(pairwise_euc(first_list, second_list))

    def percentile(data, percentile):
      data = sorted(data)
      k = (len(data) - 1) * (percentile / 100)
      return data[int(k)]

    lst = [10, 20, 30, 40, 50]
    q1 = percentile(lst, 25)
    q3 = percentile(lst, 75)
    lst = [0 if q1 <= x <= q3 else x for x in lst]
    print(lst)

    lst = [10, 20, 30, 40, 50]
    percentile_25th = sorted(lst)[int(len(lst) * 0.25)] # indexing into the first quarter
    percentile_75th = sorted(lst)[int(len(lst) * 0.75)]
    lst = [0 if percentile_25th <= x <= percentile_75th else x for x in lst]
    print(lst)

  import math
  first_list = [1, 2, 0.5, 0.25]
  second_list = list(range(4))
  pairwise_squared = lambda x, y: [(i[0] - i[1])**2 for i in zip(x,y)]
  print(pairwise_euc(first_list, second_list))

  my_list = list(range(10))
  replace_evens = lambda l: list(map(lambda y: y+1 if y%2==0 else y, l))
  print(replace_evens(my_list))

  random.seed(4)
  twod_list = [list(random.randint(0,10) for _ in range(10)) for _ in range(4)]
  get_range_rows = lambda l: sorted(new_list,reverse=True)[0] - sorted(new_list)[0]
  normalise_2d_rows = lambda l: [ [l[row_idx][col_idx]/get_range_rows(row) for col_idx in range(len(row))] for row_idx, row in enumerate(l) ]
  get_range_cols = lambda matrix: (num_rows := len(matrix),
				   num_cols := len(matrix[0]),
				   [max(row[col_idx] for row in matrix) - min(row[col_idx] for row in matrix) for col_idx in range(num_cols)])[-1]
  normalise_2d_cols = lambda l: [ [(l[row_idx][col_idx]-min(row[col_idx] for row in l))/(get_range_cols(l))[col_idx] for col_idx in range(len(row))] for row_idx, row in enumerate(l) ]

  print(twod_list)
  print(get_range_cols(twod_list))
  #print(sorted(twod_list,reverse=True))
  #print(normalise_2d_rows(twod_list))
  print(normalise_2d_cols(twod_list))

import random
matrix = [[random.random() for _ in range(3)] for _ in range(3)]
min_col = [min(row[i] for row in matrix) for i in range(3)]
max_col = [max(row[i] for row in matrix) for i in range(3)]
normalized_matrix = [[(row[i] - min_col[i]) / (max_col[i] - min_col[i]) for i in range(3)] for row in matrix]
print(normalized_matrix)

  cum_sum = lambda l, axis: [ [sum(l[row_idx][:col_idx+1]) for col_idx in range(len(row)) ] for row_idx, row in enumerate(l) ]
  print(twod_list)
  print(cum_sum(twod_list, 0))
  cum_sum_lambda = lambda l, axis: (
    [
	[sum(col[0:row_idx+1]) for row_idx in range(len(col))]
	for col in zip(*l)
    ] if axis == 0 else [
	[sum(row[0:col_idx+1]) for col_idx in range(len(row))]
	for row in l
    ]
  )
  print(cum_sum_lambda(twod_list, 0))
  print(cum_sum_lambda(twod_list, 1))

  non_zero = lambda l: any(l)
  print(non_zero(twod_list[0]))

  threshold_replace = lambda l, t: [ [ t if l[row_idx][col_idx] > t else l[row_idx][col_idx] for col_idx in range(len(row)) ] for row_idx, row in enumerate(l) ]
  print(threshold_replace(twod_list, 5))

  import random
  random.seed()
  list_nums = [random.randint(0,5) for _ in range(5)]
  median = lambda l: l[len(l) / 2 if len(l) % 2 == 0 else len(l)//2 ]
  print(list_nums)
  print(median(list_nums))

  import math
  log_list = lambda l: [math.log(x) for x in l]
  print(log_list(list_nums))

  list_nums = [random.randint(0,5) for _ in range(5)]
  def mode(l):
    uniques = set(l)
    mo = (0,) # most often
    for x in uniques:
      y = l.count(x)
      if y > mo[0]:
	mo = (y, x)
    return mo[1]
  print(list_nums)
  print(mode(list_nums))

  nested_list = [[ [ random.randint(0,4) for _ in range(4) ] for _ in range(3) ] for _ in range(2) ]
  twod_nested_list = [ [ random.randint(0,4) for _ in range(4) ] for _ in range(3) ]
  print(nested_list)
  unwrap_2d = lambda l: [x for rows in l for x in rows]
  print(unwrap_2d(twod_nested_list))
  print(nested_list)
  unwrap_3d = lambda l: [x for matrices in l for rows in matrices for x in rows]
  print(unwrap_3d(nested_list))

  print(twod_nested_list)
  transpose = lambda l: [[ l[j][i] for j in range(len(l)) ] for i in range(len(l[0]))]
  print(transpose(twod_nested_list))

  lst = [5,3,2,3,4,5,5,1,2,1,1]
  seen = set()
  print(set(lst)) # note that this orders things, that's all.
  unique_lst = [x for x in lst if not (x in seen or seen.add(x))] # i'm not grasping the seen.add(x) part.
  print(unique_lst)

  lst1 = [5,2,5,3,1,2]
  lst2 = [1,3,9,5,2]
  print(set(lst1).intersection(lst2))
  # turns out there's another way:
  print(set(lst1) & set(lst2))

  dic1 = {'a': 1, 'c': 6}
  dic2 = {'d': 6, 'r': 2, 'l': 3}
  print(dic1 | dic2)
  # furthermore, there is
  print({**dic1, **dic2})

  print(sorted(dic2.items(), key=lambda x:x[0])) # can sort on values with x[1]

  lst = [{'name' : 'Alice', 'age': 10}, {'name':'Bob','age':15}, {'name':'Charlie','age':20}]
  print(sorted(lst, key=lambda x:x['age']))

  d = {'a': 1, 'b':2, 'c':3}
  filtered_dict = {k:v for k,v in d.items() if v > 1}
  print(filtered_dict)

  keys = ['a','b','c','d']
  values = [1,2,3,4]
  joined_dict = dict(zip(keys,values))
  print(joined_dict)

  print(max(joined_dict))
  print(max(joined_dict.items()))
  print(max(joined_dict.values()))

  new_dict = {v:k for k,v in joined_dict.items()}
  print(new_dict)

  keys = ['x', 'y', 'z']
  v = 5
  mydict = {k:v for k in keys}
  print(mydict)

  ts = [item for item in mydict.items()]
  # the above is probably a little slower than:
  ts_fast = list(mydict.items()) # note that [] is different here than to list.
  print(ts_fast)

  # [] is different to list(). [] is a literal, whereas list() is a constructor
  # [] is bytecode, list() requires a function call
  import timeit
  print(timeit.timeit("[]", number=10**6)) # faster
  print(timeit.timeit("list()", number=10**6)) # slower
  # list() is more versatile and can convert iterables into lists
  # [] can only define new lists.

  strings = ["my", "cartridge", "got", "hitroadige", "by", "a", "truck"]
  print(max(strings)) # alphabetised
  print(max(strings, key=lambda x: len(x)))

  s = "oh my god, I might fail this course"
  list_of_words = s.split()
  print(' '.join(list_of_words[::-1]))

  palindrome_checker = lambda s: True if s==s[::-1] else False
  print(palindrome_checker("lick"))
  print(palindrome_checker("kayak"))

  import string
  remove_punc = lambda s: s.translate(str.maketrans('','',string.punctuation))
  print(remove_punc("remove, punc? punk!"))

  print(s)
  count_chars = lambda s: {char: s.count(char) for char in set(s)}
  print(sorted(list(count_chars(s).items()), key=lambda x:x[1]))

  lstrings = ["hello", "world", "worldly", "hells"]

  def longest_prefix(lstr):
        if not lstr:
            return ""
        shortest_str = min(lstr, key=len)
        longest_common_prefix = ""
        for i in range(len(shortest_str)):
            current_char = shortest_str[i]
            if all(x[i] == current_char for x in lstr):
                longest_common_prefix += current_char
            else:
                break
        return longest_common_prefix

  print(longest_prefix(["flower","flow","flight"]))

  stringcheese = "stringcheese"
  listcheese = [stringcheese[i] for i in range(len(stringcheese))]
  print(listcheese)
  # this could be done more easily with:
  print(list(stringcheese)) # recall that list takes an iterable object

  import random
  rand_list = [random.randint(0,5) for _ in range(5)]
  print(rand_list)

  print(random.shuffle(rand_list)) # returns none
  print(rand_list)

  #cheating with this one to see what the sols want:
  import string
  import random
  length = 8
  password = ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(length))
  print(password)

  def factorial(n):
    if n < 0:
      return -1
    if n == 0:
      return 1
    return n*factorial(n-1)

  print(factorial(-1))
  print(factorial(10))

  def fibonacci(n):
       if n == 0:
           return 0
       if n == 1:
           return 1
       return fibonacci(n-1) + fibonacci(n-2)
  for i in range(10):
       print(fibonacci(i))

  def is_prime(n):
       if n <= 1:
            return False
       for i in range(2, n):
           if n % i == 0:
               return False
       return True

  for i in range(1,20):
      print(i, "prime" if is_prime(i) else "not")

  def gcd(a, b):
      limit = max(a,b)
      highest = 1
      for i in range(1,limit+1):
          if a%i==0 and b%i==0:
              highest=i

      return highest

  print(gcd(8,6))

  """ returns the highest number that is divisible by both a and b """
  def lcm(a, b):
      i = 1
      while True:
          if i%a==0 and i%b==0:
              return i
          else:
              i += 1
              
  print(lcm(8,6))

  lt = [('a',2),('c',3),('b',1)]
  sorted(lt,key=lambda x:x[1])

  second_largest = [5,1,2,1,3,4,7]
  sorted(second_largest)[-2]

  p = ['k', 'a', 'y', 'a', 'k']
  n = ['n', 'o', 't']
  def list_palindrome(l):
      for i in range(len(l)//2):
          if l[i] != l[-1-i]:
              return False
      return True

  list_palindrome(n)

  num = 804
  def sum_digits(n):
      digits = len(str(n))
      sum = 0
      for i in range(digits):
          sum += int(str(n)[i])
      return sum

  sum_digits(num)

  def prod_digits(n):
      digits = len(str(n))
      prod = 1
      for i in range(digits):
          prod *= int(str(n)[i])
      return prod

  prod_digits(43)

  def check_str_is_num(s):
    return s.replace('.', '', 1).isdigit()
  check_str_is_num("6s")
  check_str_is_num("s")
  check_str_is_num("7")
  check_str_is_num("4.0")

  import string
  sentence = "here are some words in a sentence"
  def len_longest_word(s):
      words = s.split()
      return len(max(words, key=len))
      #return ' '.join(["word", "maybe", "cat"])
  len_longest_word(sentence)

  print(lt)
  print(dict(lt))

  lst = [{'name': 'Vivek', 'age': 25}, {'name': 'Esther', 'age': 22}, {'name': ' Neassa', 'age': 28}]                            
  filtered_lst = [x for x in lst if x['age'] > 23]
  print(filtered_lst)

  list_of_t = [(1,2,3,4),(1,2,3),(4,2,1),(1,2,3)]
  print(sorted(list_of_t,key=lambda x: (x[1],x[2])))

  keys = ['jonah','sarah','cupcake']
  values = [14,21,33]
  merge_lists_dict = lambda k,v: dict(zip(k,v))
  print(merge_lists_dict(keys,values))

  nums = range(6)
  dict_square = dict(zip(nums, [x**2 for x in nums]))
  print(dict_square)

  str1, str2 = "listen", "silent"
  str3, str4 = "mold", "wolf"
  check_anagram = lambda s1,s2: True if sorted(s1)==sorted(s2) else False
  print(check_anagram(str1,str2))
  print(check_anagram(str3,str4))

  vowel_counter= lambda s: sum(1 for c in s.lower() if c in "aeiou")
  print(vowel_counter("hello world's people"))

  str_is_dig = lambda s:True if sum(1 for c in s if c.isdigit()) == len(s) else False
  print(str_is_dig("123"))
  print(str_is_dig("12a"))
  # as it turns out, you don't even need the for loop:
  print("123456".isdigit())
  print("1a23".isdigit())

  ultimate = "frisbee"
  non_repeated_char = lambda s: [char for char in s if s.count(char) == 1][0] # you could also use next!
  print(non_repeated_char(ultimate))
  print(non_repeated_char(ultimate))

  s = "oh my god, I will not fail any course"
  s_as_l = s.split()
  print(' '.join(word[::-1] for word in s_as_l))

  def fibonacci(n):
       if n == 0:
           return 0
       if n == 1:
           return 1
       return fibonacci(n-1) + fibonacci(n-2)

  def fibo_until(x):
      n=0
      y=[fibonacci(n)]
      while x >= y[n]:
          fib = fibonacci(n)
          if fib > x:
               break
          n+=1
          y.append(fib)
      return y

  print(fibo_until(55))

  tring = "here are some words and a \n"
  print(tring.strip()) # won't replace all whitespace, only trailing and leading.
  print(tring.replace(" ", ""))

  mainstr = "my mother is a grand wolf"
  print(mainstr.replace("wolf", "bob"))