Coding in Python

• Introduction
• Chapter 1 Getting Started with Python
• Chapter 2 Python Basics: Variables and Data Types
• Chapter 3 Operators and Expressions
• Chapter 4 Control Flow: Conditional Statements
• Chapter 5 Control Flow: Loops
• Chapter 6 Data Structures: Lists and Tuples
• Chapter 7 Data Structures: Dictionaries and Sets
• Chapter 8 Functions: The Building Blocks of Code
• Chapter 9 Working with Strings
• Chapter 10 File Input and Output
• Chapter 11 Modules and Packages
• Chapter 12 Introduction to Object-Oriented Programming
• Chapter 13 Classes and Objects
• Chapter 14 Inheritance and Polymorphism
• Chapter 15 Error Handling and Exceptions
• Chapter 16 Introduction to Standard Libraries
• Chapter 17 Working with Dates and Times
• Chapter 18 Regular Expressions
• Chapter 19 Introduction to Web Scraping
• Chapter 20 Working with APIs
• Chapter 21 Introduction to GUI Programming
• Chapter 22 Introduction to Data Science with Python
• Chapter 23 Working with NumPy
• Chapter 24 Working with Pandas
• Chapter 25 Next Steps and Further Learning

Welcome to the world of coding! If you've ever found yourself wondering how your favorite website was built, how a computer can recognize your face, or how you could get a machine to do your most repetitive tasks for you, then you've come to the right place. This book is your first step into the vast and exciting universe of programming, and your guide on this journey will be a language called Python. Don't worry if you've never written a single line of code before. We're starting from scratch, assuming nothing more than a curious mind and a willingness to learn.

So, what is this "Python" we speak of? It is a popular, general-purpose programming language. That simply means it's a tool that programmers can use to give instructions to a computer to create all sorts of things, from websites and software to data analysis and artificial intelligence. Its creation began in the late 1980s when its developer, Guido van Rossum, set out to design a language that was both powerful and easy to read. He was so committed to this idea of readability and simplicity that it became the core philosophy of Python. As for the name, it has nothing to do with snakes; it was inspired by the British comedy troupe Monty Python's Flying Circus, which gives you a hint about the fun and approachable nature of the language.

You might be asking, "With so many programming languages out there, why start with Python?" The answer is simple: Python was designed with beginners in mind. One of the biggest hurdles for newcomers is often the complex and rigid syntax of their first language. Python elegantly sidesteps this issue with a syntax that is clean, intuitive, and reads almost like plain English. This focus on readability means you can spend more time understanding the fundamental concepts of programming—the "what" and "why"—instead of getting bogged down in confusing symbols and strict punctuation rules.

To give you a clearer picture, let's consider the simple task of telling a computer to display the message "Hello, World!". In a language like Java, you might have to write something like this:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Now, look at the same instruction in Python:

print("Hello, World!")

See the difference? Python accomplishes the same result with a single, straightforward command. This simplicity is not a gimmick; it is a core design principle. It allows you to write programs with fewer lines of code than many other languages, making your code easier to write, easier to read, and easier to fix when things go wrong—which they inevitably will, and that's perfectly okay!

This gentle learning curve is a significant advantage, but it's not the only reason Python is an excellent choice for your first programming language. Python is incredibly versatile. It's not a one-trick pony. The skills you learn here can be applied to an astonishingly wide array of fields. Are you interested in building dynamic websites? Python has powerful frameworks like Django and Flask to help you do just that. Does the idea of uncovering hidden patterns in data excite you? Python is the leading language in data science, with a rich set of libraries for analysis and visualization.

Perhaps you're fascinated by the cutting edge of technology, such as artificial intelligence and machine learning. Python is the dominant force in these fields, powering everything from the recommendation engines that suggest what you should watch next to the complex algorithms that help scientists analyze vast datasets. Python is also used for developing games, creating desktop applications with graphical user interfaces (GUIs), automating tedious tasks, and even in scientific computing for research and engineering. By learning Python, you are not just learning to code; you are opening doors to countless potential career paths and hobbies.

