80+ Python Coding Challenges For Beginners

80+ Python Coding Challenges
for Beginners
Python Exercises to Make You a Better Programmer. No Prior

Experience Needed: 80+ Python Challenges to Launch Your
Coding Journey.
By
Katie Millie
Copyright notice
Copyright © 2024 Katie Millie. All rights reserved.
The contents of this material are protected by copyright law.

Any reproduction, distribution, or transmission in any form
or by any means, including photocopying, recording, or
other electronic or mechanical methods, is strictly
prohibited without the explicit prior written consent of the
copyright holder. Exceptions are granted for short citations
utilized in critical evaluations and certain noncommercial
uses allowed by copyright regulations. Unauthorized
utilization or duplication of this content could lead to legal
consequences. Please respect intellectual property rights
and contact the copyright holder for permission inquiries.
Table of Contents
INTRODUCTION
Chapter 1
Welcome to the World of Python!
Chapter 2
Setting Up Your Python Environment
Chapter 3
Basic Python Syntax: Variables, Data Types, Operators, and Expressions
Chapter 4
Control Flow Statements: Decision-making with if/else and Looping with

for/while
Chapter 5
Functions: Defining and Calling Functions
Chapter 6
Putting Your Skills to the Test: Level 1 Challenges (Basic Concepts)
Section 2: Control Flow

Section 3: Functions
Chapter 7
Deepening Your Knowledge: Level 2 Challenges (Intermediate Concepts)
Section 2: Dictionaries
Section 3: Files and Exception Handling

