Exercise 1:

Create a list with values ranging from 0 to 9.

Solution:

lst = list(range(10))

print(lst)

Output:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Exercise 2:

Convert a list of integers to a list of strings.

Solution:

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

str_lst = list(map(str, lst))

print(str_lst)

Output:
['1', '2', '3', '4', '5']
Exercise 3:

Multiply all elements in a list by 2.

Solution:

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

multiplied_lst = [x * 2 for x in lst]

print(multiplied_lst)

Output:
[2, 4, 6, 8, 10]
Exercise 4:
Extract all odd numbers from a list of integers.

Solution:

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

odd_numbers = [x for x in lst if x % 2 != 0]

print(odd_numbers)

Output:
[1, 3, 5, 7, 9]
Exercise 5:

Replace all odd numbers in a list with -1.

Solution:

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

replaced_lst = [-1 if x % 2 != 0 else x for x in lst]

print(replaced_lst)

Copy
Output:
[-1, 2, -1, 4, -1, 6, -1, 8, -1, 10]
Exercise 6:

Convert a list of integers to a list of booleans where all non-zero values become
True.

Solution:

lst = [-1, 2, 0, -4, 5]

boolean_lst = [bool(x) for x in lst]

print(boolean_lst)

Copy
Output:
[True, True, False, True, True]
Exercise 7:

Replace all even numbers in a list with their negative.

Solution:

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]

neg_even_lst = [-x if x % 2 == 0 else x for x in lst]

print(neg_even_lst)

Copy
Output:
[1, -2, 3, -4, 5, -6, 7, -8, 9]
Exercise 8:

Create a 3x3 list of lists with random values and normalize it.

Solution:

import random

matrix = [[random.random() for _ in range(3)] for _ in

range(3)]

mean = sum(sum(row) for row in matrix) / 9

std = (sum((x - mean) ** 2 for row in matrix for x in row) /

9) ** 0.5

normalized_matrix = [[(x - mean) / std for x in row] for row

in matrix]

print(normalized_matrix)

Copy
Output:
[[0.34306706561420186, 1.7297679842916804, -1.443812122309246], [-
1.1000344556487114, 0.44974827677363144, -1.2563329881914924],
[0.02737489828434499, 0.4974073324300242, 0.7528140087555657]]
Exercise 9:
Calculate the sum of the diagonal elements of a 3x3 matrix (list of lists).

Solution:

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

diagonal_sum = sum(matrix[i][i] for i in range(3))

print(diagonal_sum)

Copy
Output:
15
Exercise 10:

Find the indices of non-zero elements in a list.

Solution:

lst = [1, 2, 0, 0, 4, 0]

non_zero_indices = [i for i, x in enumerate(lst) if x != 0]

print(non_zero_indices)

Copy
Output:
[0, 1, 4]
Exercise 11:

Reverse a list.

Solution:

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

reversed_lst = lst[::-1]

print(reversed_lst)

Copy
Output:
[5, 4, 3, 2, 1]
Exercise 12:

Create a 3x3 identity matrix as a list of lists.

Solution:

identity_matrix = [[1 if i == j else 0 for j in range(3)] for

i in range(3)]

print(identity_matrix)

Copy
Output:
[[1, 0, 0], [0, 1, 0], [0, 0, 1]]
Exercise 13:

Reshape a 1D list to a 2D list with 2 rows.

Solution:

lst = list(range(10))

reshaped_lst = [lst[:5], lst[5:]]

print(reshaped_lst)

Copy
Output:
[[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]
Exercise 14:

Stack two lists vertically.

Solution:

lst1 = [1, 2, 3]

lst2 = [4, 5, 6]

stacked_lst = [lst1, lst2]

print(stacked_lst)
Copy
Output:
[[1, 2, 3], [4, 5, 6]]
Exercise 15:

Get the common items between two lists.

Solution:

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

lst2 = [3, 4, 5, 6, 7]

common_items = list(set(lst1) & set(lst2))

print(common_items)

Copy
Output:
[3, 4, 5]
Exercise 16:

Create a 5x5 list of lists with row values ranging from 0 to 4.

Solution:

matrix = [[i for i in range(5)] for _ in range(5)]

print(matrix)

Copy
Output:
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2,
3, 4]]
Exercise 17:

Find the index of the maximum value in a list.

Solution:

lst = [3, 7, 1, 10, 4]

max_index = lst.index(max(lst))

print(max_index)

Copy
Output:
3
Exercise 18:

Normalize the values in a list between 0 and 1.

Solution:

lst = [2, 5, 10, 3, 8]

min_val, max_val = min(lst), max(lst)

normalized_lst = [(x - min_val) / (max_val - min_val) for x in

lst]

print(normalized_lst)

Copy
Output:
[0.0, 0.375, 1.0, 0.125, 0.75]
Exercise 19:

Calculate the dot product of two lists.

Solution:

lst1 = [1, 2, 3]

lst2 = [4, 5, 6]

dot_product = sum(x * y for x, y in zip(lst1, lst2))

print(dot_product)

Copy
Output:
32
Exercise 20:

Count the number of elements in a list within a specific range.

Solution:

lst = [2, 5, 8, 10, 12, 15]

count_within_range = sum(5 <= x <= 12 for x in lst)

print(count_within_range)

Copy
Output:
4
Exercise 21:

Find the mean of each row in a 2D list.

Solution:

import random

matrix = [[random.random() for _ in range(4)] for _ in

range(3)]

row_means = [sum(row) / len(row) for row in matrix]

print(row_means)

Copy
Output:
[0.6915055628886714, 0.6582373120045442, 0.6397767328136329]
Exercise 22:

Create a random 4x4 list of lists and extract the diagonal elements.

Solution:

import random

matrix = [[random.random() for _ in range(4)] for _ in

range(4)]
diagonal_elements = [matrix[i][i] for i in range(4)]

print(diagonal_elements)

Copy
Output:
[0.21801982194433744, 0.6811834934253869, 0.7035225685261018,
0.2381369684708886]
Exercise 23:

Count the number of occurrences of a specific value in a list.

Solution:

lst = [1, 2, 3, 4, 2, 3, 2, 1]

count_of_2 = lst.count(2)

print(count_of_2)

Copy
Output:
3
Exercise 24:

Replace all values in a list with the mean of the list.

Solution:

lst = [10, 20, 30, 40, 50]

mean_val = sum(lst) / len(lst)

lst = [mean_val] * len(lst)

print(lst)

Copy
Output:
[30.0, 30.0, 30.0, 30.0, 30.0]
Exercise 25:
Find the indices of the maximum and minimum values in a list.

Solution:

lst = [5, 2, 8, 1, 7]

max_index = lst.index(max(lst))

min_index = lst.index(min(lst))

print("Index of max:", max_index)

print("Index of min:", min_index)

Copy
Output:
Index of max: 2
Index of min: 3
Exercise 26:

Create a 2D list with 1 on the border and 0 inside.

Solution:

matrix = [[1 if i == 0 or i == 4 or j == 0 or j == 4 else 0

for j in range(5)] for i in range(5)]

print(matrix)

Copy
Output:
[[1, 1, 1, 1, 1], [1, 0, 0, 0, 1], [1, 0, 0, 0, 1], [1, 0, 0, 0, 1], [1, 1, 1,
1, 1]]
Exercise 27:

Find the unique values and their counts in a list.

Solution:

lst = [1, 2, 3, 2, 4, 1, 5, 4, 6]

unique_values = list(set(lst))
counts = {x: lst.count(x) for x in unique_values}

print("Unique values:", unique_values)

print("Counts:", counts)

Copy
Output:
Unique values: [1, 2, 3, 4, 5, 6]
Counts: {1: 2, 2: 2, 3: 1, 4: 2, 5: 1, 6: 1}
Exercise 28:

Create a 3x3 list of lists with values ranging from 0 to 8.

Solution:

matrix = [[i + j*3 for i in range(3)] for j in range(3)]

print(matrix)

Copy
Output:
[[0, 1, 2], [3, 4, 5], [6, 7, 8]]
Exercise 29:

Calculate the exponential of all elements in a list.

Solution:

import math

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

