Python: From Beginners to Pro in 30 Mins

Learning how to code or becoming a programmer can be daunting. The steps to becoming proficient take a lot of effort, and for some of us who have been in the game, it is even harder as there are so many things to juggle learning with.

From the moment you write your first line of code, it becomes a grueling race, a race that breaks you, keeps you up at night, and even sometimes makes you antisocial and depressed.

This path takes you through many dark tunnels and sad nights, but in the end, you realize that success is 90% hard work and 10% skills.

After spending years as a tutor teaching Python, I realized there are so many tutorials and courses on Python but not enough shared to help beginners in learning and mentorship.

While I teach and write about what I know, I will also take from others and combine their knowledge into full-fledged material for GETTING STARTED WITH PYTHON FOR TEENS.

I aim to create a guide for teens and to set them up with a clear-cut path for beginning with coding so they do not make the same mistakes I did.

So walk with me, connect with me, send me questions, and let’s build the next big, great things. If you haven’t subscribed to my newsletters yet, please do so.

What is Python?

Imagine being able to create your games, build websites, analyze data like a scientist, or even teach computers to think. That’s the power Python puts at your fingertips. It’s not just about writing code; it’s about bringing your ideas to life and solving real-world problems.

Python is more than just a skill; it’s a key that unlocks countless doors. In school, it can help you ace your math and science projects. At home, it lets you automate boring tasks or create cool apps for your friends. And looking ahead, it’s a huge plus on college applications and a vital skill in many exciting careers.

But why Python? Well, it’s known for being one of the easiest programming languages to learn. It uses simple, English-like commands, so reading Python code is almost like reading a story. Yet don’t let its simplicity fool you – this is the same language used by tech giants like Google and NASA!

As a teen, learning Python now puts you ahead of the curve. You’re not just learning to code; you’re developing problem-solving skills, logical thinking, and creativity that will serve you well in any field you choose. Whether you dream of becoming a game developer, data scientist, AI engineer, or even if you’re unsure what you want to do, Python is a great place to start.

Getting started with Python is an adventure in itself. You’ll begin by installing Python on your computer – don’t worry, it’s free! Then, you’ll take your first steps by writing simple programs. Before you know it, you’ll create games, build websites, and maybe even program robots.

The best part?

You don’t have to go it alone. A community of young Pythonistas is out there, sharing ideas, helping each other, and creating amazing things. There are countless ways to learn and grow your Python skills, from online tutorials and coding challenges to local coding clubs and global competitions.

So, are you ready to embark on this exciting journey?

Let’s dive into the basics of Python before building our GUI Number Guessing Game. We’ll break everything down into simple, easy-to-follow steps.

Note: Some of the basics might sound like repetition, but please stay with me. We will explore some paths that developers easily ignore as unimportant, but there are.

Python Basics: Baby Steps

Installing Python
Download and install Python from the official website, and download the latest version for your operating system (Windows, Mac, or Linux). During installation, check the box that says “Add Python to PATH” to run Python from the command line easily.

Most people seem to forget the next steps of how editors work, so let’s break it down: if you use a Windows laptop, your system comes with a basic editor called Notepad.

This is relatively basic and easy to forget, as not enough is said or taught about editors. So, what are editors, and why are they important?

What are Code Editors?

Code editors are specialized text editors designed for writing and editing code. While you can write code in any text editor (like Notepad on Windows), dedicated code editors offer features that make coding easier and more efficient.

Why are Code Editors Important?

• Syntax Highlighting: They color-code different parts of your code, making it easier to read and understand.
• Auto-completion: Suggests code as you type, saving time and reducing errors.
• Error Detection: Many editors can spot basic coding errors before you run your program.
• File Management: Easily manage multiple files and projects.
• Integrated Terminal: Run code directly from the editor.
• Customization: Adapt the editor to your preferences and needs.Popular Code Editors for Beginners include.
  

  Visual Studio Code

  

Overview of Visual Studio Code Editor:

• Supported languages: JavaScript, TypeScript, Python, and C++
• Supported platforms: macOS, Windows, Linux (Debian, Ubuntu, Red Hat, Fedora, SUSE)
• Best for beginners who are learning to code
• Price: free

Visual Studio Code is a free and open-source code editor developed by Microsoft. It is lightweight but powerful and used by millions of developers worldwide. VS Code has built-in support for JavaScript, TypeScript, and Node.js but can also be extended with a wide range of extensions.

One of the best things about VS Code is its customization options. You can change the color theme, keyboard shortcuts, and UI layout to fit your preferences. It’s Copilot features also has a powerful AI engine that helps you write code faster and more accurately.

If you’re looking for a free and powerful code editor, Visual Studio Code is a great option. It’s lightweight, customizable, and has a wide range of features.

TextMate

Overview of TextMate:

• Supported languages: AppleScript, C++, HTML, CSS, Java, PHP, Python, SQL, and more
• Supported platforms: macOS
• Best for macOS users
• Price: free

TextMate is a lightweight text editor with a clean UI. By default, this text editor will create a plain text file whenever users create a new file. From there, users decide what type of document it will be.

However, if you work often on a specific language, you can save time by changing the default file setting to your most common document type.

TextMate is an open-source text editor that offers bundles for programming languages, source code control, odd file formats, and build systems to make the workflow faster and easier.
For instance, the programming language bundle provides snippets and syntax highlighting for any language. That said, users can add or remove bundles as they go.

This text editor is also easy to navigate, with plenty of shortcuts for various actions such as word, sub-word, column, and paired character movements.

TextMate also lets users make edits quickly and easily using the search and replace feature. You can also easily jump between blocks and lines with options such as find next, find previous, and show history.