Another of Python's greatest strengths is its community. Because it's so popular and has been around for decades, a massive and supportive global community has grown around it. This means that whenever you get stuck, have a question, or need help with a problem, the answer is likely just a quick search away. There are countless tutorials, forums, and resources available to assist you. This vast support network is an invaluable asset for any beginner, making the learning process less intimidating and more collaborative.

Behind Python's user-friendly nature is a set of guiding principles known as the "Zen of Python". Penned by a longtime Python developer named Tim Peters, these 19 aphorisms capture the language's core philosophy. You can actually read them yourself by typing import this into a Python interpreter. Principles like "Beautiful is better than ugly," "Simple is better than complex," and "Readability counts" are not just catchy phrases; they are the ideas that have guided Python's development and encouraged developers to write code that is clear, elegant, and easy to understand. This philosophy is a major reason why Python code is often described as "Pythonic"—it's not just about making it work, but making it work in a way that is clean and logical.

But what exactly is programming? At its heart, programming is simply the art of giving instructions to a computer. Think of it like writing a recipe. A recipe is a list of precise steps that, if followed correctly, will result in a delicious cake. A computer program is similar: it's a sequence of instructions written in a language the computer can understand, designed to accomplish a specific task. The computer, much like a very literal-minded chef, will follow your instructions exactly as you've written them. It doesn't know what you meant to say, only what you did say. This is why clarity and precision are so important in coding.

Our goal in this book is to teach you how to "speak" to the computer in Python. We will start with the most basic vocabulary and grammar and gradually build up your fluency. You'll learn how to store information, make decisions based on that information, repeat tasks automatically, and organize your instructions in a clean and efficient way. We'll take you step-by-step through the fundamental concepts that are common to almost all programming languages, giving you a solid foundation that will serve you well no matter where your coding journey takes you.

The power and influence of Python can be seen in the real world every day. It's not just a language for learners and hobbyists; it's a serious tool used by some of the biggest and most innovative companies on the planet. Google, for instance, has used Python from its very beginning for everything from its core search algorithms to its myriad of internal tools. The popular video-sharing site YouTube is largely written in Python.

When you're scrolling through your feed on Instagram, you're interacting with a system built on Python. The recommendation algorithms on streaming services like Netflix and Spotify, which suggest movies and music tailored to your tastes, are powered by Python's data analysis capabilities. Companies like Dropbox use it for their server-side logic, and even NASA uses Python for scientific computing and data analysis. Learning Python means you're learning a skill that is highly valued in the tech industry and beyond.

This book is designed for the absolute beginner. We make no assumptions about your prior experience. If you've never seen a line of code, you are in the right place. We will guide you from the very first step of setting up Python on your computer all the way through to writing your own programs. For those who may have tried coding before and felt overwhelmed, this book offers a fresh start with a language famous for its gentle learning curve. Even if you have some experience with other programming languages, you may find this book a useful and straightforward introduction to the Pythonic way of thinking.

To get the most out of this book, we encourage you to be an active learner. Reading about coding is one thing, but writing code is where the real learning happens. When you see a code example, don't just read it—type it out yourself. Run the code. See what happens. Then, play with it. Change a value here, modify a command there. See how your changes affect the outcome. This hands-on experimentation is one of the most effective ways to build your understanding and confidence.

Don't be afraid to make mistakes. Every single programmer, from the novice to the seasoned expert, makes mistakes. Errors and bugs are not a sign of failure; they are a natural part of the development process. In fact, they are valuable learning opportunities. Learning to read error messages, debug your code, and figure out why something isn't working is a critical skill for any developer. We'll provide guidance on how to approach this process, so embrace the errors—they are your teachers.

It is also important to set realistic expectations. Learning to code is a journey, not a race. You will not become a master programmer overnight, and that's perfectly fine. The goal of this book is not to teach you everything there is to know about Python—that would be impossible in a single volume. Instead, our aim is to provide you with a strong and comprehensive foundation. We want to equip you with the fundamental knowledge and skills you need to start building your own projects and, just as importantly, the confidence to continue learning on your own.

The path we will take through this book is a logical and progressive one. We will begin our journey in Chapter 1 by getting Python set up on your computer. From there, we'll dive into the absolute basics, exploring how to store and manage information using variables and different data types. We will then learn how to perform calculations and make comparisons using operators and expressions.