exponential_lst = [math.exp(x) for x in lst]

print(exponential_lst)

Copy
Output:
[2.718281828459045, 7.38905609893065, 20.085536923187668, 54.598150033144236,
148.4131591025766]
Exercise 30:
Swap two rows in a 2D list.

Solution:

import random

matrix = [[random.random() for _ in range(4)] for _ in

range(3)]

matrix[0], matrix[1] = matrix[1], matrix[0]

print(matrix)

Copy
Output:
[[0.9076338086781157, 0.7017330953175929, 0.9071101156414131,
0.7963804534021283], [0.1506094428868956, 0.717811641354629,
0.199640773755009, 0.5015662651200953], [0.6747176907056143,
0.9966157783211159, 0.22320361325507043, 0.6811201297753695]]
Exercise 31:

Create a random 3x3 list of lists and replace all values greater than 0.5 with 1
and all others with 0.

Solution:

import random

matrix = [[random.random() for _ in range(3)] for _ in

range(3)]

matrix = [[1 if x > 0.5 else 0 for x in row] for row in

matrix]

print(matrix)

Copy
Output:
[[0, 1, 1], [1, 0, 1], [0, 1, 1]]
Exercise 32:

Find the indices of the top N maximum values in a list.

Solution:

lst = [10, 5, 8, 20, 15]

N = 2

top_indices = sorted(range(len(lst)), key=lambda i: lst[i],

reverse=True)[:N]

print(top_indices)

Copy
Output:
[3, 4]
Exercise 33:

Calculate the mean of each column in a 2D list.

Solution:

import random

matrix = [[random.random() for _ in range(3)] for _ in

range(4)]

column_means = [sum(row[i] for row in matrix) / len(matrix)

for i in range(3)]

print(column_means)

Copy
Output:
[0.5213504257085785, 0.6484573100091598, 0.47727280812201445]
Exercise 34:

Normalize the values in each column of a 2D list.

Solution:

import random

matrix = [[random.random() for _ in range(3)] for _ in

range(4)]
normalized_matrix = [[(x - min(col)) / (max(col) - min(col))
for x in col] for col in zip(*matrix)]

normalized_matrix = list(map(list, zip(*normalized_matrix)))

print(normalized_matrix)

Copy
Output:
[[0.0, 0.0, 1.0], [0.5862533402007957, 0.2971854665761528,
0.30676715747976807], [1.0, 1.0, 0.4559427452444642], [0.8555205149635996,
0.9893735744208437, 0.0]]
Exercise 35:

Concatenate two lists.

Solution:

lst1 = [1, 2, 3]

lst2 = [4, 5, 6]

concatenated_lst = lst1 + lst2

print(concatenated_lst)

Copy
Output:
[1, 2, 3, 4, 5, 6]
Exercise 36:

Create a 2D list with random values and sort each row.

Solution:

import random

matrix = [[random.random() for _ in range(4)] for _ in

range(3)]

sorted_matrix = [sorted(row) for row in matrix]

print(sorted_matrix)
Copy
Output:
[[0.28068707911702817, 0.574715722056814, 0.6091238772389816,
0.7243160686088788], [0.08077308781723325, 0.2634152550419555,
0.3714086587664981, 0.5881583318738046], [0.2507019854506827,
0.4647657324258968, 0.7275116612000609, 0.8479103996736468]]
Exercise 37:

Check if all elements in a list are non-zero.

Solution:

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

all_nonzero = all(lst)

print(all_nonzero)

Copy
Output:
True
Exercise 38:

Find the indices of the maximum value in each row of a 2D list.

Solution:

import random

matrix = [[random.random() for _ in range(4)] for _ in

range(3)]

max_indices_per_row = [row.index(max(row)) for row in matrix]

print(max_indices_per_row)

Copy
Output:
[0, 3, 1]
Exercise 39:

Create a 2D list and replace all nan values with the mean of the list.
Solution:

import math

matrix = [[1, float('nan'), 3], [4, 5, float('nan')], [7, 8,

9]]

mean_val = sum(x for row in matrix for x in row if not

math.isnan(x)) / sum(not math.isnan(x) for row in matrix for x
in row)

