Python Programming Examples 50 Programs with Code and Output

Basic Python Programs

Basic Python programs cover the foundational concepts every programmer must know: print statements, variables, arithmetic operators, user input, conditional logic, loops, and functions. These are the most searched simple Python programs for beginners and form the building blocks for every more advanced program on this page.

1. Python Hello World Program

The Hello World program is the first Python program every beginner writes. It confirms that Python is installed correctly and demonstrates the print() function the most basic output operation in Python.

Code:

Output:

How it works: The print() function takes a value and displays it on screen. Python reads the call, evaluates the string ‘Hello, World!’, and sends it to standard output. This is the simplest possible Python program. In Python 3, print() is always a function always use parentheses.

2. Add Two Numbers in Python

This program adds two numbers and prints the result. It demonstrates variable assignment, the addition operator, and f-string formatting three concepts used in almost every Python program.

Code:

Output:

How it works: Python stores 50 and 270 in variables num1 and num2. The + operator adds them. The f-string uses curly braces to embed variable values directly inside the printed string Python substitutes them at runtime. This is cleaner and more readable than string concatenation with +.

3. Check Even or Odd Number

This program takes a number as input and checks whether it is even or odd. It uses the modulus operator (%) to check the remainder when divided by 2 a logic pattern that appears in many Python programs.

Code:

Output:

How it works: The modulus operator % returns the remainder after division. Any even number divided by 2 gives remainder 0; any odd number gives 1. input() collects user input as a string and int() converts it to an integer so arithmetic works correctly.

4. Swap Two Variables

This program swaps the values of two variables using Python’s simultaneous assignment a single-line operation that requires no temporary variable, unlike most other programming languages.

Code:

Output:

How it works: Python evaluates the entire right side before assigning to the left. So num2, num1 forms a temporary tuple (90, 56) and simultaneously assigns 90 to num1 and 56 to num2. In Java or C you would need a third temporary variable: temp = a; a = b; b = temp.

5. Find Factorial of a Number

The factorial of n is the product of all positive integers from 1 to n. For example, factorial(5) = 5 × 4 × 3 × 2 × 1 = 120. This program uses recursion, a function that calls itself to compute it.

Code:

Output:

How it works: factorial() calls itself with a smaller value each time. For factorial(5): 5 × factorial(4) → 4 × factorial(3) → down to the base case factorial(0) = 1. The call stack then unwinds and multiplies back up: 1 × 2 × 3 × 4 × 5 = 120. The base case (num == 0) is essential; without it the function would recurse forever and crash with a RecursionError.

6. Reverse a Number

This program takes a number as input and reverses its digits. For example, 524512 becomes 215425. It uses a while loop and the modulus operator to extract digits one at a time from the right.

Code:

Output:

How it works: Modulus 10 extracts the last digit of num each iteration. That digit is appended to rev_num by multiplying rev_num by 10 and adding the digit. Integer division by 10 removes the last digit from num. The loop continues until num becomes 0, at which point rev_num holds the fully reversed number.

7. Check Prime Number

A prime number is greater than 1 and has no divisors other than 1 and itself. This program uses an efficient algorithm that only tests divisors up to the square root of the number.

Code:

Output:

How it works: If n has a divisor larger than its square root, it must also have one smaller so checking only up to the square root is both correct and faster than checking all values up to n. Numbers less than or equal to 1 are not prime by definition. If no divisor divides num evenly within the range, the function returns True.

8. Find GCD of Two Numbers

The Greatest Common Divisor (GCD) of two numbers is the largest number that divides both without a remainder. This program uses the Euclidean algorithm, one of the oldest and most efficient algorithms in mathematics.

Code:

Output:

How it works: The algorithm replaces the larger number with the remainder of dividing the two. For gcd(10, 5): a=10, b=5 becomes a=5, b=0, which returns 5. The loop runs while b is non-zero. This runs in O(log min(a,b)) time far faster than checking all possible divisors.

9. Find Sum of Digits

This program calculates the sum of all individual digits in a number. For example, the digits of 251 add up to 2 + 5 + 1 = 8. This is a common Python program for beginners that practises loops and modulus arithmetic.

Code:

Output:

How it works: Modulus 10 extracts the last digit of num each iteration and adds it to the running sum. Integer division by 10 removes that digit. For 251: iteration 1 adds 1, iteration 2 adds 5, iteration 3 adds 2, giving a total of 8.

10. Check Armstrong Number

An Armstrong number (also called a narcissistic number) is a number equal to the sum of its digits each raised to the power of the number of digits. For example, 153 = 1³ + 5³ + 3³ = 153.