Once we have those fundamentals down, we'll move on to controlling the flow of our programs. You'll learn how to make your code execute different actions based on specific conditions and how to make your computer perform repetitive tasks with loops. These are the core building blocks that allow you to create dynamic and intelligent programs.

Next, we'll explore Python's powerful built-in data structures, such as lists, tuples, dictionaries, and sets. These tools will allow you to organize and work with collections of data in sophisticated and efficient ways. We will also cover functions, which are essential for writing clean, reusable, and well-organized code.

As we progress, we'll tackle more advanced and specialized topics. You'll learn how to work with text using strings, how to read from and write to files on your computer, and how to use modules and packages to extend Python's capabilities. We will also provide an introduction to Object-Oriented Programming (OOP), a powerful paradigm for structuring your code.

In the final section of the book, we will give you a taste of what's possible with Python in the real world. We'll introduce you to some of Python's standard libraries and touch upon exciting areas like web scraping, working with APIs (Application Programming Interfaces), and even provide a brief introduction to the world of data science with Python. By the time you reach the end, you will not only understand the fundamentals of programming but also have a clear roadmap for your next steps and future learning.

Welcome to the start of a new and exciting adventure. The ability to code is a powerful skill that can unlock creativity, enhance problem-solving abilities, and open up new opportunities you may not have even imagined. It can be challenging at times, but it is also incredibly rewarding. We are excited to be your guides as you take your first steps into the wonderful world of Python programming. Let's begin.

Welcome to the first hands-on step of your coding journey. Before we can start telling the computer what to do, we need to make sure it understands the language we're going to be speaking: Python. This chapter is all about setting up your environment. We'll install Python on your computer, take a look at a couple of different ways to interact with it, and, most importantly, we will write and run your very first computer program. It might sound like a lot, but we'll take it one step at a time. The goal here is to get you from zero to "Hello, World!" comfortably and with a clear understanding of what you're doing and why.

First, let's talk about how Python actually works. When you write code in a language like Python, you're writing instructions in a format that is readable to you, a human. However, a computer's central processing unit (CPU) doesn't understand things like print or name = "Alice". It operates on a much lower level, dealing with electronic signals that represent ones and zeros. So, how does your human-readable code get translated into something the machine can execute? This is where an interpreter comes in.

Think of an interpreter as a real-time translator. If you were in a foreign country and didn't speak the local language, you might have a translator with you. You would say a sentence, and the translator would immediately repeat it in the local language for others to understand. A programming language interpreter does something very similar. It reads your Python code line by line, and for each line, it translates it into instructions that the computer's processor can understand and execute right away. This "on-the-fly" translation is why Python is called an interpreted language.

This is different from a compiled language, like C++ or Java. In a compiled language, you would first run your entire program through a special program called a compiler. The compiler translates all of your code at once, creating a new file containing all the machine-level instructions. This new file, often called an executable, can then be run by the computer. To use our analogy, this is like translating an entire book from one language to another before anyone reads it. For beginners, the immediate feedback of an interpreted language like Python is a huge advantage, as you can test small pieces of code instantly.

Before we go to the Python website to download the software, we need to address a small but important piece of history: the existence of two major versions, Python 2 and Python 3. Python 3 was released in 2008 as a major update to the language. It was designed to fix some fundamental design flaws and inconsistencies in Python 2. While these changes made the language better and more logical, it also meant that Python 3 was not backward-compatible. In other words, code written for Python 2 would not necessarily run correctly with a Python 3 interpreter, and vice versa.

For many years, the programming world existed in a transitional state, with both versions being used. However, that era is now firmly over. As of January 1, 2020, the creators of Python officially stopped providing support for Python 2. All new development, library updates, and community focus are now squarely on Python 3. For anyone starting to learn Python today, the choice is clear and simple: you should learn and use Python 3. This book is written exclusively for Python 3, and all the examples and concepts we discuss will adhere to its syntax and features.