This text editor also has a multiple-choice feature, which allows you to make several changes simultaneously, such as swapping, copying, and pasting lines of code.

Moreover, TextMate comes with macros to eliminate repetitive work, as developers can record and replay lines on different sections.

Bluefish

Overview of Bluefish:

• Supported languages: HTML, CSS, JavaScript, Perl, Python, C++, Ruby, SQL, and many more
• Supported platforms: cross-platform for Windows, Linux, macOS, FreeBSD, OpenBSD, and Solaris
• Best for programmers and web developers
• Price: free

Bluefish is a robust code editor for experienced users such as programmers, web developers, and web designers.

It is an open-source code editor that works cross-platform on various operating systems. Additionally, Bluefish is a lightweight and fast GUI editor.

This code editor has helpful features such as a snippets sidebar for keyboard shortcuts and custom dialog, auto-recovery for modified documents, and auto-completion for hundreds of programming languages.

Bluefish also has a Quickbar where users can add frequently used tools to build a customized toolbar. On top of that, this code editor’s UI is customizable with different colors and language adjustment options.

Bluefish also has a code folding feature, where users can set whether the root tag is foldable.

Users can also configure external commands by enabling or disabling each command instead of adding and deleting them. A reset button also restores the commands to the default setting.

As Bluefish keeps updating, the external command setting offers an update default button for users to click and get the latest commands.

Other notable features include full-screen editing, unlimited undo and redo and search and replace options.

GNU Emacs

Overview of Emacs:

• Supported languages: C, C++, Python, Lisp, and more
• Supported platforms: Windows, Linux, macOS, and BSD
• Best for: Unix systems
• Price: free

Emacs is the best code editor if you’re looking for a highly customizable environment. By default, the editor has a menu bar, toolbar, scroll bar, and context menu, which can be turned on and off individually.

You can also add files and personalized workspace tabs and customize the fonts and colors for the UI elements.

Emacs is a complete productivity tool as it integrates with GDB to provide an IDE interface.

This code editor lets users write in various human, programming, and markup languages.
Emacs also supports compiling, running, and testing programs and shell commands.

Another notable feature of Emacs is the powerful search and replace option. Available prompts include “replace the current match,” “skip to the next match without replacing,” and “replace all remaining matches with no more questions.”

Also, this code editor provides a solution for those who’d like to experience a simple code editor environment.

For instance, you can add Vim modal editing style using the popular evil-mode package so users can code using the Vim editing commands.

Emacs is also cross-platform so that the editor can be used with the same configuration on many platforms.

Additionally, Emacs offers GUI and terminal modes. You can use the terminal mode to SSH into a different computer and use Emacs remotely regularly.

This open-source code editor tool is free to download. However, it has a steep learning curve, especially for beginners.

Emacs provides plenty of resources such as documentation, manuals, wikis, and FAQs to help.

PyCharm

Overview of PyCharm:

• Supported languages: Primarily Python, with support for web development languages
• Supported platforms: Windows, macOS, Linux
• Best for: Python development, from beginners to professionals
• Price: Free (Community Edition), Paid (Professional Edition)

PyCharm is a powerful integrated development environment (IDE) specifically designed for Python programming. Developed by JetBrains, it offers a comprehensive set of tools that cater to both beginners and experienced developers.

The IDE comes in two versions: the free Community Edition and the paid Professional Edition. The Community Edition is fully featured for pure Python development, making it an excellent choice for beginners and many intermediate users.

PyCharm stands out for its intelligent code assistance and analysis. It offers smart code completion, on-the-fly error detection, and quick fixes, which can significantly speed up the coding process and help beginners avoid common mistakes. The IDE also provides powerful debugging tools, allowing users to step through their code line by line and inspect variables in real-time.

One of PyCharm’s strengths is its project management capabilities. It allows users to easily organize large codebases, manage dependencies, and work with version control systems like Git.

Pycharm can be particularly helpful in learning good project organization practices from the start.

PyCharm also integrates well with various Python frameworks and tools. It offers excellent support for web development frameworks like Django and Flask and scientific computing libraries like NumPy and Matplotlib.

The IDE’s user interface is customizable, allowing users to adjust the layout, color schemes, and keyboard shortcuts to their preferences. This flexibility makes it suitable for different coding styles and workflows.

PyCharm offers a gentle learning curve for those new to Python with its intuitive interface. However, it also provides advanced features that users can grow into as they become more proficient. The IDE includes built-in tools for code refactoring, which can help beginners learn best practices in code structure and design.

PyCharm also supports virtual environments, a crucial feature for Python development. This allows users to manage different project dependencies separately, an important concept for beginners to understand as they start working on various projects.

While PyCharm is feature-rich, it can be resource-intensive, especially on older or less powerful computers. However, most modern systems run smoothly and provide a responsive coding environment.

Which Editor is Best for Beginners?

Thonny or IDLE are great starting points for beginners due to their simplicity. As you become more comfortable, VS Code or PyCharm Community Edition offers more features to help you develop your skills.

Tips for Choosing an Editor:

• Start Simple: Don’t overwhelm yourself with complex features or the lure of using a complex editor to prove a point. Stick to the basics.
• Explore: Try different editors to see which interface you prefer, pick what suits you, and learn how it works from the start.
• Community Support: Choose editors with active communities for help and resources.
• Future-Proofing: Consider editors that support multiple languages for future learning.

Remember, the best editor is the one you’re comfortable using. Don’t be afraid to switch editors as your skills and needs evolve. Many professional developers use different editors for different projects or languages.

What to Focus on as a Python Beginner

As a Python beginner, it’s crucial to build a strong foundation. too many YouTube videos without context can overwhelm you. Stick to the basics. Make sure you build a simple application after each session.