Chapter 8
Expanding Your Horizons: Level 3 Challenges (Advanced Concepts)
Section 2: Object-Oriented Programming (OOP) Fundamentals
Bonus Chapter: Project Ideas
Conclusion
Appendix
A Glossary of Terms for Python Beginner
Answers to Selected Challenges (Solutions for selected
challenges)
INTRODUCTION
80+ Python Coding Challenges for Beginners: Unleash
the Python Power Within
Do you dream of building dynamic websites, automating
tasks, or analyzing data like a pro? Python, a powerful and
versatile programming language, can turn those dreams
into reality. Even with no prior experience, you can unlock
the magic of Python with this exciting collection of 80+
coding challenges designed specifically for beginners.
This book is not your typical dry coding manual. We'll throw
you headfirst into the world of Python with engaging, bite-
sized challenges that will have you solving problems and
building programs in no time. Forget memorizing complex
syntax; here, you'll learn by doing, mastering the
fundamentals one challenge at a time.
Why Python? Why This Book?
Python isn't just another programming language. It's
renowned for its incredibly readable syntax, making it easier
to learn and understand than its more complex
counterparts. With Python, you don't have to spend hours
deciphering cryptic code - you can focus on the logic and
unleash your creativity.
This book is your ultimate companion on your Python
journey as a beginner. Here's what sets it apart:
● Progressive Learning: We'll start with the
building blocks of Python, gradually introducing
more advanced concepts as you progress through
the challenges. You'll build a solid foundation in
variables, data types, loops, functions, and more, all
while having fun!
● Challenge Variety: From number manipulation
and string manipulation to list comprehensions and
file handling, this book throws a wide variety of
challenges your way. You'll never get bored as you
tackle problems that test your newfound skills while
expanding your coding repertoire.
● Interactive and Engaging: Forget passive
learning! This book encourages active participation.
With clear explanations and well-defined problem
statements, you'll be coding from the get-go. Stuck
on a challenge? Don't worry! We offer helpful hints
and tips to guide you in the right direction.
● Real-World Applications: You won't just be
solving abstract problems. This book encourages
you to think like a programmer by incorporating
real-world scenarios into many challenges. You'll
create programs that could be used to analyze
movie ratings, build a simple password checker, or
even generate random poems!
● Beyond the Basics: As you gain confidence, we'll
delve deeper into more advanced topics like object-
oriented programming and data structures. This
prepares you to tackle more complex projects in the
future.
What You'll Achieve:
By conquering these 80+ coding challenges, you'll gain the
following:
● A Solid Grasp of Python Fundamentals: Master
core concepts like variables, data types, operators,
control flow, functions, and more.
● Problem-Solving Skills: Develop the ability to
break down complex tasks into smaller, manageable
steps - a valuable skill for both programming and
life in general.
● Logical Thinking: Learn to think like a
programmer, approaching problems with a
structured and logical mindset.
● Coding Confidence: As you conquer each
challenge, your confidence as a programmer will
soar. You'll look at problems with a new perspective,
knowing you have the tools to tackle them head-on.
● A Strong Foundation for Future Learning: This
book is just the beginning! By mastering the basics,
you'll be well-equipped to delve deeper into more
advanced Python topics.
Ready to Unleash Your Python Power?
This book is an invitation to an exciting adventure into the
world of Python coding. Whether you're a student, a
professional looking to expand your skill set, or simply
someone curious about programming, these challenges are
for you. So, grab your keyboard, open this book, and get
ready to embark on a journey that will transform you from a
Python novice to a confident coder!
Chapter 1
Welcome to the World of Python!
Python, renowned for its simplicity and readability, is a
robust and adaptable programming language. Whether
you're a complete beginner or an experienced programmer,
Python offers a wide range of applications, from web
development and data analysis to artificial intelligence and
scientific computing.
This book serves as your gateway to mastering Python
through a series of 80+ coding challenges designed
specifically for beginners. Each challenge is carefully crafted
to introduce fundamental concepts and reinforce your
understanding of Python syntax and programming
principles.
Let's dive into the world of Python by exploring some of the
key features and benefits of this remarkable language:
1. Readable and Expressive Syntax: Python's syntax is
designed to be clear and concise, making it easy to write
and understand code. With its use of indentation for block
structure, Python promotes clean and organized code that is
easy to maintain.
```python
# Example of Python's readable syntax
if x > 5:
print("x is greater than 5")
else:
"Display the statement 'x is less than or equal to 5'."
```
2. Extensive Standard Library: Python comes with a rich
standard library that provides a wide range of modules and
functions for various tasks, such as file I/O, networking, and
data manipulation. This extensive library allows you to
accomplish complex tasks with minimal effort.
```python
# Example of using the math module for mathematical
operations
import math
radius = 5
area = math.pi * radius ** 2
print("Area of the circle:", area)
```
3. Cross-Platform Compatibility: Python is cross-
platform, allowing Python code to execute seamlessly across
various operating systems without any adjustments.
Whether you're using Windows, macOS, or Linux, Python
offers consistent behavior across platforms.
```python
# Example of cross-platform compatibility
import os
os_name = os.name
print("Operating system:", os_name)
```
4. Large and Active Community: Python has a vibrant
community of developers who contribute to its growth and
development. You'll find a wealth of resources, including
documentation, tutorials, forums, and libraries, to support
your learning journey and help you solve challenges.
```python
# Example of accessing community resources
# Visit the official Python website for documentation and
tutorials
python_docs_url = "https://docs.python.org/3/"
print("Python Documentation:", python_docs_url)
# Join online forums like Stack Overflow to ask questions
and seek help
stack_overflow_url = "https://stackoverflow.com/"
print("Stack Overflow:", stack_overflow_url)
```
5. Versatility and Scalability: Python is a versatile
language that can be used for a wide range of applications,
from simple scripting tasks to complex software
development projects. Its scalability makes it suitable for
projects of any size, whether you're building a small utility
or a large-scale enterprise application.
```python
# Example of using Python for web development with Flask
from flask import Flask
app = Flask(__name__)
@app.route("/")
def hello():
return "Welcome to Python!"
if __name__ == "__main__":
app.run()
```
Throughout this book, you'll embark on a journey of
discovery as you tackle a variety of coding challenges that
progressively build your Python skills. Each challenge
presents a problem to solve and encourages you to apply
what you've learned to find a solution.
Are you prepared to begin this thrilling journey? Let's begin
our exploration of Python and unleash the power of
programming together!
Chapter 2
Setting Up Your Python Environment
Before diving into the world of Python coding challenges, it's
essential to set up your Python environment. In this guide,
we'll walk you through the process of installing Python and
essential tools to ensure you're ready to tackle the
challenges ahead.
1. Installing Python:
The initial action involves installing Python on your device.
Python is accessible across various platforms such as
Windows, macOS, and Linux. Follow these steps to install
Python:
● Visit the official Python website at
https://www.python.org/.
● Go to the Downloads area and select the suitable
installer for your OS.
● Download the installer and follow the on-screen
instructions to complete the installation process.
After installing Python, you can confirm the installation by
opening a command prompt or terminal and entering the
command `python --version`. This command will show the
installed Python version.
2. Setting Up a Code Editor:
While Python code can be written in any text editor, using a
code editor with features like syntax highlighting and code
completion can enhance your coding experience. Here are
some popular code editors for Python:
● Visual Studio Code: A lightweight and versatile
code editor with built-in support for Python
development.
● PyCharm: A powerful IDE specifically designed for
Python development, offering advanced features
like code analysis and debugging.
● Atom: A customizable text editor with a rich
ecosystem of packages for Python development.
Choose the code editor that best suits your preferences and
install it on your system.
3. Installing Additional Packages:
Python's extensive ecosystem includes thousands of third-
party packages that extend its functionality for various
tasks. While many challenges may not require additional
packages, some may benefit from libraries like NumPy for
numerical computations or requests for HTTP requests.
You can install Python packages using the `pip` package
manager, which comes bundled with Python. To install a
package, open a command prompt or terminal and type `pip
install package_name`.
As an illustration, to install NumPy, you'd execute:
```bash
pip install numpy
```
4. Creating a Virtual Environment:
It's good practice to create a virtual environment for each
Python project to manage dependencies and isolate project
environments. Virtual environments prevent conflicts
between different project dependencies and ensure
consistency across environments.
To create a virtual environment, navigate to your project
directory in a command prompt or terminal and run the
following command:
```bash
python -m venv venv_name
```
Substitute `venv_name` with the preferred name for your
virtual environment. Activate the virtual environment by
executing the suitable command for your operating system:
- On Windows:
```bash
venv_name\Scripts\activate
```
- On macOS/Linux:
```bash
source venv_name/bin/activate
```
Once activated, you'll see the virtual environment name in
your command prompt or terminal, indicating that you're
working within the virtual environment.
With your Python environment set up, you're now ready to
embark on your journey of Python coding challenges. Stay
tuned for the next installment, where we'll dive into the first
set of challenges designed to build your Python skills from
the ground up. Happy coding!
Chapter 3
Basic Python Syntax: Variables, Data Types,
Operators, and Expressions
In this guide, we'll cover the fundamental aspects of Python
syntax, including variables, data types, operators, and
expressions. These concepts form the building blocks of any
Python program and are essential for understanding and
solving coding challenges effectively.
1. Variables:
In Python, variables are employed to retain data values. You
can conceptualize a variable as a named repository that
holds a value. Python variables have the capability to store
a range of data types, encompassing numbers, strings, lists,
dictionaries, and beyond.
In Python, initializing a variable involves assigning a value
to a name utilizing the `=` operator. Here's an example:
```python
# Declaring variables
x = 10
name = "John"
is_student = True
```
In this example, `x`, `name`, and ìs_student` are variables
storing an integer, a string, and a boolean value,
respectively.
2. Data Types:
Python supports several built-in data types, including:
● Integers: Whole numbers without decimal points,
e.g., `10`, `-5`, `1000`.
● Floats: Numbers with decimal points, e.g., `3.14`,
`-0.5`, `2.0`.
● Strings: Textual data enclosed in single or double
quotes, e.g., `"hello"`, `'Python'`, `"123"`.
● Booleans: Logical values representing True or
False.
● Lists: Ordered collections of items, e.g., `[1, 2, 3]`,
`["apple", "banana", "orange"]`.
● Tuples: Immutable ordered collections of items,
e.g., `(1, 2, 3)`, `("red", "green", "blue")`.
● Dictionaries: Unordered collections of key-value
pairs, e.g., `{"name": "John", "age": 30}`.
You have the option to utilize the `type()` function to
ascertain the data type of a variable:
```python
# Check data types
x = 10
print(type(x)) # Output: <class 'int'>
name = "John"
print(type(name)) # Output: <class 'str'>
is_student = True
print(type(is_student)) # Output: <class 'bool'>
```
3. Operators:
Operators are symbols that perform operations on
operands. Python supports various types of operators,
including arithmetic, comparison, assignment, logical, and
bitwise operators.
● Arithmetic Operators: Execute arithmetic
operations such as addition, subtraction,
multiplication, division, and so on.
```python
x = 10
y=5
print(x + y) # Addition: Output: 15
print(x - y) # Subtraction: Output: 5
print(x * y) # Multiplication: Output: 50
print(x / y) # Division: Output: 2.0
print(x % y) # Modulus: Output: 0
print(x ** y) # Exponentiation: Output: 100000
```
● Comparison Operators: Compare the values of
two operands and yield a boolean outcome.
```python
x = 10
y=5
print(x > y) # Greater than: Output: True
print(x < y) # Less than: Output: False
print(x == y) # Equal to: Output: False
print(x != y) # Not equal to: Output: True
print(x >= y) # Greater than or equal to: Output: True
print(x <= y) # Less than or equal to: Output: False
```
● Assignment Operators: Assign values to
variables.
```python
x = 10
y=5
x += y # Equivalent to x = x + y
print(x) # Output: 15
y -= 2 # Equivalent to y = y - 2
print(y) # Output: 3
```
● Logical Operators: Perform logical operations on
boolean values.
```python
x = True
y = False
print(x and y) # Logical AND: Output: False
print(x or y) # Logical OR: Output: True
print(not x) # Logical NOT: Output: False
```
● Bitwise Operators: Perform bitwise operations on
binary numbers.
```python
x = 5 # 101 in binary
y = 3 # 011 in binary
print(x & y) # Bitwise AND: Output: 1 (001 in binary)
print(x | y) # Bitwise OR: Output: 7 (111 in binary)
print(x ^ y) # Bitwise XOR: Output: 6 (110 in binary)
print(~x) # Bitwise NOT: Output: -6 (-110 in binary)
print(x << 1) # Left shift by 1: Output: 10 (1010 in binary)
print(x >> 1) # Right shift by 1: Output: 2 (10 in binary)
```
4. Expressions:
An expression is a combination of variables, values, and
operators that evaluates to a single value. Python
expressions can be simple or complex, depending on the
number of operands and operators involved.
```python
# Simple expression
result = 5 + 3 * 2
print(result) # Output: 11
# Complex expression
x = 10
y=5
result = (x + y) * (x - y)
print(result) # Output: 75
```
In this tutorial, we've addressed the fundamental syntax of
Python, encompassing variables, data types, operators, and
expressions. Understanding these fundamental concepts is
crucial for mastering Python programming and solving
coding challenges effectively. Stay tuned for more guides
and coding challenges as you continue your Python journey!
Chapter 4
Control Flow Statements: Decision-making with
if/else and Looping with for/while
Control flow statements are essential in programming as
they allow you to control the execution flow of your code
based on certain conditions or iterate over a sequence of
elements. In Python, control flow statements include
decision-making constructs like if/else and looping
constructs like for/while. In this guide, we'll explore these
concepts and how they can be used to solve coding
challenges effectively.
1. Decision-making with if/else:
The if/else statement is used to make decisions in Python
based on certain conditions. It allows you to execute a block
of code if a condition is true and another block of code if the
condition is false.
```python
# Example of if/else statement
x = 10
if x > 5:
else:
Output the statement "x is less than or equal to 5"
```
In this instance, should the value of `x` surpass 5, the
phrase "x is greater than 5" will be displayed. Alternatively,
if the value is 5 or less, the phrase "x is less than or equal to
5" will be displayed.
You can also use the èlif` (else if) statement to check
additional conditions:
```python
# Example of if/elif/else statement
x = 10
if x > 10:
elif x == 10:
print("x is equal to 10")
else:
print("x is less than 10")
```
In this example, if the value of `x` is greater than 10, the
first condition will be executed. If `x` is equal to 10, the
second condition will be executed. Alternatively, the code
within the else block will be executed.
2. Looping with for/while:
Looping constructs allow you to execute a block of code
repeatedly. Python facilitates two primary types of loops: for
loops and while loops.
For Loops:
A for loop is used to iterate over a sequence of elements,
such as lists, tuples, or strings.
```python
# Example of for loop
fruits = ["apple", "banana", "orange"]
for fruit in fruits:
print(fruit)
```
In this example, the for loop iterates over each element in
the list `fruits` and prints each element.
You can also use the `range()` function to generate a
sequence of numbers to iterate over:
```python
# Example of using range() with for loop
for i in range(5):
print(i)
```
This loop will print the numbers from 0 to 4.
While Loops:
A while loop is employed to execute a block of code
repeatedly as long as a condition remains true.
```python
# Example of while loop
x=0
while x < 5:
print(x)
x += 1
```
In this example, the while loop will continue executing as
long as the value of `x` is less than 5. It will print the value
of `x` and then increment it by 1 in each iteration.
3. Combining Control Flow Statements:
You can combine decision-making constructs with looping
constructs to create more complex control flow structures.
```python
# Example of combining if/else with for loop
numbers = [1, 2, 3, 4, 5]
for num in numbers:
if num % 2 == 0:
print(num, "is even")
else:
print(num, "is odd")
```
In this example, the for loop iterates over each number in
the list `numbers`. If the number is even (i.e., the remainder
of dividing by 2 is 0), it prints that the number is even. If
not, it will output that the number is odd.
4. Control Flow in Coding Challenges:
Control flow statements play a crucial role in solving coding
challenges. They allow you to manipulate data and control
the flow of execution to meet the requirements of the
problem.
For example, consider a coding challenge where you need to
find the sum of all even numbers in a given list:
```python
# Example of using control flow in a coding challenge
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
sum_of_evens = 0
for num in numbers:
if num % 2 == 0:
sum_of_evens += num
print("Sum of even numbers:", sum_of_evens)
```
In this solution, we use a for loop to iterate over each
number in the list `numbers`. We then use an if statement
to check if the number is even, and if it is, we add it to the
variable `sum_of_evens`. Finally, we print the sum of all
even numbers.
Control flow statements are essential tools in Python
programming for making decisions and iterating over data.
By mastering these concepts, you'll be better equipped to
tackle a wide range of coding challenges and solve them
efficiently. Stay tuned for more coding challenges and
guides as you continue your Python journey!
Chapter 5
Functions: Defining and Calling Functions
Functions are a fundamental concept in Python
programming that allow you to encapsulate reusable pieces
of code. They help you organize your code, make it more
readable, and avoid repetition. In this guide, we'll explore
how to define and call functions in Python, and how they
can be used to solve coding challenges effectively.
1. Defining Functions:
To define a function in Python, you use the `def` keyword
followed by the function name and parentheses containing
any parameters the function accepts. You then write the
code block that defines what the function does.
```python
# Example of defining a function
def greet(name):
print("Hello, " + name + "!")
```
In this example, we define a function named `greet` that
accepts one parameter `name`. Inside the function, we print
a greeting message using the provided name.
You can also specify default parameter values for a function:
```python
# Example of defining a function with default parameter
values
def greet(name="World"):
print("Hello, " + name + "!")
```
In this case, if no value is provided for the `name`
parameter when calling the function, it defaults to
`"World"`.
2. Calling Functions:
To call a function in Python, you simply use the function
name followed by parentheses containing any arguments
you want to pass to the function.
```python
# Example of calling a function
greet("Alice") # Output: Hello, Alice!
```
In this example, we call the `greet` function with the
argument `"Alice"`, which will print the greeting message
"Hello, Alice!".
3. Returning Values:
Functions can also return values using the `return`
statement. This allows you to compute a result within the
function and return it to the caller.
```python
# Example of a function that returns a value
def add(a, b):
return a + b
result = add(3, 5)
print("The sum is:", result) # Output: The sum is: 8
```
In this example, the àdd` function takes two parameters
à` and `b`, adds them together, and returns the result. We
then assign the return value of the function to the variable
`result` and print it.
4. Using Functions in Coding Challenges:
Functions are incredibly useful in coding challenges as they
allow you to encapsulate specific functionality and reuse it
multiple times. Let's consider an example where you need
to find the factorial of a given number:
```python
# Example of using a function to find the factorial of a
number
def factorial(n):
result = 1
for i in range(1, n + 1):
result *= i
return result
number = 5
print("Factorial of", number, "is:", factorial(number)) #
Output: Factorial of 5 is: 120
```
In this solution, we define a function named `factorial` that
takes one parameter `n`. Inside the function, we initialize a
variable `result` to 1 and use a for loop to iterate from 1 to
`n`, multiplying each iteration's value to `result`. Finally, we
return the `result`, which represents the factorial of `n`.
By using functions, we encapsulate the factorial calculation
logic, making the code more readable and reusable. We can
call the `factorial` function with different numbers to find
their factorials without rewriting the factorial calculation
code each time.
Functions are essential building blocks of Python
programming that help you organize and structure your
code. By defining and calling functions, you can create
modular and reusable code that is easier to understand and
maintain. Stay tuned for more coding challenges and guides
as you continue your Python journey!
Chapter 6
Putting Your Skills to the Test: Level 1
Challenges (Basic Concepts)
Section 1: Numbers and Strings
In this section, we'll explore challenges 1-10, which focus on
working with numbers, strings, and user input in Python.
These challenges are designed to help beginners
understand the basic concepts of handling numerical data,
manipulating strings, and interacting with users through
input/output operations.
Challenge 1: Sum of Two Numbers
Create a Python script that asks the user to input two
numbers and computes their total.
```python
# Challenge 1: Sum of Two Numbers
num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))
sum = num1 + num2
print("Sum:", sum)
```
This program requests the user to input two numbers,
converts them into floating-point numbers, computes their
sum, and subsequently displays the result.
Challenge 2: Area of a Rectangle
Write a Python program that calculates the area of a
rectangle given its length and width.
```python
# Challenge 2: Area of a Rectangle
length = float(input("Enter the length of the rectangle: "))
width = float(input("Enter the width of the rectangle: "))
area = length * width
print("Area of the rectangle:", area)
```
This program prompts the user to enter the length and
width of a rectangle, calculates its area, and then prints the
result.
Challenge 3: Volume of a Cylinder
Write a Python program that calculates the volume of a
cylinder given its radius and height.
```python
# Challenge 3: Volume of a Cylinder
import math
radius = float(input("Please input the cylinder's radius: "))
height = float(input("Enter the height of the cylinder: "))
The volume is calculated as the product of π, the square of
the radius, and the height.
print("Volume of the cylinder:", volume)
```
This program prompts the user to enter the radius and
height of a cylinder, calculates its volume using the formula
πr²h, and then prints the result.
Challenge 4: String Concatenation
Write a Python program that prompts the user to enter two
strings and concatenates them together.
```python
# Challenge 4: String Concatenation
string1 = input("Enter the first string: ")
string2 = input("Enter the second string: ")
concatenated_string = string1 + string2
print("Concatenated string:", concatenated_string)
```
This program prompts the user to enter two strings,
concatenates them together, and then prints the result.
Challenge 5: Reverse a String
Write a Python program that prompts the user to enter a
string and then prints the reverse of that string.
```python
# Challenge 5: Reverse a String
string = input("Enter a string: ")
reversed_string = string[::-1]
print("Reversed string:", reversed_string)
```
This program prompts the user to enter a string, reverses
the string using slicing, and then prints the result.
Challenge 6: Count Vowels in a String
string and counts the number of vowels (a, e, i, o, u) in that
string.
```python
# Challenge 6: Count Vowels in a String
count = 0
for char in string:
if char.lower() in 'aeiou':
count += 1
print("Number of vowels:", count)
```
This program prompts the user to enter a string, iterates
through each character in the string, checks if it's a vowel,
and increments a counter if it is. Lastly, it displays the
overall count of vowels.
Challenge 7: Check if a Number is Even or Odd
number and checks if it's even or odd.
```python
# Challenge 7: Check if a Number is Even or Odd
number = int(input("Enter a number: "))
if number % 2 == 0:
print("Even")
else:
print("Odd")
```
This program prompts the user to enter a number, checks if
it's divisible by 2 (i.e., even), and prints the result
accordingly.
Challenge 8: Find the Maximum of Two Numbers
numbers and finds the maximum of the two.
```python
# Challenge 8: Find the Maximum of Two Numbers
num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))
maximum = max(num1, num2)
print("Maximum:", maximum)
```
This program prompts the user to enter two numbers, uses
the `max()` function to find the maximum of the two, and
then prints the result.
Challenge 9: Check if a Number is Prime
number and checks if it's a prime number.
```python
# Challenge 9: Check if a Number is Prime
if number > 1:
for i in range(2, int(math.sqrt(number)) + 1):
if number % i == 0:
print("Not Prime")
break
else:
print("Prime")
else:
print("Not Prime")
```
This program prompts the user to enter a number, iterates
through all numbers from 2 to the square root of the
number, and checks if any of them divide the number
evenly. If not, it's considered a prime number.
Challenge 10: Fibonacci Series
Write a Python program that prints the Fibonacci series up
to a specified number of terms.
```python
# Challenge 10: Fibonacci Series
num_terms = int(input("Please provide the number of
terms: "))
first_term = 0
second_term = 1
print("Fibonacci Series:")
for i in range(num_terms):
print(first_term, end=" ")
next_term = first_term + second_term
first_term = second_term
second_term = next_term
```
This program prompts the user to enter the number of
terms in the Fibonacci series, initializes the first two terms
as 0 and 1, and then iterates to generate the subsequent
terms based on the sum of the previous two terms.
These challenges provide a solid foundation for working with
numbers, strings, and user input in Python. By
understanding these concepts and practicing them in coding
challenges, beginners can gain confidence and proficiency
in Python programming. Stay tuned for more challenges and
Section 2: Control Flow
In this section, we'll explore challenges 11-20, which focus
on using conditional statements and loops in various
scenarios. Control flow statements such as if/else and loops
like for/while are crucial for controlling the flow of execution
in a Python program. These challenges will help beginners
understand how to use these constructs effectively to solve
a variety of problems.
Challenge 11: Check Leap Year
year and checks if it's a leap year.
```python
# Challenge 11: Check Leap Year
year = int(input("Enter a year: "))
if (year % 4 == 0 and year % 100 != 0) or (year % 400 ==
0):
print("Leap Year")
else:
print("Not a Leap Year")
```
This program prompts the user to enter a year, checks if it's
divisible by 4 and not divisible by 100, or if it's divisible by
400. If either condition is true, it's considered a leap year.
Challenge 12: Print Multiplication Table
number and prints its multiplication table up to a specified
range.
```python
# Challenge 12: Print Multiplication Table
range_limit = int(input("Enter the range limit: "))
print("Multiplication Table for", number, ":")
for i in range(1, range_limit + 1):
print(number, "x", i, "=", number * i)
```
This program prompts the user to enter a number and a
range limit, then iterates from 1 to the range limit and prints
the multiplication table for the given number.
Challenge 13: Check Palindrome
string and checks if it's a palindrome.
```python
# Challenge 13: Check Palindrome
if string == string[::-1]:
print("Palindrome")
else:
print("Not a Palindrome")
```
This program prompts the user to enter a string, reverses
the string using slicing, and then checks if the original string
is equal to its reverse.
Challenge 14: Find Factorial
number and finds its factorial.
```python
# Challenge 14: Find Factorial
factorial = 1
for i in range(1, number + 1):
factorial *= i
print("Factorial:", factorial)
```
This program prompts the user to enter a number and
calculates its factorial by multiplying all the numbers from 1
to the given number.
Challenge 15: Print Fibonacci Series
Write a Python program that prompts the user to enter the
number of terms and prints the Fibonacci series.
```python
# Challenge 15: Print Fibonacci Series
num_terms = int(input("Enter the number of terms: "))
first_term = 0
second_term = 1
```
This program prompts the user to enter the number of
terms in the Fibonacci series and prints the series up to that
number of terms.
Challenge 16: Check Armstrong Number
number and checks if it's an Armstrong number.
```python
# Challenge 16: Check Armstrong Number
original_number = number
num_digits = len(str(number))
sum = 0
while number > 0:
digit = number % 10
sum += digit ** num_digits
number //= 10
if sum == original_number:
print("Armstrong Number")
else:
print("Not an Armstrong Number")
```
This program prompts the user to enter a number,
calculates the sum of its digits raised to the power of the
number of digits, and checks if it's equal to the original
number.
Challenge 17: Find GCD
numbers and finds their greatest common divisor (GCD).
```python
# Challenge 17: Find GCD
import math
num1 = int(input("Enter the first number: "))
num2 = int(input("Enter the second number: "))
gcd = math.gcd(num1, num2)
print("GCD:", gcd)
```
This program prompts the user to enter two numbers and
uses the `gcd()` function from the `math` module to find
their greatest common divisor.
Challenge 18: Reverse a Number
number and prints its reverse.
```python
# Challenge 18: Reverse a Number
reverse = 0
while number > 0:
digit = number % 10
The variable "reverse" is updated by multiplying its
current value by 10 and then adding the value of "digit" to
it.
number //= 10
print("Reverse:", reverse)
```
This program prompts the user to enter a number,
iteratively extracts the digits from the number, and builds
the reverse number by appending each digit to the right of
the current reverse. Finally, it prints the reverse of the input
number.
Challenge 19: Print Pattern
Write a Python program that prompts the user to enter the
number of rows and prints a pattern.
```python
# Challenge 19: Print Pattern
rows = int(input("Enter the number of rows: "))
for i in range(1, rows + 1):
print("*" * i)
```
This program prompts the user to enter the number of rows
and prints a pattern of asterisks (*), where the number of
asterisks in each row increases by one from 1 to the
specified number of rows.
Challenge 20: Check Prime Number
number and checks if it's a prime number.
```python
# Challenge 20: Check Prime Number
if number > 1:
Iterate through the range starting from 2 up to the
square root of "number" plus 1.
if number % i == 0:
print("Not Prime")
break
else:
print("Prime")
else:
print("Not Prime")
```
This program prompts the user to enter a number, iterates
from 2 to the square root of the number, and checks if any
of the numbers divide the input number evenly. If not, the
number is considered prime.
These challenges provide practice in using conditional
statements and loops to solve various problems. By
understanding and mastering these constructs, beginners
can become proficient in controlling the flow of execution in
their Python programs. Stay tuned for more challenges and
Section 3: Functions
In this section, we'll delve into challenges 21-30, which
focus on defining and applying functions for code reusability.
Functions are a fundamental aspect of programming that
allow you to encapsulate a block of code and execute it
multiple times with different inputs. By defining functions,
you can modularize your code, improve readability, and
promote code reuse. Let's explore these challenges and see
how functions can be utilized effectively.
Challenge 21: Calculate Area of a Circle
Write a Python function that calculates the area of a circle
given its radius.
```python
# Challenge 21: Calculate Area of a Circle
import math
def calculate_area(radius):
return math.pi * radius ** 2
radius = float(input("Enter the radius of the circle: "))
print("Area of the circle:", calculate_area(radius))
```
In this challenge, we define a function `calculate_area()`
that takes the radius of the circle as input and returns its
area. We then prompt the user to enter the radius and call
the function to calculate and print the area.
Challenge 22: Check Even or Odd
Create a Python function to determine whether a provided
number is even or odd.
```python
# Challenge 22: Check Even or Odd
def check_even_odd(number):
if number % 2 == 0:
return "Even"
else:
return "Odd"
print(check_even_odd(number))
```
Here, we define a function `check_even_odd()` that takes a
number as input and returns "Even" if the number is even,
and "Odd" otherwise. We then prompt the user to enter a
number and call the function to check and print whether it's
even or odd.
Challenge 23: Convert Celsius to Fahrenheit
Develop a Python function to convert a temperature from
Celsius to Fahrenheit.
```python
# Challenge 23: Convert Celsius to Fahrenheit
def celsius_to_fahrenheit(celsius):
return (celsius * 9/5) + 32
celsius = float(input("Please input the temperature in
Celsius: "))
print("Temperature in Fahrenheit:",
celsius_to_fahrenheit(celsius))
```
In this challenge, we define a function
`celsius_to_fahrenheit()` that takes a temperature in Celsius
as input and returns its equivalent in Fahrenheit. We prompt
the user to enter the temperature in Celsius and call the
function to convert and print the temperature in Fahrenheit.
Challenge 24: Check Palindrome
Create a Python function to verify whether a provided string
is a palindrome.
```python
# Challenge 24: Check Palindrome
def check_palindrome(string):
return string == string[::-1]
if check_palindrome(string):
print("Palindrome")
else:
print("Not a Palindrome")
```
Here, we define a function `check_palindrome()` that takes
a string as input and returns True if it's a palindrome (i.e.,
the same forwards and backwards), and False otherwise. We
prompt the user to enter a string and call the function to
check and print whether it's a palindrome.
Challenge 25: Calculate Factorial
Write a Python function that calculates the factorial of a
given number.
```python
# Challenge 25: Calculate Factorial
def calculate_factorial(number):
factorial = 1
Iterate through the range starting from 1 up to and
including "number".
factorial *= i
return factorial
print("Factorial:", calculate_factorial(number))
```
In this challenge, we define a function `calculate_factorial()`
that takes a number as input and returns its factorial. We
prompt the user to enter a number and call the function to
calculate and print its factorial.
Challenge 26: Find GCD
Write a Python function that finds the greatest common
divisor (GCD) of two numbers.
```python
# Challenge 26: Find GCD
import math
def find_gcd(num1, num2):
return math.gcd(num1, num2)
num1 = int(input("Enter the first number: "))
num2 = int(input("Enter the second number: "))
print("GCD:", find_gcd(num1, num2))
```
Here, we define a function `find_gcd()` that takes two
numbers as input and returns their greatest common divisor
using the `gcd()` function from the `math` module. We
prompt the user to enter two numbers and call the function
to find and print their GCD.
Challenge 27: Print Fibonacci Series
Write a Python function that prints the Fibonacci series up to
a specified number of terms.
```python
# Challenge 27: Print Fibonacci Series
def fibonacci_series(num_terms):
first_term, second_term = 0, 1
for _ in range(num_terms):
num_terms = int(input("Please input the number of terms:

"))
fibonacci_series(num_terms)
```
In this challenge, we define a function `fibonacci_series()`
that takes the number of terms as input and prints the
Fibonacci series up to that number of terms. We prompt the
user to enter the number of terms and call the function to
print the series.
Write a Python function that reverses a given string.
```python
# Challenge 28: Reverse a String
def reverse_string(string):
return string[::-1]
print("Reversed string:", reverse_string(string))
```
In this section, we establish a function called
`reverse_string()` which accepts a string as an argument
and yields its reverse through slicing. We prompt the user to
enter a string and call the function to reverse and print the
string.
Challenge 29: Check Armstrong Number
Create a Python function to determine whether a provided
number is an Armstrong number.
```python
# Challenge 29: Check Armstrong Number
def check_armstrong(number):
num_digits = len(str(number))
sum = 0
temp = number
while temp > 0:
digit = temp % 10
temp //= 10
return sum == number
if check_armstrong(number):
else:
print("Not an Armstrong Number")
```
In this challenge, we define a function `check_armstrong()`
that takes a number as input and returns True if it's an
Armstrong number (i.e., the sum of its digits raised to the
power of the number of digits is equal to the original
number), and False otherwise. We prompt the user to enter
a number and call the function to check and print whether
it's an Armstrong number.
Challenge 30: Print Pattern
Write a Python function that prints a pattern based on the
number of rows specified.
```python
# Challenge 30: Print Pattern
def print_pattern(rows):
print("*" * i)
rows = int(input("Enter the number of rows: "))
print_pattern(rows)
```
Here, we define a function `print_pattern()` that takes the
number of rows as input and prints a pattern of asterisks (*),
where the number of asterisks in each row increases by one
from 1 to the specified number of rows. We prompt the user
to enter the number of rows and call the function to print
the pattern.
These challenges demonstrate the power and versatility of
functions in Python programming. By defining and applying
functions effectively, you can modularize your code,
improve its readability, and promote code reusability. As you
continue your journey in Python programming, mastering
functions will be essential for writing efficient and
maintainable code. Stay tuned for more challenges and
guides as you enhance your Python skills!
Chapter 7
Deepening Your Knowledge: Level 2 Challenges
(Intermediate Concepts)
Section 1: Lists and Tuples
on creating, manipulating, and utilizing lists and tuples in
Python. Lists and tuples are fundamental data structures
that allow you to store and manipulate collections of items.
They offer various operations for accessing, modifying, and
iterating over the elements they contain. Let's delve into
these challenges and see how lists and tuples can be used
effectively.
Challenge 31: Create a List
Write a Python program that creates a list of numbers
entered by the user.
```python
# Challenge 31: Create a List
numbers = input("Enter numbers separated by space:
").split()
numbers = [int(num) for num in numbers]
print("List of numbers:", numbers)
```
In this challenge, we prompt the user to enter numbers
separated by space, split the input string into a list of
strings, and then convert each string to an integer using a
list comprehension.
Challenge 32: Access Elements of a List
Write a Python program that accesses and prints the first
and last elements of a given list.
```python
# Challenge 32: Access Elements of a List
def access_elements(lst):
print("First element:", lst[0])
print("Last element:", lst[-1])
numbers = [1, 2, 3, 4, 5]
access_elements(numbers)
```
Here, we define a function àccess_elements()` that takes a
list as input and prints its first and last elements using list
indexing.
Challenge 33: Append Element to List
Write a Python program that appends a new element to the
end of a given list.
```python
# Challenge 33: Append Element to List
def append_element(lst, element):
lst.append(element)
return lst
numbers = [1, 2, 3, 4, 5]
new_element = 6
print("Updated list:", append_element(numbers,
new_element))
```
This program defines a function àppend_element()` that
takes a list and an element as input, appends the element
to the end of the list, and returns the updated list.
Challenge 34: Insert Element into List
Write a Python program that inserts a new element at a
specified index in a given list.
```python
# Challenge 34: Insert Element into List
def insert_element(lst, index, element):
lst.insert(index, element)
return lst
numbers = [1, 2, 3, 5]
new_element = 4
index = 3
print("Updated list:", insert_element(numbers, index,
new_element))
```
Here, we define a function ìnsert_element()` that takes a
list, an index, and an element as input, inserts the element
at the specified index in the list, and returns the updated
list.
Challenge 35: Remove Element from List
Write a Python program that removes a specified element
from a given list.
```python
# Challenge 35: Remove Element from List
def remove_element(lst, element):
if element in lst:
lst.remove(element)
return lst
else:
return "Element not found in the list"
numbers = [1, 2, 3, 4, 5]
element_to_remove = 3
print("Updated list:", remove_element(numbers,
element_to_remove))
```
This program defines a function `remove_element()` that
takes a list and an element as input, removes the element
from the list if it exists, and returns the updated list.
Challenge 36: Count Occurrences in List
Write a Python program that counts the occurrences of a
specified element in a given list.
```python
# Challenge 36: Count Occurrences in List
def count_occurrences(lst, element):
return list.count(element)
numbers = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4,5,5,5,5,5]
element_to_count = 3
print("Occurrences of", element_to_count, "in the list:",
count_occurrences(numbers, element_to_count))
```
Here, we define a function `count_occurrences()` that takes
a list and an element as input and returns the number of
occurrences of the element in the list.
Challenge 37: Reverse a List
Write a Python program that reverses a given list.
```python
# Challenge 37: Reverse a List
def reverse_list(lst):
return lst[::-1]
numbers = [1, 2, 3, 4, 5]
print("Reversed list:", reverse_list(numbers))
```
This program defines a function `reverse_list()` that takes a
list as input and returns its reverse using list slicing.
Challenge 38: Sort List
Write a Python program that sorts a given list in ascending
order.
```python
# Challenge 38: Sort List
def sort_list(lst):
return sorted(lst)
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3,4,3]
print("Sorted list:", sort_list(numbers))
```
Here, we define a function `sort_list()` that takes a list as
input, sorts it in ascending order using the `sorted()`
function, and returns the sorted list.
Challenge 39: Create a Tuple
Write a Python program that creates a tuple of numbers
```python
# Challenge 39: Create a Tuple
numbers = tuple(input("Enter numbers separated by space:
").split())
numbers = tuple(map(int, numbers))
print("Tuple of numbers:", numbers)
```
In this challenge, we prompt the user to enter numbers
separated by space, split the input string into a list of
strings, and then convert each string to an integer using the
`map()` function. Lastly, we transform the list into a tuple.
Challenge 40: Access Elements of a Tuple
Write a Python program that accesses and prints the first
and last elements of a given tuple.
```python
# Challenge 40: Access Elements of a Tuple
def access_elements(tup):
print("First element:", tup[0])
print("Last element:", tup[-1])
numbers = (1, 2, 3, 4, 5)
access_elements(numbers)
```
This program defines a function àccess_elements()` that
takes a tuple as input and prints its first and last elements
using tuple indexing.
These challenges demonstrate various operations and
manipulations that can be performed on lists and tuples in
Python. By mastering these concepts, you can effectively
manage collections of data in your Python programs. Stay
tuned for more challenges and guides as you continue your
Python journey!
Section 2: Dictionaries
on working with key-value pairs and utilizing dictionary
functionality in Python. Dictionaries are versatile data
structures that allow you to store and manipulate data in
the form of key-value pairs. They offer various operations for
accessing, modifying, and iterating over the elements they
contain. Let's delve into these challenges and see how
dictionaries can be used effectively.
Challenge 41: Create a Dictionary
Write a Python program that creates a dictionary from user
input, where keys are names and values are ages.
```python
# Challenge 41: Create a Dictionary
names = input("Enter names separated by space: ").split()
ages = input("Enter ages separated by space: ").split()
ages_dict = {name: int(age) for name, age in zip(names,
ages)}
print("Dictionary:", ages_dict)
```
In this challenge, we prompt the user to enter names and
ages separated by space, split the input strings into lists of
strings, and then create a dictionary using a dictionary
comprehension.
Challenge 42: Access Elements of a Dictionary
Write a Python program that accesses and prints the value
associated with a specified key in a given dictionary.
```python
# Challenge 42: Access Elements of a Dictionary
def access_element(dictionary, key):
return dictionary.get(key, "Key not found")
ages_dict = {'Alice': 25, 'Bob': 30, 'Charlie': 35}
key_to_access = 'Bob'
print("Value associated with", key_to_access, ":",
access_element(ages_dict, key_to_access))
```
Here, we define a function àccess_element()` that takes a
dictionary and a key as input and returns the value
associated with the key using the `get()` method.
Challenge 43: Add Element to a Dictionary
Write a Python program that adds a new key-value pair to a
given dictionary.
```python
# Challenge 43: Add Element to a Dictionary
def add_element(dictionary, key, value):
dictionary[key] = value
return dictionary
new_key = 'David'
new_value = 40
print("Updated dictionary:", add_element(ages_dict,
new_key, new_value))
```
This program defines a function àdd_element()` that takes
a dictionary, a key, and a value as input, adds the key-value
pair to the dictionary, and returns the updated dictionary.
Challenge 44: Remove Element from a Dictionary
Write a Python program that removes a specified key-value
pair from a given dictionary.
```python
# Challenge 44: Remove Element from a Dictionary
def remove_element(dictionary, key):
if key in dictionary:
del dictionary[key]
return dictionary
else:
return "Key not found in the dictionary"
key_to_remove = 'Bob'
print("Updated dictionary:", remove_element(ages_dict,
key_to_remove))
```
Here, we define a function `remove_element()` that takes a
dictionary and a key as input, removes the key-value pair
from the dictionary if the key exists, and returns the
updated dictionary.
Challenge 45: Update Element in a Dictionary
Write a Python program that updates the value associated
with a specified key in a given dictionary.
```python
# Challenge 45: Update Element in a Dictionary
def update_element(dictionary, key, new_value):
if key in dictionary:
dictionary[key] = new_value
return dictionary
else:
return "Key not found in the dictionary"
key_to_update = 'Bob'
new_age = 32
print("Updated dictionary:", update_element(ages_dict,
key_to_update, new_age))
```
This program defines a function ùpdate_element()` that
takes a dictionary, a key, and a new value as input, updates
the value associated with the key in the dictionary if the key
exists, and returns the updated dictionary.
Challenge 46: Check if Key Exists
Write a Python program that checks if a specified key exists
in a given dictionary.
```python
# Challenge 46: Check if Key Exists
def check_key(dictionary, key):
return key in dictionary
key_to_check = 'Bob'
print("Key exists in the dictionary:", check_key(ages_dict,
key_to_check))
```
Here, we define a function `check_key()` that takes a
dictionary and a key as input and returns True if the key
exists in the dictionary, and False otherwise.
Challenge 47: Iterate Over Dictionary
Write a Python program that iterates over a given dictionary
and prints key-value pairs.
```python
# Challenge 47: Iterate Over Dictionary
def iterate_dictionary(dictionary):
for key, value in dictionary.items():
print(key, ":", value)
iterate_dictionary(ages_dict)
```
This program defines a function ìterate_dictionary()` that
takes a dictionary as input and iterates over its key-value
pairs using the ìtems()` method, printing each pair.
Challenge 48: Clear Dictionary
Write a Python program that clears all key-value pairs from
a given dictionary.
```python
# Challenge 48: Clear Dictionary
def clear_dictionary(dictionary):
dictionary.clear()
return dictionary
print("Cleared dictionary:", clear_dictionary(ages_dict))
```
Here, we define a function `clear_dictionary()` that takes a
dictionary as input, clears all key-value pairs from the
dictionary using the `clear()` method, and returns the
cleared dictionary.
Challenge 49: Copy Dictionary
Write a Python program that creates a shallow copy of a
given dictionary.
```python
# Challenge 49: Copy Dictionary
def copy_dictionary(dictionary):
return dictionary.copy()
copied_dict = copy_dictionary(ages_dict)
print("Copied dictionary:", copied_dict)
```
This program defines a function `copy_dictionary()` that
takes a dictionary as input, creates a shallow copy of the
dictionary using the `copy()` method, and returns the
copied dictionary.
Challenge 50: Merge Dictionaries
Write a Python program that merges two dictionaries into a
single dictionary.
```python
# Challenge 50: Merge Dictionaries
def merge_dictionaries(dict1, dict2):
merged_dict = dict1.copy()
merged_dict.update(dict2)
return merged_dict
ages_dict1 = {'Alice': 25, 'Bob': 30}
ages_dict2 = {'Charlie': 35, 'David': 40}
print("Merged dictionary:", merge_dictionaries(ages_dict1,
ages_dict2))
```
Here, we define a function `merge_dictionaries()` that takes
two dictionaries as input, creates a shallow copy of the first
dictionary, updates it with the key-value pairs from the
second dictionary using the ùpdate()` method, and returns
the merged dictionary.
These challenges demonstrate the versatility and
functionality of dictionaries in Python, showcasing how they
can be used to store and manipulate key-value pairs
efficiently. By mastering these concepts and practicing with
various challenges, beginners can develop a solid
understanding of dictionary operations and enhance their
skills in working with complex data structures. Stay tuned
for more challenges and guides as you continue your Python
journey!
Section 3: Files and Exception Handling
on reading, writing, and handling exceptions in Python
programs. Dealing with files and exceptions is crucial in
programming, as it allows you to interact with external data
sources and handle errors gracefully. Let's delve into these
challenges and see how files and exception handling can be
utilized effectively.
Challenge 51: Read from a File
Write a Python program that reads and prints the contents
of a text file.
```python
# Challenge 51: Read from a File
filename = input("Enter the name of the file: ")
try:
with open(filename, 'r') as file:
contents = file.read()
print("Contents of the file:")
print(contents)
except FileNotFoundError:
print("File not found.")
```
In this challenge, we prompt the user to enter the name of
the file, attempt to open the file in read mode, and then
read and print its contents. We handle the FileNotFoundError
exception in case the specified file does not exist.
Challenge 52: Write to a File
Write a Python program that writes user input to a text file.
```python
# Challenge 52: Write to a File
data = input("Enter data to write to the file: ")
try:
with open(filename, 'w') as file:
file.write(data)
print("Data written to the file successfully.")
except IOError:
print("Error writing to the file.")
```
Here, we prompt the user to enter the name of the file and
the data to write to the file. We then attempt to open the file
in write mode, write the data to the file, and handle the
IOError exception if there's an error writing to the file.
Challenge 53: Append to a File
Write a Python program that appends user input to an
existing text file.
```python
# Challenge 53: Append to a File
data = input("Enter data to append to the file: ")
try:
with open(filename, 'a') as file:
file.write(data)
print("Data appended to the file successfully.")
except IOError:
print("Error appending to the file.")
```
the file and the data to append to the file. We then attempt
to open the file in append mode, append the data to the file,
and handle the IOError exception if there's an error
appending to the file.
Challenge 54: Read and Write to a File
Write a Python program that reads from one text file and
writes its contents to another text file.
```python
# Challenge 54: Read and Write to a File
input_filename = input("Please provide the name of the
input file: ")
output_filename = input("Enter the name of the output file:
")
try:
with open(input_filename, 'r') as input_file,
open(output_filename, 'w') as output_file:
contents = input_file.read()
output_file.write(contents)
print("Data copied from", input_filename, "to",
output_filename, "successfully.")
except IOError:
print("Error reading from or writing to the file.")
```
Here, we prompt the user to enter the name of the input
and output files. We then attempt to open the input file in
read mode and the output file in write mode, read the
contents of the input file, write them to the output file, and
handle the FileNotFoundError and IOError exceptions as
necessary.
Challenge 55: Read and Display CSV File
Write a Python program that reads and displays the
contents of a CSV (Comma-Separated Values) file.
```python
# Challenge 55: Read and Display CSV File
import csv
filename = input("Please enter the name of the CSV file: ")
try:
with open(filename, 'r') as file:
reader = csv.reader(file)
print("Contents of the CSV file:")
for row in reader:
print(row)
```
the CSV file and attempt to open the file in read mode using
the csv module. We then read the file using a csv.reader
object and display its contents row by row, handling the
FileNotFoundError exception if necessary.
Challenge 56: Write to CSV File
Write a Python program that writes user input to a CSV
(Comma-Separated Values) file.
```python
# Challenge 56: Write to CSV File
import csv
filename = input("Please provide the name of the CSV file:
")
data = input("Please input data to be written to the CSV file
(separated by commas): ").split(',')
with open(filename, 'w', newline='') as file:
writer = csv.writer(file)
writer.writerow(data)
Output: "Data has been successfully written to the CSV
file."
except IOError:
print("Error writing to the CSV file.")
```
Here, we prompt the user to enter the name of the CSV file
and the data to write to the file (comma-separated). We
then attempt to open the file in write mode using the csv
module, create a csv.writer object, write the data to the file,
and handle the IOError exception if necessary.
Challenge 57: Read and Write JSON File
Write a Python program that reads from one JSON
(JavaScript Object Notation) file and writes its contents to
another JSON file.
```python
# Challenge 57: Read and Write JSON File
import json
input_filename = input("Enter the name of the input JSON
file: ")
output_filename = input("Please provide the name of the
output JSON file: ")
try:
with open(input_filename, 'r') as input_file,
open(output_filename, 'w') as output_file:
data = json.load(input_file)
json.dump(data, output_file, indent=4)
print("Data copied from", input_filename, "to",
output_filename, "successfully.")
except IOError:
print("Error reading from or writing to the file.")
```
In this challenge, we prompt the user to enter the names of
the input and output JSON files. We then attempt to open
the input file in read mode and the output file in write mode,
load the data from the input file using json.load(), dump the
data to the output file using json.dump(), and handle the
FileNotFoundError and IOError exceptions as necessary.
Challenge 58: Read and Display XML File
Write a Python program that reads and displays the
contents of an XML (eXtensible Markup Language) file.
```python
# Challenge 58: Read and Display XML File
import xml.etree.ElementTree as ET
filename = input("Enter the name of the XML file: ")
try:
tree = ET.parse(filename)
root = tree.getroot()
print("Contents of the XML file:")
for child in root:
print(ET.tostring(child, encoding='unicode',
method='xml'))
except ET.ParseError:
print("Error parsing the XML file.")
```
Here, we prompt the user to enter the name of the XML file
and attempt to parse the file using the
xml.etree.ElementTree module. We then iterate over the
root element and its children, printing each element's XML
representation using ET.tostring().
Challenge 59: Write to XML File
Write a Python program that writes user input to an XML
(eXtensible Markup Language) file.
```python
# Challenge 59: Write to XML File
import xml.etree.ElementTree as ET
root = ET.Element("data")
data = input("Enter data to write to the XML file: ")
child = ET.SubElement(root, "item")
child.text = data
tree = ET.ElementTree(root)
filename = input("Please provide the name of the XML file to
be written: ")
try:
tree.write(filename)
Output: "Data has been successfully written to the XML
file."
except IOError:
print("Error writing to the XML file.")
```
In this challenge, we create an XML element with the tag
"data" as the root element. We then prompt the user to
enter the data to write to the file, create a child element
with the tag "item" and the user input as its text content,
and add it as a child of the root element. Finally, we write
the XML tree to a file specified by the user and handle any
IOError that may occur.
Challenge 60: Exception Handling
Write a Python program that handles division by zero
exception gracefully.
```python
# Challenge 60: Exception Handling
try:
dividend = int(input("Enter the dividend: "))
divisor = int(input("Enter the divisor: "))
result = dividend / divisor
print("Result of division:", result)
except ValueError:
print("Please enter valid integers for dividend and
divisor.")
except ZeroDivisionError:
print("Cannot divide by zero.")
except Exception as e:
print("An error occurred:", e)
```
Here, we attempt to perform division based on user input for
the dividend and divisor. We handle the ValueError if the
user enters invalid integers, the ZeroDivisionError if the
divisor is zero, and any other exceptions using a generic
Exception handler.
These challenges showcase various file operations and
exception handling techniques in Python, essential for
building robust and reliable programs. By mastering these
concepts and practicing with different scenarios, beginners
can develop a solid understanding of file I/O and error
handling in Python programming. Stay tuned for more
challenges and guides as you continue your Python journey!
Chapter 8
Expanding Your Horizons: Level 3 Challenges
(Advanced Concepts)
Section 1: Modules and Packages
on importing and utilizing modules and packages for code
organization in Python. Modules and packages are essential
for organizing and modularizing code, allowing you to break
down large programs into smaller, manageable units. They
facilitate code reuse, maintainability, and scalability. Let's
delve into these challenges and see how modules and
packages can be utilized effectively.
Challenge 61: Import Module
Write a Python program that imports and utilizes functions
from a custom module named `math_operations.py`.
```python
# Challenge 61: Import Module
import math_operations
num1 = 10
num2 = 5
print("Sum:", math_operations.add(num1, num2))
print("Difference:", math_operations.subtract(num1, num2))
print("Product:", math_operations.multiply(num1, num2))
print("Quotient:", math_operations.divide(num1, num2))
```
In this challenge, we import the `math_operations` module
and use its functions àdd()`, `subtract()`, `multiply()`, and
`divide()` to perform basic arithmetic operations.
Challenge 62: Import Specific Functions
Write a Python program that imports specific functions from
the `math` module and calculates the square root of a given
number.
```python
# Challenge 62: Import Specific Functions
from math import sqrt
number = float(input("Enter a number: "))
if number >= 0:
print("Square root:", sqrt(number))
else:
Output: "Square root cannot be determined for negative
numbers."
```
Here, we import only the `sqrt()` function from the `math`
module and use it to calculate the square root of a number
Challenge 63: Import Module as Alias
Write a Python program that imports a module and assigns
it an alias for ease of use.
```python
# Challenge 63: Import Module as Alias
import math as m
radius = float(input("Enter the radius of the circle: "))
area = m.pi * (radius ** 2)
print("Area of the circle:", area)
```
In this challenge, we import the `math` module and assign
it the alias `m`. We then use the alias `m` to access the `pi`
constant for calculating the area of a circle.
Challenge 64: Import All Functions
Write a Python program that imports all functions from a
module for convenience.
```python
# Challenge 64: Import All Functions
from math_operations import *
num1 = 10
num2 = 5
print("Sum:", add(num1, num2))
print("Difference:", subtract(num1, num2))
print("Product:", multiply(num1, num2))
print("Quotient:", divide(num1, num2))
```
In this section, we import all functions from the
`math_operations` module utilizing the wildcard `*` and
invoke the functions directly without explicitly stating the
module name.
Challenge 65: Import Package
Write a Python program that imports and utilizes functions
from a custom package named `my_package`.
```python
# Challenge 65: Import Package
from my_package import module1, module2
print("Square of 5:", module1.square(5))
print("Cube of 5:", module2.cube(5))
```
In this challenge, we import specific modules `module1` and
`module2` from the `my_package` package and use their
functions to calculate the square and cube of a number,
respectively.
Challenge 66: Import Module from Package
Write a Python program that imports a module from a
package and utilizes its functions.
```python
# Challenge 66: Import Module from Package
from my_package import module1
```
Here, we import the `module1` module from the
`my_package` package and use its `square()` function to
calculate the square of a number.
Challenge 67: Import Package as Alias
Write a Python program that imports a package and assigns
it an alias for ease of use.
```python
# Challenge 67: Import Package as Alias
import my_package as mp
print("Square of 5:", mp.module1.square(5))
print("Cube of 5:", mp.module2.cube(5))
```
In this challenge, we import the `my_package` package and
assign it the alias `mp`. We then use the alias `mp` to
access the modules and their functions within the package.
Challenge 68: Import Module from Subpackage
Write a Python program that imports a module from a
subpackage and utilizes its functions.
```python
# Challenge 68: Import Module from Subpackage
from my_package.subpackage import module3
print("Factorial of 5:", module3.factorial(5))
```
Here, we import the `module3` module from the `sub
package` subpackage of the `my_package` package and
use its `factorial()` function to calculate the factorial of a
number.
Challenge 69: Import All Modules from Package
Write a Python program that imports all modules from a
package for convenience.
```python
# Challenge 69: Import All Modules from Package
from my_package import *
print("Cube of 5:", module2.cube(5))
print("Factorial of 5:", subpackage.module3.factorial(5))
```
In this challenge, we import all modules from the
`my_package` package using the wildcard `*` and directly
call the functions without specifying the module names.
Challenge 70: Handle Module Import Errors
Write a Python program that handles module import errors
gracefully.
```python
# Challenge 70: Handle Module Import Errors
try:
from non_existing_module import function
function()
except ImportError:
print("Module not found.")
```
Here, we attempt to import a function from a non-existent
module and handle the ImportError gracefully by printing a
descriptive error message.
These challenges showcase various techniques for
importing and utilizing modules and packages in Python,
essential for organizing and structuring code effectively. By
mastering these concepts, beginners can develop cleaner
and more modular code, improving code readability and
maintainability. Stay tuned for more challenges and guides
as you continue your Python journey!
Section 2: Object-Oriented Programming (OOP)
Fundamentals
Challenges 71-80: Introduction to classes, objects, and basic
OOP concepts.

on the fundamentals of Object-Oriented Programming (OOP)
in Python. Object-Oriented Programming is a powerful
paradigm that allows you to model real-world entities as
objects, which have attributes (variables) and methods
(functions) associated with them. By understanding OOP
concepts such as classes, objects, inheritance, and
encapsulation, you can write more organized, modular, and
reusable code. Let's delve into these challenges and see
how OOP can be utilized effectively.
Challenge 71: Create a Class
Write a Python program that defines a simple class named
`Car` with attributes for make, model, and year.
```python
# Challenge 71: Create a Class
class Car:
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
# Instantiate objects
car1 = Car("Toyota", "Corolla", 2022)
car2 = Car("Honda", "Civic", 2023)
```
In this challenge, we define a class `Car` with an `__init__()`
method to initialize its attributes `make`, `model`, and
`year`. We then instantiate two `Car` objects using different
parameters.
Challenge 72: Create Methods in a Class
Write a Python program that adds methods to the `Car`
class for displaying information about the car.
```python
# Challenge 72: Create Methods in a Class
class Car:
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
def display_info(self):
print("Car Information:")
print("Make:", self.make)
print("Model:", self.model)
print("Year:", self.year)
# Instantiate object
car = Car("Toyota", "Corolla", 2022)
car.display_info()
```
Here, we add a method `display_info()` to the `Car` class to
print information about the car, such as its make, model,
and year. We then instantiate a `Car` object and call the
`display_info()` method.
Challenge 73: Class Inheritance
Write a Python program that demonstrates inheritance by
creating a subclass ÈlectricCar` that inherits from the `Car`
class.
```python
# Challenge 73: Class Inheritance
class ElectricCar(Car):
def __init__(self, make, model, year, battery_size):
super().__init__(make, model, year)
self.battery_size = battery_size
def display_battery_info(self):
print("Battery Information:")
print("Battery Size:", self.battery_size, "kWh")
electric_car = ElectricCar("Tesla", "Model S", 2024, 100)
electric_car.display_info()
electric_car.display_battery_info()
```
In this challenge, we define a subclass ÈlectricCar` that
inherits from the `Car` class. We override the `__init__()`
method to include an additional attribute `battery_size` and
define a new method `display_battery_info()` to display
information about the battery. We then instantiate an
ÈlectricCar` object and call both the `display_info()` and
`display_battery_info()` methods.
Challenge 74: Encapsulation
Write a Python program that demonstrates encapsulation by
defining private attributes and using getter and setter
methods.
```python
# Challenge 74: Encapsulation
class Person:
def __init__(self, name, age):
self._name = name
self._age = age
def get_name(self):
return self._name
def set_age(self, age):
if age > 0:
self._age = age
else:
print("Invalid age")
person = Person("Alice", 30)
print("Name:", person.get_name())
person.set_age(35)
print("Age:", person._age)
```
Here, we define a class `Person` with private attributes
`_name` and `_age`. We provide getter and setter methods
`get_name()` and `set_age()` to access and modify these
attributes, respectively. We then instantiate a `Person`
object, retrieve the name using the getter method, and set
the age using the setter method.
Challenge 75: Polymorphism
Write a Python program that demonstrates polymorphism
by defining methods with the same name in different
classes.
```python
# Challenge 75: Polymorphism
class Dog:
def sound(self):
print("Woof")
class Cat:
def sound(self):
print("Meow")
# Function to produce sound
def make_sound(animal):
animal.sound()
dog = Dog()
cat = Cat()
# Polymorphic function calls
make_sound(dog)
make_sound(cat)
```
In this challenge, we define two classes `Dog` and `Cat`,
each with a `sound()` method. We also define a function
`make_sound()` that takes an animal object as input and
calls its `sound()` method. We then instantiate `Dog` and
`Cat` objects and call the `make_sound()` function with
each object, demonstrating polymorphic behavior.
Challenge 76: Abstract Base Classes
Write a Python program that demonstrates abstract base
classes by defining an abstract method in a base class and
implementing it in a subclass.
```python
# Challenge 76: Abstract Base Classes
from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self):
pass
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def area(self):
return 3.14 * self.radius ** 2
circle = Circle(5)
print("Area of the circle:", circle.area())
```
Here, we define an abstract base class `Shape` with an
abstract method àrea()`. We then define a subclass `Circle`
that implements the àrea()` method to calculate the area
of a circle based on its radius. We instantiate a `Circle`
object and call the àrea()` method to calculate the area.
Challenge 77: Operator Overloading
Write a Python program that demonstrates operator
overloading by defining methods to add and subtract
objects of a custom class.
```python
# Challenge 77: Operator Overloading
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __sub__(self, other):
return Point(self.x - other.x, self.y - other.y)
point1 = Point(5, 10)
point2 = Point(3, 7)
# Operator overloading
result_add = point1 + point2
result_sub = point1 - point2
print("Addition:", (result_add.x, result_add.y))
print("Subtraction:", (result_sub.x, result_sub.y))
```
In this challenge, we define a class `Point` with methods
`__add__()` and `__sub__()` to overload the addition and
subtraction operators, allowing objects of the `Point` class
to be added and subtracted. We then instantiate two `Point`
objects and perform addition and subtraction operations
using the overloaded operators.
Challenge 78: Class Methods
Write a Python program that demonstrates class methods
by defining a class method to create objects from
alternative constructors.
```python
# Challenge 78: Class Methods
class Employee:
def __init__(self, name, salary):
self.name = name
self.salary = salary
@classmethod
def from_string(cls, string):
name, salary = string.split(',')
return cls(name, int(salary))
# Alternative constructor
employee = Employee.from_string("Alice,50000")
print("Name:", employee.name)
print("Salary:", employee.salary)
```
Here, we define a class Èmployee` with a class method
`from_string()` that takes a string containing employee
information and creates an Èmployee` object using that
information. We then call the class method to create an
Èmployee` object from a string and print its attributes.
Challenge 79: Static Methods
Write a Python program that demonstrates static methods
by defining a static method to perform a generic operation
that does not depend on class or instance variables.
```python
# Challenge 79: Static Methods
class MathUtils:
@staticmethod
def add(x, y):
return x + y
@staticmethod
def subtract(x, y):
return x - y
# Static method calls
print("Sum:", MathUtils.add(5, 3))
print("Difference:", MathUtils.subtract(5, 3))
```
In this challenge, we define a class `MathUtils` with static
methods àdd()` and `subtract()` to perform addition and
subtraction operations. We then call these static methods
directly using the class name without instantiating objects.
Challenge 80: Use of Class Variables
Write a Python program that demonstrates the use of class
variables by defining a class with a class variable to keep
track of the number of instances created.
```python
# Challenge 80: Use of Class Variables
class Book:
num_instances = 0
def __init__(self, title):
self.title = title
Book.num_instances += 1
# Create instances
book1 = Book("Python Programming")
book2 = Book("Data Structures")
book3 = Book("Algorithms")
# Access class variable
print("Number of instances created:", Book.num_instances)
```
Here, we define a class `Book` with a class variable
`num_instances` to keep track of the number of instances
created. We increment the class variable each time an
instance is created using the `__init__()` method. Finally, we
access and print the value of the class variable to see the
total number of instances created.
These challenges highlight various aspects of Object-
Oriented Programming (OOP) fundamentals in Python,
including class definition, inheritance, encapsulation,
polymorphism, abstract base classes, operator overloading,
class methods, static methods, and class variables. By
mastering these concepts, beginners can write more
organized, modular, and reusable code, leading to better
software design and development practices. Stay tuned for
more challenges and guides as you continue your Python
journey!
Bonus Chapter: Project Ideas
Exploring Ideas for Personal Projects
As you delve deeper into Python programming and
complete various coding challenges, you'll undoubtedly gain
confidence and proficiency in your coding skills. Now, it's
time to put those skills to work and embark on personal
projects that not only showcase your abilities but also
provide practical solutions to real-world problems. Let's
explore some exciting ideas for applying your newfound
Python skills to personal projects.
1. Web Scraping and Data Analysis
Utilize Python's web scraping libraries such as Beautiful
Soup or Scrapy to extract data from websites of interest. You
can scrape data from e-commerce websites to analyze
product prices, from news websites to gather information on
trending topics, or from social media platforms to analyze
user sentiments. Once you've collected the data, use
Python's data analysis libraries like Pandas and Matplotlib to
gain insights, visualize trends, and make data-driven
decisions.
```python
import requests
from bs4 import BeautifulSoup
# Example: Web scraping to extract product prices from an
e-commerce website
url = 'https://www.example.com/products'
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')
product_prices = [price.text for price in soup.find_all('span',
class_='price')]
print(product_prices)
```
2. Automation Scripts
Automate repetitive tasks and streamline workflows by
writing Python scripts to handle them. For example, you can
create a script to automatically download files from a
specific website, organize files in a directory, or send
automated emails for scheduled reminders. By automating
these tasks, you'll save time and effort, allowing you to
focus on more important aspects of your work or personal
life.
```python
import os
import shutil
# Example: Script to organize files in a directory by file type
source_dir = 'Downloads'
target_dirs = {'Documents': ['pdf', 'doc', 'docx'], 'Images':
['jpg', 'png', 'gif']}
for filename in os.listdir(source_dir):
file_extension = filename.split('.')[-1]
for target_dir, extensions in target_dirs.items():
if file_extension.lower() in extensions:
source_path = os.path.join(source_dir, filename)
target_path = os.path.join(target_dir, filename)
shutil.move(source_path, target_path)
break
```
3. GUI Applications
Create graphical user interface (GUI) applications using
Python's Tkinter or PyQt libraries. You can develop
applications for various purposes such as task managers,
weather forecast apps, budget trackers, or even simple
games. GUI applications provide an intuitive and user-
friendly interface, making them accessible to a wider
audience.
```python
import tkinter as tk
# Example: Simple GUI application to display a welcome
message
def display_message():
The message is: "Greetings to my Python Graphical User
Interface (GUI) Application!"
label.config(text=message)
app = tk.Tk()
app.title("Python GUI")
app.geometry("300x200")
label = tk.Label(app, text="")
label.pack()
button = tk.Button(app, text="Click Me",
command=display_message)
button.pack()
app.mainloop()
```
4. Machine Learning Projects
Explore machine learning algorithms and libraries such as
scikit-learn and TensorFlow to build predictive models and
solve classification or regression problems. You can work on
projects like sentiment analysis, image recognition, or even
develop your own chatbot. Machine learning projects offer
endless possibilities for experimentation and innovation,
allowing you to delve into the exciting field of artificial
intelligence.
```python
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
# Example: Sentiment analysis using logistic regression
# (Assuming you have a dataset with labeled sentiment
data)
# Load and preprocess data
X, y = np.load('features.npy'), np.load('labels.npy')
X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size=0.2, random_state=42)
# Train logistic regression model
model = LogisticRegression()
model.fit(X_train, y_train)
# Evaluate model
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)
```
5. IoT Projects
Combine your Python skills with hardware components like
Raspberry Pi or Arduino to build Internet of Things (IoT)
projects. You can create smart home systems,
environmental monitoring devices, or even automated plant
watering systems. IoT projects offer hands-on experience
with both software and hardware, allowing you to develop
practical solutions for home automation or environmental
monitoring.
```python
import RPi.GPIO as GPIO
import time
# Example: Raspberry Pi project to control an LED using
Python
LED_PIN = 18
GPIO.setmode(GPIO.BCM)
GPIO.setup(LED_PIN, GPIO.OUT)
try:
while True:
GPIO.output(LED_PIN, GPIO.HIGH)
time.sleep(1)
GPIO.output(LED_PIN, GPIO.LOW)
time.sleep(1)
except KeyboardInterrupt:
GPIO.cleanup()
```
These are just a few ideas to get you started on your Python
programming journey. Feel free to explore and expand upon
these ideas or come up with your own projects that align
with your interests and goals. Remember, the best projects
are those that challenge you, allow you to learn new
concepts, and ultimately, bring value to your life or the lives
of others. Happy coding!
Conclusion
80+ Python Coding Challenges for Beginners
Coding challenges are a great way to improve your problem-
solving skills and solidify your understanding of
programming concepts. Below are 80+ Python coding
challenges designed specifically for beginners to help you
practice and enhance your Python skills.
1. Sum of Two Numbers
Develop a Python script that prompts the user to input two
numbers and displays their total.
```python
num1 = int(input("Enter first number: "))
num2 = int(input("Enter second number: "))
sum = num1 + num2
print("Sum:", sum)
```
2. Product of Two Numbers
Write a Python program that takes two numbers as input
and prints their product.
```python
product = num1 * num2
print("Product:", product)
```
3. Area of a Rectangle
Write a Python program that calculates and prints the area
of a rectangle given its length and width.
```python
length = float(input("Enter length of rectangle: "))
width = float(input("Enter width of rectangle: "))
area = length * width
print("Area of rectangle:", area)
```
4. Area of a Circle
Write a Python program that calculates and prints the area
of a circle given its radius.
```python
import math
radius = float(input("Enter radius of circle: "))
area = math.pi * (radius ** 2)
print("Area of circle:", area)
```
5. Celsius to Fahrenheit Conversion
Write a Python program that converts Celsius to Fahrenheit.
```python
celsius = float(input("Enter temperature in Celsius: "))
fahrenheit = (celsius * 9/5) + 32
print("Temperature in Fahrenheit:", fahrenheit)
```
6. Fahrenheit to Celsius Conversion
Write a Python program that converts Fahrenheit to Celsius.
```python
fahrenheit = float(input("Enter temperature in Fahrenheit:
"))
celsius = (fahrenheit - 32) * 5/9
print("Temperature in Celsius:", celsius)
```
7. Swap Two Numbers
Create a Python script to exchange the values stored in two
variables.
```python
num1 = 10
num2 = 20
# Swap logic
temp = num1
num1 = num2
num2 = temp
print("After swapping:")
print("num1:", num1)
print("num2:", num2)
```
8. Check Even or Odd
Write a Python program that checks if a given number is
even or odd.
```python
num = int(input("Enter a number: "))
if num % 2 == 0:
print("Even")
else:
print("Odd")
```
9. Check Prime Number
Develop a Python script to calculate the factorial of a
provided number.
```python
if num > 1:
for i in range(2, num):
if num % i == 0:
print("Not Prime")
break
else:
print("Prime")
else:
print("Not Prime")
```
10. Factorial of a Number
Write a Python program to find the factorial of a given
number.
```python
factorial = 1
for i in range(1, num + 1):
factorial *= i
print("Factorial:", factorial)
```
11. Fibonacci Series
Write a Python program to generate the Fibonacci series up
to a specified number of terms.
```python
num_terms = int(input("Enter number of terms: "))
a, b = 0, 1
count = 0
while count < num_terms:
print(a)
nth = a + b
a=b
b = nth
count += 1
```
12. Reverse a String
Write a Python program to reverse a given string.
```python
reversed_string = string[::-1]
print("Reversed string:", reversed_string)
```
13. Check Palindrome
Write a Python program that checks if a given string is a
palindrome.
```python
if string == string[::-1]:
print("Palindrome")
else:
print("Not Palindrome")
```
14. Count Vowels
Write a Python program that counts the number of vowels in
a given string.
```python
vowels = 'aeiouAEIOU'
count = 0
for char in string:
if char in vowels:
count += 1
print("Number of vowels:", count)
```
15. Count Words in a String
Write a Python program that counts the number of words in
a given string.
```python
words = len(string.split())
print("Number of words:", words)
```
16. Check Leap Year
Create a Python script to determine whether a provided
year is a leap year or not.
```python
year = int(input("Enter a year: "))
If the condition (year % 4 == 0 and year % 100 != 0) or
(year % 400 == 0) is satisfied, then output "Leap Year".
else:
print("Not Leap Year")
```
17. Generate Multiplication Table
Write a Python program that generates the multiplication
table for a given number.
```python
for i in range(1, 11):
Output the multiplication of `num` and ì` as `num`
times ì`.
```
18. Check Armstrong Number
number is an Armstrong number or not.
```python
sum = 0
temp = num
while temp > 0:
digit = temp % 10
sum += digit ** 3
temp //= 10
if num == sum:
else:
print("Not Armstrong Number")
```
19. Print Pattern
Write a Python program to print a specific pattern.
```python
rows = int(input("Enter number of rows: "))
for j in range(1, i + 1):
print(j, end=' ')
print()
```
20. Find Largest Among Three Numbers
Write a Python program that finds the largest among three
numbers.
```python
num2 = int(input("Enter
```
second number: "))
num3 = int(input("Enter third number: "))
if num1 >= num2 and num1 >= num3:
largest = num1
elif num2 >= num1 and num2 >= num3:
largest = num2
else:
largest = num3
print("Largest number:", largest)
```
21. Check Positive, Negative, or Zero
Develop a Python script to determine whether a provided
number is positive, negative, or zero.
```python
num = float(input("Enter a number: "))
if num > 0:
print("Positive")
elif num < 0:
print("Negative")
else:
print("Zero")
```
22. Find Sum of Natural Numbers
Write a Python program to find the sum of natural numbers
up to a given number.
```python
sum = 0
sum += i
print("Sum of natural numbers:", sum)
```
23. Check Perfect Number
number is a perfect number or not.
```python
sum = 0
if num % i == 0:
sum += i
if sum == num:
print("Perfect Number")
else:
print("Not Perfect Number")
```
24. Check Strong Number
Develop a Python script to ascertain whether a provided
number is a strong number or not.
```python
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)
sum = 0
temp = num
while temp > 0:
digit = temp % 10
sum += factorial(digit)
temp //= 10
if sum == num:
print("Strong Number")
else:
print("Not Strong Number")
```
25. Check Disarium Number
Create a Python script to verify whether a given number is a
Disarium number.
```python
sum = 0
length = len(str(num))
temp = num
while temp > 0:
digit = temp % 10
sum += digit ** length
length -= 1
temp //= 10
if sum == num:
print("Disarium Number")
else:
print("Not Disarium Number")
```
26. Check Harshad Number
Develop a Python script to determine whether a provided
number is a Harshad number.
```python
sum = 0
temp = num
while temp > 0:
digit = temp % 10
sum += digit
temp //= 10
if num % sum == 0:
print("Harshad Number")
else:
print("Not Harshad Number")
```
27. Check Pronic Number
Create a Python script to determine whether a given
number is a Pronic number.
```python
flag = False
If the product of ì` and `(i + 1)` equals `num`, then...
flag = True
break
if flag:
print("Pronic Number")
else:
print("Not Pronic Number")
```
28. Find GCD (Greatest Common Divisor)
Write a Python program to find the GCD of two numbers
using the Euclidean algorithm.
```python
def gcd(a, b):
while b:
Assign the values of `b` and à % b` to à` and `b`,
respectively.
return a
print("GCD:", gcd(num1, num2))
```
29. Find LCM (Least Common Multiple)
Write a Python program to find the LCM of two numbers
using the formula LCM = (a * b) / GCD(a, b).
```python
def lcm(a, b):
return (a * b) // gcd(a, b)
print("LCM:", lcm(num1, num2))
```
30. Find Factorial Using Recursion
Create a Python script to calculate the factorial of a
provided number using recursion.
```python
def factorial(n):
if n == 0:
return 1
else:
print("Factorial:", factorial(num))
```
31. Find Power of a Number
Develop a Python script to determine the power of a number
using recursion.
```python
def power(base, exp):
if exp == 0:
return 1
else:
return base * power(base, exp-1)
base = int(input("Enter base: "))
exp = int(input("Enter exponent: "))
print("Result:", power(base, exp))
```
32. Find Sum of Digits Using Recursion
Create a Python script to calculate the sum of digits of a
provided number using recursion.
```python
def sum_of_digits(n):
if n == 0:
return 0
else:
return n % 10 + sum_of_digits(n // 10)
print("Sum of digits:", sum_of_digits(num))
```
33. Find Fibonacci Series Using Recursion
Write a Python program to generate the Fibonacci series up
to a specified number of terms using recursion.
```python
def fibonacci(n):
if n <= 1:
return n
else:
return fibonacci(n-1) + fibonacci(n-2)
num_terms = int(input("Enter number of terms: "))
print(fibonacci(i), end=' ')
```
34. Find Armstrong Numbers in an Interval
Write a Python program to find Armstrong numbers within a
given interval.
```python
start = int(input("Enter start of interval: "))
end = int(input("Enter end of interval: "))
for num in range(start, end + 1):
order = len(str(num))
sum = 0
temp = num
while temp > 0:
digit = temp % 10
sum += digit ** order
temp //= 10
if num == sum:
print(num)
```
35. Find Perfect Numbers in an Interval
Write a Python program to find perfect numbers within a
given interval.
```python
for num in range(start, end + 1):
sum = 0
if num % i == 0:
sum += i
if sum == num:
print(num)
```
36. Find Strong Numbers in an Interval
Write a Python program to find strong numbers within a
given interval.
```python
def factorial(n):
if n ==
```python
0:
return 1
else:
def is_strong_number(num):
sum = 0
temp = num
while temp > 0:
digit = temp % 10
sum += factorial(digit)
temp //= 10
return sum == num
print("Strong Numbers in the interval:")
for i in range(start, end + 1):
if is_strong_number(i):
print(i)
```
37. Find Disarium Numbers in an Interval
Write a Python program to find Disarium numbers within a
given interval.
```python
def is_disarium_number(num):
sum = 0
length = len(str(num))
temp = num
while temp > 0:
digit = temp % 10
sum += digit ** length
length -= 1
temp //= 10
return sum == num
print("Disarium Numbers in the interval:")
if is_disarium_number(i):
print(i)
```
38. Find Harshad Numbers in an Interval
Write a Python program to find Harshad numbers within a
given interval.
```python
def is_harshad_number(num):
sum = 0
temp = num
while temp > 0:
digit = temp % 10
sum += digit
temp //= 10
return num % sum == 0
print("Harshad Numbers in the interval:")
if is_harshad_number(i):
print(i)
```
39. Find Pronic Numbers in an Interval
Write a Python program to find Pronic numbers within a
given interval.
```python
def is_pronic_number(num):
for i in range(num):
If the product of ì` and its consecutive number equals
`num`, then...
return True
return False
print("Pronic Numbers in the interval:")
if is_pronic_number(i):
print(i)
```
40. Check Palindrome Number
Write a Python program that checks if a given number is a
palindrome.
```python
temp = num
reverse = 0
while temp > 0:
digit = temp % 10
Update the variable "reverse" by adding the digit and
multiplying the result by 10.
temp //= 10
if num == reverse:
print("Palindrome Number")
else:
print("Not Palindrome Number")
```
41. Print Pattern - Triangle
Write a Python program to print a triangle pattern.
```python
print(' ' * (rows - i) + '*' * i)
```
42. Print Pattern - Diamond
Write a Python program to print a diamond pattern.
```python
Output a combination of spaces and asterisks, where the
number of spaces is determined by `(rows - i)` and the
number of asterisks is determined by `(2 * i - 1)`.
for i in range(rows - 1, 0, -1):
Display a pattern consisting of spaces and asterisks, with
the number of spaces determined by `(rows - i)` and the
number of asterisks determined by `(2 * i - 1)`.
```
43. Check Armstrong Number (n-digits)
Write a Python program that checks if a given n-digit
number is an Armstrong number.
```python
num_digits = len(str(num))
sum = 0
temp = num
while temp > 0:
digit = temp % 10
temp //= 10
if num == sum:
else:
print("Not Armstrong Number")
```
44. Find Sum of Natural Numbers Using Recursion
Write a Python program to find the sum of natural numbers
up to a given number using recursion.
```python
def sum_of_natural_numbers(n):
if n == 1:
return 1
else:
return n + sum_of_natural_numbers(n - 1)
print("Sum of natural numbers up to", num, ":",
sum_of_natural_numbers(num))
```
45. Find Factors of a Number
Create a Python script to determine the factors of a
provided number.
```python
print("Factors of", num, ":", end=' ')
if num % i == 0:
print(i, end=' ')
```
46. Check Perfect Number (n-digits)
number is a perfect number.
```python
def is_perfect_number(num):
sum = 0
if num % i == 0:
sum += i
return sum == num
if is_perfect_number(num):
print("Perfect Number")
else:
print("Not Perfect Number")
```
47. Check Prime Number (n-digits)
number is prime or not.
```python
def is_prime_number(num):
if num > 1:
if num % i == 0:
return False
return True
return False
if is_prime_number(num):
print("Prime Number")
else:
print("Not Prime Number")
```
48. Find Prime Factors of a Number
Develop a Python script to identify the prime factors of a
provided number.
```python
def prime_factors(num):
factors = []
while num % 2 == 0:
factors.append(2)
num //= 2
for i in range(3, int(num ** 0.5) + 1, 2):
while num % i == 0:
factors.append(i)
num //= i
if num > 2:
factors.append(num)
return factors
print("Prime factors of", num, ":", prime_factors(num))
```
49. Find Reverse of a Number
Write a Python program to find the reverse of a given
number.
```python
reverse = 0
while num > 0:
digit = num % 10
Assign the product of "reverse" and 10 plus "digit" to
"reverse".
num //= 10
print("Reverse:", reverse)
```
50. Check Disjoint Sets
Write a Python program to check if two given sets are
disjoint or not.
```python
set1 = {1, 2, 3}
set2 = {4, 5, 6}
if len(set1.intersection(set2)) == 0:
print("Disjoint sets")
else:
print("Not disjoint sets")
```
51. Check Sublist
Write a Python program to check if a given list is a subset of
another list.
```python
list1 = [1, 2, 3, 4, 5]
list2 = [2, 3]
if set(list2).issubset(set(list1)):
print("List2 is a subset of List1")
else:
print("List2 is not a subset of List1")
```
52. Check Superlist
Write a Python program to check if a given list is a superset
of another list.
```python
list1 = [1, 2, 3, 4, 5]
list2 = [2, 3]
if set(list1).issuperset(set(list2)):
print("List1 is a superset of List2")
else:
print("List1 is not a superset of List2")
```
53. Remove Duplicates from a List
Develop a Python script to eliminate duplicate elements
from a list.
```python
list1 = [1, 2, 3, 2, 4, 5, 1]
unique_list = list(set(list1))
print("List with duplicates removed:", unique_list)
```
54. Merge Two Dictionaries
Create a Python script to combine two dictionaries.
```python
dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
merged_dict = {**dict1, **dict2}
print("Merged dictionary:", merged_dict)
```
55. Check Anagram
Write a Python program to check if two given strings are
anagrams or not.
```python
str1 = input("Enter first string: ")
str2 = input("Enter second string: ")
if sorted(str1) == sorted(str2):
print("Anagrams")
else:
print("Not Anagrams")
```
56. Count Characters in a String
Write a Python program to count the occurrences of each
character in a given string.
```python
char_count = {}
for char in string:
char_count[char] = char_count.get(char, 0) + 1
print("Character count:", char_count)
```
57. Reverse Words in a String
Write a Python program to reverse the order of words in a
given string.
```python
reversed_string = ' '.join(reversed(string.split()))
print("Reversed words:", reversed_string)
```
58. Find Longest Word in a String
Write a Python program to find the longest word in a given
string.
```python
longest_word = max(string.split(), key=len)
print("Longest word:", longest_word)
```
59. Convert List to String
Write a Python program to convert a list of characters into a
string.
```python
char_list = ['H', 'e', 'l', 'l', 'o']
string = ''.join(char_list)
print("String:", string)
```
60. Shuffle a List
Write a Python program to shuffle a given list.
```python
import random
list1 = [1, 2, 3, 4, 5]
random.shuffle(list1)
print("Shuffled list:", list1)
```
61. Find Missing Number
Write a Python program to find the missing number in a
given list of numbers from 1 to n.
```python
def find_missing_number(nums):
n = len(nums) + 1
The expected sum is calculated as `n` multiplied by `n +
1`, then divided by 2.
actual_sum = sum(nums)
return expected_sum - actual_sum
nums = [1, 2, 4, 5, 6]
print("Missing number:", find_missing_number(nums))
```
62. Find Duplicate Numbers
Write a Python program to find the duplicate numbers in a
given list.
```python
def find_duplicate_numbers(nums):
duplicates = set()
seen = set()
for num in nums:
if num in seen:
duplicates.add(num)
else:
seen.add(num)
return list(duplicates)
nums = [1, 2, 3, 2, 4, 5, 4]
print("Duplicate numbers:", find_duplicate_numbers(nums))
```
63. Merge Two Sorted Lists
Write a Python program to merge two sorted lists into a
single sorted list.
```python
def merge_sorted_lists(list1, list2):
merged_list = []
i=j=0
while i < len(list1) and j < len(list2):
if list1[i] < list2[j]:
merged_list.append(list1[i])
i += 1
else:
merged_list.append(list2[j])
j += 1
merged_list.extend(list1[i:])
merged_list.extend(list2[j:])
return merged_list
list1 = [1, 3, 5, 7]
list2 = [2, 4, 6, 8]
print("Merged sorted list:", merge_sorted_lists(list1, list2))
```
64. Find Common Elements
Write a Python program to find the common elements
between two lists.
```python
def find_common_elements(list1, list2):
return list(set(list1) & set(list2))
list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
print("Common elements:", find_common_elements(list1,
list2))
```
65. Remove All Occurrences
Write a Python program to remove all occurrences of a
specified element from a given list.
```python
def remove_all_occurrences(nums, target):
return [num for num in nums if num != target]
nums = [1, 2, 3, 2, 4, 5, 2]
target = 2
print("List after removal:", remove_all_occurrences(nums,
target))
```
66. Remove Duplicate Characters
Write a Python program to remove all duplicate characters
from a string.
```python
def remove_duplicate_characters(string):
unique_chars = []
for char in string:
if char not in unique_chars:
unique_chars.append(char)
return ''.join(unique_chars)
string = "hello"
print("String after removal of duplicates:",
remove_duplicate_characters(string))
```
67. Check Pangram
Write a Python program to check if a given string is a
pangram or not.
```python
import string
def is_pangram(sentence):
alphabet = set(string.ascii_lowercase)
return set(sentence.lower()) >= alphabet
sentence = "The quick brown fox jumps over the lazy dog"
if is_pangram(sentence):
print("Pangram")
```python
else:
print("Not a Pangram")
```
68. Count Words Frequency
Write a Python program to count the frequency of words in a
given sentence.
```python
def count_word_frequency(sentence):
word_freq = {}
words = sentence.split()
for word in words:
word_freq[word] = word_freq.get(word, 0) + 1
return word_freq
sentence = "This is a test sentence to test word frequency"
print("Word frequency:", count_word_frequency(sentence))
```
69. Find Maximum Occurring Character
Develop a Python script to determine the character that
occurs most frequently in a provided string.
```python
def max_occuring_character(string):
char_count = {}
for char in string:
char_count[char] = char_count.get(char, 0) + 1
max_count = max(char_count.values())
max_chars = [char for char, count in char_count.items() if
count == max_count]
return max_chars
string = "hello world"
print("Maximum occurring character(s):",
max_occuring_character(string))
```
70. Find Intersection of Two Arrays
Write a Python program to find the intersection of two
arrays.
```python
def find_intersection(arr1, arr2):
return list(set(arr1) & set(arr2))
arr1 = [1, 2, 3, 4, 5]
arr2 = [4, 5, 6, 7, 8]
print("Intersection:", find_intersection(arr1, arr2))
```
71. Find Union of Two Arrays
Create a Python script to compute the union of two arrays.
```python
def find_union(arr1, arr2):
return list(set(arr1) | set(arr2))
arr1 = [1, 2, 3, 4, 5]
arr2 = [4, 5, 6, 7, 8]
print("Union:", find_union(arr1, arr2))
```
72. Find Symmetric Difference of Two Arrays
Write a Python program to find the symmetric difference of
two arrays.
```python
def find_symmetric_difference(arr1, arr2):
return list(set(arr1) ^ set(arr2))
arr1 = [1, 2, 3, 4, 5]
arr2 = [4, 5, 6, 7, 8]
print("Symmetric Difference:",
find_symmetric_difference(arr1, arr2))
```
73. Find Missing Element in a Sorted Array
Develop a Python script to identify the absent element in a
sorted array of consecutive numbers.
```python
def find_missing_element(arr):
n = len(arr)
total = (n + 1) * (n + 2) // 2
arr_sum = sum(arr)
return total - arr_sum
arr = [1, 2, 3, 5, 6, 7, 8,10]
print("Missing element:", find_missing_element(arr))
```
74. Find Single Element in a Sorted Array
Write a Python program to find the single element in a
sorted array where every element appears twice except for
one.
```python
def find_single_element(arr):
Define variables "low" and "high" with initial values of 0
and the length of the array minus 1, respectively.
while low < high:
The midpoint equals the low value plus half the
difference between the high and low values.
if mid % 2 == 0:
if arr[mid] == arr[mid + 1]:
low = mid + 2
else:
high = mid
else:
if arr[mid] == arr[mid - 1]:
low = mid + 1
else:
high = mid
return arr[low]
arr = [1, 1, 2, 2, 3, 3, 4, 4, 5]
print("Single element:", find_single_element(arr))
```
75. Rotate Array Left
Write a Python program to rotate an array to the left by a
given number of steps.
```python
def rotate_array_left(arr, steps):
n = len(arr)
steps = steps % n
return arr[steps:] + arr[:steps]
arr = [1, 2, 3, 4, 5]
steps = 2
print("Rotated array:", rotate_array_left(arr, steps))
```
76. Rotate Array Right
Write a Python program to rotate an array to the right by a
given number of steps.
```python
def rotate_array_right(arr, steps):
n = len(arr)
steps = steps % n
return arr[-steps:] + arr[:-steps]
arr = [1, 2, 3, 4, 5]
steps = 2
print("Rotated array:", rotate_array_right(arr, steps))
```
77. Find Maximum Sum Subarray
Write a Python program to find the contiguous subarray with
the largest sum from a given array.
```python
def max_subarray_sum(arr):
max_sum = float('-inf')
current_sum = 0
for num in arr:
current_sum = max(num, current_sum + num)
max_sum = max(max_sum, current_sum)
return max_sum
arr = [-2, 1, -3, 4, -1, 2, 1, -5, 4,5]
print("Maximum sum of subarray:", max_subarray_sum(arr))
```
78. Find Missing Number in Arithmetic Progression
Write a Python program to find the missing number in an
arithmetic progression of numbers.
```python
def find_missing_in_ap(arr):
n = len(arr) + 1
total = n * (arr[0] + arr[-1]) // 2
actual_sum = sum(arr)
return total - actual_sum
arr = [1, 3, 5, 7, 9, 13]
print("Missing number in AP:", find_missing_in_ap(arr))
```
79. Find Peak Element
Write a Python program to find a peak element in an array. A
peak element is an element that is larger than the elements
adjacent to it.
```python
def find_peak_element(arr):
Set the low value to 0 and the high value to the length of
the array minus 1.
while low < high:
Calculate the midpoint by adding half of the difference
between the high and low values to the low value.
if arr[mid] > arr[mid + 1]:
high = mid
else:
low = mid + 1
return arr[low]
arr = [1, 3, 20, 4, 1, 0]
print("Peak element:", find_peak_element(arr))
```
80. Find Majority Element
Write a Python program to find the majority element in an
array. The majority element is the element that occurs in
more than half of the total occurrences in a set.
```python
def find_majority_element(arr):
count = 0
candidate = None
for num in arr:
if count == 0:
candidate = num
count += (1 if num == candidate else -1)
return candidate
arr = [3, 3, 4, 2, 4, 4, 2, 4, 4,2,2]
print("Majority element:", find_majority_element(arr))
```
These Python coding challenges cover a wide range of
topics and are suitable for beginners to improve their
programming skills. Each challenge provides an opportunity
to practice problem-solving and algorithmic thinking,
essential skills for any programmer.
Appendix
A Glossary of Terms for Python Beginner

1. Python: A high-level programming language known for
its simplicity and readability.
2. Interpreter: A program that reads and executes Python
code line by line, translating it into machine-understandable
instructions.
3. Syntax: The rules governing the structure and format of
Python code, including indentation, punctuation, and
keywords.
4. Variable: A named storage location used to store data
that can be accessed and modified throughout the program.
5. Data Types: The classification of data in Python,
including integers, floats, strings, lists, tuples, dictionaries,
and sets.
6. String: A sequence of characters enclosed within single
(' ') or double (" ") quotes, used for text manipulation.
7. Integer: A whole number without decimal points, used
for arithmetic operations.
8. Float: A numerical data type representing numbers with
decimal points, used for more precise calculations.
9. List: An ordered collection of items enclosed within
square brackets [], allowing for mutable operations like
adding, removing, and accessing elements.
10. Tuple: Similar to lists but immutable, meaning their
elements cannot be changed after creation and are
enclosed within parentheses ().
11. Dictionary: A collection of key-value pairs enclosed
within curly braces {}, allowing for efficient retrieval of
values based on keys.
12. Set: A collection of unique elements enclosed within
curly braces {}, useful for mathematical operations like
union, intersection, and difference.
13. Boolean: A data type representing truth values, either
True or False, often used in conditional statements and
logical operations.
14. Conditional Statements: Statements that control the
flow of a program based on specified conditions, including if,
elif, and else.
15. Loop: A control structure that repeats a block of code
until a specified condition is met, such as for loops and while
loops.
16. Function: A reusable block of code that performs a
specific task, often with parameters and a return value.
17. Module: A file containing Python code that can be
imported and reused in other Python programs, helping to
organize code into logical units.
18. Package: A collection of related Python modules
organized into directories, facilitating modular programming
and code reuse.
19. Exception: An error that occurs during the execution of
a program, disrupting its normal flow, which can be caught
and handled using try-except blocks.
20. Object-Oriented Programming (OOP): A
programming paradigm that organizes code into objects,
which encapsulate data and behavior, promoting modularity
and reusability.
21. Class: A blueprint for creating objects, defining their
properties (attributes) and behaviors (methods).
22. Instance: An individual object created from a class,
possessing its own unique set of attributes and behaviors.
23. Inheritance: A mechanism in OOP where a class
(subclass) can inherit attributes and methods from another
class (superclass), promoting code reuse and extensibility.
24. Polymorphism: The capacity for diverse objects to
react to identical messages or method calls in varied
manners, thereby boosting adaptability and
compartmentalization.
25. Encapsulation: The bundling of data and methods that
operate on the data within a single unit (class), hiding the
internal implementation details from the outside world.
Answers to Selected Challenges (Solutions for
selected challenges)
Here are solutions to selected challenges from a variety of
beginner-level Python coding challenges:
Challenge 1: Calculate the Sum of Two Numbers
```python
def sum_of_two_numbers(num1, num2):
return num1 + num2
# Example usage:
result = sum_of_two_numbers(5, 3)
print("Sum of two numbers:", result)
```
Challenge 2: Find the Area of a Rectangle
```python
def area_of_rectangle(length, width):
return length * width
# Example usage:
area = area_of_rectangle(4, 6)
print("Area of rectangle:", area)
```
Challenge 3: Convert Celsius to Fahrenheit
```python
def celsius_to_fahrenheit(celsius):
return (celsius * 9/5) + 32
# Example usage:
fahrenheit_temp = celsius_to_fahrenheit(20)
print("Temperature in Fahrenheit:", fahrenheit_temp)
```
Challenge 4: Find the Maximum of Two Numbers
```python
def max_of_two_numbers(num1, num2):
return max(num1, num2)
# Example usage:
maximum = max_of_two_numbers(10, 15)
print("Maximum of two numbers:", maximum)
```
Challenge 5: Calculate the Factorial of a Number
```python
def factorial(num):
if num == 0:
return 1
else:
return num * factorial(num - 1)
# Example usage:
fact = factorial(5)
print("Factorial of 5:", fact)
```
Challenge 6: Check if a Number is Even or Odd
```python
def check_even_odd(num):
if num % 2 == 0:
return "Even"
else:
return "Odd"
# Example usage:
result = check_even_odd(7)
print("7 is:", result)
```
Challenge 7: Find the Sum of Natural Numbers
```python
def sum_of_natural_numbers(n):
return (n * (n + 1)) // 2
# Example usage:
sum_natural = sum_of_natural_numbers(10)
print("Sum of first 10 natural numbers:", sum_natural)
```
Challenge 8: Check if a Number is Prime
```python
def is_prime(num):
if num < 2:
return False
for i in range(2, int(num**0.5) + 1):
if num % i == 0:
return False
return True
# Example usage:
prime_check = is_prime(13)
if prime_check:
print("13 is a prime number.")
else:
print("13 is not a prime number.")
```
```python
def reverse_string(s):
return s[::-1]
# Example usage:
reversed_str = reverse_string("hello")
print("Reversed string:", reversed_str)
```
Challenge 10: Find the Square of a Number
```python
def square_of_number(num):
return num ** 2
# Example usage:
square = square_of_number(7)
print("Square of 7:", square)
```
These solutions demonstrate basic Python programming
concepts such as functions, conditionals, loops, and
arithmetic operations. They establish a basis for
comprehending and addressing more intricate coding
problems.

80+ Python Coding Challenges For Beginners

Uploaded by

80+ Python Coding Challenges For Beginners

Uploaded by

80+ Python Coding Challenges

Python Exercises to Make You a Better Programmer. No Prior

The contents of this material are protected by copyright law.

Control Flow Statements: Decision-making with if/else and Looping with

Section 2: Control Flow

Section 3: Files and Exception Handling

num_terms = int(input("Please input the number of terms:

In this section, we'll explore challenges 71-80, which focus

A Glossary of Terms for Python Beginner

You might also like