With that settled, let's get Python 3 installed on your computer. The process varies slightly depending on your operating system—Windows, macOS, or Linux—so follow the instructions for the system you are using. Our goal is to install the Python interpreter itself, which is the core program that will read and execute our code. We also want to make sure we can easily access it from our computer's command line, a text-based interface for interacting with the operating system.

Let's start with Windows. Your first step is to open a web browser and navigate to the official Python website at python.org. This is the central repository for everything Python, from the software itself to extensive documentation. Once you are there, hover over the "Downloads" menu. You should see a button that prominently displays the latest version available for Windows, something like "Download Python 3.12.0". Click this button to download the official installer.

Once the installer file has finished downloading, find it in your "Downloads" folder and double-click it to run. This is the most critical step for Windows users: on the very first screen of the installer, you will see a checkbox at the bottom labeled "Add Python to PATH". You absolutely must check this box. This simple action will save you a lot of headaches later on. It tells the Windows operating system where to find the Python interpreter, allowing you to run your programs from any folder on your computer.

What is this "PATH" we're talking about? The PATH is an environment variable on your operating system. Think of it as a list of directions. When you type a command, like python, into the command prompt, the system looks through the list of folders specified in the PATH to find a program with that name. By checking that box, you're adding the location of your new Python installation to that list, making it easy to find. After checking the box, you can simply click "Install Now" and follow the on-screen prompts to complete the installation.

To verify that everything worked correctly on Windows, we need to open the Command Prompt. You can do this by clicking the Start menu, typing cmd, and pressing Enter. In the black window that appears, type the following command and press Enter:

py --version

If the installation was successful, the command prompt will respond by printing the version of Python you just installed, for example, Python 3.12.0. You may also be able to use the command python --version. Congratulations, you have successfully installed Python on your Windows machine!

Now for macOS users. The good news is that macOS often comes with a version of Python already installed. The bad news is that it's usually an older, outdated version of Python 2, which, as we've discussed, you don't want to use. You can verify this by opening the Terminal application (you can find it in Applications/Utilities, or by using Spotlight search). In the terminal, type python --version and press Enter. You'll likely see a version number starting with 2.

To get the modern version, you will follow a process similar to Windows users. Open your web browser and go to python.org. Navigate to the "Downloads" section, where it should automatically detect you are on a Mac and offer the latest macOS installer package. Download this .pkg file. Once it has downloaded, open it from your "Downloads" folder. This will launch a standard macOS installer. Simply follow the on-screen instructions, agreeing to the license and confirming the installation, until it is complete.

After the installation finishes, you need to verify it from the Terminal. It's important to note how macOS handles multiple Python versions. To ensure you are using the new version you just installed, you should specifically use the python3 command. Open a new Terminal window and type:

python3 --version

You should see the version number of the Python 3 installation you just completed. If you were to type just python, it would likely still launch the old Python 2 that came with the system. For the rest of this book, whenever we refer to running Python from the command line, macOS users should remember to use python3.

Finally, let's cover Linux. Most modern Linux distributions, such as Ubuntu, Fedora, and Mint, already come with Python 3 pre-installed, as it's a critical component of the system itself. To check if it's there and what version you have, open your terminal (sometimes called a shell or console) and type the command:

python3 --version

Chances are you will see a Python 3 version number printed back to you, and you are already good to go. Linux is generally very developer-friendly, and for Python, the setup is often already done for you.

In the unlikely event that Python 3 is not installed, or if you have a very old version, you can easily install it using your distribution's package manager. For Debian-based distributions like Ubuntu or Mint, the command would be:

sudo apt-get update
sudo apt-get install python3

For Red Hat-based distributions like Fedora or CentOS, you would use the dnf or yum package manager. For example, on a recent version of Fedora, the command would be:

sudo dnf install python3

After running the appropriate commands for your system, you can verify the installation with python3 --version, and you'll be ready to start coding.

Now that Python is installed, let's play with it. One of the most useful tools that comes with Python is the interactive interpreter, also known as the REPL. REPL is an acronym that stands for Read-Eval-Print Loop. It's a program that reads a single line of code you type, evaluates (or executes) it, prints the result, and then loops back to wait for your next line of code. It's a fantastic way to quickly test small snippets of code without having to create a file.