Impress only yourself; you are the most important person on your journey, and why you are on your path, you need to understand the fundamentals of Python syntax. This includes:

• Variables and data types:name = “Alex” # String
  age = 15 # Integer
  height = 5.7 # Float
  is_student = True # Boolean

In Python, a variable is like a container that holds a value. We use variables to store and manage data in our programs.

In this example, we have four variables: name, age, height, and is_student.

Assignment

• The = sign is used to assign a value to a variable.
• For example, name = "Alex" means we’re storing the value “Alex” in the variable called name.name = “Alex”
• Strings are used for text data.
• They are enclosed in quotes (either single ‘ or double “).

Integer (int)

age = 15

• Integers are whole numbers without decimal points.

Float

height = 5.7

• Floats are numbers with decimal points.

Boolean (bool)

is_student = True

• Booleans represent True or False values.
• They are often used for conditions and logic in programming.

Comments

• The # ''' “ ''' symbol is used to write comments in Python. – Comments are notes for humans and are ignored by Python when running the code.

Variable Naming

• Variable names in Python should be descriptive and follow certain rules:
• They can contain letters, numbers, and underscores.
• They must start with a letter or underscore.
• They are case-sensitive (e.g., name and Name are different variables).
• Basic operations:x = 5 + 3 # Addition
  y = 10 – 2 # Subtraction
  z = 4 * 3 # Multiplication
  w = 15 / 3 # Division
• Print statements and string formatting:print(“Hello, World!”)
  print(“Hello i am a boy and i am”, 5+7 ,”years old”)
  name = “scofield”
  age = 29
  print(f”My name is {name} and I’m {age} years old.”)

Basic Print Statement

print("Hello, World!")

• The print() function is used to output text to the console.
• Text inside quotes is a string, which will be printed without changing it.
• This line will output: Hello, World!

Print with Multiple Arguments

print("Hello i am a boy and i am", 5+7 ,"years old")

• You can pass multiple items to print(), separated by commas.
• Python will automatically add spaces between these items.

5+7 is an expression that Python will evaluate (to 12) before printing.

This line will output: Hello, i am a boy and i am 12 years old

*****Variables in Print Statements*

name = "scofield"
age = 29

• Here, we’re defining two variables: name and age.
• These variables can be used in our print statements.

F-Strings (Formatted String Literals)

print(f"My name is {name} and I'm {age} years old.")

F-strings provide an easy way to embed expressions inside string literals. once we start the string with f before the opening quotation mark, variables or expressions in curly braces {} will be replaced with their values.

This line will output: My name is scofield and I'm 29 years old.

Key Points:

• The print() function is used to display output in Python.
• You can print strings, numbers, variables, and even the results of expressions.
• Commas in print() separate multiple items and add spaces between them.
• F-strings (starting with f) allow you to easily include variable values in strings.
• Curly braces {} in f-strings are placeholders for variables or expressions.
  

  Control Flow: control the flow of your program

• If statements

we use if statements to control which parts of our code run based on whether certain conditions are true or false. For example, imagine you are contemplating between two choices or more than two choices, and you then say if this choice does not work, the other will or the third choice will.

If statement is a probability based on your options.

Let’s break down the example:

if age >= 18:
    print("You're an adult.")
elif age >= 13:
    print("You're a teenager.")
else:
    print("You're a child.")

First, we have the if statement. It starts with the keyword if, followed by a condition. In this case, the condition is age >= 18. This is asking, “Is the age 18 or greater?” If this condition is true, the code indented under this line will run. So if someone is 18 or older, they’ll see “You’re an adult.” printed.

if age >= 18:
    print("You're an adult.")

But what if they’re not 18 or older? That’s where the ‘elif’ comes in. ‘elif’ is short for “else if”. It’s like saying, “If the first condition wasn’t true, let’s check this one instead.” Here, we’re checking if ‘age >= 13’. So if someone is 13 or older (but not 18 or older because the first condition would have caught that), they’ll see “You’re a teenager.” printed.

elif age >= 13:
    print("You're a teenager.")

Finally, we have the else statement. This is like a catch-all. If none of the above conditions were true, this code will run. So if someone is neither 18 or older, nor 13 or older, they must be younger than 13, and they’ll see “You’re a child.” printed.

else:
    print("You're a child.")

It’s important to note the indentation in Python. The code that should run if a condition is true must be indented under that condition. This is how Python knows which code belongs to which part of the if-elif-else structure.

NOTE: Indentation is very important and can ruin your code if you do not learn it properly; I had a lot of issues with indention at the beginning until I came up with a personal cheat sheet where I have everywhere indentation can be used and mastered the list.

It includes,

• After a colon (:) Indentation is required after any line that ends with a colon. This includes:
• If statements
• Elif and else clauses
• For and while loops
• Function definitions
• Class definitions
• With statements
• Try/except blocks
• Continuation of long lines When a line of code is too long, and you need to split it across multiple lines, the continuation lines are often indented.
• Nested structures: When you have structures inside other structures (like a loop inside an if statement), each level needs its indentation.

Let us return to our if statement and master it properly. Imagine you’re creating a simple age-based recommendation system for a movie streaming service. Here’s how you might use an if statement:

age = int(input("Please enter your age: "))

if age >= 18:
    print("You can watch all movies, including R-rated ones.")
elif age >= 13:
    print("You can watch PG-13 movies and below.")
else:
    print("You can only watch G and PG rated movies.")

This script asks the user for their age and then uses an if-elif-else structure to provide a recommendation based on that age.

A quick quiz to check your understanding

Let’s say you run this code and input the age 15. What message will be printed, and why?

