30 Small Python Tasks for Beginners

This article provides thirty small Python tasks designed for beginners to practice and understand fundamental programming concepts.

1. Duplicate Element Check

The following function checks whether a list contains duplicate elements by comparing its length to the length of a set created from the list.

def all_unique(lst):
    return len(lst) == len(set(lst))

x = [1,1,2,2,3,2,3,4,5,6]
y = [1,2,3,4,5]
print(all_unique(x))  # False
print(all_unique(y))  # True

2. Anagram Check

Checks whether two strings consist of the same characters using Counter.

from collections import Counter

def anagram(first, second):
    return Counter(first) == Counter(second)

print(anagram("abcd3", "3acdb"))  # True

3. Memory Size

Displays the memory size of a variable using sys.getsizeof.

import sys
variable = 30
print(sys.getsizeof(variable))  # 24

4. Byte Size of a String

Returns the number of bytes a string occupies when encoded in UTF‑8.

def byte_size(string):
    return len(string.encode('utf-8'))

print(byte_size(''))        # 0
print(byte_size('Hello World'))  # 11

5. Print a String N Times

Prints a string repeated N times without using a loop.

n = 2
s = "Programming"
print(s * n)  # ProgrammingProgramming

6. Capitalize First Letter of Each Word

Uses the title() method to capitalize the first letter of each word in a string.

s = "programming is awesome"
print(s.title())  # Programming Is Awesome

7. Chunk a List

Splits a list into sub‑lists of a given size.

from math import ceil

def chunk(lst, size):
    return list(map(lambda x: lst[x*size:x*size+size], range(0, ceil(len(lst)/size))))

print(chunk([1,2,3,4,5], 2))  # [[1, 2], [3, 4], [5]]

8. Compact List

Removes falsy values (False, None, 0, "") from a list using filter.

def compact(lst):
    return list(filter(bool, lst))

print(compact([0, 1, False, 2, '', 3, 'a', 's', 34]))  # [1, 2, 3, 'a', 's', 34]

9. Unpack Paired Lists

Transposes a list of paired elements into two separate tuples.

array = [['a', 'b'], ['c', 'd'], ['e', 'f']]
transposed = zip(*array)
print(list(transposed))  # [('a', 'c', 'e'), ('b', 'd', 'f')]

10. Chain Comparison

Demonstrates Python's ability to chain comparison operators in a single expression.

a = 3
print(2 < a < 8)   # True
print(1 == a < 2) # False

11. Join List with Commas

Concatenates list elements into a single string separated by commas.

hobbies = ["basketball", "football", "swimming"]
print("My hobbies are: " + ", ".join(hobbies))
# My hobbies are: basketball, football, swimming

12. Vowel Count

Counts the number of vowels in a string using a regular expression.

import re

def count_vowels(s):
    return len(re.findall(r'[aeiou]', s, re.IGNORECASE))

print(count_vowels('foobar'))  # 3
print(count_vowels('gym'))     # 0

13. Decapitalize First Letter

Converts the first character of a string to lowercase.

def decapitalize(string):
    return string[:1].lower() + string[1:]

print(decapitalize('FooBar'))  # fooBar

14. Flatten a Nested List

Recursively flattens a nested list into a single‑level list.

def spread(arg):
    ret = []
    for i in arg:
        if isinstance(i, list):
            ret.extend(i)
        else:
            ret.append(i)
    return ret

def deep_flatten(lst):
    result = []
    result.extend(spread(list(map(lambda x: deep_flatten(x) if isinstance(x, list) else x, lst))))
    return result

print(deep_flatten([1, [2], [[3], 4], 5]))  # [1, 2, 3, 4, 5]

15. List Difference

Returns elements present in the first list but not in the second.

def difference(a, b):
    return list(set(a).difference(set(b)))

print(difference([1,2,3], [1,2,4]))  # [3]

16. Difference by Function

Applies a function to elements before computing the difference.