To start the interactive interpreter, open your command prompt (on Windows) or terminal (on macOS/Linux). Simply type python (or py on Windows, or python3 on macOS/Linux) and press Enter. You should see some information about your Python version, followed by a new prompt that looks like three greater-than signs: >>>. This is the Python prompt, and it's waiting for you to give it a command.

Let's try a few things. You can use it as a simple calculator. Type 2 + 2 and press Enter.

>>> 2 + 2
4

The interpreter immediately evaluates the expression and prints the result, 4. You can try other basic arithmetic as well, like 10 - 3 or 5 * 7. This instant feedback is incredibly useful for learning and experimentation. You can even use the print command we saw in the introduction. Type print("This is the interactive interpreter!") and press Enter.

>>> print("This is the interactive interpreter!")
This is the interactive interpreter!

The REPL is a playground for you to explore Python commands. Don't worry about breaking anything; the worst that can happen is you'll get an error message. When you're finished experimenting, you can exit the interpreter by typing exit() and pressing Enter, or by pressing Ctrl+D on macOS/Linux or Ctrl+Z followed by Enter on Windows.

While the interactive interpreter is great for quick tests, you'll be writing most of your programs in files. A program is simply a sequence of instructions saved in a text file, which you can then run using the Python interpreter. This is our ultimate goal: to write and run a complete Python program. To do this, we'll need a tool for writing our code: a code editor.

A code editor is fundamentally a text editor, but it's one that has been specifically designed for writing code. Unlike a word processor like Microsoft Word or Google Docs, which adds a lot of invisible formatting for fonts, margins, and spacing, a code editor saves plain text. This is crucial because the Python interpreter only understands plain text characters, not bolding or italics.

Furthermore, good code editors come with features that make a programmer's life much easier. One of the most common is syntax highlighting, which uses different colors for different parts of your code—for example, making functions one color and text another. This makes your code much easier to read and helps you spot mistakes at a glance. Many editors also offer features like code completion, which suggests commands as you type, and integrated terminals for running your code.

There are many excellent and free code editors available. A few of the most popular choices for beginners are Visual Studio Code (often called VS Code), Sublime Text, and Cursor. All of these are available for Windows, macOS, and Linux. For the purposes of this book, any of them will work perfectly. We highly recommend you download and install one of these now. For a fantastic all-around experience, Visual Studio Code is a great place to start.

It's also worth mentioning that Python itself comes with a very basic integrated editor and interpreter environment called IDLE (Integrated Development and Learning Environment). You can find it by searching for "IDLE" in your applications. It's perfectly functional for starting out, but most developers quickly move to a more powerful editor. We recommend starting with a mainstream editor like VS Code as it will serve you better in the long run.

Once you have your code editor installed and open, it's time for the main event: writing your first program. This is a rite of passage for every new programmer. We are going to create a program that simply displays the message "Hello, World!" on the screen. It may seem like a small step, but it proves that your entire setup is working correctly, from the editor to the Python interpreter.

In your new code editor, create a new file. You'll be presented with a blank slate, a clean text area waiting for your instructions. Here, you will type just one single line of code. It's the same command we've seen before, but this time we're putting it in a file to be saved and executed. Type the following exactly as it appears:

print("Hello, World!")

Take a moment to double-check what you've typed. Ensure that the word print is in lowercase, that the message is enclosed in double quotes, and that the quotes themselves are wrapped in a pair of parentheses.

The next step is to save this file. This is an important step because the file extension—the part of the filename after the dot—tells the operating system, and you, what kind of file it is. All Python script files should be saved with a .py extension. In your editor, go to File > Save. We recommend creating a special folder for all the projects you'll be working on from this book, perhaps on your Desktop called python_projects. Save the file inside that folder with the name hello.py.

With your file saved, the only thing left to do is to run it. To do this, we need to go back to our command line—the Command Prompt on Windows or the Terminal on macOS and Linux. When you first open the command line, you are usually in your user's home directory. You need to navigate to the folder where you saved your hello.py file.

