CULTIVATING PYTHON:
Planting and Nurturing Your Skills
Embark on a Green-Thumbed Python Adventure! Explore the
World of Programming Through the Metaphor of Gardening.
Learn Python from the Ground Up, Planting Seeds of
Knowledge, Watering Concepts, and Cultivating Skills. This
Beginner's Guide Will Help You Blossom as a Python
Programmer.
SifuSherif
2
TABLE OF CONTENTS
Cultivating Python: Planting and Nurturing Your Skills
Introduction
- The Garden of Python
- Introduction to Python as a programming
language.
- Why Python is a great choice for beginners.
- Preparing your gardening tools (setting up
Python).
Chapter 1: Planting the Seeds
- Setting Up Your Python Garden(Installing a
code editor).
- Your First Python Plant.
- Writing and running your first "Hello,
World!" program.
Chapter 2: Watering the Basics
- Understanding Variables
- How to store and manipulate data in
Python.
- Using real-life examples like storing
temperatures.
3
-
Data Types(Exploring data types like
integers, floats, and strings. Using a
gardening analogy to explain these
concepts.)
Chapter 3: Growing Your Python Vocabulary
- Operators and Expressions
- Learning arithmetic, comparison, and
logical operators.
- Real-life( calculating garden expenses).
- Making Decisions(Introducing conditional
statements with an analogy to weather
conditions in your garden).
Chapter 4: Cultivating Control Structures
- Loops and Iteration
- Understanding for and while loops.
- Using a watering system analogy.
- Lists and Arrays
- How to organize and manipulate collections
of data( A list of planted flowers.).
Chapter 5: Nurturing Functions and Modules
- Functions: Your Gardening Tools
- Creating and using functions in Python.
- A real-life example of a watering function.
- Python's Plant Nursery: Modules
- How to use and create modules for reusable
code.
4
Chapter 6: Tending to Errors and Exceptions
- Debugging: Weeding Your Garden
- Techniques for finding and fixing errors in
your code.
- A metaphor of weeding out errors.
- Handling Exceptions
- Dealing with errors gracefully.
Chapter 7: Blooming Beyond the Basics
- File Handling
- Reading from and writing to files.
- Using a diary analogy for file handling.
- Dictionaries and Sets
- Exploring more advanced data structures.
- A garden catalog using dictionaries.
Chapter 8: Sprouting into Object-Oriented
Programming
- Object-Oriented Concepts
- Introduction to classes and objects.
- Comparing them to plants and planters.
- Growing Your Own Plant Class
- Building a custom class to represent plants.
5
Chapter 9: Harvesting Python Projects
- A plant watering reminder and a garden
planner.
- More Examples
Conclusion
- Reflecting on Your Python Garden
- Summarizing the journey from planting to
harvesting.
- Cultivating a Lifelong Passion
- Encouragement for continuing your Python
journey.
- Python Resources
6
Cultivating Python: Planting and Nurturing Your Skills
Preface
Greetings, fellow budding Pythonistas!
So, you've decided to dive headfirst into the world of Python,
the programming language that's as versatile as a Swiss Army
knife and as friendly as your neighbor's overly enthusiastic
Labrador. But hold on to your gardening gloves, my friend,
because this isn't your typical programming manual. No, siree!
This is more like a journey into the wild, wild garden of code.
Imagine Python as a lush, thriving garden. Instead of soil and
seeds, you've got lines of code and your trusty keyboard. Just
like in the garden, you'll plant your Python seeds, water them
with knowledge, and watch your skills grow like the most
stubborn dandelion in your front yard. And don't worry; if
you've never held a watering can (or a keyboard) in your life,
we've got you covered. This book is meant for the greenest of
thumbs.
So, why garden-themed Python? Well, think about it. Gardening
is all about patience, nurturing, and watching your efforts bear
fruit (or vegetables, if you're into that sort of thing). Python, too,
requires patience, a nurturing touch, and the thrill of seeing your
code produce results. It's not just about writing lines of text; it's
about creating something that works, just like coaxing a
stubborn tomato plant to yield that juicy red fruit.
7
Cultivating Python: Planting and Nurturing Your Skills
But fear not, my dear reader, because we're not going to get all
highfalutin with jargon and syntax. We're going to have some
fun, like two buddies planting tomatoes and debating the merits
of composting. By the end of this journey, you'll not only speak
Python, but you'll also see the world through a coder's eyes,
spotting opportunities for automation and efficiency everywhere
you look.
So, grab your shovel—or, in this case, your keyboard—and let's
get ready to dig into the fertile soil of Python. Prepare to laugh,
scratch your head, and maybe even curse a bit (Python can be a
sneaky rascal), but above all, get ready to become a Python
gardener extraordinaire. Your coding adventure awaits!
Happy coding!
8
Python??
Introduction
The Garden of Python
Welcome, dear reader, to the lush and vibrant world of Python
programming! As you embark on this journey, think of it as
stepping into a beautiful garden where the possibilities are as
abundant as a field of wildflowers on a sunny day.
Let's begin by strolling through this garden and understanding
what Python is all about. Python is a programming language
released in 1991 by Guido van Rossum, but don't let the fancy
term scare you away. It's like the secret language of computers,
and we're here to unveil its mysteries.
Python has gained fame for being one of the most
beginner-friendly languages out there. Imagine it as the perfect
entry point into the world of coding. Why, you ask? Well, it's as
easy to understand as your grandma's recipe for apple pie.
Python's syntax (that's just a fancy way of saying its rules) is
clean and simple. You can read Python code almost like a book,
1
and writing it feels more like crafting a story than solving an
advanced math problem.
But Python's appeal isn't just about being easy-breezy. It's a
versatile language, much like a Swiss Army knife. You can use it
to build websites, analyze data, create games, or even control
robots (yes, you read that right, robots!). Python is like the
universal language of the tech world. It's the cool kid in school
who can hang out with the geeks, the artists, and the scientists,
all at once.
Now, if you're wondering why Python is the perfect choice for
beginners, it's because Python is like the patient and
encouraging gardener who guides you through your first steps.
It doesn't rush you, and it doesn't make you feel like you need a
PhD in computer science to get started. Python is all about
letting you learn and grow at your own pace, just like nurturing
a garden.
So, fasten your seatbelt (or gardening gloves, if you prefer),
because in this book, we'll walk together through the Garden of
Python, sowing the seeds of knowledge, nurturing your skills,
and helping you become a confident Python gardener. It's going
to be an exciting and rewarding journey. Let's dive in!
Why learn Python?
There are many reasons to learn Python:
1. It is easy to learn and use: Python has a simple and
readable syntax, which makes it a great language
2
for beginners. It also has a large standard library
that provides support for many common
programming tasks.
2. It is versatile: Python can be used for a wide range
of tasks, including web development, data analysis,
machine learning, and scientific computing. This
makes it a valuable skill to have in any
programmer's toolkit.
3. It has a large and active community: Python has a
large and active community of users and
developers, which means there is a wealth of online
resources, libraries, and frameworks available to
help you get started and solve problems.
4. It has a bright future: Python is consistently ranked
as one of the most popular programming languages
and is widely used in industry and academia. This
makes it a good choice for those who want to build
a career in programming.
3
Preparing your Gardening Tools
Before you can start writing Python programs, you will need to
have a development environment set up on your computer. This
typically involves installing Python and a text editor or
integrated development environment (IDE).
Installing
Python on Ubuntu: A Breeze in the Linux
Garden:
If you're an Ubuntu user, Installing Python here is as smooth as
planting tulips in well-tilled soil. Ubuntu comes preloaded with
Python, but we'll show you how to make sure you have the
version you need without breaking a sweat. Think of it as
tending to a thriving garden with a variety of beautiful plants;
you just need to pick the right tools.
1. Install Python Using APT:
In the vibrant Ubuntu garden, we have a trusty gardener called
APT, short for Advanced Package Tool. APT is the default
package manager, like the guardian of the garden's treasures,
overseeing all the beautiful plants (packages) that grow here,
including Python.
4
Step 1: Open up your terminal by pressing Ctrl + Alt + T.
Step 2: Update your system's repository list by entering the
following command:
sudo apt update
Step 3: Download the latest version of Python with:
sudo apt install python3
Step 4: APT will automatically find the package and install
it on your computer.
2. Use Deadsnakes PPA to Install Python 3.12 on Ubuntu:
Try adding the Deadsnakes PPA to your list of system
repositories if you are unable to obtain the Python package from
the standard Ubuntu repositories for some reason. Personal
Package Archives, or PPAs, are repositories created specifically
for Ubuntu users.
By default, you can't add PPAs to your system. The
"software-properties-common" package provides you with an
efficient way to manage and add PPAs on Ubuntu.
Step 1: Install the above-mentioned package on your system by
typing the following command:
sudo apt install software-properties-common
5
Step 2: Add the official Deadsnakes PPA to your system's
repository list with:
sudo add-apt-repository ppa:deadsnakes/ppa
Step 3: Update your system's package list:
sudo apt update
Step 4: Download the latest version of Python from the added
PPA:
sudo apt install python3.12
Older versions of Python can also be installed because the
Deadsnakes PPA's database contains practically all of them.
Simply substitute the version of Python you want to install on
your machine with the preferred Python Version:
sudo apt install python3.3
sudo apt install python3.8
sudo apt install python3.10
6
3. Install Python 3 on Ubuntu From Source:
You can also download and build the latest version of Python
from the official Python website. Although compiling the source
code might seem a bit daunting at first, it'll become easier once
you know the process.
Step 1: Update your system's local repository list by running:
sudo apt update
Step 2: Install supporting dependencies on your system with
APT:
sudo apt install build-essential zlib1g-dev
libncurses5-dev libgdbm-dev libnss3-dev libssl-dev
libreadline-dev libffi-dev wget
Step 3: Make a new directory to store the Python source files:
mkdir ./python && cd ./python
Step 4: Download the Python source code from the official FTP
server:
wget
https://www.python.org/ftp/python/3.12.0/Python-3.12.0b3
.tgz
7
Step 5: Extract the TGZ file that you just downloaded with:
tar -xvf Python-3.12.0b3.tgz
Step 6: You need to perform tests and optimizations before
installing Python. This is important as it increases the execution
speed of your code by at least 10 percent:
cd Python-3.12.0b3
./configure --enable-optimizations
Step 7: Build the package using the MakeFile present in the
directory:
sudo make install
After you've implemented these steps, check if Python was
installed properly on your computer by typing python3 --version
in the terminal.
8
Chapter 1: Planting the Seeds
Setting Up Your Python
Garden
In this chapter, we'll embark on our journey into the world of
Python programming. Much like starting a garden, we'll begin
by setting up the tools we need, planting our first Python "seed,"
and nurturing it to grow into a beautiful program.
Before we can start growing Python programs, we need a place
to nurture them. Think of this as preparing the soil for your
plants. In our case, the soil is your computer, and we'll need a
special tool called a "code editor" to do the planting.
Code Editor: A code editor is like a gardening tool for
programmers. It's where you'll write your Python code. There
are many code editors available, but for our garden, we'll use a
popular one called "Visual Studio Code" or "VS Code" for short.
You can download it from their website and install it on your
computer.
9
For Windows:
1. Go to the VS Code Website (https://code.visualstudio.com/).
2. Download the installer for your operating system (Windows,
macOS).
3. Run the installer and follow the on-screen instructions. It's like
planting a tree in your garden - you need to dig a hole, place the
tree, and water it.
For Linux:
The simplest approach to install Visual Studio Code for
Debian/Ubuntu-based distributions is to download and install
the .deb package (64-bit), either via the graphical program center
if one is provided, or via the command line with:
sudo apt install ./<file>.deb
# If you're on an older Linux distribution,
you will need to run this instead:
# sudo dpkg -i <file>.deb
# sudo apt-get install -f # Install
dependencies
Other binaries can also be found on the VS Code download
page.
When you install the.deb package, it will immediately install the
apt repository and signing key, enabling auto-updates through
the system's package management.
10
Your First Python Plant
Now that we have our garden (VS Code) ready, it's time to plant
our first Python "seed." In programming, we often start with a
simple task to get familiar with the language.
Python Seed: In Python, the smallest unit of code is often called a
"seed." It's like a tiny plant that will grow into a bigger program.
Writing and Running your First "Hello, World!" Program
In gardening, you'd water your seeds to help them grow. In
programming, we write code to make our "seeds" do something.
Let's write a simple program that prints "Hello, World!" on the
screen. This is a tradition in programming and is often the first
thing people do when learning a new language.
Step 1: Writing Your First Python Code:
1.
Open VS Code.
2.
Click on "File" in the top-left corner.
3.
Select "New File" to create a new, empty file.
4.
In the new file, type the following code:
print("Hello, World!")
11
Step 2: Running Your Code:
Now that you've written your Python code, it's time to see it in
action.
Save your file by clicking "File" > "Save" and giving it a name
like "hello.py". This is like marking the location where you
planted your seed.
To run your code, click the green triangle button (Run Python
File in Terminal) in the top-right corner of VS Code or You can
use your command line like this:
python hello.py
Results:
sherif@sherif:~$ python hello.py
Hello, World!
Congratulations! You've just planted your first Python "seed"
and watched it grow into a small program that says "Hello,
World!" This is just the beginning of your Python journey. As we
move forward, we'll learn how to grow more complex programs
and explore the vast world of Python programming. It's like
tending to a garden - with time and practice, your programming
skills will flourish
12
Chapter 2: Watering the Basics
Understanding Variables
In this chapter, we're going to delve deep into the fundamental
aspects of Python, much like nourishing your plants with the
right amount of water. We'll start by understanding what
variables are and how they help us store and manage data in
Python. Then, we'll explore the essential data types in Python,
like integers, floats, and strings, using a gardening analogy to
make these concepts crystal clear.
Imagine your Python program as a gardener's notebook. In this
notebook, you jot down information about your garden, such as
plant names and their growth. Variables in Python are like pages
in this notebook. Each variable can hold different kinds of
information, just as you'd write various notes about different
plants.
Variables: Variables are your notebook pages. They're
containers for information (data), like the pages that hold your
gardening notes. Each variable has a name, just like you'd label a
page to find your notes easily.
13
How to Use Variables:
Let's say you want to remember the temperature in your garden.
You can create a variable called temperature and store the value
in it.
temperature = 25
Here, temperature is like a tag you put on a page in your
notebook. The value 25 is what you want to remember. Later,
you can use temperature in your code to refer to this value, just as
you'd turn to the right page in your notebook to find specific
information.
The Versatility of Variables:
Variables in Python are incredibly versatile. Just like your
notebook can contain notes on various aspects of your garden,
variables can hold different types of data. For example, you can
use variables to keep track of not only temperatures but also the
number of plants, rainfall, or any other information relevant to
your garden.
How to Store and Manipulate Data in Python:
Storing Data:
In gardening, you'd want to keep track of how much water each
plant needs. Similarly, in Python, you use variables to store data.
For instance:
water_needed_for_roses = 2
14
water_needed_for_sunflowers = 3
water_needed_for_tomatoes = 1
Here, you've stored the water needs of each plant type in
different variables, just like you'd note down the care
requirements for various plants in your gardening journal.
Manipulating Data:
Imagine you need to know the total water needed for roses and
sunflowers. In Python, you can manipulate data just like you'd
combine the water requirements for different plants:
total_water_needed = water_needed_for_roses +
water_needed_for_sunflowers
In this case, you've added the water needs for roses and
sunflowers to find the total, similar to how you'd calculate the
total care requirements for different plant varieties.
Calculations and Variables:
Variables are not only for storing data but also for performing
calculations. You can use them to keep track of totals, averages,
or any other mathematical operations you might need in your
Python gardening adventures. For example:
Finding the Total Water Needed:
Suppose you want to calculate the total amount of water needed
for your roses and sunflowers based on the water requirements
you've stored in variables.
15
# Water requirements for each plant type
water_needed_for_roses = 2
water_needed_for_sunflowers = 3
# Calculate the total water needed
total_water_needed = water_needed_for_roses +
water_needed_for_sunflowers
# Display the result
print("Total water needed for roses and
sunflowers:", total_water_needed)
In this example, we've used variables water_needed_for_roses and
water_needed_for_sunflowers to store the water requirements for
roses and sunflowers, respectively. Then, we calculated the total
water needed by adding these two variables together. Finally, we
printed the result.
Finding the Average Temperature:
Let's create another calculator to find the average temperature
for a week based on daily temperature recordings.
# Daily temperature recordings for the week
monday_temperature = 25
tuesday_temperature = 28
wednesday_temperature = 24
thursday_temperature = 26
friday_temperature = 23
16
# Calculate the average temperature
average_temperature = (monday_temperature +
tuesday_temperature + wednesday_temperature +
thursday_temperature + friday_temperature) / 5
# Display the result
print("Average temperature for the week:",
average_temperature)
In this example, we've stored the daily temperatures in variables,
one for each day of the week. Then, we calculated the average
temperature by adding up the temperatures for all five days and
dividing the sum by 5 (the number of days). Finally, we printed
the average temperature.
These calculators showcase how you can use variables to store
data, perform calculations, and display the results in Python,
much like keeping track of and making sense of data in your
gardening endeavors.
Real-Life Example - Storing Temperatures
Imagine you want to track the daily temperatures in your
garden. You can create variables for each day of the week:
monday_temperature = 25
tuesday_temperature = 28
wednesday_temperature = 24
17
thursday_temperature = 26
friday_temperature = 23
Now, you've labeled each day with its temperature, much like
taking daily notes in your gardening diary. These temperature
variables allow you to keep a detailed record of your garden's
climate, just as you'd monitor and note the weather conditions
for your plants.
Data Types
Imagine your garden tools – each one serves a unique purpose. In the
world of programming, data types are like these specialized tools, each
designed for a specific task. Python, being a versatile language,
provides several data types to handle different kinds of information
effectively. Understanding these data types is vital because it helps
Python know how to manage and manipulate your data correctly.
Let's explore some of the essential data types Python has to offer:
1. Integers (int): Think of integers as whole numbers, like counting the
number of plants in your garden. They don't have decimal points.
Example:
roses_count = 10
sunflowers_count = 5
total_plants = roses_count + sunflowers_count
In this example, roses_count and sunflowers_count are both integers,
and we use them to calculate the total_plants.
18
2. Floating-Point Numbers (float): Floats are numbers with
decimal points, perfect for measuring things like the height of a
plant or the amount of rainfall.
Example:
sunflower_height = 1.5
rainfall_amount = 12.75
total_height = sunflower_height + rainfall_amount
Here, sunflower_height and rainfall_amount are float variables,
and we use them to calculate total_height.
3. Strings (str): Strings are like labels for your plants. They're
sequences of characters, often used to represent text.
Example:
plant_name = "Rose"
garden_description = "My Beautiful Garden"
In this case, plant_name and garden_description are string
variables, used for storing text information.
4. Booleans (bool): Booleans represent two states, either True or
False. They're handy for making decisions in your code, like
whether to water your plants or not.
Example:
is_raining = True
19
needs_watering = False
Here, is_raining and needs_watering are boolean variables,
indicating whether it's raining or if your plants need water.
5. Lists: Lists are like rows of plants in your garden. They can
hold multiple values of different data types in a specific order.
Example:
plants = ["Rose", "Sunflower", "Tomato"]
In this list, plants, we store multiple string values.
6. Dictionaries: Dictionaries are similar to plant labels, where
you associate a key (like a plant name) with a value (like its
color). These are also called key-value pairs.
Example:
plant_info = {"Rose": "Red", "Sunflower":
"Yellow", "Tomato": "Red"}
Here, plant_info is a dictionary containing keys (plant names)
and values (colors).
7. Sets: Set is an unordered collection of unique items. Set is
defined by values separated by commas inside braces { }.
20
Example:
# create a set named plant_id
plant_id = {112, 114, 116, 118, 115}
# display plant_id elements
print(plant_id)
# display type of plant_id
print(type(plant_id))
OutPut:
{112, 114, 115, 116, 118}
<class 'set'>
Here, we have created a set named plant_id with 5 integer
values.
Since sets are unordered collections, indexing has no meaning.
Hence, the slicing operator [] does not work.
21
Using a Gardening Analogy to Explain These Concepts
Think of data types as different tools in your gardening shed.
Just as you use a shovel for digging, scissors for pruning, and a
watering can for watering, in Python, you use different data
types to work with various kinds of data.
To summarize, in this chapter, we've learned how to use
variables as containers for data and manipulate that data. We've
also explored essential data types in Python, drawing parallels
with gardening. These concepts are like the basic tools you need
in your Python garden, and as we progress, we'll build on these
foundations to cultivate more complex and exciting programs.
Much like nurturing your plants, practice and patience will help
you become a proficient Python gardener.
22
Chapter 3: Expanding Your Python
Vocabulary
In this expansive chapter, we are about to embark on a journey
into the world of Python vocabulary. Imagine this as an exciting
treasure hunt where every new word and concept is a shiny gem
you can use to make your Python programs sparkle. Don't
worry; we'll take this journey step by step, making sure
everything is crystal clear and easy to understand.
Operators and Expressions
Arithmetic Operators: Math Magic with Python:
Let's start with arithmetic operators. Think of these as your
trusty garden tools for doing math in Python. If you have a
beautiful garden, you'd want to know how many flowers you
have, right? Well, arithmetic operators help you count them.
23
1. Addition (+): This operator is like counting how many red
and yellow flowers you have together to find the total. It's as
simple as 1, 2, 3!
Example:
red_flowers = 22
yellow_flowers = 33
total_flowers = red_flowers + yellow_flowers
print(total_flowers)
OutPut:
sherif@sherif:~$ python hello.py
55
2. Subtraction (-): Sometimes, you might give some flowers to
your friend. Subtraction helps you know how many you have
left.
Example:
total_flowers = red_flowers + yellow_flowers
flowers_given_away = 2
flowers_left = total_flowers - flowers_given_away
print(flowers_left)
24
OutPut:
sherif@sherif:~$ python hello.py
53
3. Multiplication (*): Suppose you want to plant more flowers
and need to know how many you'll have in total. Multiplication
is your tool.
flowers_per_packet = 10
packets_of_seeds = 8
total_flowers = flowers_per_packet *
packets_of_seeds
print(total_flowers)
OutPut:
sherif@sherif:~$ python hello.py
80
4. Division (/): What if you want to share your flowers equally
among friends? Division helps you find out how many each
friend can get.
25
Example:
total_flowers = 18
number_of_friends= 4
flowers_per_friend = total_flowers /
number_of_friends
print(flowers_per_friend)
OutPut:
sherif@sherif:~$ python hello.py
4.5
Comparison Operators: Comparing Things in Your Garden
Next, let's explore comparison operators. Imagine you're in your
garden and you want to figure out if you have more red flowers
than yellow ones. Comparison operators can help with that.
1. Greater Than (>): Are the red flowers more numerous than
the yellow ones?:
Example:
red_flowers = 280
yellow_flowers = 187
26
more_red_than_yellow = red_flowers >
yellow_flowers
print(more_red_than_yellow)
OutPut:
sherif@sherif:~$ python hello.py
True
2. Less Than (<): Or is it the other way around?:
Example:
red_flowers = 280
yellow_flowers = 187
more_yellow_than_red = red_flowers <
yellow_flowers
print(more_yellow_than_red)
OutPut:
sherif@sherif:~$ python hello.py
False
27
3. Equal To (==): Maybe you want to know if the red and
yellow flowers are exactly the same in number?:
Example:
red_flowers = 280
yellow_flowers = 280
equal_red_and_yellow = red_flowers ==
yellow_flowers
print(equal_red_and_yellow)
OutPut:
sherif@sherif:~$ python hello.py
True
4. Not Equal To (!=): Or perhaps you're curious if they are
different?:
red_flowers = 280
yellow_flowers = 280
different_red_and_yellow = red_flowers !=
yellow_flowers
print(different_red_and_yellow)
28
OutPut:
sherif@sherif:~$ python hello.py
False
Real-Life Garden Expenses Calculator:
Now, let's put all this to use! Think about your garden expenses.
You bought some soil, seeds, and gardening tools. You can use
Python to calculate how much you spent in total. Here's how:
●
●
●
Soil: $10 per bag
Seeds: $2 per packet
Tools: $15 each
You bought 3 bags of soil, 10 packets of seeds, and 2 tools. To
calculate the total cost:
# Calculate garden expenses
soil_cost = 10 * 3
seeds_cost = 2 * 10
tools_cost = 15 * 2
total_cost = soil_cost + seeds_cost +
tools_cost
print("Total garden expenses: $" +
str(total_cost))
29
In this example, we've used arithmetic operators to calculate
expenses for soil, seeds, and tools. By adding them up, we found
the total cost of setting up your beautiful garden.
Logical Operators: Cultivating Smart Choices in Your
Garden:
Now, imagine you're deciding whether to water your plants
based on the weather. This is similar to how Python makes
decisions using conditional statements. Let's use a weather
analogy:
●
●
●
If it's sunny, you water the plants.
If it's cloudy, you check the soil's moisture before
deciding.
If it's rainy, you don't water at all.
In Python, it would look like this:
weather = "sunny" # You can change this to
"cloudy" or "rainy"
if weather == "sunny":
print("Water the plants!")
elif weather == "cloudy":
print("Check the soil moisture before
watering.")
else:
30
print("Don't water today; it's rainy.")
OutPut:
sherif@sherif:~$ python hello.py
Water the plants!
Python's if, elif (short for "else if"), and else statements help your
program make decisions, just like you do in your garden.
Depending on the weather (or any condition you set), Python
will execute different actions.
Furthermore, let's embark on a comprehensive exploration of
logical operators. These are like the compasses guiding your
decisions in the garden, helping you make informed choices
based on various conditions. We'll delve into this topic with not
just one, but five vivid examples.
1. Logical 'AND' (and) - Sun and Wind: Imagine you're making
planting decisions based on two factors: sunshine and wind
conditions. You want to plant roses only when it's sunny and not
windy. The logical 'AND' operator is your tool.
Example:
is_sunny = True
not_windy = True
if is_sunny and not_windy:
31
print("Planting Roses")
OutPut:
sherif@sherif:~$ python hello.py
Planting Roses
2. Logical 'OR' (or) - Clouds and Overcast Skies: On a day when
the weather is uncertain, like when it's either cloudy or overcast,
you decide to plant either sunflowers or daisies. The logical 'OR'
operator helps you make this choice.
Example:
is_cloudy = False
is_overcast = True
if is_cloudy or is_overcast:
print("Planting Sunflower")
OutPut:
sherif@sherif:~$ python3 hello.py
Planting Sunflower
3. Logical 'NOT' (not) - No Rain Today: You've checked the
weather forecast, and it doesn't predict rain. That's when you
32
decide to plant lilies. The logical 'NOT' operator comes into play
here.
Example:
is_rainy = False
if not is_rainy:
print("Planting Lilies")
OutPut:
sherif@sherif:~$ python3 hello.py
Planting Lilies
4. Complex Conditions - Sun and No Frost: Sometimes, your
decisions require considering multiple conditions. To plant
tulips, you need both sunshine and a frost-free environment.
Python lets you create complex conditions with ease.
Example:
is_sunny = True
not_frosty = True
if is_sunny and not_frosty:
print("Planting Tulips")
OutPut:
33
sherif@sherif:~$ python hello.py
Planting Tulips
5. Nested Decisions - Adjusting Based on Time: Imagine you
want to plant different flowers based on the time of day. In the
morning, you prefer daisies, while in the afternoon, you opt for
sunflowers. Nested decisions allow you to make such detailed
choices.
Example:
is_morning = False
is_afternoon = True
if is_morning:
print("Planting Daisies")
elif is_afternoon:
print("Planting Sunflowers")
OutPut:
sherif@sherif:~$ python hello.py
Planting Sunflowers
In this chapter, we've not only expanded your Python vocabulary but
also provided you with the essential tools to make intelligent decisions
and solve real-life problems, all while nurturing the beauty of your
digital garden. As we continue to explore the rich landscape of Python,
remember that the possibilities are as boundless as the blossoms in a
well-tended garden. Isn't learning Python fun?
34
Chapter 4: Cultivating Control
Structures
Loops and Iteration
In the vast garden of Python programming, control structures
are the tools that help us nurture our code. They are like the
guiding principles for a gardener, helping to manage and control
the flow of a program. In this chapter, we'll delve into two vital
control structures: loops and lists (often referred to as arrays in
other programming languages).
Imagine you have a garden teeming with diverse plants, each
requiring care in various ways. Just as in your garden, your code
might need to perform specific actions repeatedly. Loops are
your trusty tools for this purpose.
Let's start by exploring two fundamental types of loops: the "for"
loop and the "while" loop.
The For Loop: Your Automated Gardening Assistant
A "for" loop is akin to setting up an automated watering system
for your garden. You specify a range or a list of items to work on
(think of these as your plants), and the loop diligently performs
the same task for each item in that range or list. It's like
systematically watering each plant in your garden, one by one,
without missing any.
35
Let's translate this into Python code:
# Suppose you have a list of plants
plants = ["Rose", "Tulip", "Lily", "Sunflower"]
# You can use a for loop to water each plant
for plant in plants:
print(f"Watering {plant}")
This loop will water each plant in your list, and you'll see the
corresponding message for each.
The While Loop: Staying in the Garden
Now, imagine you want to keep watering your plants until the
soil is no longer dry. This scenario calls for a "while" loop. It's
like staying in your garden until a specific condition is met, and
then you gracefully exit.
Here's a Python example of a "while" loop:
import random
def check_soil_moisture():
moisture_level = random.randint(1, 10)
if moisture_level > 5:
print("Soil is moist enough.")
return False
else:
print("Soil is still dry.")
return True
36
dry_soil = True
while dry_soil:
print("Watering plants...")
dry_soil = check_soil_moisture()
OutPut:
sherif@sherif:~$ python hello.py
Watering plants...
Soil is still dry.
Watering plants...
Soil is still dry.
Watering plants...
Soil is moist enough.
In this example, the check_soil_moisture() function generates a
random number to simulate the moisture level in the soil. If the
moisture level is greater than 5 (indicating moist soil), the
function returns False, indicating that it's time to stop watering.
Otherwise, it returns True, indicating that the soil is still dry and
needs more watering. So, the code will keep watering the plants
in your garden until the check_soil_moisture() function indicates
that the soil is moist enough by returning False.
37
Lists and Arrays: Organizing Data in Your Garden
Just as in a garden, you often need to organize and manage various
items. In programming, one of the most versatile tools for this task is the
list (or array, as it's called in some other programming languages).
How to Organize and Manipulate Collections of Data:
Think of a list as a collection of pots in your garden, each containing a
different type of flower. Each pot can hold various pieces of data, just
like these pots hold different flowers.
You can plant, remove, or rearrange flowers in these pots. Similarly, in
Python, you can add, remove, or modify elements in a list to organize
your data effectively.
Example:
# Create a list of fruits
fruits = ["apple", "banana", "cherry"]
# Adding a new fruit to the list
fruits.append("orange")
# Removing a fruit from the list
fruits.remove("banana")
# Accessing elements in the list
print(fruits[0]) # Output: "apple"
In this code, we have a list of fruits, and we perform various
operations on it. You can think of this list as a collection of pots,
each containing a different fruit.
38
Going Beyond the Basics: Loops and Lists in Harmony
Now, let's explore how loops and lists can work together
harmoniously to solve more complex problems.
Imagine you want to water all the plants in your garden twice a
day for a week. A "for" loop combined with a list of plants can
make this task a breeze:
Example:
plants = ["Rose", "Tulip", "Lily", "Sunflower"]
for day in range(1, 8): # Loop for a week (7
days)
for plant in plants:
print(f"Day {day}: Watering {plant}")
OutPut:
sherif@sherif:~$ python hello.py
Day 1: Watering Rose
Day 1: Watering Tulip
Day 1: Watering Lily
Day 1: Watering Sunflower
Day 2: Watering Rose
Day 2: Watering Tulip
Day 2: Watering Lily
Day 2: Watering Sunflower
Day 3: Watering Rose
Day 3: Watering Tulip
Day 3: Watering Lily
39
Day
Day
Day
Day
Day
Day
Day
Day
Day
Day
Day
Day
Day
Day
Day
Day
Day
3:
4:
4:
4:
4:
5:
5:
5:
5:
6:
6:
6:
6:
7:
7:
7:
7:
Watering
Watering
Watering
Watering
Watering
Watering
Watering
Watering
Watering
Watering
Watering
Watering
Watering
Watering
Watering
Watering
Watering
Sunflower
Rose
Tulip
Lily
Sunflower
Rose
Tulip
Lily
Sunflower
Rose
Tulip
Lily
Sunflower
Rose
Tulip
Lily
Sunflower
In this example, the outer loop iterates through each day of the
week, and the inner loop waters each plant on that day. It's like
having a well-organized schedule for your gardening tasks.
Conclusion: Cultivating Control Structures
In this extensive exploration of control structures, we've
uncovered the power of loops and the utility of lists in Python.
These fundamental concepts are like the roots and branches of a
healthy garden, providing structure and efficiency to your code.
Just as a gardener learns to tend to different plants, you'll learn
to choose the right loop or list manipulation technique for the
task at hand. With practice and patience, you'll cultivate the
skills needed to nurture your Python programs.
40
Chapter 5: Nurturing Functions and
Modules
Nurturing Functions and
Modules
In this chapter, we'll delve into the world of functions and
modules in Python. Think of functions as your gardening tools
and modules as your trusty plant nursery. We'll break down
these concepts into bite-sized pieces, making sure they're as easy
to understand as planting a seed in your backyard.
Functions: Your Gardening Tools
Functions are like the tools you use in your garden. Just as you
wouldn't try to dig a hole with your bare hands, you wouldn't
want to write long, repetitive code in Python when you can use a
function to do the heavy lifting for you.
Functions are like mini-programs within your Python program.
They're a way to group together a set of instructions so you can
use them whenever you need to perform a specific task. For
example, imagine you have a magical watering can in your
garden. Instead of explaining how to use it every time, you can
create a function called water_plants() that takes care of the task
for you.
41
Creating Functions:
Creating functions in Python is as easy as planting a seed. You
start with the def keyword, followed by the name of your
function. Then, you add parentheses () to hold any input (we'll
talk more about this later), and finally, you put a colon :. It looks
something like this:
def water_plants(arguments):
# function body
return
Here,
def - keyword used to declare a function
water_plants - name given to the function
arguments - any value passed to function
return (optional) - returns value from a function
Using Functions:
Once you've defined a function, you can use it by calling its
name. If you want to water your plants, you simply call
water_plants(), and the instructions within the function will be
executed.
42
Furthermore:
Types of function:
There are two types of function in Python programming:
1.
2.
Standard library functions - These are built-in functions
in Python that are available to use.
User-defined functions - We can create our own
functions based on our requirements.
Let’s Declare another function:
def greet(name):
return f"Hello, {name}!"
Using Functions
Here, we defined a function called greet. It takes an argument
name and returns a greeting message. Now, let's use this
function:
message = greet("Sifusherif")
print(message)
OutPut:
sherif@sherif:~$ python hello.py
Hello, Sifusherif!
43
Here,
When the function is called, the control of the program
goes to the function definition.
All codes inside the function are executed.
The control of the program jumps to the next statement
after the function call.
Multiple Arguments:
As mentioned earlier, a function can also have arguments. An
argument is a value that is accepted by a function. Imagine you
want to sum up all your crops.
Example:
# function with two arguments
def add_numbers(sunflowers, tulips):
sum = sunflowers + tulips
print('Sum: ',sum)
# function call with two values
add_numbers(5, 4)
OutPut:
sherif@sherif:~$ python hello.py
Sum: 9
Here, add_numbers(5, 4) specifies that arguments sunflowers
and tulips will get values 5 and 4 respectively.
44
We can also call the function by mentioning the argument name
as:
add_numbers(sunflowers = 5, tulips = 4)
In Python, we call it a keyword argument (or named argument).
The code above is equivalent to
add_numbers(5, 4)
The return Statement:
A Python function can either return a value or not. The return
statement is used when we want our function to return a value
to a function call.
Example:
def add_numbers():
...
return sum
Here, we are returning the variable sum to the function call.
Example:
# function definition
def find_square(num):
result = num * num
return result
45
# function call
square = find_square(3)
print('Square:',square)
OutPut:
sherif@sherif:~$ python hello.py
Square: 9
A Real-Life Example
Imagine you have different plants in your garden, and you want
to calculate their growth rate. You can create a function like this:
def calculate_growth_rate(initial_height,
final_height, days):
rate = (final_height - initial_height) / days
return rate
Now, you can calculate the growth rate for different plants
easily:
rose_growth_rate = calculate_growth_rate(10, 18,
5)
sunflower_growth_rate = calculate_growth_rate(12,
24, 7)
print(f"Rose Growth Rate: {rose_growth_rate}
cm/day")
print(f"Sunflower Growth Rate:
{sunflower_growth_rate} cm/day")
46
OutPut:
sherif@sherif:~$ python hello.py
Rose Growth Rate: 1.6 cm/day
Sunflower Growth Rate: 1.7142857142857142 cm/day
This example demonstrates how functions simplify complex
calculations.
Python's Plant Nursery: Modules
Modules are like your plant nursery in Python. They help you
organize and reuse code efficiently, just like organizing your
gardening tools.
Our program may have numerous lines of code as it develops in
size. Instead of placing everything in one file, we may utilize
modules to divide codes into several files based on their
functionality. This organizes our code and makes it easier to
maintain.
A module is a file that contains code that is used to complete a
certain task. Variables, functions, classes, and so on can all be
found in a module.
47
Creating Modules:
Before creating a module, it's essential to organize your code
logically. Think of your code as different types of plants and
gardening tools, and group related functions, variables, and
classes together. For instance, you might want to create a module
for handling various gardening tasks.
Let's assume you have a file named gardening.py and you want
to create a module to manage watering and pruning tasks.
# gardening.py
def water_plants():
print("Watering the plants.")
def prune_plants():
print("Pruning the plants.")
To turn this script into a module that can be reused in other
Python programs, save it with a .py extension. In this case, save
it as gardening.py. Your module is now ready to be used.
Using Your Custom Module
Now, let's create a separate Python script to use the gardening
module we just created.
# main.py
import gardening
# Using functions from the gardening module
48
gardening.water_plants()
gardening.prune_plants()
To run this program, make sure both main.py and gardening.py
are in the same directory.
python main.py
OutPut:
sherif@sherif:~/Desktop/bookpy$ python main.py
Watering the plants.
Pruning the plants.
Here, we've successfully imported and used the functions from
our custom module.
Advanced Module Usage:
Modules can also contain variables and classes. For example,
you might want to store the names of different plant species in
your gardening module.
# gardening.py
# Variables
plant_species = ["Rose", "Sunflower", "Tulip",
"Lily"]
49
# Function to add a new plant to the list
def add_plant(new_plant):
plant_species.append(new_plant)
# Class for representing a garden
class Garden:
def __init__(self, name):
self.name = name
self.plants = []
def add_plant(self, plant):
self.plants.append(plant)
def display_plants(self):
print(f"Plants in {self.name} garden:")
for plant in self.plants:
print(plant)
Now, in your main.py script, you can use these variables and
classes:
# main.py
import gardening
# Using variables from the gardening module
print(gardening.plant_species)
# Using the Garden class
my_garden = gardening.Garden("My Backyard")
my_garden.add_plant("Rose")
my_garden.add_plant("Sunflower")
my_garden.display_plants()
50
OutPut:
sherif@sherif:~/Desktop/bookpy$ python main.py
['Rose', 'Sunflower', 'Tulip', 'Lily']
Plants in My Backyard garden:
Rose
Sunflower
This demonstrates that modules can contain various elements,
making them versatile for organizing and reusing code.
Benefits of Using Modules
Code Reusability: Modules allow you to reuse code
across multiple programs, saving you time and effort.
Organization: Modules help you structure your code
logically, making it easier to maintain.
Collaboration: When working on projects with others,
modules help organize code components and reduce
conflicts.
Namespace Management: Modules prevent naming
clashes by encapsulating variables, functions, and
classes within their own namespaces.
Readability: Using modules makes your code more
readable and understandable, as you can import and use
functions, variables, and classes with meaningful names.
Furthermore,
51
Import Python Standard Library Modules:
There are about 200 modules in the Python standard library. We
can import a module based on our requirements.
Suppose we want to get the value of pi. First, we import the
math module and use math.pi.
Example:
# import standard math module
import math
# use math.pi to get value of pi
print("The value of pi is", math.pi)
OutPut:
sherif@sherif:~/Desktop/bookpy$ python example.py
The value of pi is 3.141592653589793
Python import with Code-Naming:
# import module by code-naming it
import math as m
print(m.pi)
# Output: 3.141592653589793
52
We have renamed the math module to m in this case. In
some circumstances, this can save us typing time.
Acknowledged that the name math is not recognized in
our context. As a result, math.pi is incorrect, whereas m.pi
is the right implementation.
Python from...import statement:
We can import individual names from a module without
importing the entire module.
Example:
# import only pi from math module
from math import pi
print(pi)
# Output: 3.141592653589793
Here, we imported only the pi attribute from the math
module.
Import all names:
In Python, we can use the following construct to import all
names (definitions) from a module:
53
Example:
# import all names from the standard module
math
from math import *
print("The value of pi is", pi)
These extensive explanations and examples should help you
grasp the concepts of functions and modules in Python
thoroughly. In the upcoming sections, we will dive deeper into
each topic, exploring advanced features and best practices for
nurturing your Python garden.
54
Chapter 6: Tending to Errors and
Exceptions
Debugging and Exception
Handling
Welcome to Chapter 6 of our Earthly Themed Python Book,
where we'll delve into the fascinating world of handling errors
and exceptions in Python. Don't worry, we won't be using too
much fancy jargon - our aim is to make this as easy as plucking
weeds from your garden.
Debugging: Weeding Your Garden
Picture your code as a lush garden. Just like a garden can have
weeds, your code can have errors. Debugging is the process of
finding and removing these errors, just like weeding your
garden.
55
What are Errors?
In the world of coding, errors are like the weeds that pop up
unexpectedly in your garden. They can mess up your beautiful
program and make it behave strangely.
Imagine you're writing a program to calculate the area of a circle,
but you accidentally type 'radisu' instead of 'radius.' This is a
common error called a typo. Just as a weed disrupts your
garden's harmony, this typo disrupts your code.
Techniques for Finding Errors
Reading Your Code: Imagine you're inspecting your
garden closely to spot weeds. Similarly, carefully read
your code line by line. For instance, if you've misspelled
a variable name, it's like mistaking a daisy for a daffodil.
radisu = 5
area = 3.14 * radius
2
# Oops! Typo here.
Using Print Statements: Think of adding print
statements in your code as placing flags next to weeds. It
helps you mark points where you suspect errors.
print("Before calculation")
area = 3.14 * radius 2
print("After calculation")
Online Resources: The internet is like a giant gardening
encyclopedia. You can search online for solutions to
56
common coding problems. Chances are, someone else
has already dealt with a similar error.
try:
result = 10 / 0 # This is bad, division by
zero error.
except ZeroDivisionError as e:
print(f"Oops! {e} occurred.")
Fixing Errors
Once you've found an error, it's time to remove it like you would
a weed:
Identify the Error Type: Just as you'd recognize different
types of weeds, understand what kind of error you're
dealing with. Python provides helpful error messages
that give you clues.
try:
result = 10 / 0
except ZeroDivisionError as e:
print(f"Oops! {e} occurred.")
Trace the Cause: Like following the roots of a weed to
remove it completely, trace the cause of the error back to
its source in your code.
def calculate_area(radius):
return 3.14 * radius 2
57
# Error here
Modify the Code: Once you've identified the problem,
make the necessary changes. Remove the error like
you'd pull out the weed from your garden.
def calculate_area(radius):
return 3.14 * radius 2
correcting the typo
# Fixed it by
Test Your Code: After making changes, test your code
again. Make sure the error is gone, just like ensuring the
weed doesn't come back.
def calculate_area(radius):
return 3.14 * radius 2
radius = 5
area = calculate_area(radius)
print(f"The area is: {area}")
Handling Exceptions
Imagine you're walking in your garden, and you trip over a
stone. Handling exceptions in Python is like gracefully
recovering from this stumble.
What are Exceptions?
Exceptions are like unexpected obstacles in your code that can
make it crash. But, just like you'd gracefully recover from a
stumble, Python allows you to handle exceptions without
crashing your program.
58
Let's take a look at some common exceptions:
ZeroDivisionError: This occurs when you try to divide a
number by zero. It's like trying to divide a pie into zero
slices - impossible!
try:
result = 10 / 0
except ZeroDivisionError as e:
print(f"Oops! {e} occurred.")
TypeError: This happens when you try to perform an
operation on an inappropriate data type. It's like trying
to water your plants with a chocolate syrup bottle
instead of a watering can.
name = "sifusherif"
age = 30
result = name + age # TypeError: can only
concatenate str (not "int") to str
FileNotFoundError: If you try to open a file that doesn't
exist, you'll get this error. It's like searching for a rare
flower in your garden that isn't there.
try:
file = open("nonexistent_file.txt", "r")
except FileNotFoundError as e:
59
print(f"Oops! {e} occurred.")
Dealing with Errors Gracefully
1.
Try and Except: This is your safety net. Wrap a piece of
code in a try block and catch potential errors in an
except block. It's like walking carefully in your garden to
avoid stumbling on hidden obstacles.
try:
result = 10 / 0
except ZeroDivisionError as e:
print(f"Oops! {e} occurred.")
2.
Specific Exception Handling: Just as you'd use different
techniques to handle different obstacles in your garden
(a slippery stone versus a thorny bush), you can handle
specific types of exceptions differently in Python.
try:
age = int(input("Enter your age: "))
except ValueError as e:
print(f"Oops! {e} occurred. Please enter a
valid number.")
3.
Finally Block: Think of this like always carrying a
first-aid kit in your garden. The finally block ensures
that certain code will run whether there's an exception or
not.
60
try:
file = open("my_file.txt", "r")
# Some code that may raise an exception
except FileNotFoundError as e:
print(f"Oops! {e} occurred.")
finally:
file.close()
4.
Raising Exceptions: Sometimes, you might need to
throw an exception yourself, just like putting up a
"Beware of the Dog" sign in your garden. You can do this
using the raise statement.
def sqrt(x):
if x < 0:
raise ValueError("Cannot calculate square
root of a negative number")
else:
return x 0.5
Remember, just like tending to your garden makes it flourish,
tending to errors and exceptions in your code makes it robust
and reliable. So, keep weeding out those errors and gracefully
handling exceptions, and your Python programs will thrive in no
time!
61
Chapter 7: Blooming Beyond
the Basics
File handling, Dictionaries and
Sets
In this chapter, we're going to dig even deeper into the
fascinating world of Python. We'll explore two crucial topics that
will help you become a proficient Python gardener: File
Handling and Dictionaries & Sets. Don't worry; we'll use simple
language and everyday analogies to make these concepts easy to
understand.
File Handling: Tending to Your Python Diary
Imagine you have a diary where you jot down your thoughts
and experiences every day. Python can do something similar
with files - think of them as digital diaries!
A file is a container used to store data in computer storage
devices.
When we wish to read or write to a file, we must first open it.
When we're finished, it needs to be closed so that the resources
associated with the file may be released.
Thus, in Python, a file operation occurs in the following order:
Open a document
Read or write (execute operation)
62
Save the file.
Reading from Files
Reading from files is like opening your diary and going through
your past entries. You can read what you wrote, learn from it,
and use that knowledge for various purposes.
Example:
my_diary.txt:
JavaScript will never be better than Python in my
Opinion.
I just wear glasses for fun.
# Let's read from a file
with open('my_diary.txt', 'r') as diary_file:
contents = diary_file.read()
print(contents)
OutPut:
sherif@sherif:~/Desktop/bookpy$ python files.py
JavaScript will never be better than Python in my
Opinion.
I just wear glasses for fun.
63
In this example, Python opens 'my_diary.txt' (our diary), reads
its contents, and displays them on the screen. By default, the files
are open in read mode (cannot be modified).
Different Modes to Open a File in Python
Mode
Description
r
Open a file for reading. (default)
w
Create a new file for writing. If
the file does not exist, it is
created; otherwise, it is
truncated.
x
Open a file for exclusive
creation. If the file already
exists, the operation fails.
a
Open a file for appending at the
end of the file without
truncating it. Creates a new file
if it does not exist.
t
Open in text mode.
b
Open in binary mode.
+
Open a file for updating
(reading and writing)
64
Writing to Files
Writing to files is like adding new entries to your diary. You can
record your thoughts, experiences, and observations for future
reference.
There are two things we need to remember while writing to a
file.
If we try to open a file that doesn't exist, a new file is
created.
If a file already exists, its content is erased, and new
content is added to the file.
# Let's write to a file
with open('my_diary.txt', 'a') as diary_file:
new_entry = "Today was a sunny day. I enjoyed
a long walk in the garden."
diary_file.write(new_entry)
my_diary.txt after running our Python file:
JavaScript will never be better than Python in my
Opinion.
I just wear glasses for fun. Today was a sunny
day. I enjoyed a long walk in the garden.
Python appends the new entry to 'my_diary.txt', just like you'd
add a new day's experiences to your physical diary.
65
Exception Handling in Files
If an exception occurs when we are performing some operation
with the file, the code exits without closing the file. A safer way
is to use a try...finally block.
# Let's write to a file
try:
with open('my_diary.txt', 'a') as diary_file:
new_entry = "Today was a sunny day. I
enjoyed a long walk in the garden."
diary_file.write(new_entry)
finally:
diary_file.close()
Here, we have closed the file in the finally block as finally always
executes, and the file will be closed even if an exception occurs.
Use of with...open Syntax
In Python, we can use the with...open syntax to automatically
close the file. Which we have been using:
with open('my_diary.txt', 'a') as diary_file:
new_entry = "Today was a sunny day. I enjoyed
a long walk in the garden."
diary_file.write(new_entry)
Note: Since we don't have to worry about closing the file, make a
habit of using the with...open syntax.
66
Python File Methods
There are various methods available with the file object. Some of
them have been used in the above examples.
Method
Description
close()
Closes an opened file. It has
no effect if the file is already
closed.
detach()
Separates the underlying
binary buffer from the
TextIOBase and returns it.
fileno()
Returns an integer number
(file descriptor) of the file.
seek(offset,from=SEEK_SET)
Changes the file position to
offset bytes, in reference to
from (start, current, end).
writelines(lines)
Writes a list of lines to the file.
write(s)
Writes the string s to the file
and returns the number of
characters written.
truncate(size=None)
Resizes the file stream to size
bytes. If size is not specified,
resizes to current location.
writable()
Returns True if the file stream
can be written to.
67
tell()
Returns an integer that
represents the current
position of the file's object.
seekable()
Returns True if the file stream
supports random access.
readlines(n=-1)
Reads and returns a list of
lines from the file. Reads in at
most n bytes/characters if
specified.
readline(n=-1)
Reads and returns one line
from the file. Reads in at most
n bytes if specified.
flush()
Flushes the write buffer of the
file stream.
isatty()
Returns True if the file stream
is interactive.
read(n)
Reads at most n characters
from the file. Reads till end of
file if it is negative or None.
and many more.
Dictionaries and Sets: Your Python Garden Catalog
Now, let's talk about Dictionaries and Sets. Think of these as
tools you can use to organize information, just like you'd create a
catalog for your garden.
68
Dictionaries: Your Plant Encyclopedia
Imagine you have a book that contains detailed information
about each plant in your garden. Each plant has a name and a
description. In Python, we can use dictionaries to achieve this.
Example:
# Creating a dictionary for your garden catalog
plant_catalog = {
'Rose': 'A beautiful, fragrant flower with
thorns.',
'Lily': 'Elegant flowers often associated with
purity.',
'Sunflower': 'Bright, yellow flowers that
follow the sun.'
}
# Accessing information about a plant
print(plant_catalog['Rose'])
OutPut:
sherif@sherif:~/Desktop/bookpy$ python dict.py
A beautiful, fragrant flower with thorns.
Here, plant_catalog is like your garden catalog, and you can
easily look up information about any plant, just like you would
in your plant book.
69
Furthermore,
You can create a dictionary using the dict() constructor to create
your dictionaries:
Example:
# Creating a dictionary for your garden catalog
plant_catalog = dict({
'Rose': 'A beautiful, fragrant flower with
thorns.',
'Lily': 'Elegant flowers often associated with
purity.',
'Sunflower': 'Bright, yellow flowers that
follow the sun.'
})
Adding an Item to our Dictionary:
We can add an item to the dictionary by assigning a value to a
new key (that does not exist in the dictionary), use the square
brackets []:
# Adding a new plant
plant_catalog['Tulip'] = 'Colorful flowers,
symbolizing spring.'
# Updating an existing plant's description
plant_catalog['Rose'] = 'A symbol of love and
romance.'
70
Remove Dictionary Items:
We use the del keyword to remove an element from our catalog
(the dictionary).
# Removing a plant
del plant_catalog['Sunflower']
Python Dictionary Methods
Here are some of the commonly used dictionary methods.
Function
Description
pop()
Remove the item with the
specified key.
update()
Add or change dictionary items.
clear()
Remove all the items from the
dictionary.
keys()
Returns all the dictionary's keys.
values()
Returns all the dictionary's
values.
get()
Returns the value of the specified
key.
popitem()
Returns the last inserted key and
value as a tuple.
copy()
Returns a copy of the dictionary.
71
Sets: Keeping Track of Garden Visitors
Think of a set as a special garden where every plant (element) is
unique. In your Python garden, you can use sets to store and
manipulate collections of distinct items.
Creating Sets
You can create a set by enclosing a list of elements in curly braces
{} or by using the set() constructor:
# Creating a set using curly braces
my_set = {1, 2, 3, 4, 5}
# Creating a set using set() constructor
another_set = set([5, 6, 7, 8, 9])
Adding Elements
In your garden, you can invite new visitors by adding elements
to your set using the add() method:
garden_visitors = {'Squirrel', 'Butterfly',
'Hummingbird'}
# Adding a new visitor
garden_visitors.add('Rabbit')
# Now your set contains: {'Squirrel', 'Butterfly',
'Hummingbird', 'Rabbit'}
Removing Elements
If a visitor overstays their welcome, you can politely remove
them from your set using the remove() method:
# Removing a visitor
72
garden_visitors.remove('Squirrel')
# Now your set contains: {'Butterfly',
'Hummingbird', 'Rabbit'
Checking for Membership
You can check if a particular visitor is in your garden using the
in keyword. It's like looking in your guestbook:
# Checking if a visitor has been to your garden
print('Squirrel' in garden_visitors) # False
print('Butterfly' in garden_visitors) # True
Set Operations
Sets support various operations that can help you manage your
garden effectively. Here are a few:
Union: Combining two sets to get a new set containing
all unique elements from both.
set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1 | set2 # or use
set1.union(set2)
# union_set contains {1, 2, 3, 4, 5}
Intersection: Finding elements that are common to both
sets.
set1 = {1, 2, 3}
set2 = {3, 4, 5}
73
intersection_set = set1 & set2 # or use
set1.intersection(set2)
# intersection_set contains {3}
Difference: Finding elements that are in one set but not
the other.
set1 = {1, 2, 3}
set2 = {3, 4, 5}
difference_set = set1 - set2 # or use
set1.difference(set2)
# difference_set contains {1, 2}
Python Sets Methods
Here are some of the commonly used set methods.
Function
Description
all()
Returns True if all elements of the
set are true (or if the set is
empty).
any()
Returns True if any element of
the set is true. If the set is empty,
returns False.
sorted()
Returns a new sorted list from
elements in the set(does not sort
the set itself).
sum()
Returns the sum of all elements
in the set.
74
min()
Returns the smallest item in the
set.
max()
Returns the largest item in the
set.
len()
Returns the length (the number
of items) in the set.
enumerate()
Returns an enumerate object. It
contains the index and value for
all the items of the set as a pair.
Sets are incredibly useful for tasks where you need to ensure
uniqueness and perform operations like finding common
elements or differences between collections. They are like your
garden, keeping track of unique visitors and helping you
manage them efficiently.
Exploring More Advanced Data Structures
In the vast garden of Python, you'll encounter a variety of data
structures that can help you manage and organize your
information efficiently. In this section, we'll take a quick look at
two advanced data structures: Lists and Tuples.
Lists: Your Dynamic Garden Bed
Imagine a dynamic garden bed where you can plant an array of
different flowers, and have the flexibility to change the
arrangement whenever you like. Python's lists are just like that!
They allow you to store multiple items in a single variable.
75
Creating Lists
You can create lists by enclosing elements in square brackets []:
flowers = ['Rose', 'Lily', 'Tulip', 'Sunflower']
Adding and Removing Elements
In your dynamic garden bed, you can plant new flowers or
remove existing ones easily:
# Adding a new flower
flowers.append('Daisy')
# Removing a flower
flowers.remove('Lily')
Accessing Elements
You can pluck any flower from your garden bed by using its
position, known as an index. In Python, the first element is at
index 0, the second at index 1, and so on:
first_flower = flowers[0]
# 'Rose'
Tuples: Your Immutable Garden Decor
Imagine you have a collection of decorative stones that you want
to strategically place in your garden, and once placed, you never
intend to move them. Tuples in Python are like these unchanging
garden decorations.
76
Creating Tuples
You can create tuples by enclosing elements in parentheses ():
garden_decor = ('Fountain', 'Gazebo', 'Stone
Bench')
Immutable Nature
Once you've placed your garden decor, it stays put. Tuples are
immutable, meaning you can't change their elements after
creation:
# This will raise an error
garden_decor[0] = 'Statue'
Garden Catalog Using Dictionaries: Your Comprehensive
Garden Database
Creating a garden catalog using dictionaries allows you to build
a comprehensive database of your plants with rich information.
It's not just about adding entries; you can also edit and remove
them as your garden evolves.
Creating a Detailed Catalog
We've already seen how to create a garden catalog using
dictionaries. Now, let's imagine you've built a substantial
catalog, and you want to make updates.
77
garden_catalog = {
'Rose': {
'Description': 'A beautiful, fragrant
flower with thorns.',
'Color': 'Red, Pink, White, Yellow',
'Care Instructions': 'Water regularly,
prune dead branches.'
},
'Lily': {
'Description': 'Elegant flowers often
associated with purity.',
'Color': 'White, Pink, Purple',
'Care Instructions': 'Plant in
well-drained soil, provide sunlight.'
},
'Tulip': {
'Description': 'Colorful flowers,
symbolizing spring.',
'Color': 'Various Colors',
'Care Instructions': 'Plant in the fall
for spring blooms.'
}
}
Editing Entries
As your garden knowledge grows, you might want to update the
information in your catalog.
# Editing the Rose entry to include more care
instructions
garden_catalog['Rose']['Care Instructions'] =
78
'Water deeply, fertilize in spring, prune in late
winter.'
Now, your catalog contains updated care instructions for roses.
Adding New Entries
When you introduce new plants to your garden, you can easily
add them to your catalog:
# Adding a new plant to the catalog
garden_catalog['Daffodil'] = {
'Description': 'Vibrant yellow spring flowers
with trumpet-shaped blooms.',
'Color': 'Yellow, White',
'Care Instructions': 'Plant bulbs in the fall
for spring blossoms.'
}
Now, your catalog includes information about Daffodils.
Removing Entries
If, for any reason, you decide to remove a plant from your
garden, you can also remove it from your catalog:
# Removing the Lily entry from the catalog
del garden_catalog['Lily']
79
Now, your catalog no longer contains information about Lilies.
By understanding how to edit, add, and remove entries in your
garden catalog using dictionaries, you can keep it up-to-date and
reflective of the ever-changing beauty of your garden. Your
catalog becomes a valuable resource.
80
Chapter 8: Sprouting into
Object-Oriented Programming
Object-Oriented Concepts
In this chapter, we'll delve into the world of object-oriented
programming (OOP), and we'll explain it like you're tending to
your very own garden. Just like plants need care, attention, and
the right tools to grow, so do objects in the world of
programming. Let's start by understanding the basic concepts.
Python is a flexible programming language that supports a
variety of programming paradigms, including object-oriented
programming (OOP), by utilizing objects and classes.
Anything with characteristics and actions is an object. A parrot is
an example of an object. It has
features - like name, age, and color.
behavior - such as singing and dancing.
A class is an object's blueprint in a similar way.
Introduction to Classes and Objects
Think of a class as a blueprint for a plant, a set of instructions
that tells the computer how to create a plant. An object, on the
other hand, is like a real plant, created based on that blueprint.
So, classes are like the plans, and objects are like the actual plants
in your garden.
81
Imagine you have a class called "Plant," and you create objects
from it, such as "Rose," "Sunflower," and "Cactus." Each of these
objects is a unique instance of the "Plant" class, just like each
plant in your garden is unique, even though they all share
common characteristics, like needing water and sunlight.
Let's see some code to make it crystal clear!
Example:
# Define a simple Plant class
class Plant:
def __init__(self, name, color):
self.name = name
self.color = color
def grow(self):
print(f"{self.name} is growing!")
# Create instances of the Plant class
rose = Plant("Rose", "Red")
sunflower = Plant("Sunflower", "Yellow")
# Accessing object properties
print(f"The {rose.name} is {rose.color}.")
print(f"The {sunflower.name} is
{sunflower.color}.")
# Calling object methods
rose.grow()
sunflower.grow()
82
Expected Outcomes:
1.
2.
3.
4.
The Plant class is defined with a constructor (__init__)
that takes two parameters: name and color. These
parameters are used to initialize the properties of the
object.
We create two objects, rose and sunflower, using the
Plant class. We pass specific names and colors for each
plant during object creation.
We access the properties name and color of each object
using dot notation.
We call the grow method on both objects, which results
in printing a message indicating that each plant is
growing.
When you run this code, you'll see the expected outcomes:
sherif@sherif:~/Desktop/bookpy$ python oop.py
The Rose is Red.
The Sunflower is Yellow.
Rose is growing!
Sunflower is growing!
Furhtermore,
Encapsulation:
Encapsulation is like putting your plants inside a planter to
protect them. It means bundling the data (like the material and
size of a planter) and the functions (methods) that work on that
data together in a class. This keeps things organized and secure.
83
Here's how it looks in code:
class Planter:
def __init__(self, material, size):
self.material = material
self.size = size
def describe(self):
return f"This planter is made of
{self.material} and is {self.size}."
# Create a planter
my_planter = Planter("Clay", "Medium")
# Access planter properties and methods
print(my_planter.describe())
In this example, the describe method is encapsulated within the
Planter class. It allows you to access planter details in a
controlled way.
Inheritance Explained
Inheritance is like a family tree in your garden. You have a
"Super Plant" class (the parent), and from it, you can create "Sub
Plant" classes (the children). The Sub Plant classes inherit
characteristics and behaviors from the Super Plant, just as
children inherit traits from their parents.
84
Let's see how this works:
# Define a Super Plant class
class SuperPlant:
def __init__(self, name, color):
self.name = name
self.color = color
def grow(self):
return f"{self.name} is growing!"
# Create a Sub Plant class (Rose) inheriting from
Super Plant
class Rose(SuperPlant):
def bloom(self):
return f"The {self.color} rose is blooming
with beautiful flowers!"
# Create a Sub Plant class (Cactus) inheriting
from Super Plant
class Cactus(SuperPlant):
def prick(self):
return f"The {self.color} cactus has sharp
spines!"
# Create instances of Sub Plant classes
red_rose = Rose("Rose", "Red")
green_cactus = Cactus("Cactus", "Green")
# Access properties and methods
print(f"The {red_rose.name} is {red_rose.color}.")
print(f"The {green_cactus.name} is
{green_cactus.color}.")
85
print(red_rose.grow())
print(green_cactus.grow())
print(red_rose.bloom())
print(green_cactus.prick())
This demonstrates how inheritance allows you to create
specialized classes (Sub Plants) that inherit common features and
behaviors from a more general class (Super Plant). Just like in
your garden, different plants can inherit traits from a common
ancestor while having their unique characteristics.
Polymorphism:
Polymorphism is like having different plants that all respond to
the same action in their unique way. For example, different
plants may all "grow" when you water them, but the way they
grow can be different. This concept is implemented using
method overriding.
Example:
class Plant:
def grow(self):
pass # Placeholder method
class Rose(Plant):
def grow(self):
return "The rose is growing tall and
86
producing beautiful flowers."
class Cactus(Plant):
def grow(self):
return "The cactus is growing slowly and
sprouting new spines."
# Create different plants
my_rose = Rose()
my_cactus = Cactus()
# Make the plants grow
print(my_rose.grow())
print(my_cactus.grow())
Here, we have a base class Plant with a grow method. Both Rose
and Cactus classes inherit from Plant and override the grow
method with their own behavior. When we call grow on each
plant, they exhibit polymorphism by responding differently.
Key Points to Remember:
●
●
●
●
Object-Oriented Programming makes the program easy
to understand as well as efficient.
Since the class is sharable, the code can be reused.
Data is safe and secure with data abstraction.
Polymorphism allows the same interface for different
objects, so programmers can write efficient code.
87
Chapter 9: Harvesting Python
Projects
Plant Watering Reminder & A
Garden Planner
In this chapter, we'll explore the concept of harvesting Python
projects, much like reaping the fruits of your labor in a bountiful
garden. We'll cover two practical project examples: a plant
watering reminder and a garden planner. Additionally, we'll
delve into the basics of sharing and publishing your Python
projects, ensuring your hard work reaches a wider audience.
A Plant Watering Reminder:
Imagine you've created a Python program that helps you keep
your plants healthy by reminding you when it's time to water
them. Let's break down how you can build such a project.
Example:
import time
class Plant:
def __init__(self, name, watering_interval):
self.name = name
self.watering_interval = watering_interval
self.last_watered = time.time()
88
def needs_water(self):
current_time = time.time()
time_since_last_water = current_time self.last_watered
return time_since_last_water >=
self.watering_interval
def water(self):
self.last_watered = time.time()
print(f"You watered the {self.name}.")
# Create plant instances
rose = Plant("Rose", 86400) # Water every day
(86400 seconds)
cactus = Plant("Cactus", 604800) # Water every
week (604800 seconds)
# Check if plants need water
if rose.needs_water():
rose.water()
else:
print("Rose Does not need watering!")
if cactus.needs_water():
cactus.water()
else:
print("Cactus Does not need watering!")
89
Explanation:
1.
2.
3.
4.
5.
We define a Plant class with attributes like the plant's
name, watering interval (in seconds), and the last time it
was watered.
The needs_water method calculates the time elapsed
since the last watering and compares it to the watering
interval. If the plant needs water, it returns True.
The water method updates the last watering time and
prints a message.
We create instances of the Plant class (e.g., rose and
cactus) with different watering intervals.
We use conditional statements to check if each plant
needs water and, if so, we water it.
A Garden Planner
Now, let's consider another project: a Python-based garden
planner. This tool can help you design your dream garden by
specifying the layout and types of plants you want to include.
Example:
class Garden:
def __init__(self):
self.layout = {}
def add_plant(self, row, col, plant):
if (row, col) not in self.layout:
self.layout[(row, col)] = []
self.layout[(row, col)].append(plant)
def view_layout(self):
for position, plants in
90
self.layout.items():
print(f"At position {position},
plant(s): {', '.join(plants)}")
# Create a garden
my_garden = Garden()
# Add plants to the garden
my_garden.add_plant(1, 1, "Rose")
my_garden.add_plant(2, 2, "Sunflower")
my_garden.add_plant(1, 1, "Tulip")
# View the garden layout
my_garden.view_layout()
Explanation:
1.
2.
3.
4.
We define a Garden class to represent the garden layout,
using a dictionary to store plant positions as keys and a
list of plants as values.
The add_plant method allows us to add plants to
specific positions in the garden.
The view_layout method displays the garden layout,
showing the positions and the plants at each position.
We create a my_garden instance and add various plants
to different positions.
Finally, we view the garden layout to see where each plant is
located.
91
Furthermore,
Example 1: Task Manager
In this example, we'll create a simple task manager that allows
users to add, view, and mark tasks as complete.
Example:
class TaskManager:
def __init__(self):
self.tasks = []
def add_task(self, task):
self.tasks.append(task)
def view_tasks(self):
for i, task in enumerate(self.tasks,
start=1):
print(f"{i}. {task}")
def complete_task(self, task_index):
if 1 <= task_index <= len(self.tasks):
self.tasks.pop(task_index - 1)
else:
print("Invalid task index.")
# Create a TaskManager instance
my_task_manager = TaskManager()
# Add tasks
my_task_manager.add_task("Buy groceries")
my_task_manager.add_task("Finish homework")
my_task_manager.add_task("Call mom")
92
# View tasks
print("Tasks:")
my_task_manager.view_tasks()
# Complete a task
my_task_manager.complete_task(2)
# View updated tasks
print("\nUpdated Tasks:")
my_task_manager.view_tasks()
Explanation:
1.
2.
3.
4.
5.
We define a TaskManager class to manage tasks using a
list.
The add_task method adds tasks to the list.
The view_tasks method displays all tasks with their
corresponding indices.
The complete_task method allows us to mark tasks as
complete by specifying their index.
This example introduces a basic project—a task
manager—that demonstrates how you can organize data
using lists, perform operations on it, and present the
results.
Example 2: Address Book
In this example, we'll create a simple address book to store
contact information using dictionaries.
Example:
93
class AddressBook:
def __init__(self):
self.contacts = {}
def add_contact(self, name, phone):
self.contacts[name] = phone
def view_contacts(self):
for name, phone in self.contacts.items():
print(f"{name}: {phone}")
def search_contact(self, name):
if name in self.contacts:
print(f"{name}:
{self.contacts[name]}")
else:
print(f"{name} not found in the
address book.")
# Create an AddressBook instance
my_address_book = AddressBook()
# Add contacts
my_address_book.add_contact("Alice", "555-1234")
my_address_book.add_contact("Bob", "555-5678")
# View contacts
print("Contacts:")
my_address_book.view_contacts()
# Search for a contact
print("\nSearching for contact:")
my_address_book.search_contact("Alice")
94
my_address_book.search_contact("Charlie")
Explanation:
1.
2.
3.
4.
5.
We define an AddressBook class to store contact
information in a dictionary.
The add_contact method adds contacts to the dictionary.
The view_contacts method displays all contacts.
The search_contact method searches for a contact by
name and displays their phone number.
This example illustrates how you can use dictionaries to
manage data, add, search, and present contact
information effectively.
95
Conclusion
Conclusion
Conclusion
Congratulations! You've embarked on a journey through your
Python garden, and now it's time to reflect on what you've
learned and how far you've come. In this final chapter, we'll
summarize your journey from planting the seeds of knowledge
to harvesting the fruits of your efforts. We'll also offer some
encouragement to cultivate a lifelong passion for Python
programming.
Reflecting on Your Python Garden
Throughout this book, you've learned about the fundamental
concepts of Python programming, much like how a gardener
learns about soil, seeds, and tools. You started by preparing the
ground, which is akin to setting up your development
environment. You planted seeds of understanding in the form of
variables, data types, and basic operations.
As your Python garden grew, you explored the branches of
control flow and learned to make decisions and repeat tasks. You
nurtured your garden with functions, organizing your code
neatly and efficiently. Just as a gardener tends to different plants,
you learned to handle lists, dictionaries, and other data
structures, allowing you to store and manipulate information
effectively.
96
In the chapter on Object-Oriented Programming, you delved into
creating your own classes and objects, drawing parallels with
planting unique plants in custom-made planters. You also
grasped the concepts of encapsulation, polymorphism, and
inheritance, understanding how to design flexible and organized
code structures.
Cultivating a Lifelong Passion
As you close this chapter and the book, remember that your
Python journey is just beginning. Cultivating a lifelong passion
for Python programming is like tending to a perennial garden.
Here are some words of encouragement:
1. Keep Growing: Just as plants continue to grow and adapt,
your Python skills will flourish with practice. Explore more
advanced topics like web development, data analysis, or
machine learning to expand your knowledge.
2. Community Matters: Just as gardeners share tips and advice,
Python enthusiasts around the world are eager to help. Engage
with the Python community, ask questions, and contribute to
open-source projects.
3. Experiment and Explore: Like a gardener trying out new
plants, don't be afraid to experiment. Build projects, solve
real-world problems, and explore Python's vast ecosystem of
libraries and frameworks.
4. Stay Curious: Just as a gardener is always curious about new
species, stay curious about the ever-evolving world of
technology. Python is a versatile language that can be applied in
various domains.
97
5. Teach and Share: Sharing your knowledge with others is like
propagating plants. Teach Python to friends, colleagues, or even
start a blog or YouTube channel to help others on their journey.
Remember, your Python garden is a place of growth and
creativity. It's a journey with no end, where each step leads to
new discoveries and opportunities. So, keep tending to your
garden, and you'll continue to reap the rewards of your efforts.
Thank you for choosing this book to start your Python
adventure. May your Python garden flourish, and may you
harvest bountiful experiences in your programming journey!
Python Resources
1. Intro to Python
This a great course to get started with learning Python, if you
have no coding experience.
https://www.kaggle.com/learn/intro-to-programming
2. CS105: Introduction to Python
The course covers a range of topics, such as data types, control
flow,
functions,
file
operations,
and object-oriented
programming. When you finish this course, you will be able to
create Python programs for a variety of applications.
https://learn.saylor.org/course/view.php?id=439
3. Python Programming course
Learn the fundamentals like functions, loops, conditional
statements, etc of the most important language for data science.
98
https://www.kaggle.com/learn/python
4. Programming Essentials in Python
Part 1 prepares you for PCEP – Certified Entry-Level Python
Programmer Certification.
Part 2 prepares you for PCAP – Certified Associate in Python
Programming Certification.
https://www.netacad.com/courses/programming/pcap-progra
mming-essentials-python
5. CS50’s Introduction to Programming with Python
Learn about functions, arguments, and return values; variables
and types; conditionals and Boolean expressions; and loops.
Learn how to handle exceptions, find and fix bugs, and write
unit tests; use third-party libraries.
https://cs50.harvard.edu/python/2022/
6. Practical-oriented Python course
A practical-oriented course with live case studies to gain
expertise, 100+ hrs of study material, practical codes, quizzes,
and interview guides.
Get 5 Real-time projects and 35 complementary projects.
https://data-flair.training/python-course/
7. Scientific Computing with Python
You'll learn Python fundamentals like variables, loops,
conditionals, and functions.
99
Then you'll quickly ramp up to complex data structures,
networking, relational databases, and data visualization.
https://www.freecodecamp.org/learn/scientific-computing-wit
h-python/
8. Data Analysis with Python
You'll learn how to read data from sources like CSVs and SQL,
and how to use libraries like Numpy, Pandas, Matplotlib, and
Seaborn to process and visualize data.
https://www.freecodecamp.org/learn/data-analysis-with-pyth
on/
9. Data Visualization with Python
You will learn how to implement the graphical representation of
data in order to interactively and efficiently convey insights to
clients, customers, and stakeholders in general.
https://cognitiveclass.ai/courses/data-visualization-python#ab
out-course
10. Python for Machine Learning
Secure a score in the leading technology domains by taking this
Python for Machine Learning course. Master NumPy and
Pandas tools and techniques for arrays, intersections, objects,
and functions for free online.
https://www.mygreatlearning.com/academy/learn-for-free/co
urses/python-for-machine-learning3
11. Python Programming MOOC
100
The Introduction to Programming course consists of parts 1
through 7 in the material, and the Advanced Course in
Programming consists of parts 8 through 14.
https://programming-23.mooc.fi/
12. Python Skills Certification Test (Basic)
This test covers topics like Scalar Types, Operators and Control
Flow, Strings, Collections, Iteration, Modularity, Objects, Types,
and Classes.
https://www.hackerrank.com/skills-verification/python_basic
13. Python.org - The official Python website, a hub for
documentation and community resources.
https://www.python.org/
14. Real Python - Offers tutorials, articles, and quizzes for
Python learners at all levels.
https://realpython.com/
101