matrix = [[mean_val if math.isnan(x) else x for x in row] for

row in matrix]

print(matrix)

Copy
Output:
[[1, 5.285714285714286, 3], [4, 5, 5.285714285714286], [7, 8, 9]]
Exercise 40:

Calculate the mean of each row in a 2D list ignoring nan values.

Solution:

import math

matrix = [[1, 2, float('nan')], [4, float('nan'), 6], [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]

print(row_means)

Copy
Output:
[1.5, 5.0, 8.0]
Exercise 41:

Compute the sum of diagonal elements in a 2D list.

Solution:
import random

matrix = [[random.random() for _ in range(3)] for _ in

range(3)]

diagonal_sum = sum(matrix[i][i] for i in range(3))

print(diagonal_sum)

Copy
Output:
0.4238758205862452
Exercise 42:

Convert radians to degrees for each element in a list.

Solution:

import math

lst = [math.pi / 2, math.pi, 3 * math.pi / 2]

degrees_lst = [math.degrees(x) for x in lst]

print(degrees_lst)

Copy
Output:
[90.0, 180.0, 270.0]
Exercise 43:

Calculate the pairwise Euclidean distance between two lists.

Solution:

lst1 = [1, 2, 3]

lst2 = [4, 5, 6]

euclidean_distance = sum((x - y) ** 2 for x, y in zip(lst1,

lst2)) ** 0.5

print(euclidean_distance)
Copy
Output:
5.196152422706632
Exercise 44:

Create a list and set the values between the 25th and 75th percentile to 0.

Solution:

lst = [10, 20, 30, 40, 50]

percentile_25th = sorted(lst)[int(len(lst) * 0.25)]

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)

Copy
Output:
[10, 0, 0, 0, 50]
Exercise 45:

Calculate the element-wise square of the difference between two lists.

Solution:

lst1 = [1, 2, 3]

lst2 = [4, 5, 6]

squared_difference = [(x - y) ** 2 for x, y in zip(lst1,

lst2)]

print(squared_difference)

Copy
Output:
[9, 9, 9]
Exercise 46:

Replace all even numbers in a list with the next odd number.

Solution:

lst = [2, 5, 8, 12, 15]

next_odd_lst = [x + 1 if x % 2 == 0 else x for x in lst]

print(next_odd_lst)

Copy
Output:
[3, 5, 9, 13, 15]
Exercise 47:

Create a 2D list and normalize each column by its range.

Solution:

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)

Copy
Output:
[[0.0, 0.9791524044681176, 0.0], [1.0, 1.0, 0.6427236160933483],
[0.12545213413765516, 0.0, 1.0]]
Exercise 48:

Compute the cumulative sum of elements along a given axis in a 2D list.

Solution:

import random

matrix = [[random.random() for _ in range(4)] for _ in

range(3)]

cumulative_sum_axis1 = [[sum(row[:i+1]) for i in

range(len(row))] for row in matrix]

print(cumulative_sum_axis1)

Copy
Output:
[[0.7546284663316909, 1.31481004728942, 1.8713995335850906,
2.308478041923004], [0.9197238360510473, 0.938647086950884, 1.24603043690484,
1.4655356220488251], [0.5592125265374753, 0.7216087739641586,
1.3660828220854073, 2.3651024686873945]]
Exercise 49:

Check if any element in a list is non-zero.

Solution:

lst = [0, 0, 0, 1, 0]

any_nonzero = any(lst)

print(any_nonzero)

Copy
Output:
True
Exercise 50:

Create a 2D list with random integers and replace all values greater than a
certain threshold with that threshold.

Solution:

import random
matrix = [[random.randint(0, 100) for _ in range(4)] for _ in
range(3)]

threshold = 75

matrix = [[min(x, threshold) for x in row] for row in matrix]

print(matrix)

Copy
Output:
[[75, 54, 43, 75], [58, 3, 16, 27], [42, 23, 4, 75]]
Exercise 51:

Find the median of a list of numbers.

Solution:

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

lst.sort()

n = len(lst)