To do this, you use the cd command, which stands for "change directory". For example, if you saved the file in a folder named python_projects on your Desktop, you would first navigate to the Desktop by typing cd Desktop and pressing Enter. Then, you would navigate into your project folder by typing cd python_projects and pressing Enter. You can use the ls command (on macOS/Linux) or dir (on Windows) to see a list of files in the current directory to make sure your hello.py file is there.

Once you are in the correct directory—the one containing hello.py—you can finally run your program. To do this, you invoke the Python interpreter and tell it which file you want it to execute. The command is:

python hello.py

Remember, if you are on macOS or Linux, you will likely need to use python3:

python3 hello.py

Press Enter. If all has gone well, the text Hello, World! will appear on the next line in your terminal. You did it! You have just written and executed your very first Python program. You have successfully given the computer an instruction, and it has followed it. This is the fundamental loop of programming: write, save, run.

So what exactly happened when you ran that command? Let's break down that single line of code, print("Hello, World!"), to understand its components. This will give you a small preview of the concepts we'll be diving into in the next chapter.

First, we have the word print. In Python, print is the name of a built-in function. You can think of a function as a named, reusable piece of code that performs a specific task. Python has many built-in functions to do things like perform mathematical operations, manipulate text, or, in this case, display output to the screen. The job of the print function is to take whatever you give it and show it to you.

Immediately following the function name are the parentheses (). In Python, parentheses are used to call, or execute, a function. They are also the place where you provide any information the function might need to do its job. This information is known as an argument. Some functions don't need any arguments, but the print function needs to know what you want it to print.

The information we passed to the print function is "Hello, World!". In programming, a piece of text like this is called a string. A string is simply a sequence of characters. To let Python know that you are writing a string of text and not a command or a variable name, you must enclose it in quotes. You can use either double quotes (") or single quotes (')—Python doesn't mind, as long as you use the same kind to open and close the string.

So, to summarize: the line print("Hello, World!") tells the Python interpreter to call the print function and to pass it the string "Hello, World!" as an argument. The print function then performs its designated task and displays that string in your terminal. This is the basic structure of many commands in Python: a function name, followed by parentheses containing any arguments the function needs.

As a beginner, you will inevitably run into errors, and your first program is no exception. Let's look at a few common mistakes. Errors are not a sign of failure; they are the interpreter's way of telling you that it doesn't understand your instructions. Learning to read and understand error messages is a core skill of programming.

One common error is a SyntaxError. This happens when you write code that violates the grammar rules of the Python language. For example, if you forgot the closing parenthesis and wrote print("Hello, World!", the interpreter wouldn't know where the command ends. It would give you a SyntaxError: unexpected EOF while parsing, which is its way of saying, "I reached the end of the file (EOF) but was expecting something else." Similarly, forgetting one of the quotes, like print("Hello, World!), would also result in a SyntaxError.

Another common error for beginners is a NameError. This occurs when you try to use a variable or function name that Python doesn't recognize. For instance, if you misspelled the print function and wrote prnt("Hello, World!"), Python would stop and report a NameError: name 'prnt' is not defined. It's telling you, "I've looked everywhere, but I have no idea what a 'prnt' is." This is a helpful clue to check your spelling.

Finally, you might encounter an error not in your code, but in how you try to run it. If you are in the wrong directory in your terminal and you type python hello.py, you might get an error like FileNotFoundError: [Errno 2] No such file or directory. The interpreter is telling you plainly that it looked for a file named hello.py in the current folder, but couldn't find it. This is your cue to use the cd command to navigate to the correct directory.

Don't be discouraged by these errors. Every programmer, no matter how experienced, sees them every day. The key is to read the message carefully, look at the line of code it points to, and try to figure out what the interpreter is trying to tell you. Debugging—the process of finding and fixing errors—is a puzzle, and solving it is one of the most satisfying parts of coding.

You have now successfully navigated the first and often most intimidating part of learning to program: the setup. You've installed the necessary software, learned how to use the command line to run programs, familiarized yourself with the interactive interpreter, and written and executed a complete Python script. You have laid the groundwork upon which all your future knowledge will be built. In the chapters to come, we will leave the world of setup and dive into the language itself, starting with how to store and manage information in your programs.