Take a moment to think about it. Remember to consider the order of the conditions. When ready, explain your answer in the comment below.

Loops in Python

# For loop
for i in range(5):
    print(i)

# While loop
count = 0
while count < 5:
    print(count)
    count += 1

Loops are used to repeat a block of code multiple times. They’re incredibly useful when you want to perform the same action over and over, or when you need to process each item in a collection. Let’s look at the two main types of loops in Python:

For Loops
A for loop iterates over a sequence (like a list, tuple, or string) or other iterable objects. It’s particularly useful when you know in advance how many times you want to execute a block of code.

for item in each sequence:
    # Code to be repeated

Example:

# For loop
for i in range(5):
    print(i)

In this example:

• range(5) creates a sequence of numbers from 0 to 4.
• The loop variable i takes on each value in this sequence.
• The indented code block (print(i)) is executed for each value of i.

Output:

0
1
2
3
4

When to use: Use a for loop to iterate over a known sequence of items or a specific number of times.

While Loops
A while loop repeats a block of code as long as a given condition is true. It’s useful when you don’t know in advance how many times you need to repeat the code.

Basic Syntax:

while condition:
    # Code to be repeated

Example:

# While loop
count = 0
while count < 5:
    print(count)
    count += 1

In this example:

• We start with count = 0.
• The loop continues as long as count < 5 is true.
• Inside the loop, we print the current value of count and then increase it by 1.
• This process repeats until count reaches 5, at which point the condition becomes false and the loop ends.

What if we remove count += 1? We have an endless loop because count would keep printing out the first iteration of 0 as it does not know if it has counted the first item.

This situation perfectly illustrates why it’s crucial in while loops to have a way to update the condition. Without count += 1, we’ve removed the loop’s ability to progress and eventually terminate.

But when we include the count += 1 we can check if we have iterated over each item and move on to the next.

Output:

0
1
2
3
4

When to use: Use a while loop when you must repeat an action until a certain condition is met, especially when you don’t know how many iterations will be needed.

Key Points for Beginners

1. Indentation: Remember that the code block to be repeated must be indented. This is crucial in Python.
2. Infinite Loops: Be careful with while loops. If the condition never becomes false, you’ll create an infinite loop. Always ensure there’s a way for the loop condition to become false.
3. Loop Variables: In for loops, the loop variable (like i in our example) is automatically updated each iteration. In while loops, you typically need to update the variable yourself.
4. Range Function: range(n) creates a sequence from 0 to n-1. It’s commonly used with for loops.
5. Incrementing: count += 1 is a shorthand for count = count + 1. This is often used in while loops to update the counter.

Practice Exercise
Try writing a loop that prints out the even numbers from 0 to 10. You can use either a for loop or a while loop. Think about which might be more appropriate and why.

Remember, the key to understanding loops is practice. Try modifying the examples, experiment with different conditions and sequences, and see what happens. Don’t be afraid to make mistakes.

Functions in Python

Functions are reusable blocks of code that perform a specific task. They help organize your code, make it more readable, and reduce repetition. Take, for example, writing codes that can become so long and very hard to read or find what each line does, mostly when you have to call value.

def greet(name):

let’s see how this works.

Why Use Functions?

Imagine you’re cooking a complex meal. Instead of trying to do everything at once, you break the process down into smaller tasks: chopping vegetables, preparing the sauce, cooking the main dish, etc. Each of these tasks could be thought of as a function in programming.

Each put in a section that can be called when we need it without having to clog the whole meal with all the code, making our code easier to read and less error.

Functions allow us to:

• Organize Code: Just like organizing ingredients and steps in a recipe, functions help us organize our code into manageable, logical parts.
• Reuse Code: If you need to perform the same task multiple times, you can create a function and call it whenever needed, rather than writing the same code over and over.
• Simplify Complex Tasks: Large problems can be broken down into smaller, more manageable pieces.
• Improve Readability: Well-named functions make code easier to understand, like clear instructions in a recipe.

Real-Life Examples:

• Calculator App: Each operation (add, subtract, multiply, divide) could be a separate function.
• Social Media Post: Functions could handle posting text, uploading images, or adding hashtags.
• Online Shopping: Functions might calculate total cost, apply discounts, or process payments.

Now, let’s look at how to create and define a Function:

def greet(name):
    """
    This function takes a name and returns a greeting message.
    """
    return f"Hello, {name}! Welcome to Python programming."

Breaking this down

• def tells Python we’re defining a function.
• greet is the function name (you can change the name to whatever you want!)
• (Alex) is the parameter – a placeholder for the data the function will receive

The indented block is the function body – what the function does.

return specifies what the function gives back when it's done

Using (Calling) a Function

# Calling the function
message = greet("Alex")
print(message)


greet("Alex"):

• This is us “calling” or “using” the function.
• We’re saying, “Hey, function named ‘greet’, please take ‘Alex’ as the input.”
• “Alex” is the argument. It’s like giving the function a specific piece of information to work with.

What happens inside the function:

• The function takes “Alex” and puts it where {name} is in the greeting.
• So it creates the message: “Hello, Alex! Welcome to Python programming.”message = …:
• We’re storing what the function gives back (returns) in a variable called ‘message’.
• So now ‘message’ contains the text “Hello, Alex! Welcome to Python programming.”print(message):
• This simply displays the contents of ‘message’ on the screen.

“This would output: “Hello, Alex! Welcome to Python programming.”
Here, “Alex” is an argument – the actual data we’re passing to the function.

More Complex Example:
Let’s create a function that calculates the total cost of items in a shopping cart:

def calculate_total(items, tax_rate):
    subtotal = sum(items)
    tax = subtotal * tax_rate
    total = subtotal + tax
    return total