Code:

Output:

How it works: The generator expression converts n to a string to iterate over each digit character, converts each back to int, cubes it, and sums the results. For 153: 1³ + 5³ + 3³ = 1 + 125 + 27 = 153. A number like 25551 does not satisfy this condition and is not an Armstrong number.

Python Array Programs

Python array programs focus on performing operations on collections of elements finding max and min values, summing elements, reversing, merging, removing duplicates, and rotating arrays. In Python, arrays are typically implemented using lists. These examples cover the most searched array problems and the operations most commonly tested in Python technical interviews.

11. Find Maximum in an Array

This program finds the largest element in an array. It demonstrates Python’s built-in max() function the simplest way to find the maximum value in a list or array.

Code:

Output:

How it works: max() iterates through all elements and returns the largest in O(n) time. For interview questions where built-in functions are not allowed, initialise a variable to arr[0] and update it inside a for loop whenever a larger value is found.

12. Find Minimum in an Array

This program finds the smallest element in an array using Python’s built-in min() function.

Code:

Output:

How it works: min() scans every element and returns the smallest in O(n) time. Both min() and max() accept an optional key argument for custom comparison; for example, min(words, key=len) returns the shortest word in a list of strings.

13. Find Sum of Array Elements

This program calculates the total of all elements in an array using Python’s built-in sum() function.

Code:

Output:

How it works: sum() adds all elements in the iterable and returns the total. You can pass a starting value as the second argument: sum(arr, 10) would return 456. For large numerical arrays in data science applications, NumPy’s np.sum() is significantly faster.

14. Reverse an Array

This program reverses the order of all elements in an array using Python’s slice notation one of the most concise ways to reverse any sequence in Python.

Code:

Output:

How it works: Slice notation [::-1] creates a new reversed copy the empty start and stop mean use the full list, and step -1 means step backwards. This does not modify the original array. To reverse in-place, use arr.reverse() instead.

15. Merge Two Arrays

This program combines two arrays into a single array using the + operator. Merging arrays is a common step in sorting algorithms and data processing.

Code:

Output:

How it works: The + operator creates a new list with all elements of arr1 followed by arr2. It runs in O(n+m) time. arr1.extend(arr2) is an equivalent that modifies arr1 in-place. Use + when you need a new merged list; use extend() when you want to avoid creating an extra object.

16. Remove Duplicates from an Array

This program removes all duplicate elements from an array and returns only unique values. Removing duplicates is one of the most frequently asked Python interview questions.

Code:

Output:

How it works: Converting a list to a set removes duplicates automatically because sets only store unique values. Converting back to list gives the result. Note: sets are unordered so output order may differ from input. To preserve original insertion order while removing duplicates, use list(dict.fromkeys(arr)) this works in Python 3.7 and above.

17. Rotate an Array

This program rotates an array to the left by d positions elements from the front move to the back. Array rotation is a classic Python interview question that tests slice manipulation.

Code:

Output:

How it works: The function splits at position d: arr[d:] takes elements from d to end and arr[:d] takes elements from start to d. Concatenating them places the tail first, achieving a left rotation by d positions. For a right rotation, use arr[-d:] + arr[:-d].

18. Find Second Largest Element in an Array

This program finds the second largest element in an array. Finding the second largest without full sorting is one of the most commonly asked Python programming questions in technical interviews.

Code:

Output:

How it works: The approach removes the maximum element then finds the new maximum giving the second largest. Note: arr.remove() modifies the original array. For a cleaner solution that handles duplicates and preserves the original array, use sorted(set(arr))[-2].

Python List Programs

Python list programs cover the essential operations used in everyday Python development: appending, extending, inserting, removing, popping, and counting elements. Python lists are dynamic, ordered, and mutable; they are the most commonly used data structure in Python and appear in nearly every real-world Python program.

19. Append Elements to a List

This program adds a new element to the end of a list using the append() method, the most commonly used list method in Python.

Code:

Output:

How it works: append() adds exactly one element to the end of the list and modifies it in-place. It runs in O(1) amortised time. The key difference from extend(): append([1,2,3]) adds the entire list as a single nested element; extend([1,2,3]) unpacks it and adds 1, 2, and 3 as separate elements.

20. Extend a List

This program extends a list by adding all elements from a second list using the extend() method.

Code:

Output:

How it works: extend() iterates over the argument and appends each element individually. It modifies the list in-place and returns None. Unlike the + operator which creates a new list, extend() is more memory-efficient and preferred when adding elements to an existing list.

21. Insert an Element at a Specific Position