median = (lst[n//2] if n % 2 != 0 else (lst[n//2 - 1] +

lst[n//2]) / 2)

print(median)

Copy
Output:
3
Exercise 52:

Convert a list of numbers to a list of their logarithms.

Solution:

import math

lst = [1, 10, 100, 1000]

log_lst = [math.log10(x) for x in lst]

print(log_lst)

Copy
Output:
[0.0, 1.0, 2.0, 3.0]
Exercise 53:

Find the mode of a list of numbers.

Solution:

from collections import Counter

lst = [1, 2, 2, 3, 3, 3, 4, 4]

mode = Counter(lst).most_common(1)[0][0]

print(mode)

Copy
Output:
3
Exercise 54:

Flatten a list of lists.

Solution:

nested_lst = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]

flat_lst = [x for sublist in nested_lst for x in sublist]

print(flat_lst)

Copy
Output:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Exercise 55:

Transpose a 2D list.

Solution:
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

transposed_matrix = [[row[i] for row in matrix] for i in

range(len(matrix[0]))]

print(transposed_matrix)

Copy
Output:
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]
Exercise 56:

Remove duplicates from a list while preserving order.

Solution:

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

seen = set()

unique_lst = [x for x in lst if not (x in seen or

seen.add(x))]

print(unique_lst)

Copy
Output:
[1, 2, 3, 4, 5]
Exercise 57:

Find the intersection of two lists.

Solution:

lst1 = [1, 2, 3, 4]

lst2 = [3, 4, 5, 6]

intersection = list(set(lst1) & set(lst2))

print(intersection)

Copy
Output:
[3, 4]
Exercise 58:

Merge two dictionaries.

Solution:

dict1 = {'a': 1, 'b': 2}

dict2 = {'b': 3, 'c': 4}

merged_dict = {**dict1, **dict2}

print(merged_dict)

Copy
Output:
{'a': 1, 'b': 3, 'c': 4}
Exercise 59:

Sort a list of dictionaries by a key.

Solution:

lst = [{'name': 'Anej', 'age': 25}, {'name': 'Matteo', 'age':

22}, {'name': 'Eliza', 'age': 28}]

sorted_lst = sorted(lst, key=lambda x: x['age'])

print(sorted_lst)

Copy
Output:
[{'name': 'Matteo', 'age': 22}, {'name': 'Anej', 'age': 25}, {'name': 'Eliza',
'age': 28}]
Exercise 60:

Filter a dictionary based on its values.

Solution:
d = {'a': 1, 'b': 2, 'c': 3}

filtered_dict = {k: v for k, v in d.items() if v > 1}

print(filtered_dict)

Copy
Output:
{'b': 2, 'c': 3}
Exercise 61:

Create a dictionary from two lists.

Solution:

keys = ['a', 'b', 'c']

values = [1, 2, 3]

dict_from_lists = dict(zip(keys, values))

print(dict_from_lists)

Copy
Output:
{'a': 1, 'b': 2, 'c': 3}
Exercise 62:

Find the maximum value in a dictionary.

Solution:

d = {'a': 1, 'b': 2, 'c': 3}

max_val = max(d.values())

print(max_val)

Copy
Output:
3
Exercise 63:
Invert a dictionary (swap keys and values).

Solution:

d = {'a': 1, 'b': 2, 'c': 3}

inverted_dict = {v: k for k, v in d.items()}

print(inverted_dict)

Copy
Output:
{1: 'a', 2: 'b', 3: 'c'}
Exercise 64:

Create a dictionary with a default value.

Solution:

keys = ['a', 'b', 'c']

default_value = 0

default_dict = {k: default_value for k in keys}

print(default_dict)

Output:
{'a': 0, 'b': 0, 'c': 0}
Exercise 65:

Convert a dictionary to a list of tuples.

Solution:

d = {'a': 1, 'b': 2, 'c': 3}

list_of_tuples = list(d.items())

print(list_of_tuples)

Output:
[('a', 1), ('b', 2), ('c', 3)]
Exercise 66:

Find the length of the longest string in a list.

Solution:

lst = ['apple', 'banana', 'cherry']

max_length = max(len(x) for x in lst)

print(max_length)

Copy
Output:
6
Exercise 67:

Reverse the words in a sentence.

Solution:

sentence = "Hello world"

reversed_sentence = ' '.join(sentence.split()[::-1])

print(reversed_sentence)

Copy
Output:
world Hello
Exercise 68:

Check if a string is a palindrome.

Solution:

s = "racecar"

is_palindrome = s == s[::-1]

print(is_palindrome)
Copy
Output:
True
Exercise 69:

Remove punctuation from a string.

Solution:

import string

s = "Hello, world!"

s_without_punctuation = s.translate(str.maketrans('', '',

string.punctuation))

print(s_without_punctuation)

Copy
Output:
Hello world
Exercise 70:

Count the occurrences of each character in a string.

Solution:

from collections import Counter

s = "hello"

char_count = Counter(s)

print(char_count)

Copy
Output:
Counter({'l': 2, 'h': 1, 'e': 1, 'o': 1})
Exercise 71:

Find the longest common prefix among a list of strings.

Solution:

lst = ["flower", "flow", "flight"]

if not lst:

longest_common_prefix = ""

else:

shortest_str = min(lst, key=len)

longest_common_prefix = ""

for i in range(len(shortest_str)):

if all(x.startswith(shortest_str[:i+1]) for x in lst):

longest_common_prefix = shortest_str[:i+1]

else:

break

print(longest_common_prefix)

Output:
fl
Exercise 72:

Convert a string to a list of characters.

Solution:

s = "hello"

char_list = list(s)

print(char_list)

Copy
Output:
['h', 'e', 'l', 'l', 'o']
Exercise 73:
Generate a list of random integers.

Solution:

import random

random_integers = [random.randint(0, 100) for _ in range(10)]

print(random_integers)

Copy
Output:
[80, 44, 74, 37, 71, 93, 14, 52, 20, 21]
Exercise 74:

Shuffle a list.

Solution:

import random

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

random.shuffle(lst)

print(lst)

Copy
Output:
[4, 5, 2, 1, 3]
Exercise 75:

Generate a random password of a given length.

Solution:

import string

import random

length = 8
password = ''.join(random.choice(string.ascii_letters +
string.digits) for _ in range(length))

print(password)

Copy
Output:
TwfnMdEq
Exercise 76:

Calculate the factorial of a number.

Solution:

def factorial(n):

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

print(factorial(5))

Copy
Output:
120
Exercise 77:

Calculate the Fibonacci sequence up to a given number of terms.

Solution:

def fibonacci(n):

fib_sequence = [0, 1]

while len(fib_sequence) < n:

fib_sequence.append(fib_sequence[-1] + fib_sequence[-
2])

return fib_sequence[:n]

print(fibonacci(10))

Copy
Output:
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
Exercise 78:

Check if a number is prime.

Solution:

def is_prime(n):

if n <= 1:

return False

for i in range(2, int(n ** 0.5) + 1):

if n % i == 0:

return False

return True

print(is_prime(17))

Copy
Output:
True
Exercise 79:

Find the greatest common divisor (GCD) of two numbers.

Solution:

def gcd(a, b):

while b:

a, b = b, a % b

return a

print(gcd(48, 18))

Copy
Output:
6
Exercise 80:

Find the least common multiple (LCM) of two numbers.

Solution:

def lcm(a, b):

def gcd(a, b):

while b:

a, b = b, a % b

return a

return a * b // gcd(a, b)

print(lcm(4, 5))

Copy
Output:
20
Exercise 81:

Sort a list of tuples by the second element.

Solution:

lst = [(1, 3), (2, 2), (3, 1)]

sorted_lst = sorted(lst, key=lambda x: x[1])

print(sorted_lst)

Copy
Output:
[(3, 1), (2, 2), (1, 3)]
Exercise 82:
Find the second largest number in a list.

Solution:

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

second_largest = sorted(set(lst))[-2]

print(second_largest)

Copy
Output:
4
Exercise 83:

Check if a list is a palindrome.

Solution:

lst = [1, 2, 3, 2, 1]

is_palindrome = lst == lst[::-1]

print(is_palindrome)

Copy
Output:
True
Exercise 84:

Find the sum of the digits of a number.

Solution:

num = 12345

digit_sum = sum(int(digit) for digit in str(num))

print(digit_sum)

Copy
Output:
15
Exercise 85:

Find the product of the digits of a number.

Solution:

num = 12345

digit_product = 1

for digit in str(num):

digit_product *= int(digit)

print(digit_product)

Copy
Output:
120
Exercise 86:

Check if a string is a valid number.

Solution:

s = "123.45"

is_valid_number = s.replace('.', '', 1).isdigit()

print(is_valid_number)

Copy
Output:
True
Exercise 87:

Find the length of the longest word in a sentence.

Solution:

sentence = "The quick brown fox jumps over the lazy dog"
longest_word_length = len(max(sentence.split(), key=len))

print(longest_word_length)

Copy
Output:
5
Exercise 88:

Convert a list of tuples to a dictionary.

Solution:

lst = [('a', 1), ('b', 2), ('c', 3)]

d = dict(lst)

print(d)

Copy
Output:
{'a': 1, 'b': 2, 'c': 3}
Exercise 89:

Filter a list of dictionaries based on a key value.

Solution:

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)