# Using the function
cart = [10.99, 5.50, 8.99]
tax = 0.08  # 8% tax
total_cost = calculate_total(cart, tax)
print(f"Your total including tax is: ${total_cost:.2f}")

In this example, I explored more than one argument where I placed items and tax_rate as arguments in our function and made some clear parameters for our function to follow.

• subtotal = sum(items) – while subtotal is a variable or placeholder for the value it calculates, which is the sum (remember sum is a library in Python that returns the sum of a ‘start’ value (default: 0) plus an iterable of numbers) of items.
• tax = subtotal * tax_rate here, we are taking tax as a new variable, and in that variable, we are saying take the previous variable subtotal(sum(items)) * tax_rate, which is a placeholder for any figure the user puts in.
• total = subtotal + tax; this is the sum of the two variables, subtotal and tax.

Once we call the function calculate_total(cart, tax) , the cart will sum all the values in the cart (10.99+5.50+8.99), and then we multiply the value by 0.08 to get the tax and then add them together to get the total.

Our print statement uses a formatted string, and then we said the total_cost should be reduced to a 2f decimal place.

Key Points to Note

• Function Names: Use clear, descriptive names. calculate_total is better than calc or function1.
• Parameters: These are the inputs your function expects. In calculate_total, we have two: items and tax_rate.
• Return Statement: This specifies what the function gives back. Not all functions need to return something, but many do.
• Indentation: Everything inside the function must be indented. This is how Python knows what’s part of the function.
• Calling the Function: We use the function name followed by parentheses containing the arguments.

Practice Exercise:
Try creating a function that takes a person’s name and age, and returns a message like “Hello [name], you will be [age+10] in 10 years.” This will help you practice using multiple parameters and doing calculations within a function.

Python Data Structures: Lists, Sets, Tuples, and Dictionaries

Python offers several built-in data structures that allow programmers to organize and manipulate data efficiently. we’ll explore four essential data structures: lists, sets, tuples, and dictionaries. Each of these structures has unique characteristics and use cases.

Lists
Lists are the most commonly used data structure in Python. They are ordered, mutable collections that can contain elements of different data types. You can create a list using square brackets:

fruits = ["apple", "banana", "cherry"]

Lists maintain the order of elements, allowing you to access them by their index. For example, fruits[0] would return “apple”. This ordering makes lists ideal for situations where the sequence of elements matters, such as maintaining a playlist or a to-do list.

One of the key advantages of lists is their mutability. You can easily add, remove, or modify elements:

fruits.append("date")  # Adds "date" to the end
fruits[1] = "blueberry"  # Replaces "banana" with "blueberry"

Lists also support various operations like slicing, concatenation, and list comprehensions, making them extremely versatile. Use lists when you need an ordered collection that you can modify and when you want to allow duplicate elements.

To learn more about lists, check this guide by Bala Priya C (Lists in Python – A Comprehensive Guide)

Sets
Sets are unordered collections of unique elements. You can create a set using curly braces or the set() function.

unique_numbers = {1, 2, 3, 4, 5}

The defining feature of sets is that they only store unique elements. If you try to add a duplicate element, it will be ignored. This makes sets perfect for removing duplicates from a list or for membership testing.

Sets also support mathematical set operations like union, intersection, and difference:

set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1.union(set2))  # {1, 2, 3, 4, 5}

While sets are mutable (you can add or remove elements), they must be immutable. Use sets when you need to ensure uniqueness of elements and don’t care about their order.

To learn more about sets, check this guide on w3school

Tuples
Tuples are similar to lists in that they are ordered sequences, but they are immutable – once created, they cannot be modified. You create a tuple using parentheses:

coordinates = (10, 20)

The immutability of tuples makes them useful for representing fixed collections of items, like the x and y coordinates in our example. They’re also commonly used to return multiple values from a function.

def get_user_info():
    return ("Alice", 30, "New York")

name, age, city = get_user_info()

Tuples can be used as dictionary keys (unlike lists) because of their immutability. Use tuples when you have a collection of related items that shouldn’t change throughout your program’s execution.

If you need more insight on tuples, Geeksforgeeks has a very informative guide on it

Dictionaries: Key-Value Pairs
Dictionaries are unordered collections of key-value pairs. They provide a way to associate related information. You create a dictionary using curly braces with key-value pairs:

person = {"name": "Alex", "age": 25, "city": "San Francisco"}

Dictionaries allow fast lookup of values based on their keys. You can access, add, or modify values using their associated keys:

print(person["name"])  # Prints "Alex"
person["job"] = "Engineer"  # Adds a new key-value pair

Dictionaries are incredibly useful for representing structured data, similar to JSON. They’re also great for counting occurrences of items or creating mappings between related pieces of information.

I love what Simplilearn did with this guide on dictionary; find it here.

Choosing the Right Data Structure

When deciding which data structure to use, consider these factors:

• Do you need to maintain order? If yes, consider lists or tuples.
• Do you need to modify the collection? If yes, use lists or dictionaries.
• Do you need to ensure uniqueness? If yes, use sets.
• Do you need to associate values with keys? If yes, use dictionaries.
• Do you need an immutable sequence? If yes, use tuples.

Understanding these data structures and when and how to use them will help you write more efficient and readable code. As you gain experience, you’ll develop an intuition for which structure best fits your specific needs.

Remember, Python’s flexibility allows you to convert between these structures when needed. For example, you can convert a list to a set to remove duplicates and then convert it back to a list if you need to maintain order. This interoperability makes these data structures even more powerful when used in combination.

How do we do this? Find out and post it on the comment session or the Python learning group.