This program inserts a new element at a specific index in a list using insert(). This is useful when the order of elements matters.

Code:

Output:

How it works: insert(index, value) places value at the specified index and shifts all elements from that position one step to the right. Index 4 makes the new element the fifth item (0-indexed). insert() runs in O(n) time because of the shifting operation.

22. Remove an Element from a List

This program removes a specific value from a list using the remove() method. It removes the first occurrence of the value, not the element at an index.

Code:

Output:

How it works: remove() finds and deletes the first occurrence of the specified value. If the value is not found, Python raises a ValueError. To remove by index instead of value, use del list[index] or pop(index). To safely avoid a ValueError, check first: if 73 in user_list_1: user_list_1.remove(73).

23. Pop an Element from a List

This program removes and returns the last element of a list using the pop() method.

Code:

Output:

How it works: pop() with no argument removes and returns the last element in O(1) time. pop(index) removes at a given position in O(n) time. A Python list used with append() and pop() behaves as a stack Last In, First Out. This is the standard way to implement a stack data structure in Python.

24. Count Occurrences of an Element in a List

This program counts how many times a specific value appears in a list using the count() method.

Code:

Output:

How it works: count() scans the entire list and returns the number of times the value appears O(n) time. To count occurrences of multiple values efficiently in one pass, use collections.Counter: Counter(user_list_1) returns a dictionary mapping each value to its frequency.

Python Matrix Programs

Python matrix programs cover creating, transposing, and performing arithmetic on two-dimensional data structures. In Python, a matrix is represented as a list of lists. These examples are essential for learners moving into data science, numerical computing, and machine learning, where matrix operations are a daily requirement.

25. Create a Matrix in Python

This program creates a 3×3 matrix as a list of lists and prints each row on a separate line.

Code:

Output:

How it works: A matrix in Python is stored as a list of lists where each inner list represents one row. Access an individual element with matrix[row][column] for example, matrix[1][2] returns 12. The for loop iterates over each inner list. For large matrices and numerical computing, use NumPy arrays instead of lists of lists.

26. Transpose a Matrix

Transposing a matrix flips it along its main diagonal rows and columns become rows. Transposition is a fundamental operation in linear algebra and machine learning.

Code:

Output:

How it works: The nested list comprehension iterates over column indices in the outer loop and over each row in the inner loop, collecting element row[i] from each row. This turns the i-th column of the original into the i-th row of the transposed matrix. NumPy equivalent: np.array(matrix).T.

27. Add and Subtract Two Matrices

This program adds and subtracts two matrices element by element using list comprehensions the Python way to handle element-wise matrix arithmetic without external libraries.

Code:

Output:

How it works: The nested list comprehension performs the operation at position [i][j] for every row i and column j. Both matrices must have identical dimensions. NumPy simplifies this to np.array(m1) + np.array(m2) and np.array(m1) – np.array(m2) for any size matrix.

28. Find Matrix Inversion

The inverse of a matrix is another matrix that when multiplied with the original gives the identity matrix. This program computes the inverse of a 2×2 matrix using the standard mathematical formula.

Code:

Output:

How it works: For a 2×2 matrix [[a,b],[c,d]], the inverse is (1/det) multiplied by [[d,-b],[-c,a]] where det = ad – bc. A determinant of 0 means the matrix is singular and has no inverse; the check prevents a division-by-zero error. For larger matrices, use np.linalg.inv(matrix).

29. Find Trace of a Matrix

The trace of a matrix is the sum of all elements on its main diagonal, the elements where the row index equals the column index.

Code:

Output:

How it works: Diagonal elements are where row index equals column index: m1[0][0]=45, m1[1][1]=67, m1[2][2]=46. The generator expression sums them: 45+67+46=158. This only works for square matrices. NumPy equivalent: np.trace(m1).

Python String Programs

Python string programs cover the most searched string operations: palindrome check, substring search, reversing words, and character manipulation. Strings are immutable in Python every modification creates a new string object. String programs are the most frequently tested category in Python technical interviews.

30. Check if a String is a Palindrome

A palindrome is a string that reads the same forwards and backwards “level”, “racecar”, “madam”. Palindrome check is one of the most commonly asked Python string programs in interviews.

Code:

Output:

How it works: Slice [::-1] creates a reversed copy of the string. Comparing the original with its reverse is the simplest Python palindrome check. For case-insensitive matching, use string.lower() == string.lower()[::-1]. To ignore spaces and punctuation, clean the string first: “”.join(c for c in s if c.isalnum()).lower().

31. Check if String is Symmetrical or Palindrome