Copy
Output:
[{'name': 'Vivek', 'age': 25}, {'name': ' Neassa', 'age': 28}]
Exercise 90:

Sort a list of tuples by multiple keys.

Solution:

lst = [(' Aisha', 'A', 25), (' Remy', 'B', 22), ('Meine', 'A',
28)]

sorted_lst = sorted(lst, key=lambda x: (x[1], x[2]))

print(sorted_lst)

Copy
Output:
[(' Aisha', 'A', 25), ('Meine', 'A', 28), (' Remy', 'B', 22)]
Exercise 91:

Merge two lists into a dictionary, using one as keys and the other as values.

Solution:

keys = ['a', 'b', 'c']

values = [1, 2, 3]

merged_dict = dict(zip(keys, values))

print(merged_dict)

Copy
Output:
{'a': 1, 'b': 2, 'c': 3}
Exercise 92:

Create a dictionary with keys as numbers and values as their squares.

Solution:

n = 5

squared_dict = {i: i**2 for i in range(1, n+1)}

print(squared_dict)

Copy
Output:
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
Exercise 93:

Check if two strings are anagrams.

Solution:

s1 = "listen"

s2 = "silent"

are_anagrams = sorted(s1) == sorted(s2)

print(are_anagrams)

Output:
True
Exercise 94:

Count the number of vowels in a string.

Solution:

s = "hello world"

vowel_count = sum(1 for char in s if char in 'aeiou')

print(vowel_count)

Copy
Output:
3
Exercise 95:

Check if a string contains only digits.

Solution:

s = "12345"

is_digit_only = s.isdigit()
print(is_digit_only)

Copy
Output:
True
Exercise 96:

Find the first non-repeated character in a string.

Solution:

s = "swiss"

non_repeated_char = next((char for char in s if s.count(char)

== 1), None)

print(non_repeated_char)

Copy
Output:

Exercise 97:

Reverse each word in a sentence.

Solution:

sentence = "Hello world"

reversed_words_sentence = ' '.join(word[::-1] for word in

sentence.split())

print(reversed_words_sentence)

Copy
Output:
olleH dlrow
Exercise 98:

Generate a list of Fibonacci numbers up to a given number.

Solution:
def fibonacci_up_to(n):

fib_sequence = [0, 1]

while fib_sequence[-1] < n:

fib_sequence.append(fib_sequence[-1] + fib_sequence[-
2])

return fib_sequence[:-1]

print(fibonacci_up_to(100))

Copy
Output:
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
Exercise 99:

Remove all whitespaces from a string.

Solution:

s = " a b c d "

s_without_whitespace = s.replace(' ', '')

print(s_without_whitespace)

Copy
Output:
abcd
Exercise 100:

Replace all occurrences of a substring in a string.

Solution:

s = "Hello world, welcome to the world of Python family."

new_s = s.replace('world', 'universe')

print(new_s)
Output:

Hello world, welcome to the universe of Python family.