By mastering lists, sets, tuples, and dictionaries, you’ll have a solid foundation for handling various data manipulation tasks in Python. As you progress in your programming journey, you’ll discover even more specialized data structures, but these four will remain fundamental tools in your Python programming toolkit.

File Handling: Learn to read from and write to files

File handling is a crucial skill for any programmer. every developer should be able to access and interact with data from external sources and implement calculations and storage.

Files are used to store data on disk. They can contain text, numbers, or binary data. In Python, we use built-in functions and methods to work with files.

To open a file, we use the open() function. It takes two main arguments:

• The file path (name)
• The mode (read, write, append, etc.)

Common modes

• ‘r’: Read (default)
• ‘w’: Write (overwrites existing content)
• ‘a’: Append (adds to existing content)
• ‘x’: Exclusive creation (fails if file already exists)
• ‘b’: Binary mode
• ‘+’: Open for updating (reading and writing)

Example:

file = open("scofield.txt", "w")

In this example, we create a variable called the file, and we said it should open a file called scofield.txt, in which we append the “w” to overwrite whatever is written inside it.

Writing to Files
To write to a file, use the write() method.

file = open("scofield.txt", "w")
file.write("Hello, World!")
file.close()

It’s important to close the file after you’re done to free up system resources. A better practice is to use a with statement, which automatically closes the file.

with open("scofiedl.txt", "w") as file:
    file.write("Hello, World!")

After overwriting what is inside, we wrote the above code but made it shorter, using the with open command closes scofield.txt.

Reading from Files
You can use several methods to read from a file.

read(): Reads the entire file
readline(): Reads a single line
readlines(): Reads all lines into a list

Example:

with open("scofield.txt", "r") as file:
    content = file.read()
    print(content)

Appending to Files
To add content to an existing file without overwriting, use the append mode:

with open("scofield.txt", "a") as file:
    file.write("\nThis is a new line.")

You can add to the existing file instead of always overwriting existing files, which is a good approach if you have an ongoing project and want access to previous work.

To fully understand this next aspect of file handling, we must pause our learning and take a deep dive into Modules and Libraries.

One of the key features that makes Python so versatile and powerful is its extensive ecosystem of modules and libraries. These tools allow you to extend Python’s functionality, making complex tasks simpler and enabling you to write more efficient and powerful programs.

What are Modules and Libraries?
At its core, a module in Python is simply a file containing Python code. It can define functions, classes, and variables you can use in your programs. A library, on the other hand, is a collection of modules. Think of modules as individual tools, while libraries are toolboxes containing multiple related tools.

The main purpose of modules and libraries is to promote code reusability. Instead of writing everything from scratch, you can use pre-written, tested code to perform common tasks. This saves time and reduces the chance of errors in your programs.

Built-in Modules
Python comes with a set of built-in modules that are part of the standard library. These modules are available in every Python installation, providing a wide range of functionality out of the box. Let’s explore a few examples.

• The ‘random’ Module

The ‘random’ module is used for generating random numbers. Here’s how you can use it:

import random

# Generate a random integer between 1 and 10
random_number = random.randint(1, 10)
print(random_number)

# Choose a random item from a list
fruits = ["apple", "banana", "cherry"]
random_fruit = random.choice(fruits)
print(random_fruit)

In this example, we first import the random module. Then we use its randint function to generate a random integer and its ‘choice’ function to select a random item from a list.

• The ‘datetime’ Module:

The ‘datetime’ module provides classes for working with dates and times:

import datetime

# Get the current date and time
current_time = datetime.datetime.now()
print(current_time)

# Create a specific date
birthday = datetime.date(1990, 5, 15)
print(birthday)

Here, we use the datetime module to get the current date and time, and to create a specific date.

• The ‘math’ Module

The ‘math’ module provides mathematical functions.

import math

# Calculate the square root of a number
sqrt_of_16 = math.sqrt(16)
print(sqrt_of_16)

# Calculate the sine of an angle (in radians)
sine_of_pi_over_2 = math.sin(math.pi / 2)
print(sine_of_pi_over_2)

This example demonstrates using the ‘math’ module to perform mathematical calculations.

Importing Modules
There are several ways to import modules in Python:

*****Import the entire module*

import random
random_number = random.randint(1, 10)

Import specific functions from a module

from random import randint
random_number = randint(1, 10)

Import all functions from a module (use cautiously)

from random import *
random_number = randint(1, 10)

Import a module with an alias

1. python import random as rnd random_number = rnd.randint(1, 10) ## Python External Libraries

While the standard library is extensive, Python’s true power lies in its vast ecosystem of third-party libraries. These libraries cover various functionalities, from web development to data analysis and machine learning.

To use external libraries, you first need to install them. This is typically done using pip, Python’s package installer. Here’s an example using the popular ‘requests’ library for making HTTP requests.

Install the library

pip install requests

Use the library in your code

import requests

response = requests.get('https://api.github.com')
print(response.status_code)
print(response.json())

This code sends a GET request to the GitHub API and prints the response status and content.

Our response was a 200, which means success; we were able to connect to the server.

Creating Your Own Modules
You might want to organize your code into modules as your projects grow. Creating a module is as simple as saving your Python code in a .py file. For example, let’s create a module called ‘write.py’

The key is to ensure all your files are in a single directory so it’s easy for Python to track the file based on the name.

with open("scofield.txt", "w") as file:
    content = file.write("Hello welcome to school")

Now, you can use this module in another Python file, so we will import it to the new file I created called read.py as long as they are in the same directory.

import write

with open("scofield.txt", "r") as file:
    filenew = file.read()
    print(filenew)

Our result would output the write command we set in write.py.

The Python Path
When you import a module, Python looks for it in several locations, collectively known as the Python path. This includes.

