We've learned how to define functions with a fixed number of positional and keyword arguments. But what if you want to create a function that can accept any number of arguments? For example, a function that can sum two numbers, or five, or a hundred. This is where args and *kwargs come in, providing the ultimate flexibility for your function definitions.
We've learned about the core components of asyncio async and await.
Theory is important, but the best way to solidify your understanding of Object-Oriented Programming is to build something. In this article, we will put together all the concepts we've learned in this series—classes, objects, attributes, methods, and encapsulation—to model a real-world entity from scratch.
We have now covered three major pillars of Object-Oriented Programming: Encapsulation, Inheritance, and Polymorphism. The final pillar we will discuss is Abstraction.
In Object-Oriented Programming, a key principle is encapsulation: the idea of bundling data (attributes) and the methods that operate on that data into a single unit (an object). Part of this principle is controlling access to that data. You might want some attributes to be freely accessible, while others should be hidden or only modified through specific methods.
Following our first API with FastAPI in Creating Your First Web API with FastAPI, this article explores API Routing and HTTP Verbs for RESTful Endpoints. We'll learn how to structure our API with different routes and how to use the correct HTTP methods for each action.
We've seen how asyncio is perfect for I/O-bound tasks and how aiohttp solves the problem of blocking network requests. But what about the other major type of I/O: reading and writing files?
Following our lesson on CORS (Cross-Origin Resource Sharing) in FastAPI APIs, this article introduces Authentication and Authorization Basics for APIs: JWT (Introduction). Securing your API is crucial, and JSON Web Tokens (JWT) are a popular way to handle authentication.
Following our exploration of Understanding None, this article dives into the world of interactive Python scripts. We'll learn how to get input from the user and display output to the console using the input() and print() functions.
Welcome to a new chapter in your Python journey! We're moving from writing command-line scripts and applications to the exciting world of web development. Before we can build web applications with Python frameworks like Flask or Django, we must first understand the fundamental concepts that power the entire internet.
Following our lesson on Session and Cookie Management in Flask, this article explores Blueprints in Flask: Modularizing your application. As your Flask application grows, it becomes necessary to organize it into smaller, reusable components. Blueprints are the perfect tool for this.
Following our introduction to Working with Databases: Introduction to SQLAlchemy, this article will guide you through Building a Simple CRUD App with Flask and SQLAlchemy. CRUD stands for Create, Read, Update, and Delete, which are the four basic functions of persistent storage.
We are now at the final article in our series on iterators, generators, and decorators. We will explore closures, a concept that is fundamental to how decorators and other advanced patterns work in Python.
Following our exploration of break and continue, this article delves into combining loops and conditionals. This concept is essential for building complex logic and is a foundational element in modern Python development.
Following our exploration of Basic Console Input and Output, this article focuses on how to make your code more readable and understandable using comments and docstrings.
Following our exploration of Operator Precedence and Associativity, this article introduces some of Python's most common and useful built-in functions. These functions are always available to you, without the need to import any modules.
Over the last several articles, we've explored Python's powerful built-in collection types: lists, tuples, dictionaries, and sets, as well as the specialized containers in the collections module. This article serves as a capstone, summarizing the best practices and helping you decide which collection to use in different scenarios.
In Object-Oriented Programming, there are two primary ways to build relationships between classes and reuse code: Inheritance and Composition. While we have already covered inheritance, it's crucial to understand its alternative, composition, and to know when to choose one over the other. This choice is one of the most fundamental design decisions you will make when structuring your programs.
Following our exploration of Common Built-in Functions, this article introduces a fundamental concept in programming: conditional statements. We'll start with the most basic conditional statement, the if statement.
Following our exploration of Conditional Statements: if-else (Part 2), this article introduces the if-elif-else statement, which allows you to check multiple conditions in a sequence.
Following our exploration of Conditional Statements: if (Part 1), this article delves into the if-else statement, which allows you to execute a different block of code when the if condition is not met.
We've seen that the standard, safe way to work with files is by using the with statement. This pattern is not unique to files; it's a general mechanism for managing resources in Python. Any object that can be used in a with statement is called a context manager.
Following our exploration of The "What" and "Why" of Python (Part 2), this article delves into two fundamental concepts that define how Python works: its nature as an interpreted language and its use of dynamic typing. Understanding these concepts is key to writing effective Python code.
Welcome to a new chapter in your Python journey! So far, we've been using a style of programming called procedural programming. We write procedures (functions) that perform operations on data. This is great, but as programs become larger and more complex, it can be hard to manage the relationship between the data and the functions that operate on it.
Following our lesson on Dependency Injection in FastAPI, this article explains CORS (Cross-Origin Resource Sharing) in FastAPI APIs. CORS is a security feature that browsers implement to control how web pages in one domain can request resources from another domain.
Following our introduction to Introduction to RESTful APIs: Principles and Design, this article will guide you through Creating Your First Web API with FastAPI. FastAPI is a modern, fast (high-performance) web framework for building APIs with Python 3.6+ based on standard Python type hints.
We've learned what modules are and how to import them. Now it's time to take the next logical step: creating your own. This is a fundamental skill for any Python developer. By creating your own modules, you can break down complex problems into logical, reusable pieces, making your code cleaner, easier to debug, and more professional.
We've spent a lot of time learning how to write classes, including the init method to store attributes and special methods like repr and eq to make our classes behave well.
This is the final article in our comprehensive series on asynchronous programming. We've learned how to create and run concurrent tasks, but with this power comes new challenges. One of the most notorious problems in any concurrent system is the deadlock.
Welcome to the final topic in our series on advanced Python concepts: decorators. Decorators are one of the most powerful and widely used features in Python, especially in web frameworks like Flask and Django. They might seem magical at first, but they are built directly on top of concepts we already know.
In our last article, we learned that a decorator is a function that wraps another function to add new behavior. However, our first decorator was simple: it only worked on functions that took no arguments.
We've learned how to define functions, pass information to them, and get values back using the [return statement]. Now, let's make our functions more flexible and readable. This article explores two powerful features: default arguments and keyword arguments, which allow you to make function parameters optional and your function calls more explicit.
In the last article, we learned that a class is a blueprint and an object is the instance we create from it. We used the init() method to set up the initial data, or attributes, of an object.
In our previous article, we introduced [Introduction to Functions: The DRY principle and code reusability]. We learned that functions are essential for writing clean, reusable, and maintainable code. This article dives deeper into the mechanics of creating functions, focusing on the def keyword and the crucial distinction between parameters and arguments.
Following our lesson on Status Codes and Error Handling in Web APIs, this article explores Dependency Injection in FastAPI. This is one of FastAPI's most powerful features, allowing you to manage dependencies and reuse code in a simple and elegant way.
After exploring the ordered worlds of lists and **tuples**, we now dive into one of Python's most powerful and flexible data structures: the dictionary. Unlike lists and tuples which are indexed by a range of numbers, dictionaries are indexed by keys, which can be any immutable type.
In the previous article, we learned how to create dictionaries and access their values. Now, we'll explore how to modify, manage, and iterate over them using dictionary methods. We'll also introduce a powerful, Pythonic feature for creating dictionaries: dictionary comprehensions.
Writing code that works is only half the battle. Writing code that you and others can understand months from now is just as important. This is where documentation comes in. In this article, we'll explore two powerful, related concepts for documenting your Python functions: docstrings and type hints. Mastering them will elevate the quality and professionalism of your code.
We have learned about some of the core pillars of Object-Oriented Programming encapsulation.
Asynchronous programming introduces new complexities, and error handling is one of the most critical. When you are running dozens of tasks concurrently, what happens if one of them fails? How do you prevent a single failure from crashing your entire application?
Following our exploration of Handling HTTP Methods Using request.form. This is key to building interactive web applications that collect and process user input.
In our last article, we learned how to define functions and pass information to them using [parameters and arguments]. So far, our functions have only performed actions, like printing to the console. But what if we need a function to give us a result back? This is where the return statement comes in, and it's a game-changer for writing powerful, modular code.
Following our exploration of Fundamental Data Types booleans. We'll cover what booleans are, the concept of "truthiness", and the logical operators used to work with them.
Following our exploration of Variables and Assignment, this article dives into one of the most fundamental data types in Python: numbers. We'll cover integers and floating-point numbers, and the common operations you can perform on them.
Following our exploration of Fundamental Data Types strings. We'll cover how to create strings, use f-strings for formatting, and some of the most common string methods.
Following our exploration of Fundamental Data Types: Strings (Part 1), this article delves deeper into the world of strings, covering indexing, slicing, and more advanced string methods.
In the last article, we saw how generator functions using yield provide a memory-efficient way to create iterators. Python offers an even more concise and elegant way to create simple generators: generator expressions.
In the last article, we learned how to create a custom iterator by building a class that implements the full iterator protocol (iter and next). While this is powerful, it's also quite verbose for many common use cases.
In the last article, we introduced the try...except block as the fundamental way to handle runtime errors in Python. It allows our programs to react to problems gracefully instead of crashing. However, the story doesn't end there. The full try statement includes two more optional but powerful clauses: else and finally.
Following our exploration of Templates in Flask (Part 2) GET, POST. This concept is essential for creating interactive web applications that can receive and process user data.
We have mastered the art of creating self-contained classes that bundle data and behavior. But what if we have multiple classes that share some common logic? For example, a Dog, a Cat, and a Fish are all types of Animal. They might all have a name and an age, but each makes a different sound.
We've learned how to define methods—functions inside a class—that give our objects behavior. So far, all the methods we've created have been instance methods, which operate on a specific instance of a class.
In Object-Oriented Programming, an interface is a description of the actions an object can do. It's a contract or a blueprint that defines a set of methods that a class must implement. For example, any object that acts as a "Data Parser" should have a .parse() method, regardless of whether it's parsing a PDF, a website, or a text file.
Welcome to the final chapter of our advanced Python section. We are about to tackle asynchronous programming, a powerful paradigm for writing concurrent code that can significantly boost the performance of certain types of applications.
This article provides an Introduction to Data Science in Python. Python has become the de facto language for data science due to its simplicity, powerful libraries, and vibrant community.
Up to this point, our scripts have followed a "happy path." We assume the user will enter the correct type of data, the files we want to read will always exist, and we'll never divide by zero. But in the real world, things go wrong. Network connections fail, files are moved, and users enter invalid input.
Welcome to a new chapter in your Python journey! We've spent a great deal of time understanding the fundamental building blocks of Python—variables, data types, and control flow. Now, it's time to learn how to organize our code into reusable, efficient, and readable blocks. This article introduces one of the most important concepts in programming: functions.
We've successfully organized our code into reusable modules. But what happens when your project grows even larger and you have dozens of modules? Throwing them all into the same directory becomes just as messy as having one giant file. The next level of organization in Python is the package. A package is simply a way to structure your project's modules into a directory hierarchy.
So far, we've worked with our own modules and those from Python's extensive Standard Library. But the true power of the Python ecosystem comes from the millions of third-party packages created by the community. To access this vast universe of code, you need a package manager. For Python, that tool is pip.
We've now mastered Python's four core collection types. But what happens when you need a more specialized tool? The collections module in Python's standard library provides high-performance, specialized container datatypes. In this article, we'll introduce three of the most useful: namedtuple, deque, and Counter.
This article introduces Introduction to RESTful APIs: Principles and Design. Before we dive into FastAPI, it's crucial to understand the principles of REST, which is the architectural style that most web APIs follow.
In the last article, we learned about the request/response cycle that powers the web. A client sends an HTTP request, and a server sends back an HTTP response. But how does a web server (like Apache or Nginx) communicate with a Python script?
One of the most powerful and frequently used features in Python is the for loop. We use it to loop over lists, strings, dictionaries, and files. But how does it actually work? How does the for loop know how to handle all these different types of objects?
We have covered almost every fundamental aspect of Python functions. For our final topic in this series, we'll explore a special type of function: the lambda function. Lambdas, also known as anonymous functions, provide a concise way to create small, single-use functions without the overhead of a full def statement.
Following our exploration of combining loops and conditionals, this article kicks off a new series on Working with Collections, starting with an introduction to Python lists. This concept is essential for storing and manipulating groups of data and is a foundational element in modern Python development.
Following our introduction to declaring and initializing lists, this article dives deeper into manipulating them. We'll explore the powerful tools Python provides: list methods, slicing, and list comprehensions. Mastering these is key to effectively working with data in Python.
Following our exploration of foreach loops, this article delves into break and continue statements. These concepts are essential for writing efficient and readable Python code and are a foundational element in modern Python development.
Following our exploration of Conditional Statements, this article introduces another fundamental concept in programming: loops. We'll start with the for loop, which allows you to iterate over a sequence of elements.
Following our exploration of Loops: for loops (Part 1), this article delves deeper into the world of for loops, covering nested loops and more advanced patterns for iterating over different data structures.
Following our exploration of Loops: while and do-while loops, this article focuses on what is often called a "foreach" loop in other languages. In Python, this is simply the standard for loop used to iterate over collections.
Following our exploration of Loops the while loop. We'll also see how to simulate a do-while loop, which is not a native feature of Python.
We've already encountered some of Python's special "dunder" (double underscore) methods, like init, str, and repr. These methods are special because we don't call them directly (e.g., myobj.str()). Instead, Python calls them for us in response to specific actions, like print(myobj).
In the last article, we learned the basics of pip for installing and removing individual packages. While that's useful, real-world projects almost always depend on multiple external packages. Managing these dependencies is a critical skill for collaboration and for ensuring your project runs reliably on different machines.
Welcome to the final article in our series on Advanced OOP. We are about to explore one of the most profound and mind-bending concepts in Python: metaclasses. This is an advanced topic, but understanding it provides a deep insight into how Python's object model works.
Following our Introduction to Data Science in Python, this article introduces NumPy (Part 1): Introduction to NumPy arrays. NumPy is the fundamental package for scientific computing in Python. It provides a high-performance multidimensional array object, and tools for working with these arrays.
Following our Introduction to NumPy arrays, this article explores NumPy (Part 2): Array indexing, slicing, and operations. We'll learn how to access and manipulate data within NumPy arrays and how to perform mathematical operations on them.
Following our exploration of Operators operator precedence and associativity.
Following our exploration of Comments and Docstrings, this article dives into the world of arithmetic operators in Python. These operators allow you to perform mathematical calculations in your code.
Following our exploration of Operators: Arithmetic Operators, this article dives into the world of comparison operators in Python. These operators allow you to compare two values and get a boolean result (True or False).
Following our exploration of Operators logical operators and bitwise operators.
Following our exploration of NumPy, this article introduces Pandas (Part 1): Introduction to Series and DataFrames. Pandas is a fast, powerful, flexible, and easy-to-use open-source data analysis and manipulation tool, built on top of the Python programming language.
Following our Introduction to Series and DataFrames, this article explores Pandas (Part 2): Reading and writing data (CSV, Excel). A common task in data science is to read data from various file formats and to write data out to files.
Following our lesson on Reading and writing data, this article explores Pandas (Part 3): Data selection and indexing. Selecting and filtering data is one of the most common tasks in data analysis.
Following our lesson on Data selection and indexing, this article explores Pandas (Part 4): Data cleaning and preparation. Real-world data is often messy. Data cleaning is a crucial step in any data analysis workflow.
We've learned about inheritance and how a child class can inherit attributes and methods from a parent class. Now we're going to explore polymorphism, a powerful concept that allows us to treat objects of different classes in a similar way.
We've seen how to use private attributes (name) and public methods (getname(), setname()) to enforce encapsulation. This pattern, common in languages like Java or C#, is often called the "getter/setter" pattern.
Welcome! This interactive online book is your comprehensive guide to mastering the Python programming language. Whether you are a complete novice taking your first steps into the world of code or a developer looking to solidify your Python skills, this resource is crafted for you.
We have learned how to handle exceptions that Python raises automatically, like ValueError or FileNotFoundError. But what if you encounter an error condition in your own code that isn't covered by a built-in exception?
In the last article, we learned how to open files using different modes. Now, let's focus on the primary reason you'd open a file in read mode ('r'): to get data out of it. Python's file objects provide several methods for reading content, each suited for different situations.
Following our lesson on API Routing and HTTP Verbs for RESTful Endpoints, this article focuses on Request and Response Bodies: Pydantic models. Pydantic is a library for data validation and settings management using Python type hints. FastAPI uses Pydantic models to define the structure of request and response bodies, providing automatic validation and serialization.
We now know how to route a URL to a specific view function. But web development is a two-way street. Our application needs to be able to receive data from the user and send back more than just a simple string of HTML.
We've successfully created a simple Flask application that can serve a response from a single URL. But a real website has many pages: an about page, a contact page, user profiles, and so on. The system that maps URLs to the Python functions that handle them is called routing.
We've seen how to create individual tasks with asyncio.create_task() and then await them. This is a great way to start multiple background jobs. However, it can be a bit verbose if you just want to run a list of coroutines concurrently and wait for all of them to finish.
We've been working with variables and functions, but we haven't yet discussed a crucial concept: scope. Scope determines the visibility and accessibility of a variable. In other words, it answers the question, "Where in my program can I access this variable?" Understanding scope is essential for writing bug-free code and avoiding common errors where variables seem to "disappear" or have unexpected values.
Following our guide on Building a Simple CRUD App with Flask and SQLAlchemy, this article explains Session and Cookie Management in Flask. HTTP is a stateless protocol, meaning each request is independent. Sessions and cookies allow us to store information across multiple requests from the same user.
We've explored ordered collections like lists and **tuples**, and the key-value world of dictionaries. Now we introduce the final core collection type: the set. Sets are all about uniqueness and are modeled after the mathematical concept of a set.
Before we can write our first line of Flask code, we need to set up a proper development environment. A clean and organized setup is crucial for any project, as it prevents dependency conflicts and makes your application easier to manage as it grows.
Following our exploration of The Python Ecosystem installing Python and the package manager, pip.
Following our exploration of Setting Up Your Development Environment (Part 1) configuring your Integrated Development Environment (IDE) and setting up virtual environments.
We've created a Car class that holds data (attributes) and has behaviors (methods). But what happens when we try to print() one of our Car objects directly?
Following our lesson on Request and Response Bodies: Pydantic models, this article focuses on Status Codes and Error Handling in Web APIs. Returning appropriate HTTP status codes and handling errors gracefully is crucial for building a robust and predictable API.
We've learned how to use Flask's render_template() function to serve HTML files and pass variables to them. This is great, but as you build a website with multiple pages, you'll notice that a lot of your HTML is repetitive. The navigation bar, the footer, the `` section with all your CSS links—these are the same on every page.
We've learned how to render templates and pass variables from our Flask application to our HTML. Now, let's unlock the true power of the Jinja2 templating engine by exploring two of its most important features: control structures and filters.
Following our exploration of Conditional Statements the ternary operator.
In our introduction to asynchronous programming, we saw how async and await can dramatically improve the performance of I/O-bound applications. Now, let's dive deeper into the three fundamental components that make this possible within the asyncio module: the Event Loop, Coroutines, and Tasks.
We've learned how to create robust decorators that can wrap any function. As we saw, a key part of that pattern is using @functools.wraps to preserve the original function's metadata. The functools module is part of Python's standard library and contains powerful tools for working with higher-order functions (functions that act on or return other functions).
In our last article, we learned how to organize code into separate files called [modules]. Now, we need to master the tool that makes modules useful: the import statement. This statement is the gateway to accessing code from other files and from Python's vast standard library, allowing you to build powerful applications without reinventing the wheel.
Throughout our articles on file I/O, we've consistently used a specific structure block. We mentioned that it's the "modern, safe, and recommended" way to handle files, but we haven't explained why.
Following our exploration of Core Concepts the Python Standard Library and the Python Package Index (PyPI).
One of Python's greatest strengths is its extensive Standard Library. This is a vast collection of modules that comes bundled with every Python installation, providing tools for a huge variety of common programming tasks. It's often referred to as Python's "batteries-included" philosophy.
Welcome to the beginning of your Python journey! This first article dives into the fundamental questions: What is Python, and why has it become one of the most popular programming languages in the world? We'll explore its core philosophy, its fascinating history, and the diverse use cases that make it such a versatile tool for developers.
Following our exploration of The "What" and "Why" of Python (Part 1), this article delves into Python's role in modern software development. We'll explore why Python is the go-to language for web development, data science, machine learning, and automation.
After mastering the flexibility of lists in Part 1 and Part 2, we now turn to their close relative they are immutable. Understanding this distinction is key to writing robust and efficient Python code.
Following our exploration of Fundamental Data Types: Booleans (True, False), this article covers type conversion, also known as casting. We'll learn how to convert variables from one data type to another.
So far, we've been writing all our code in a single Python file. This is fine for small scripts, but as your projects grow, it becomes messy, hard to navigate, and difficult to maintain. The solution is to break your code into multiple files, and in Python, these files are called modules. This article is the first step toward organizing your code like a professional developer.
Following our exploration of Type Conversion (Casting), this article delves into a special and important value in Python: None. We'll learn what None represents, how to use it, and how to check for it.
Following our exploration of Your First Python Script variables. We'll learn how to create and use variables in Python, and the best practices for naming them.
We've learned how to install packages with pip and manage them with a requirements.txt file. This is a great workflow, but it has one major flaw: by default, pip installs packages globally.
Now that we understand the basic concepts of how the web works, it's time to choose a tool to help us build web applications in Python. There are many choices, but one of the most popular, especially for beginners and for building smaller applications and APIs, is Flask.
The most common use case for asyncio is to handle I/O-bound tasks, and the most common I/O task in modern software is making network requests. However, the popular requests library is synchronous. If you use it in an async function, it will block the entire event loop, defeating the purpose of asyncio.
Following our exploration of Forms in Flask Introduction to SQLAlchemy. Most web applications need to store data persistently, and SQLAlchemy is a powerful library for this purpose.
When we work with files, we often hardcode the file path as a simple string, like 'myfolder/myfile.txt'. This works, but it's not robust. What happens if your script is run on a different operating system? Windows uses a backslash (\) as a path separator, while macOS and Linux use a forward slash (/). Hardcoding paths with one type of slash can make your script fail on other systems.
So far, our Python programs have been self-contained. They run, perform calculations, and when they finish, any data they generated is gone. To create persistent programs that can save data and read it back later, we need to interact with files.
We've mastered the art of reading from files. Now it's time to look at the other side of the coin: writing data to files. This is how you can save program state, log events, generate reports, or create any text-based output you need.
In the last article, we created our first Flask application, but our view function returned a simple string of HTML. This is not practical for building real websites. A real website has complex HTML, and we need a way to keep our Python logic separate from the presentation markup.
With our environment set up, it's time to write our very first web application with Flask. The traditional starting point for any new programming endeavor is the "Hello, World!" application. We'll create a simple web server that, when accessed, returns that classic phrase to the user's browser.
Following our exploration of Setting Up Your Development Environment (Part 2): Configuring Your IDE and Virtual Environments, it's time to write and run your very first Python script. In this article, we'll cover the classic "Hello, World!" program and how to run it from the command line.
Following our exploration of Your First Python Script: "Hello, World!" (Part 1), this article delves deeper into the structure of a Python script and the versatile print() function.