This program checks two distinct string properties: symmetrical (first half equals second half) and palindrome (equals its reverse). “abba” is a palindrome but not symmetrical.

Code:

Output:

How it works: Symmetrical means the first half exactly equals the second half. For “abba”: first half = “ab”, second half = “ba” not equal, so not symmetrical. A palindrome means the full string equals its reverse: “abba” reversed is “abba” equal, so it is a palindrome. These are two distinct properties.

32. Reverse Words in a String

This program reverses the order of words in a sentence while keeping each word intact. “Hello World” becomes “World Hello”. This is a frequently tested Python string manipulation question.

Code:

Output:

How it works: split() with no argument splits on any whitespace and returns a list of words. reversed() yields them in reverse order. join() reassembles the words into a single string with spaces. A one-liner alternative: “ ”.join(s.split()[::-1]). Both handle multiple spaces correctly.

33. Remove Kth Character from a String

This program removes the character at a specific index from a string. Since Python strings are immutable, removing a character creates a new string.

Code:

Output:

How it works: s[:i] takes everything before index i and s[i+1:] takes everything after joining them skips the character at position i. Index 3 in “HeroVide” is “o”, so removing it gives “HerVide”. Python uses 0-based indexing: H=0, e=1, r=2, o=3.

34. Check if a Substring is Present in a String

This program checks whether one string appears inside another using the in operator the most Pythonic way to perform a substring search.

Code:

Output:

How it works: The in operator returns True if the substring appears anywhere in the string. To get the position too, use str.find(sub) which returns the starting index or -1 if not found. str.index(sub) does the same but raises a ValueError when not found.

Python Dictionary Programs

Python dictionary programs cover storing, accessing, and manipulating key-value pairs. Dictionaries provide O(1) average-time lookup by key, making them one of the most important and versatile data structures in Python. Dictionary operations are tested in almost every Python interview.

35. Extract Unique Values from a Dictionary

This program extracts all unique values from a dictionary whose values are lists, using a set to remove duplicates.

Code:

Output:

How it works: The generator uses two nested for loops: the outer iterates over each key’s list of values, the inner over each element in that list. Wrapping in set() removes duplicates. Output order may vary because sets are unordered. For a sorted result, use sorted(chk_unique(di)).

36. Find Sum of All Items in a Dictionary

This program calculates the total of all numeric values stored in a dictionary.

Code:

Output:

How it works: di.values() returns a view of all dictionary values. Passing this to sum() adds them together. This works when all values are numeric. Dictionary order is guaranteed in Python 3.7 and above values are returned in insertion order.

37. Remove a Key from a Dictionary

This program removes a specific key-value pair from a dictionary. It checks for key existence first to prevent a KeyError.

Code:

Output:

How it works: del di[key] removes the key-value pair permanently. The ‘if key in di’ check prevents a KeyError when the key does not exist. A cleaner alternative: di.pop(key, None) removes the key if present and returns None if missing no prior check needed.

38. Sort List of Dictionaries by Value Using itemgetter

This program sorts a list of dictionaries by a specified key using itemgetter from the operator module one of the most common dictionary operations in Python data processing.

Code:

Output:

How it works: itemgetter(‘year’) creates a callable that retrieves the ‘year’ key from any dictionary. sorted() calls this on each item to determine order. To sort in descending order, add reverse=True to sorted().

39. Sort List of Dictionaries by Value Using Lambda

This program sorts a list of dictionaries by a specified key using a lambda function the inline alternative to itemgetter.

Code:

Output:

How it works: lambda x: x[key] takes a dictionary x and returns its value at the given key. sorted() calls this on each item to determine order. The output is identical to the itemgetter approach the choice between them is stylistic.

Python Tuple Programs

Python tuple programs cover operations on immutable ordered sequences. Tuples are faster than lists and are used when data should not change after creation. Because tuples are hashable, they can be used as dictionary keys and set elements something lists cannot do. These programs cover the most common tuple operations every Python learner needs.

40. Find the Size of a Tuple

This program finds the memory size of a tuple in bytes using the __sizeof__() method.

Code:

Output:

How it works: __sizeof__() returns the memory size of the tuple object in bytes. To get the number of elements (not memory size), use len(item). Tuples are immutable: elements cannot be added, removed, or changed after creation. This immutability also makes them hashable and usable as dictionary keys, unlike lists.

41. Find Maximum and Minimum K Elements in a Tuple

This program extracts the K smallest and K largest elements from a tuple a common data selection operation in Python.

Code:

Output:

How it works: sorted() on a tuple returns a new sorted list. Slicing [:k] gives the k smallest elements and [-k:] gives the k largest. For large tuples where k is much smaller than the total length, heapq.nsmallest(k, tup) and heapq.nlargest(k, tup) are faster alternatives.

42. Create a List of Tuples with Number and its Cube

This program creates a list of tuples where each tuple pairs a number with its cube a practical example of building structured data with list comprehensions.

Code:

Output:

How it works: The list comprehension (x, x**3) for x in lst creates a (number, cube) tuple for each element. x**3 is Python’s exponentiation operator. Pairing a value with a derived value is a pattern used frequently in sorting, lookup tables, and data transformation pipelines.

43. Add a Tuple to a List

This program demonstrates two operations: adding a tuple as a single element to a list, and merging a list into a tuple.

Code:

Output:

How it works: append(tp) adds the entire tuple as a single item. To unpack its elements individually instead, use extend(tp). For the reverse, tuple(ls) converts the list to a tuple and + concatenates both tuples into a new one. Tuples are immutable, so concatenation always creates a new tuple.

44. Find Closest Pair to the Kth Index Element in a Tuple

This program finds the element in a tuple that is numerically closest to the element at a given index.

Code:

Output:

How it works: tp[k] retrieves the element at index k (which is 80). min(tp, key=lambda x: abs(x – k_el)) finds the element with the smallest absolute difference from k_el. Since 80 is in the tuple, the closest element to itself is itself.

Python Searching and Sorting Programs

Searching and sorting are the most tested algorithm categories in Python technical interviews. Understanding not just the code but the time complexity of each algorithm and when to use one over another is what interviewers evaluate. These examples cover the six most important searching and sorting algorithms every Python programmer must know.

45. Binary Search in Python

Binary search finds a target value in a sorted array by halving the search space each iteration. It runs in O(log n) time far faster than linear search for large datasets. This program shows both the recursive and iterative approaches.

Code:

Output:

How it works: Binary search only works on sorted arrays. Each iteration checks the middle element: if equal the search ends; if target is larger, search the right half (start = mid+1); if smaller, search the left half (end = mid-1). Each step halves the search space O(log n) time. For 1,000,000 elements, binary search needs at most 20 comparisons versus 1,000,000 for linear search.

46. Linear Search in Python

Linear search checks each element one by one from left to right until the target is found or the array ends. It works on both sorted and unsorted arrays and runs in O(n) time.

Code:

Output:

How it works: Linear search visits each element in order and returns the index of the first match. Unlike binary search, it works on unsorted arrays. Best case is O(1) when the target is the first element. Worst case is O(n) when the target is last or not present. Use linear search for small or unsorted arrays.

47. Insertion Sort in Python

Insertion sort builds a sorted array one element at a time by inserting each new element into its correct position within the already-sorted portion similar to how you sort playing cards in your hand.

Code:

Output:

How it works: For each element from index 1, the algorithm compares it with elements to its left and shifts each larger element one position right until the correct insertion point is found. Time complexity: O(n²) average, O(n) best case on already-sorted input. Insertion sort is a stable sort equal elements keep their original relative order.

48. Quick Sort in Python

Quick sort is a divide-and-conquer sorting algorithm. It picks a pivot element, partitions elements into groups smaller and larger than the pivot, then recursively sorts each group. Average time complexity: O(n log n).

Code:

Output:

How it works: List comprehensions partition arr into three groups: less than, equal to, and greater than the pivot. The middle list handles duplicates correctly. Recursion sorts the left and right groups. A bad pivot choice (always smallest or largest) degrades performance to O(n²). Average time: O(n log n). This version uses O(n) extra space.

49. Selection Sort in Python

Selection sort divides the array into sorted and unsorted portions. It repeatedly finds the minimum element in the unsorted portion and swaps it into the next position of the sorted portion.

Code:

Output:

How it works: The inner loop finds the index of the minimum element in the unsorted portion. The outer loop swaps that minimum into position i. Selection sort makes exactly n-1 swaps regardless of input order useful when write operations are expensive. Time: O(n²) in all cases. Not a stable sort.

50. Bubble Sort in Python

Bubble sort repeatedly compares adjacent elements and swaps them if they are in the wrong order. After each pass through the array, the largest unsorted element moves to its correct position at the end.

Code:

Output:

How it works: Two nested loops compare adjacent pairs and swap if out of order. After pass 1, the largest element is at the end. After pass 2, the two largest are in place, and so on. range(0, n-i-1) shrinks the inner loop each pass because the last i elements are already sorted. Time: O(n²) average and worst, O(n) best case with an early-exit flag.