1. The directory containing the script you’re running
2. The Python standard library
3. Directories listed in the PYTHONPATH environment variable
4. Site-packages directories where third-party libraries are installed

Understanding the Python path can help you troubleshoot import issues and organize your projects effectively.

Best Practices

1. Import only what you need: Instead of importing entire modules, import specific functions or classes when possible.
2. Use meaningful aliases: If you use aliases, make sure they’re clear and descriptive.
3. Keep your imports organized: Group your imports at the top of your file, typically in the order of standard library imports, third-party imports, and then local imports.
4. Be cautious with ‘from module import ***'**: This can lead to naming conflicts and make your code harder to understand.
5. Use virtual environments: When working on different projects, use virtual environments to manage dependencies and avoid conflicts between different versions of libraries.

Modules and libraries are fundamental to Python programming. They allow you to leverage existing code, extend Python’s functionality, and effectively organize your code.

Now you understand imports, let’s see how it works with file handling.

import os

file_path = os.path.join("folder", "scofield_fiel1.txt")
with open(file_path, "w") as file:
    file.write("success comes with patience and commitment")

First, we import the os module. This module provides a way to use operating system-dependent functionality like creating and removing directories, fetching environment variables, or in our case, working with file paths. By importing ‘os’, we gain access to tools that work regardless of whether you’re using Windows, macOS, or Linux.

Next, we use os.path.join() to create a file path. This function is incredibly useful because it creates a correct path for your operating system.

On Windows, it might produce “folder\example.txt”, while on Unix-based systems, it would create “folder/scofield_file1.txt“. This small detail makes your code more portable and less likely to break when run on different systems.
The variable ‘file_path’ now contains the correct path to a file named “example.txt” inside a folder called “folder”.

As mentioned above, the with statement allows Python to close the file after we finish writing to it.

The open() function is used to open the file. We pass it two arguments: our file_path and the mode “w”. The “w” mode stands for write mode, which will create the file if it doesn’t exist or overwrite it if it does. Other common modes include “r” for read and “a” for append.

Finally, we use the write() method to put some text into our file. The text “Using os.path.join for file paths” will be written to the file, demonstrating that we’ve successfully created and written to a file using a path that works on any operating system.

Advance Error Handling
It’s good practice to use try-except blocks when working with files:

try:
    with open("nonexistent.txt", "r") as file:
        content = file.read()
except FileNotFoundError:
    print("The file does not exist.")

Working with CSV Files
CSV (Comma-Separated Values) files are common for storing tabular data. Python has a built-in csv module to handle them:

import csv

# Writing to a CSV file
with open("data.csv", "w", newline="") as file:
    writer = csv.writer(file)
    writer.writerow(["Name", "Age"])
    writer.writerow(["Alice", 30])
    writer.writerow(["Bob", 25])

# Reading from a CSV file
with open("data.csv", "r") as file:
    reader = csv.reader(file)
    for row in reader:
        print(row)

Working with JSON Files
JSON is a popular data format. Python’s json module makes it easy to work with JSON files:

import json

data = {"name": "Alice", "age": 30}

# Writing JSON to a file
with open("data.json", "w") as file:
    json.dump(data, file)

# Reading JSON from a file
with open("data.json", "r") as file:
    loaded_data = json.load(file)
    print(loaded_data)

Binary Files
For non-text files (like images), use binary mode:

# Reading a binary file
with open("image.jpg", "rb") as file:
    image_data = file.read()

# Writing to a binary file
with open("copy.jpg", "wb") as file:
    file.write(image_data)

Steps to Become Proficient in File Handling:

• Start with the basics: Practice opening, reading, writing, and closing text files.
• Experiment with different file modes and understand their effects.
• Learn to handle exceptions that may occur during file operations.
• Practice working with different file formats (CSV, JSON, etc.).

Mindset and Approach

Practice Regularly: Consistency is key. Try to code a little bit every day, even if it’s just for 15-30 minutes. the more you practice, the more it becomes tasking and more enjoyable; coding might soon become a hobby you will enjoy if you give in the time and let it become part of your routine. Read the book The Power of Habit by Charles Duhigg.

Learn by Doing: Don’t just read about Python; write code! Create small projects to apply what you’re learning. Go online and ask Google what project you can create with your current knowledge; do it on your own and then review your code using ChatGPT or Claudia.

Embrace Errors: Don’t be discouraged by errors. They’re a normal part of learning and can teach you a lot; errors such as indentation can be a pain and can cause you to swear, and spelling errors can be stressful as well, but as you keep tagging along, you get better at them, and editors like Pycharm can spot them and tell you before you run your code.

Think Logically: Break down problems into smaller, manageable steps before you start coding. Don’t start with advanced videos from YouTubers; their priority is to get views, and the project might not really help you as they often overlook some basic steps in their rush to drop new videos and earn views.

Follow a simple study process, break the study into steps, and repeat these steps repeatedly until you can feel it in your bones that there are parts of you; this would help you think through problems and not make you more proactive when solving real-life issues.

Comment Your Code: Get into the habit of explaining your code with comments. It helps reinforce your understanding and is a good practice for the future, I love writing the explanation for every line of code, it gives me a jog when I read my code again and need clarification on something.

This step has helped me keep track of my progress because as you keep learning, you forget previous knowledge, and it becomes a task to go back to the videos or materials, but looking at your previous work can jog your memory and bring you up to speed.

Ask Questions: Everybody loves to correct a moron, so act a fool and ask questions in a dumb-like pattern but check out the replies mostly on community forums and stack overflow. For those that answer your question, poke them for more, and you will get a response faster.

Acting a fool has always helped me out; It works every time.

Be Patient: Learning to code takes time. Celebrate small victories, and don’t get discouraged if something doesn’t click immediately.