def difference_by(a, b, fn):
    b = set(map(fn, b))
    return [item for item in a if fn(item) not in b]

from math import floor
print(difference_by([2.1, 1.2], [2.3, 3.4], floor))  # [1.2]

17. Chain Function Calls

Shows how to choose between two functions in a single line.

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

a, b = 4, 5
print((subtract if a > b else add)(a, b))  # 9

18. Check for Duplicates

Determines whether a list contains duplicate elements.

def has_duplicates(lst):
    return len(lst) != len(set(lst))

print(has_duplicates([1,2,3,4,5,5]))  # True
print(has_duplicates([1,2,3,4,5]))    # False

19. Merge Two Dictionaries

Combines two dictionaries, with values from the second overriding those from the first.

def merge_two_dicts(a, b):
    c = a.copy()
    c.update(b)
    return c

a = {'x':1, 'y':2}
b = {'y':3, 'z':4}
print(merge_two_dicts(a, b))  # {'x': 1, 'y': 3, 'z': 4}

20. Convert Two Lists to a Dictionary

Creates a dictionary by zipping a list of keys with a list of values.

def to_dictionary(keys, values):
    return dict(zip(keys, values))

keys = ["a", "b", "c"]
values = [2, 3, 4]
print(to_dictionary(keys, values))  # {'a': 2, 'b': 3, 'c': 4}

21. Enumerate a List

Iterates over a list while accessing both index and element.

lst = ["a", "b", "c", "d"]
for index, element in enumerate(lst):
    print("Value", element, "Index", index)

22. Measure Execution Time

Calculates the time taken to execute a block of code.

import time
start_time = time.time()
# code to measure
a = 1
b = 2
c = a + b
print(c)
end_time = time.time()
print("Time:", end_time - start_time)

23. Try/Except with Else

Demonstrates the use of an else clause with try/except.

try:
    2 * 3
except TypeError:
    print("An exception was raised")
else:
    print("Thank God, no exceptions were raised.")

24. Most Frequent Element

Finds the element that appears most frequently in a list.

def most_frequent(lst):
    return max(set(lst), key=lst.count)

lst = [1,2,1,2,3,2,1,4,2]
print(most_frequent(lst))  # 2

25. Palindrome Check

Checks whether a string is a palindrome, ignoring case and non‑alphabetic characters.

import re

def palindrome(string):
    s = re.sub(r'[\W_]', '', string.lower())
    return s == s[::-1]

print(palindrome('taco cat'))  # True

26. Operator‑Based Calculator Without If‑Else

Performs arithmetic operations using a dictionary of operator functions.

import operator
action = {"+": operator.add, "-": operator.sub, "/": operator.truediv, "*": operator.mul, "**": pow}
print(action['-'](50, 25))  # 25

27. Shuffle a List (Fisher‑Yates)

Randomly shuffles a list using the Fisher‑Yates algorithm.

from copy import deepcopy
from random import randint

def shuffle(lst):
    temp_lst = deepcopy(lst)
    m = len(temp_lst)
    while m:
        m -= 1
        i = randint(0, m)
        temp_lst[m], temp_lst[i] = temp_lst[i], temp_lst[m]
    return temp_lst

foo = [1,2,3]
print(shuffle(foo))  # e.g., [2,3,1]

28. Expand Nested List

Flattens a list containing nested sub‑lists into a single list.

def spread(arg):
    ret = []
    for i in arg:
        if isinstance(i, list):
            ret.extend(i)
        else:
            ret.append(i)
    return ret

print(spread([1,2,3,[4,5,6],[7],8,9]))  # [1,2,3,4,5,6,7,8,9]

29. Swap Two Values

Swaps the values of two variables without using a temporary variable.

def swap(a, b):
    return b, a

a, b = -1, 14
print(swap(a, b))  # (14, -1)

30. Dictionary Default Value

Retrieves a value from a dictionary with a default if the key is missing.

d = {'a': 1, 'b': 2}
print(d.get('c', 3))  # 3