Forget about others’ success stories; you will get distracted. Focus and be patient; make time to rest and drink lots of fluid.

Finally, let’s build a tiny project to test our skills

Verifying the Installation
Open your command prompt or terminal and type.

python --version

This should display the installed Python version.

Setting Up
First, we need to tell Python what tools we’re going to use.

import tkinter as tk
import random

These lines bring the tkinter library for our graphics and the random library to create mystery numbers.

Creating the Game Window
Now, let’s make the window where our game will live.

window = tk.Tk()
window.title("Guess the Number!")
window.geometry("300x200")

This creates a window using the tk.Tk() library tk and function Tk() gives it a title called Guess the Number and then the size of the windows, which we set as 300*200.

If you run this code, you will get a loop as it won’t open the GUI but rather be left in a loop.

We must close our endless loop by adding a window.mainloop()

Adding Game Elements
Let’s populate some things to our window.

label = tk.Label(window, text="Guess a number between 1 and 100:")
label.pack()

entry = tk.Entry(window)
entry.pack()

result_label = tk.Label(window, text="")
result_label.pack()

submit_button = tk.Button(window, text="Submit")
submit_button.pack()

new_game_button = tk.Button(window, text="New Game")
new_game_button.pack()

Each line adds something to our window: instructions, a place to type your guess, a spot for results, and buttons to submit your guess or start a new game.

label = tk.Label(window, text="Guess a number between 1 and 10:")
label.pack()

This Creates a label widget with text (Guess a number between 1 and 20) and add it to the window

entry = tk.Entry(window)
entry.pack()

This creates an entry widget for user input value and adds it to the window.

result_label = tk.Label(window, text="")
result_label.pack()

This creates a label widget to display results and add them to the window.

submit_button = tk.Button(window, text="Submit")
submit_button.pack()

Here, we created a submit button and added it to the window.

new_game_button = tk.Button(window, text="New Game")
new_game_button.pack()

Finally, we created a new game button and added it to the window.

Game Logic
Without the logic, we would have a GUI, but nothing would work, and that is not the focus, so let’s develop the logic based on what we have been learning so far

We would add the following code.

secret_number = random.randint(1, 10)
attempts = 0

def check_guess():
    global attempts
    guess = int(entry.get())
    attempts += 1

    if guess < secret_number:
        result_label.config(text="Too low! Try again.")
    elif guess > secret_number:
        result_label.config(text="Too high! Try again.")
    else:
        result_label.config(text=f"You got it in {attempts} attempts!")

def new_game():
    global secret_number, attempts
    secret_number = random.randint(1, 100)
    attempts = 0
    result_label.config(text="")
    entry.delete(0, tk.END)

submit_button.config(command=check_guess)
new_game_button.config(command=new_game)



secret_number = random.randint(1, 10)
attempts = 0

This initializes the game.
secret_number is set to a random integer between 1 and 10 using random.randint().
attempts is set to 0 to keep track of how many guesses the player makes.

Reason: We use random.randint() to create unpredictability in the game. Starting attempts at 0 allows us to count from the first guess.

Alternative: We could use random.choice(range(1, 11)) instead, but randint is more straightforward for beginners.

def check_guess():
    global attempts
    guess = int(entry.get())
    attempts += 1

This function is called when the player submits a guess.
global attempts allows us to modify the attempts variable that was defined outside the function.

int(entry.get()) converts the player’s input from a string to an integer.

attempts is incremented by 1 for each guess.

Reason: We use global because attempts is defined outside the function. We convert the input to an integer because entry.get() returns a string, but we need a number for comparison.

Alternative: Instead of using a global variable, we could pass attempts as an argument and return its new value, but this is more complex for beginners.

    if guess < secret_number:
        result_label.config(text="Too low! Try again.")
    elif guess > secret_number:
        result_label.config(text="Too high! Try again.")
    else:
        result_label.config(text=f"You got it in {attempts} attempts!")

This checks the player’s guess against the secret number and updates the result label accordingly.
Reason: We use if-elif-else structure for clarity. The config() method updates the text of the label widget.

We could use a match-case statement in Python 3.10+, but if-elif-else is more widely understood, we discussed it above.

def new_game():
    global secret_number, attempts
    secret_number = random.randint(1, 100)
    attempts = 0
    result_label.config(text="")
    entry.delete(0, tk.END)

This function resets the game state.

• It generates a new secret number and resets attempts to 0.
• It clears the result label and the entry widget.

We need to reset all game state variables and clear the UI for a fresh start.

submit_button.config(command=check_guess)
new_game_button.config(command=new_game)

This connects the button clicks to their respective functions.

Best way for beginners to grasp this

• Understand the game flow: initialization, guessing, and resetting.
• Focus on how variables (secret_number, attempts) are used to maintain game state.
• Notice how functions (check_guess, new_game) encapsulate specific behaviors.
• Observe how the UI elements (labels, entry, buttons) are updated to reflect the game state.
• Experiment by modifying values (e.g., change the range of random numbers) to see how it affects the game.

Run the Game
Finally, let’s start the game

You can find the complete code here.

Conclusion:
Congratulations! You’ve just created your very own Number Guessing Game with a graphical interface.

1. How to create a window for your game
2. Adding labels, buttons, and entry fields to your window
3. Creating game logic to check guesses
4. Using functions to make your buttons work

Remember, the most important part is understanding each step. Don’t worry if your game doesn’t work perfectly right away. Keep practicing and experimenting with your code.

Your Task: Guess should be only two, after which the game ends, and the user is asked to start again.

Happy coding, and have fun playing your new game!

Resource

• Python Beginners Guide 
• Python loops for beginners