Real Python

The Real Python Podcast – Episode #255: Structuring Python Scripts & Exciting Non-LLM Software Trends

2025-06-27T12:00:00+00:00

What goes into crafting an effective Python script? How do you organize your code, manage dependencies with PEP 723, and handle command-line arguments for the best results? Christopher Trudeau is back on the show this week, bringing another batch of PyCoder's Weekly articles and projects.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Your Guide to the Python print() Function

2025-06-25T14:00:00+00:00

If you’re like most Python users, then you probably started your Python journey by learning about print(). It helped you write your very own “Hello, World!” one-liner and brought your code to life on the screen. Beyond that, you can use it to format messages and even find some bugs. But if you think that’s all there is to know about Python’s print() function, then you’re missing out on a lot!

Keep reading to take full advantage of this seemingly boring and unappreciated little function. This tutorial will get you up to speed with using Python print() effectively. However, be prepared for a deep dive as you go through the sections. You may be surprised by how much print() has to offer!

By the end of this tutorial, you’ll understand that:

The print() function can handle multiple arguments and custom separators to format output effectively.
You can redirect print() output to files or memory buffers using the file argument, enhancing flexibility.
Mocking print() in unit tests helps verify code behavior without altering the original function.
Using the flush argument ensures immediate output, overcoming buffering delays in certain environments.
Thread-safe printing is achievable by implementing locks to prevent output interleaving.

If you’re just getting started with Python, then you’ll benefit most from reading the first part of this tutorial, which illustrates the essentials of printing in Python. Otherwise, feel free to skip ahead and explore the sections that interest you the most.

Get Your Code: Click here to download the free sample code that shows you how to use the print() function in Python.

Take the Quiz: Test your knowledge with our interactive “The Python print() Function” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

The Python print() Function

In this quiz, you'll test your understanding of Python's built-in print() function, covering how to format output, specify custom separators, and more.

Printing in a Nutshell

It’s time to jump in by looking at a few real-life examples of printing in Python. By the end of this section, you’ll know every possible way of calling print().

Producing Blank Lines

The simplest example of using Python print() requires just a few keystrokes:

Python

print()

This produces an invisible newline character, which in turn causes a blank line to appear on your screen. To add vertical space, you can call print() multiple times in a row like this:

Python
      
    
print()
print()
print()

It’s just as if you were hitting Enter on your keyboard in a word processor program or a text editor.

While you don’t pass any arguments to print(), you still need to put empty parentheses at the end of the line to tell Python to actually execute that function rather than just refer to it by name. Without parentheses, you’d obtain a reference to the underlying function object:

Python
      
>>> print()

>>> print
<built-in function print>

The code snippet above runs within an interactive Python REPL, as indicated by the prompt (>>>). Because the REPL executes each line of Python code immediately, you see a blank line right after calling print(). On the other hand, when you skip the trailing parentheses, you get to see a string representation of the print() function itself.

As you just saw, calling print() without arguments results in a blank line, which is a line comprised solely of the newline character. Don’t confuse this with an empty string, which doesn’t contain any characters at all, not even the newline!

You can use Python’s string literals to visualize these two:

Blank Line: "\n"
Empty String: ""

The first string literal is exactly one character long, whereas the second one has no content—it’s empty.

Note: To remove the newline character from a string in Python, use its .rstrip() method, like this:

Python
      
>>> "A line of text.\n".rstrip()
'A line of text.'

This strips any trailing whitespace from the right edge of the string of characters. To learn more about .rstrip(), check out the How to Strip Characters From a Python String tutorial.

Even though Python usually takes care of the newline character for you, it helps to understand how to deal with it yourself.

Dealing With Newlines

Read the full article at https://realpython.com/python-print/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: The Python print() Function

2025-06-25T12:00:00+00:00

In this quiz, you’ll test your understanding of Your Guide to the Python print() Function.

The print() function outputs objects to the console or a specified file-like stream. You’ll practice:

Printing multiple values with custom separators
Changing the end-of-line character
Redirecting output using the file parameter
Forcing immediate output with the flush parameter

Work through these questions to reinforce your knowledge of print()’s parameters and best practices for clear, formatted I/O.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Starting With DuckDB and Python

2025-06-24T14:00:00+00:00

The DuckDB database provides a seamless way to handle large datasets in Python with Online Analytical Processing (OLAP) optimization. You can create databases, verify data imports, and perform efficient data queries using both SQL and DuckDB’s Python API.

By the end of this video course, you’ll understand that:

You can create a DuckDB database by reading data from files like Parquet, CSV, or JSON and saving it to a table.
You query a DuckDB database using standard SQL syntax within Python by executing queries through a DuckDB connection object.
You can also use DuckDB’s Python API, which uses method chaining for an object-oriented approach to database queries.
Concurrent access in DuckDB allows multiple reads but restricts concurrent writes to ensure data integrity.
DuckDB integrates with pandas and Polars by converting query results into DataFrames using the .df() or .pl() methods.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Python enumerate(): Simplify Loops That Need Counters

2025-06-23T14:00:00+00:00

Python’s enumerate() function helps you with loops that require a counter by adding an index to each item in an iterable. This is particularly useful when you need both the index and value while iterating, such as listing items with their positions. You can also customize the starting index with the start argument, offering flexibility in various scenarios.

By the end of this tutorial, you’ll understand that:

enumerate() in Python adds a counter to an iterable and returns it as an enumerate object, pairing each item with an index.
enumerate() accepts an iterable and an optional start argument to set the initial index value.
The advantage of enumerate() is that it provides both index and value pairs without manual counter management.
You can use zip() or slicing as alternatives to enumerate() for iterating multiple sequences or selecting specific elements.

Explore how to implement your own version of enumerate() and discover alternative methods like zip() and itertools for more complex iteration patterns.

Get Your Code: Click here to download the free sample code you’ll use to explore how enumerate() works in Python.

Using Python’s `enumerate()`

There are situations when you need both the index and the value of items in an iterable. That’s when Python’s enumerate() function can come in handy for you.

Python’s enumerate() function adds a counter to an iterable and returns it in the form of an enumerate object, which can be used directly in loops. For example, when you want to display the winners of a race, you might write:

Python
      
        
      
    
>>> runners = ["Lenka", "Martina", "Gugu"]
>>> for winner in enumerate(runners):
...     print(winner)
...
(0, 'Lenka')
(1, 'Martina')
(2, 'Gugu')

Since enumerate() is a built-in function, you can use it right away without importing it. When you use enumerate() in a for loop, you get pairs of count and value from the iterable.

Note: If you’re coming from languages like C, Java, or JavaScript, you might be tempted to use range(len()) to get both the index and value in a loop. While this works in Python, enumerate() is considered a more Pythonic and preferred approach.

In the example above, you’re storing the position and the runner’s name in a variable named winner, which is a tuple. To display the position and the name right away, you can unpack the tuple when you define the for loop:

Python
      
        
      
    
>>> runners = ["Lenka", "Martina", "Gugu"]
>>> for position, name in enumerate(runners):
...     print(position, name)
...
0 Lenka
1 Martina
2 Gugu

Just like the winner variable earlier, you can name the unpacked loop variables whatever you want. You use position and name in this example, but they could just as easily be named i and value, or any other valid Python names.

When you use enumerate() in a for loop, you typically tell Python to use two variables: one for the count and one for the value itself. You’re able to do this by applying a Python concept called tuple unpacking.

Unpacking is the idea that a tuple—or another type of a Python sequence—can be split into several variables depending on the length of that sequence. For instance, you can unpack a tuple of two elements into two variables:

Python
      
        
      
    
>>> cart_item = ("Wireless Mouse", 2)
>>> product_name, quantity_ordered = cart_item
>>> product_name
'Wireless Mouse'
>>> quantity_ordered
2

First, you create a tuple with two elements, "Wireless Mouse" and 2. Then, you unpack that tuple into product_name and quantity_ordered, which are each assigned one of the values from the tuple.

When you call enumerate() and pass a sequence of values, Python returns an iterator. When you ask the iterator for its next value, it yields a tuple with two elements. The first element of the tuple is the count, and the second element is the value from the sequence that you passed:

Python
      
        
      
    
>>> values = ["first", "second"]

>>> enumerate_instance = enumerate(values)
>>> print(enumerate_instance)
<enumerate at 0x7fe75d728180>

>>> next(enumerate_instance)
(0, 'first')

>>> next(enumerate_instance)
(1, 'second')

>>> next(enumerate_instance)
Traceback (most recent call last):
  File "<python-input-5>", line 1, in <module>
    next(enumerate_instance)
    ~~~~^^^^^^^^^^^^^^^
StopIteration

In this example, you create a Python list called values with two elements, "first" and "second". Then, you pass values to enumerate() and assign the return value to enumerate_instance. When you print enumerate_instance, you’ll see that it’s an enumerate object with a particular memory address.

Then, you use Python’s built-in next() to get the next value from enumerate_instance. The first value that enumerate_instance returns is a tuple with the count 0 and the first element from values, which is "first".

Calling next() again on enumerate_instance yields another tuple—this time, with the count 1 and the second element from values, "second". Finally, calling next() one more time raises a StopIteration exception since there are no more values to be returned from enumerate_instance.

When an iterable is used in a for loop, Python automatically calls next() at the start of every iteration until StopIteration is raised. Python assigns the value it retrieves from the iterable to the loop variable.

By default, the count of enumerate() starts at 0. This isn’t ideal when you want to display the winners of a race. Luckily, Python’s enumerate() has one additional argument that you can use to control the starting value of the count.

When you call enumerate(), you can use the start argument to change the starting count:

Python
      
        
      
    
>>> runners = ["Lenka", "Martina", "Gugu"]
>>> for position, name in enumerate(runners, start=1):
...     print(position, name)
...
1 Lenka
2 Martina
3 Gugu

In this example, you pass start=1, which initializes position with the value 1 on the first loop iteration.

You should use enumerate() anytime you need to use the count and an item in a loop. Keep in mind that enumerate() increments the count by one on every iteration. However, this only slightly limits your flexibility. Since the count is a standard Python integer, you can use it in many ways.

Practicing With Python `enumerate()`

Now that you’ve explored the basics of enumerate(), it’s time to practice using enumerate() with some real-world examples.

Read the full article at https://realpython.com/python-enumerate/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #254: Scaling Python Web Applications With Kubernetes and Karpenter

2025-06-20T12:00:00+00:00

What goes into scaling a web application today? What are resources for learning and practicing DevOps skills? This week on the show, Calvin Hendryx-Parker is back to discuss the tools and infrastructure for autoscaling web applications with Kubernetes and Karpenter.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Python Project: Build a Word Count Command-Line App

2025-06-18T14:00:00+00:00

The word count command (wc) is a classic utility that you might use to determine the number of lines, words, and bytes in files or standard input. It’s a staple tool for anyone working with text files on Unix-like systems. But have you ever wondered how such a tool is designed and implemented?

In this practice exercise, you’ll dive into the inner workings of the Unix wc command by building its simplified version from scratch using Python. Not only will this coding challenge solidify your understanding of file handling and text processing, but it’ll also give you a taste of how to structure command-line utilities in Python.

By the end of this challenge, you’ll have a functional version of the wc command that can faithfully reproduce the outputs you’re accustomed to seeing in a Unix terminal. However, it won’t be an exact replica of the wc command, as you’ll omit or adapt some features for simplicity.

In this coding challenge, you’ll:

Read content from files and standard input (stdin)
Count the number of lines, words, and bytes in the input
Differentiate between bytes and characters to handle Unicode
Implement command-line arguments to specify what counts to display

While working on this challenge, you’ll gain hands-on experience with several modules from Python’s standard library, such as pathlib for manipulating the file system and argparse for parsing command-line arguments. Familiarity with basic Python programming and file handling will be beneficial, but detailed instructions and helpful tips will guide you through each step of the process.

The challenge is broken down into a number of tasks, each accompanied by clear instructions and illustrative examples. You’ll receive automated feedback on your solutions when you follow along using the accompanying materials. If you run into any issues or have questions, then don’t hesitate to ask for help in the comments section below the corresponding lesson.

Note: You can also reach out to the Real Python community on Slack or join live conversations during Office Hours, where you’ll have an opportunity to share your screen remotely.

Completing each task unlocks the next one. Once you’ve completed a task, you can compare your code with the sample solution provided in the following lesson. Remember that there’s often more than one way to solve a problem. If your solution differs slightly but meets the acceptance criteria and adheres to good programming practices, then that’s perfectly fine.

Good luck!

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Exploring Python's list Data Type With Examples

2025-06-17T14:00:00+00:00

The list class is a fundamental built-in data type in Python. It has an impressive and useful set of features, allowing you to efficiently organize and manipulate heterogeneous data. Knowing how to use lists is a must-have skill for you as a Python developer. Lists have many use cases, so you’ll frequently reach for them in real-world coding.

By working through this video course, you’ll dive deep into lists and get a solid understanding of their key features. This knowledge will allow you to write more effective code by taking advantage of lists.

In this video course, you’ll learn how to:

Create new lists in Python
Access the items in an existing list
Copy, update, grow, shrink, and concatenate existing lists
Sort, reverse, and traverse existing lists
Use other features of Python lists

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Write Pythonic and Clean Code With namedtuple

2025-06-16T14:00:00+00:00

Python’s namedtuple in the collections module allows you to create immutable sequences with named fields, providing a more readable and Pythonic way to handle tuples. You use namedtuple to access values with descriptive field names and dot notation, which improves code clarity and maintainability.

By the end of this tutorial, you’ll understand that:

Python’s namedtuple is a factory function that creates tuple subclasses with named fields.
The main difference between tuple and namedtuple is that namedtuple allows attribute access via named fields, enhancing readability.
The point of using namedtuple is to improve code clarity by allowing access to elements through descriptive names instead of integer indices.
Some alternatives to namedtuple include dictionaries, data classes, and typing.NamedTuple.

Dive deeper into creating namedtuple classes, exploring their powerful features, and writing Python code that’s easier to read and maintain.

Get Your Code: Click here to download the free sample code that shows you how to use namedtuple to write Pythonic and clean code.

Take the Quiz: Test your knowledge with our interactive “Write Pythonic and Clean Code With namedtuple” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Write Pythonic and Clean Code With namedtuple

In this quiz, you'll test your understanding of Python's namedtuple() factory function from the collections module.

Getting to Know `namedtuple` in Python

Python’s namedtuple() is a factory function that’s available in the collections module. It allows you to create a tuple subclass with named fields. These named fields let you to access the values in a given named tuple using dot notation and field names—for example, my_tuple.field_name.

Python’s namedtuple was created to improve code readability by providing a way to access values using descriptive field names instead of integer indices, which often don’t provide any context on what the values are. This feature also makes the code cleaner and more maintainable.

In contrast, accessing values by index in a regular tuple can be frustrating, hard to read, and error-prone. This is especially true if the tuple has a lot of fields and is constructed far away from where you’re using it.

Note: In this tutorial, you’ll find different terms used to refer to Python’s namedtuple, its factory function, and its instances.

To avoid confusion, here’s a summary of how each term is used throughout the tutorial:

Term	Meaning
`namedtuple()`	The factory function
`namedtuple`, `namedtuple` class	The tuple subclass returned by `namedtuple()`
`namedtuple` instance, named tuple	An instance of a specific `namedtuple` class

You’ll find these terms used with their corresponding meaning throughout the tutorial.

Besides providing named fields, named tuples in Python offer the following features:

Are immutable data structures
Can have a hash value and work as dictionary keys
Can be stored in sets when they have a hash value
Generate a basic docstring using the type and field names
Provide a helpful string representation that displays the tuple content in a name=value format
Support indexing and slicing
Provide additional methods and attributes, such as ._make(), _asdict(), and ._fields
Are backward compatible with regular tuples
Have similar memory usage to regular tuples

You can use namedtuple instances wherever you need a tuple-like object. They offer the added benefit of accessing values using field names and dot notation, which makes your code more readable and Pythonic.

With this brief introduction to namedtuple and its general features, you’re ready to explore how to create and use them effectively in your own code.

Creating Tuple-Like Classes With the `namedtuple()` Function

You use a namedtuple() to create an immutable, tuple-like sequence with named fields. A popular example that you’ll often find in resources about namedtuple is defining a class to represent a mathematical point.

Depending on the problem, you’ll probably want to use an immutable data structure to represent your points. Here’s how you can create a two-dimensional point using a regular tuple:

Python
      
        
      
    
>>> # Create a 2D point as a regular tuple
>>> point = (2, 4)
>>> point
(2, 4)

>>> # Access coordinate x
>>> point[0]
2
>>> # Access coordinate y
>>> point[1]
4

>>> # Try to update a coordinate value
>>> point[0] = 100
Traceback (most recent call last):
    ...
TypeError: 'tuple' object does not support item assignment

In this example, you create an immutable, two-dimensional point using a regular tuple. This code works. You have a point with two coordinates that you can access by index. The point is immutable, so you can’t modify the coordinates. However, do you think this code is readable? Can you tell upfront what the 0 and 1 indices mean?

To improve clarity, you can use a namedtuple like in the following code. Note that you need to import the function from the collections module first:

Python
      
        
      
    
>>> from collections import namedtuple

>>> # Create a namedtuple type, Point
>>> Point = namedtuple("Point", "x y")

>>> point = Point(2, 4)
>>> point
Point(x=2, y=4)

>>> # Access the coordinates by field name
>>> point.x
2
>>> point.y
4

>>> # Access the coordinates by index
>>> point[0]
2
>>> point[1]
4

>>> point.x = 100
Traceback (most recent call last):
    ...
AttributeError: can't set attribute

>>> issubclass(Point, tuple)
True

Now you have a Point class with two appropriately named fields, .x and .y. Your point provides a descriptive string representation by default: Point(x=2, y=4).

You can access the coordinates with dot notation and the field names, which is convenient, readable, and explicit. You can also use indices to access each coordinate’s value if you prefer.

Note: As with regular tuples, named tuples are immutable. However, the values they store don’t necessarily have to be immutable.

It’s completely valid to create a tuple or a named tuple that holds mutable values:

Python
      
        
      
    
>>> from collections import namedtuple

>>> Person = namedtuple("Person", "name children")
>>> john = Person("John Doe", ["Timmy", "Jimmy"])
>>> john
Person(name='John Doe', children=['Timmy', 'Jimmy'])
>>> id(john.children)
139695902374144

>>> john.children.append("Tina")
>>> john
Person(name='John Doe', children=['Timmy', 'Jimmy', 'Tina'])
>>> id(john.children)
139695902374144

>>> hash(john)
Traceback (most recent call last):
    ...
TypeError: unhashable type: 'list'

You can create named tuples that contain mutable objects. Then, you can modify the mutable objects in the underlying tuple. However, this doesn’t mean that you’re modifying the tuple itself. The tuple will continue being the same object.

Finally, tuples or named tuples with mutable values aren’t hashable, as you saw in the above example.

Read the full article at https://realpython.com/python-namedtuple/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #253: Starting With marimo Notebooks & Python App Config Management

2025-06-13T12:00:00+00:00

Looking for a guide on getting started with marimo notebooks? How do you build a reproducible notebook for sharing or create a dashboard with interactive UI elements? Christopher Trudeau is back on the show this week, bringing another batch of PyCoder's Weekly articles and projects.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Defining Your Own Python Function

2025-06-11T14:00:00+00:00

A Python function is a named block of code that performs specific tasks and can be reused in other parts of your code. Python has several built-in functions that are always available, and you can also create your own. These are known as user-defined functions.

To define a function in Python, you use the def keyword, followed by the function name and an optional list of parameters enclosed in a required pair of parentheses. You can call and reuse a function by using its name, a pair of parentheses, and the necessary arguments.

Learning to define and call functions is a fundamental skill for any Python developer. Functions help organize your code and make it more modular, reusable, and easier to maintain.

By the end of this tutorial, you’ll understand that:

A Python function is a self-contained block of code designed to perform a specific task, which you can call and reuse in different parts of your code.
You can define a Python function with the def keyword, followed by the function name, parentheses with optional parameters, a colon, and then an indented code block.
You call a Python function by writing its name followed by parentheses, enclosing any necessary arguments, to execute its code block.

Understanding functions is key to writing organized and efficient Python code. By learning to define and use your own functions, you’ll be able to manage complexity and make your code easier to read.

Get Your Code: Click here to download the free sample code that shows you how to define your own function in Python.

Take the Quiz: Test your knowledge with our interactive “Defining Your Own Python Function” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Defining Your Own Python Function

In this quiz, you'll test your understanding of defining and calling Python functions. You'll revisit the def keyword, parameters, arguments, and more.

Getting to Know Functions in Python

In mathematics, a function is a relationship or mapping between one or more inputs and a set of outputs. This concept is typically represented by the following equation:

Here, f() is a function that operates on the variables x and y, and it generates a result that’s assigned to z. You can read this formula as z is a function of x and y. But how does this work in practice? As an example, say that you have a concrete function that looks something like the following:

Now, say that x is equal to 4 and y is 2. You can find the value of z by evaluating the function. In other words, you add 4 + 2 to get 6 as a result. That’s it!

Functions are also used in programming. In fact, functions are so fundamental to software development that virtually all modern, mainstream programming languages support them. In programming, a function is a self-contained block of code that encapsulates a specific task under a descriptive name that you can reuse in different places of your code.

Many programming languages have built-in functions, and Python is no exception. For example, Python’s built-in id() function takes an object as an argument and returns its unique identifier:

Python
      
>>> language = "Python"
>>> id(language)
4390667816

The integer number in this output uniquely identifies the string object you’ve used as an argument. In CPython, this number represents the memory address where the object is stored.

Note how similar this notation is to what you find in mathematics. In this example, language is equivalent to x or y, and the pair of parentheses calls the function to run its code, comparable to evaluating a math function. You’ll learn more about calling Python functions in a moment.

Note: To learn more about built-in functions, check out Python’s Built-in Functions: A Complete Exploration.

Similarly, the built-in len() function takes a data collection as an argument and returns its length:

Python
      
>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> items = len(numbers)
>>> items
10

In this example, the list of numbers has ten values, so len() returns 10. You assign this value to the items variable, which is equivalent to z in the mathematical equation you saw before.

Most programming languages—including Python—allow you to define your own functions. When you define a Python function, you decide whether it takes arguments. You’re also responsible for how the function internally computes its result.

Once you’ve defined a function, you can call it from different parts of your code to execute its specific computation or action. When the function finishes running, it returns to the location where you called it.

Read the full article at https://realpython.com/defining-your-own-python-function/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: Defining Your Own Python Function

2025-06-11T12:00:00+00:00

In this quiz, you’ll test your understanding of Defining Your Own Python Function.

You’ll revisit how to define a function with the def keyword, specify parameters, pass arguments, and call your functions to make code modular and reusable. You’ll also see how functions help organize and maintain your Python projects.

Ready to demonstrate your skills? Let’s begin!

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Python Continuous Integration and Deployment Using GitHub Actions

2025-06-10T14:00:00+00:00

Creating software is an achievement worth celebrating. But software is never static. Bugs need to be fixed, features need to be added, and security demands regular updates. In today’s landscape, with agile methodologies dominating, robust DevOps systems are crucial for managing an evolving codebase. That’s where GitHub Actions shine, empowering Python developers to automate workflows and ensure their projects adapt seamlessly to change.

GitHub Actions for Python empowers developers to automate workflows efficiently. This enables teams to maintain software quality while adapting to constant change.

Continuous Integration and Continuous Deployment (CI/CD) systems help produce well-tested, high-quality software and streamline deployment. GitHub Actions makes CI/CD accessible to all, allowing automation and customization of workflows directly in your repository. This free service enables developers to execute their software development processes efficiently, improving productivity and code reliability.

In this video course, you’ll learn how to:

Use GitHub Actions and workflows
Automate linting, testing, and deployment of a Python project
Secure credentials used for automation
Automate security and dependency updates

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Python Hits the Big Screen and Other Python News for June 2025

2025-06-09T14:00:00+00:00

A newly announced documentary brings Python’s history and culture to the screen, offering a rare behind-the-scenes look at the people and philosophies that shaped it. Meanwhile, new releases and PEPs continue to drive the evolution in packaging and language design.

Conferences also continue to foster inclusion, learning, and connection. With new leadership at the PSF and a slate of impactful updates, the Python community is clearly energized and looking ahead.

Let’s dive into the biggest developments shaping Python this month.

Python Documentary Trailer Released

CultRepo, formerly known as Honeypot, has unveiled the trailer for its upcoming feature-length documentary Python: The Documentary, set to premiere on YouTube later this year. Known for high-quality open-source origin stories like those of Vue.js, React, and Node.js, CultRepo is returning to form with a long-awaited tribute to our beloved programming language.

The documentary promises a deep dive into Python’s cultural and technical journey, featuring interviews with key contributors including Guido van Rossum, Mariatta Wijaya, Brett Cannon, and many others who’ve shaped Python’s legacy.

The trailer generated buzz across social media and the Python community after debuting at PyCon US. In the first 15 hours alone, it racked up over 35,000 YouTube views.

Python 3.14.0 Beta Feature Freeze Begins

After a busy alpha cycle, Python 3.14 has entered beta with the release of versions 3.14.0b1 and 3.14.0b2. This milestone marks the feature freeze, shifting the development focus to bug fixes, polish, and documentation ahead of the final release in October 2025.

Python 3.14 is shaping up to be a feature-packed release. Highlights include:

Template strings for safer string processing, allowing expressions like t"Hello {name}" to capture string components and interpolated values as structured data before formatting. This allows for custom processing and helps prevent injection attacks in templating scenarios.
Deferred annotations as the new default, meaning type hints are stored as strings rather than evaluated immediately. This reduces import overhead and allows forward references without using quotes.
Sigstore replacing PGP for release verification, offering a modern, keyless signing approach that leverages certificate transparency and removes the complexity of key management that has long hindered PGP adoption.
Enhanced JIT compiler with continued improvements to the copy-and-patch technique introduced in Python 3.13, providing performance changes ranging from 10% slower to 20% faster depending on workload.
Safe external debugger interface enabling pdb to attach to running Python processes by process ID, allowing real-time debugging of live applications without stopping or restarting them.

The timeline remains on track for the final release in October 2025, with additional beta releases expected throughout the summer. Users can expect improved startup performance, better type checking capabilities, and enhanced security verification processes.

You can preview the upcoming changes by installing the beta release in an isolated environment, and help improve Python 3.14 by reporting bugs or compatibility issues.

Three Accepted PEPs Tackle Typing, Installation, and Compression

Read the full article at https://realpython.com/python-news-june-2025/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #252: Rodrigo Girão Serrão: Python Training, itertools, and Idioms

2025-06-06T12:00:00+00:00

Once you've learned the vocabulary and syntax of the Python language, how do you progress into learning the right combinations to put into your code? How can Python's built-in itertools library enhance your skills? This week on the show, we speak with Rodrigo Girão Serrão about teaching Python through his blog and his passion for the itertools library.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

How to Find an Absolute Value in Python

2025-06-04T14:00:00+00:00

Learn how to work with absolute values in Python using the built-in abs() function for numbers, arrays, and custom objects. This tutorial shows you how to implement the absolute value function from scratch, use abs() with numbers, and customize its behavior for data types like NumPy arrays and pandas Series.

By the end of this tutorial, you’ll understand that:

You can implement the absolute value function in Python using conditional statements or mathematical operations.
Python’s built-in abs() function efficiently handles integers, floating-point numbers, complex numbers, and more.
NumPy and pandas extend the abs() function to work directly with arrays and Series.
You can customize the behavior of abs() for your own data types by implementing the .__abs__() method.
The abs() function can process fractions and decimals from Python’s standard library.

Don’t worry if your mathematical knowledge of the absolute value function is a little rusty. You’ll begin by refreshing your memory before diving deeper into Python code. That said, feel free to skip the next section and jump right into the nitty-gritty details that follow.

Get Your Code: Click here to download the free sample code that you’ll use to find absolute values in Python.

Take the Quiz: Test your knowledge with our interactive “How to Find an Absolute Value in Python” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

How to Find an Absolute Value in Python

In this quiz, you'll test your knowledge of calculating absolute values in Python, mastering both built-in functions and common use cases to improve your coding accuracy.

Defining the Absolute Value

The absolute value lets you determine the size or magnitude of an object, such as a number or a vector, regardless of its direction. Real numbers can have one of two directions when you ignore zero: they can be either positive or negative. On the other hand, complex numbers and vectors can have many more directions.

Note: When you take the absolute value of a number, you lose information about its sign or, more generally, its direction.

Consider a temperature measurement as an example. If the thermometer reads -12°C, then you can say it’s twelve degrees Celsius below freezing. Notice how you decomposed the temperature in the last sentence into a magnitude, twelve, and a sign. The phrase below freezing means the same as below zero degrees Celsius. The temperature’s size or absolute value is identical to the absolute value of the much warmer +12°C.

Using mathematical notation, you can define the absolute value of 𝑥 as a piecewise function, which behaves differently depending on the range of input values. A common symbol for absolute value consists of two vertical lines:

Absolute Value Defined as a Piecewise Function

This function returns values greater than or equal to zero without alteration. On the other hand, values smaller than zero have their sign flipped from a minus to a plus. Algebraically, this is equivalent to taking the square root of a number squared:

Absolute Value Defined Algebraically

When you square a real number, you always get a positive result, even if the number that you started with was negative. For example, the square of -12 and the square of 12 have the same value, equal to 144. Later, when you compute the square root of 144, you’ll only get 12 without the minus sign.

Geometrically, you can think of an absolute value as the distance from the origin, which is zero on a number line in the case of the temperature reading from before:

To calculate this distance, you can subtract the origin from the temperature reading (-12°C - 0°C = -12°C) or the other way around (0°C - (-12°C) = +12°C), and then drop the sign of the result. Subtracting zero doesn’t make much difference here, but the reference point may sometimes be shifted. That’s the case for vectors bound to a fixed point in space, which becomes their origin.

Vectors, just like numbers, convey information about the direction and the magnitude of a physical quantity, but in more than one dimension. For example, you can express the velocity of a falling snowflake as a three-dimensional vector:

This vector indicates the snowflake’s current position relative to the origin of the coordinate system. It also shows the snowflake’s direction and pace of motion through the space. The longer the vector, the greater the magnitude of the snowflake’s speed. As long as the coordinates of the vector’s initial and terminal points are expressed in meters, calculating its length will get you the snowflake’s speed measured in meters per unit of time.

Note: There are two ways to look at a vector. A bound vector is an ordered pair of fixed points in space, whereas a free vector only tells you about the displacement of the coordinates from point A to point B without revealing their absolute locations. Consider the following code snippet as an example:

Python
      
        
      
    
>>> A = [1, 2, 3]
>>> B = [3, 2, 1]

>>> bound_vector = [A, B]
>>> bound_vector
[[1, 2, 3], [3, 2, 1]]

>>> free_vector = [b - a for a, b in zip(A, B)]
>>> free_vector
[2, 0, -2]

A bound vector wraps both points, providing quite a bit of information. In contrast, a free vector only represents the shift from A to B. You can calculate a free vector by subtracting the initial point, A, from the terminal one, B. One way to do so is by iterating over the consecutive pairs of coordinates with a list comprehension.

A free vector is essentially a bound vector translated to the origin of the coordinate system, so it begins at zero.

The length of a vector, also known as its magnitude, is the distance between its initial and terminal points, 𝐴 and 𝐵, which you can calculate using the Euclidean norm:

The Length of a Bound Vector as a Euclidean Norm

This formula calculates the length of the 𝑛-dimensional vector 𝐴𝐵, by summing the squares of the differences between the coordinates of points 𝐴 and 𝐵 in each dimension indexed by 𝑖. For a free vector, the initial point, 𝐴, becomes the origin of the coordinate system—or zero—which simplifies the formula, as you only need to square the coordinates of your vector.

Read the full article at https://realpython.com/python-absolute-value/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: How to Find an Absolute Value in Python

2025-06-04T12:00:00+00:00

In this quiz, you’ll test your understanding of How to Find an Absolute Value in Python.

By working through this quiz, you’ll revisit key concepts such as how to use Python’s built-in functions to compute absolute values, apply them in mathematical operations, and handle different data types effectively.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Execute Your Python Scripts With a Shebang

2025-06-03T14:00:00+00:00

In shell scripts, the shebang line (#!) specifies the path to the interpreter that should execute the file. You can place it at the top of your Python file to tell the shell how to run your script, allowing you to execute the script directly without typing python before the script name. The shebang is essential for Unix-like systems but ignored on Windows unless using specific compatibility layers.

By the end of this video course, you’ll understand that:

A shebang specifies the path to the Python interpreter in scripts, allowing direct execution.
You should include a shebang when a script needs direct execution, but not in import-only modules.
Best practices for shebangs include using /usr/bin/env for portability and ensuring the script is executable.
Shebangs have limitations, such as being ignored on Windows without compatibility layers like WSL.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

How Can You Structure Your Python Script?

2025-06-02T14:00:00+00:00

You may have begun your Python journey interactively, exploring ideas within Jupyter Notebooks or through the Python REPL. While that’s great for quick experimentation and immediate feedback, you’ll likely find yourself saving code into .py files. However, as your codebase grows, your Python script structure efficiency becomes increasingly important.

Transitioning from interactive environments to structured scripts helps promote readability, enabling better collaboration and more robust development practices. This tutorial transforms messy scripts into well-organized, shareable code. Along the way, you’ll learn standard Python practices and tools. These techniques bridge the gap between quick scripting and disciplined software development.

By the end of this tutorial, you’ll know how to:

Organize your Python scripts logically with functions, constants, and appropriate import practices.
Efficiently manage your script’s state using data structures such as enumerations and data classes.
Enhance interactivity through command-line arguments and improve robustness with structured feedback using logging and libraries like Rich.
Create self-contained, shareable scripts by handling dependencies inline using PEP 723.

Without further ado, it’s time to start working through a concrete script that interacts with a web server to obtain and manipulate a machine learning dataset.

Get Your Code: Click here to download the free sample code you’ll use to learn how you can structure your Python script.

Take the Quiz: Test your knowledge with our interactive “How Can You Structure Your Python Script?” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

How Can You Structure Your Python Script?

In this quiz, you'll test your understanding of organizing and structuring Python scripts. You'll revisit key concepts about best practices for writing clear, maintainable, and executable Python code.

Setting the Stage for Scripting

Throughout this tutorial, you’ll apply the structuring concepts by building a Python script step-by-step. The goal of this script will be to work with the well-known Iris dataset, a classic dataset in machine learning containing measurements for three species of Iris flowers.

Your script, called iris_summary.py, will evolve through several stages, demonstrating different structural improvements. These stages are:

Set Up the Initial Script: Begin with a functional script using standard language features. Apply a foundational structure using named constants for clarity and the entry-point guard to separate executable code from importable definitions.
Integrate External Libraries and Dependencies: Incorporate third-party libraries when needed to leverage specialized functionality or simplify complex tasks. Declare and manage script dependencies within the file using standards like PEP 723 for better reproducibility.
Handle Command-Line Arguments: Add command-line arguments using helper libraries to make the script interactive and configurable. Define a clear main() function to encapsulate the core script logic triggered by the command-line interface (CLI).
Structure Internal Data: Improve how data is represented by selecting appropriate data structures. Move beyond basic types and use constructs like enum for fixed choices, or dataclass and namedtuple for structured records.
Enhance Feedback and Robustness: Refine how the script communicates its progress and results. Implement structured logging instead of relying solely on print(). Use assert statements for internal consistency checks during development, and improve the terminal output presentation, potentially using libraries designed for richer interfaces, like Rich.

By following these steps, you’ll see how structure transforms a basic script into something more robust, readable, and shareable. Each new concept will be introduced and immediately applied to the evolving Iris script.

Before diving into the specifics of script structure, it’s important to understand some foundational elements that make your Python scripts executable and well-organized.

Using the Shebang Line

On Unix-like systems, such as Linux and macOS, you can make your Python script directly executable from the command line, like ./iris_summary.py, instead of always typing python iris_summary.py. This involves making the file executable with chmod +x iris_summary.py, and adding a shebang line at the top of your file.

The shebang tells the system which interpreter to use. The recommended, portable shebang for Python is:

Python
      
    
#!/usr/bin/env python3
# Your script logic goes here...

This small addition signals that your file is intended to be run as a standalone script.

Note: The dedicated tutorial Executing Python Scripts With a Shebang provides a comprehensive look at how a shebang works, why /usr/bin/env is used, how to handle arguments, and how to account for platform differences.

Now that you know how to tell the operating system how to run your script, you can focus on organizing the code within the script, starting with imports.

Organizing the Import Statements

As your script starts interacting with more modules, the import statements at the top of your file become important for clarity and code quality. Python’s official style guide, PEP 8, recommends specific conventions for ordering imports, which significantly improves readability. Following these conventions is standard practice, and there are modern tools like Ruff to enforce these conventions.

Following a standard order helps anyone reading your code quickly understand its dependencies. The recommended grouping is:

Standard Library Imports: Modules included with Python, like pathlib.
Third-Party Imports: Libraries you’ve installed with pip, like requests.
Local Imports: Local modules, either application files or libraries, such as when importing another .py file you wrote.

A good scripting practice for sharing code is to avoid local or library-specific imports and to ensure that only cross-platform third-party packages are used.

Read the full article at https://realpython.com/python-script-structure/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: How Can You Structure Your Python Script?

2025-06-01T12:00:00+00:00

In this quiz, you’ll test your understanding of the tutorial How Can You Structure Your Python Script?

By working through this quiz, you’ll revisit best practices for organizing your Python scripts, including setting up the main entry point, using imports effectively, and writing code that can be reused as modules or run as standalone scripts.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #251: Python Thread Safety & Managing Projects With uv

2025-05-30T12:00:00+00:00

What are the ways you can manage multithreaded code in Python? What synchronization techniques are available within Python's threading module? Christopher Trudeau is back on the show this week, bringing another batch of PyCoder's Weekly articles and projects.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Control Flow Structures in Python

2025-05-28T14:00:00+00:00

Python’s control flow structures allow you to dictate the order in which statements execute in your program. You can do this by using structures like conditionals, loops, and others.

Normally, your code executes sequentially. You can modify this behavior using control flow structures that let you make decisions, run specific pieces of code in response to certain conditions, repeat a code block several times, and more.

Knowing about control flow structures is a fundamental skill for you as a Python developer because they’ll allow you to fine-tune how your programs behave.

By the end of this tutorial, you’ll understand that:

Control flow in Python refers to the order in which code statements are executed or evaluated.
Common control flow statements in Python include conditionals with the if, elif, else keywords, loops with for and while, exception handling with try … except, and structural pattern matching with match … case.
Control flow structures in Python let you make decisions, repeat tasks, and handle exceptions, enhancing the dynamism and robustness of your code.

To dive deeper into Python’s control flow, explore how these constructs allow you to write more dynamic and flexible programs by making decisions and handling repetitive tasks efficiently.

Get Your Code: Click here to download the free sample code that shows you how to use control flow structures in Python.

Take the Quiz: Test your knowledge with our interactive “Control Flow Structures in Python” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Control Flow Structures in Python

In this quiz, you'll test your understanding of Python control flow structures, which include conditionals, loops, exception handling, and structural pattern matching. Strengthening these skills will help you write more dynamic, smart, and robust Python code.

Getting to Know Control Flow in Python

Most programming languages, including Python, execute code sequentially from the top of the source file to the bottom, line by line. This way of running code is entirely logical. It’s like following a series of steps in order. However, what if you’re solving a problem with two or more action paths that depend on the result of evaluating a given condition?

For example, say that you’re building an online store and need to implement a feature that decides whether a customer is eligible for free shipping. You’ve decided that if the order is greater than $150.00, then the customer gets free shipping. In this situation, you have two action paths:

If the order is less than $150.00, then the customer doesn’t get free shipping.
If the order is equal to or greater than $150.00, then the customer gets free shipping.

Now, think of a way you could do this with sequential statements. It isn’t an easy task, right? You’d need something that allows you to check the order and decide what course of action to take. That’s exactly what a conditional statement lets you do:

Python
      
        
      
    
>>> order_total = 215.00

>>> if order_total >= 150:
...     print("You got free shipping!")
... else:
...     print("The shipping fee is $5.00")
...
You got free shipping!

Note how the code isn’t executed sequentially. Instead, the execution path depends on the condition’s result. Statements and syntax constructs that allow you to alter the normal execution flow as you did in the example above are known as control flow structures.

Note: In programming, the ability of a program to choose between multiple paths of execution based on certain conditions is known as branching.

In programming, the term control flow refers to the order in which individual statements are executed or evaluated within a program. As you already know, the normal flow of execution is sequential. However, you can alter this by using control flow statements, which include conditionals, loops, and several others.

Here’s another example. This time, you need to repeat a task several times. You can do this by duplicating the same line of code as many times as needed:

Pythongreeting.py
      
    
print("Hello!")
print("Hello!")
print("Hello!")

This code works. However, repeating the same code several times is error-prone and introduces maintainability issues. Additionally, what if you don’t know the number of repetitions beforehand? In this situation, a loop will save you:

Python
      
        
      
    
>>> for _ in range(3):
...     print("Hello!")
...
Hello!
Hello!
Hello!

In this example, you use a for loop to run the code three times. This code is much more elegant, flexible, and less repetitive.

Control flow statements like these let you make decisions, repeat tasks, and handle exceptions, making your code more dynamic and powerful. In short, they let you customize the control flow of your programs. In the rest of this tutorial, you’ll dive into Python’s most commonly used control flow statements.

Using Conditional Statements

You took a quick peek at conditional statements in the previous section. A conditional statement is a syntax construct that lets you execute certain code blocks only when a specific condition is true, while skipping them when the condition is false. It allows your programs to respond to different situations rather than just running sequentially.

Read the full article at https://realpython.com/python-control-flow/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: Control Flow Structures in Python

2025-05-28T12:00:00+00:00

In this quiz, you’ll test your understanding of control flow structures in Python. Control flow dictates the order in which your code executes, letting you make choices, repeat work, and handle exceptions to build more flexible, reliable programs. For hands-on examples and a deeper dive, check out the tutorial Control Flow Structures in Python.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The LEGB Rule & Understanding Python Scope

2025-05-27T14:00:00+00:00

The concept of scope rules how variables and names are looked up in your code. It determines the visibility of a variable within the code. The scope of a name or variable depends on the place in your code where you create that variable. The Python scope concept is generally presented using a rule known as the LEGB rule.

The letters in the acronym LEGB stand for Local, Enclosing, Global, and Built-in scopes. This summarizes not only the Python scope levels but also the sequence of steps that Python follows when resolving names in a program.

In this video course, you’ll learn:

What scopes are and how they work in Python
Why it’s important to know about Python scope
What the LEGB rule is and how Python uses it to resolve names
How to modify the standard behavior of Python scope using global and nonlocal
What scope-related tools Python offers and how you can use them

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

marimo: A Reactive, Reproducible Notebook

2025-05-26T14:00:00+00:00

marimo notebooks redefine the notebook experience by offering a reactive environment that addresses the limitations of traditional linear notebooks. With marimo, you can seamlessly reproduce and share content while benefiting from automatic cell updates and a correct execution order. Discover how marimo’s features make it an ideal tool for documenting research and learning activities.

By the end of this tutorial, you’ll understand that:

marimo notebooks automatically update dependent cells, ensuring consistent results across your work.
Reactivity allows marimo to determine the correct running order of cells using a directed acyclic graph (DAG).
Sandboxing in marimo creates isolated environments for notebooks, preventing package conflicts and ensuring reproducibility.
You can add interactivity to marimo notebooks using UI elements like sliders and radio buttons.
Traditional linear notebooks have inherent flaws, such as hidden state issues, that marimo addresses with its reactive design.

Before you can get started with marimo, you’ll need to install it. Fortunately, this is quick and easy to do:

Shell
      
$ python -m pip install marimo

You use pip to install the marimo library on your system. With this done, it’s time to get started, be amazed, and learn all about a different type of notebook.

The best way to approach this tutorial is to use the instructions to complete the various examples and try the exercises yourself. If you want copies of the various notebook files created during the tutorial, you’ll find them in your download bundle. The README.md file provides further details of what’s in your downloads.

Take the Quiz: Test your knowledge with our interactive “marimo: A Reactive, Reproducible Notebook” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

marimo: A Reactive, Reproducible Notebook

This quiz is a great way to reinforce and build on what you've learned about marimo notebooks. You'll find most of the answers in the tutorial, but you'll need to do some additional research to find some of the answers.

How to Get Started in a marimo Notebook

A notebook is a file where you can write your programming code, run it, and view the output. You can add formatted text to explain how your code works, display charts to clarify results, and even allow your notebook’s users to try out different scenarios using a customized user interface. Once your notebook is complete, you can save everything in a single file and share your creation with others.

In this section, you’ll learn to use marimo to create a simple notebook to perform a calculation and clearly display its results.

Like many notebooks, marimo notebooks consist of cells. The primary cell types are code cells, where you enter and run your Python code, and Markdown cells, where you enter formatted text to augment the code and its output.

In this first example, you’ll use a marimo notebook and NumPy to solve a pair of simultaneous equations. To do this, you’ll first need to install the NumPy library:

Shell
      
$ python -m pip install numpy

With NumPy installed, you can now create your notebook by typing the following command into your console:

Shell
      
$ marimo edit simultaneous_equations.py

When you run this command, you’ll most likely create a new notebook named simultaneous_equations.py for editing. If you already have a marimo notebook with that name, you’ll open it instead. Either way, your notebook will be ready for you to use within your browser.

Switch to your web browser, and you’ll see your new notebook. It’ll contain a single cell. Hover your mouse over the cell to reveal a range of icons, each with a tooltip that explains its purpose and shows the associated keyboard shortcuts:

Each of the main icons are described in the screenshot above. While most of these are self-explanatory, there are some points you should be aware of:

The red trash can icon shown here won’t appear immediately in your notebook. This is used to delete a cell and will only appear when you add other cells. You can’t see it yet because all notebooks must have at least one cell. Deleting the last cell is impossible.
The color of the Run current cell icon is also significant. If this cell is white, as it is in the screenshot, it’s up to date and doesn’t need to be run. Once you start changing cells, you’ll see their Run icons develop a yellow tinge. This warns you that the cell has become stale, meaning you must run it to update it.
Finally, notice that the numbers to the left of each cell indicate the line numbers of the code within the cell. Unlike most other notebooks, there are no numbers to indicate the running order of the cells. This is because marimo allows you to add code cells in any order. marimo can work out the correct cell running order for itself. Even so, placing cells in an illogical order should be avoided.

When you hover your mouse over some of marimo’s icons, you’ll see their associated keyboard shortcuts. Unfortunately, they don’t work correctly in all browsers. If they don’t work for you, stick to using your mouse. Feel free to try them to find out if they work for you.

Adding Code and Markdown Content

It’s time for you to gain experience creating some content in marimo. By following the walk-through, you’ll get hands-on practice with the basics.

Although confusing the first time you see it, the single cell that contains import marimo as mo is actually a blank cell. This code allows you to work with the marimo API. However, it’s not in the cell unless you type it in manually.

Read the full article at https://realpython.com/marimo-notebook/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: marimo: A Reactive, Reproducible Notebook

2025-05-26T12:00:00+00:00

Why not challenge yourself and see how much you know about marimo notebooks?

Working your way through this quiz is a great way to reinforce and build on what you learned in the marimo: A Reactive, Reproducible Notebook tutorial.

You could try answering the questions without reading the tutorial first, but you’d miss out on a great learning experience!

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #250: DjangoCon Europe 2025: Live Recording From Dublin

2025-05-23T12:00:00+00:00

What goes into making video courses at Real Python? How should you build an installable Django application? Christopher Trudeau is back on the show this week, bringing another batch of PyCoder's Weekly articles and projects.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Nested Loops in Python

2025-05-21T14:00:00+00:00

Nested loops in Python allow you to place one loop inside another, enabling you to perform repeated actions over multiple sequences. Understanding nested loops helps you write more efficient code, manage complex data structures, and avoid common pitfalls such as poor readability and performance issues.

By the end of this tutorial, you’ll understand that:

Nested loops in Python involve placing one loop inside another, enabling iteration over multiple sequences or repeated actions.
Situations where nested loops are a good idea include handling multidimensional data, generating patterns, and performing repetitive tasks with multiple layers of iteration.
You can break out of nested loops by using the break statement, which exits the innermost loop when a condition is met.
Disadvantages of nested loops include potential performance bottlenecks, poor readability, and variable scoping issues.

This tutorial provides practical examples and optimization techniques for using nested loops effectively in your Python programs.

Get Your Code: Click here to download the free sample code that you’ll use to learn about nested loops in Python.

Take the Quiz: Test your knowledge with our interactive “Nested Loops in Python” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Nested Loops in Python

Nested loops allow you to perform repeated actions over multiple sequences, but is there more? Test your understanding of nested loops in Python!

Getting Started With Nested Loops in Python

Loops are fundamental building blocks in programming, allowing you to iterate through actions efficiently. In Python, there are two primary types of loops: the for loop and the while loop. Both serve the same purpose —executing a block of code multiple times—but they differ in how they operate and in their use cases:

A for loop iterates over a sequence, such as a list or a range, and executes a block of code for each item. They’re useful when the number of iterations is known beforehand.
A while loop runs as long as a specified condition remains true, making it useful when the number of iterations isn’t known in advance.

You create a nested loop by placing one loop inside another. This structure is especially helpful when working with multidimensional data, generating patterns, or handling tasks that involve several layers of repetition.

In a nested loop, the first loop is called the outer loop, and the loop inside is the inner loop. So, for every iteration of the outer loop, the inner loop runs completely before the outer loop moves to the next iteration.

Here’s the basic syntax of a nested loop:

Python Syntax
      
    
for outer_variable in outer_iterable:
    for inner_variable in inner_iterable:
        <body>

The outer_iterable must be a list, a dictionary, or some other sequence of items that you can iterate over. The same applies to the inner_iterable. The <body> inside the inner loop contains the code that runs once for each for loop step in the inner_iterable. Since the inner loop is nested inside the outer loop, it runs in full for each iteration of the outer loop.

A good analogy for a nested loop is the hour and minute hands of a clock. The hour hand moves slowly around the clock, completing one full revolution every twelve hours. Meanwhile, the minute hand moves at a much faster rate, completing a revolution every hour. While both hands rotate at different speeds, they work together, each completing their own cycle within the same clock.

Here’s how the clock logic looks in Python code:

Python
      
        
      
    
>>> for hour in range(0, 24):
...     for minute in range(0, 60):
...         print(f"{hour:02d}:{minute:02d}")
...
00:00
00:01
00:02
  ⋮
23:57
23:58
23:59

As you can see, every time the minute hand completes a cycle, the hour hand moves to the next hour. :02d is a format specifier that ensures the number is printed as a two-digit-wide integer value.

Now that you’ve been introduced to nested loops, it’s time to explore some practical examples. You’ll become familiar with writing programs using nested loops in the following section.

Exploring Practical Examples of Nested Loops

As you just learned, nested loops have a number of use cases. Here, you’ll have a look at a few examples. These examples are interesting and practical, allowing you to have fun as you explore their syntax and semantics.

Printing Patterns With Nested Loops

Being able to print any pattern of your choosing is a fascinating feat in programming. One way you can achieve this is by understanding how nested loops work. The code snippet below builds a sail pattern using a few simple symbols. While this may not seem particularly exciting, consider it a first step toward creating something spectacular—like a spaceship:

Python
      
        
      
    
>>> height = 6
>>> sail_patterns = "*#-x+o"
>>> for row in range(height):
...     pattern = ""
...     spacing = " " * (height - row)
...     for symbol in sail_patterns:
...         pattern += symbol * row + spacing
...
...     print(pattern)
...

*     #     -     x     +     o
**    ##    --    xx    ++    oo
***   ###   ---   xxx   +++   ooo
****  ####  ----  xxxx  ++++  oooo
***** ##### ----- xxxxx +++++ ooooo

Here’s what the code does line by line:

Read the full article at https://realpython.com/nested-loops-python/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: Nested Loops in Python

2025-05-21T12:00:00+00:00

In this quiz, you’ll test your understanding of Nested Loops in Python.

Nested loops in Python involve placing one loop inside another, enabling iteration over multiple sequences or repeated actions. They’re particularly useful for handling multidimensional data, generating patterns, and performing repetitive tasks with multiple layers of iteration.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

First Steps With LangChain

2025-05-20T14:00:00+00:00

You’ve likely interacted with large language models (LLMs), like the ones behind OpenAI’s ChatGPT, and experienced their remarkable ability to answer questions, summarize documents, write code, and much more.

While LLMs are remarkable by themselves, with a little programming knowledge, you can leverage libraries like LangChain to create your own LLM-powered applications that can do just about anything.

In this video course, you’ll learn how to:

Use LangChain to build LLM-powered applications
Create reusable instructions with prompt templates
Create and extend LangChain chains
Debug what happens when a chain executes

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: How to Group Data Using Polars .group_by()

2025-05-19T12:00:00+00:00

In this quiz, you’ll test your understanding of the techniques covered in How to Group Data Using Polars .group_by().

By working through the questions, you’ll review your understanding of how to use the data aggregation and grouping techniques provided by Polars.

You’ll need to do some research outside of the tutorial to answer all the questions, so let this challenge take you on a learning journey.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #249: Going Beyond requirements.txt With pylock.toml and PEP 751

2025-05-16T12:00:00+00:00

What is the best way to record the Python dependencies for the reproducibility of your projects? What advantages will lock files provide for those projects? This week on the show, we welcome back Python Core Developer Brett Cannon to discuss his journey to bring PEP 751 and the pylock.toml file format to the community.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Working With Missing Data in Polars

2025-05-13T14:00:00+00:00

Efficiently handling missing data in Polars is essential for keeping your datasets clean during analysis. Polars provides powerful tools to identify, replace, and remove null values, ensuring seamless data processing.

This video course covers practical techniques for managing missing data and highlights Polars’ capabilities to enhance your data analysis workflow. By following along, you’ll gain hands-on experience with these techniques and learn how to ensure your datasets are accurate and reliable.

By the end of this video course, you’ll understand that:

Polars allows you to handle missing data using LazyFrames and DataFrames.
You can check for null values in Polars using the .null_count() method.
NaN represents non-numeric values while null indicates missing data.
You can replace NaN in Polars by converting them to nulls and using .fill_null().
You can fix missing data by identifying, replacing, or removing null values.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: Getting Started With Python IDLE

2025-05-13T12:00:00+00:00

In this quiz, you’ll test your understanding of Python IDLE.

Python IDLE is an IDE included with Python installations, designed for basic editing, execution, and debugging of Python code. You can also customize IDLE to make it a useful tool for writing Python.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #248: Experiments With Gen AI, Knowledge Graphs, Workflows, and Python

2025-05-09T12:00:00+00:00

Are you looking for some projects where you can practice your Python skills? Would you like to experiment with building a generative AI app or an automated knowledge graph sentiment analysis tool? This week on the show, we speak with Raymond Camden about his journey into Python, his work in developer relations, and the Python projects featured on his blog.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Using the Python subprocess Module

2025-05-06T14:00:00+00:00

Python’s subprocess module allows you to run shell commands and manage external processes directly from your Python code. By using subprocess, you can execute shell commands like ls or dir, launch applications, and handle both input and output streams. This module provides tools for error handling and process communication, making it a flexible choice for integrating command-line operations into your Python projects.

By the end of this video course, you’ll understand that:

The Python subprocess module is used to run shell commands and manage external processes.
You run a shell command using subprocess by calling subprocess.run() with the command as a list of arguments.
subprocess.call(), subprocess.run(), and subprocess.Popen() differ in how they execute commands and handle process output and return codes.
multiprocessing is for parallel execution within Python, while subprocess manages external processes.
To execute multiple commands in sequence using subprocess, you can chain them by using pipes or running them consecutively.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Quiz: Python Logging With the Loguru Library

2025-05-06T12:00:00+00:00

In this quiz, you’ll test your understanding of How to Use Loguru for Simpler Python Logging.

By working through this quiz, you’ll revisit key concepts like installing Loguru, basic logging, formatting, sinks, log rotation, and capturing exception information.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Thread Safety in Python: Locks and Other Techniques

2025-04-29T14:00:00+00:00

Threads share state in your programs, which means race conditions can be created when two or more threads fight to update a value. This course is about the various primitives you can use to ensure atomic access to your program’s shared state.

By the end of this video course, you’ll be able to identify safety issues and prevent them by using the synchronization primitives in Python’s threading module to make your code thread-safe.

In this video course, you’ll learn:

What thread safety is
What race conditions are and how to avoid them
How to identify thread safety issues in your code
What different synchronization primitives exist in the threading module
How to use synchronization primitives to make your code thread-safe

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #247: Exploring DuckDB & Comparing Python Expressions vs Statements

2025-04-18T12:00:00+00:00

Are you looking for a fast database that can handle large datasets in Python? What's the difference between a Python expression and a statement? Christopher Trudeau is back on the show this week, bringing another batch of PyCoder's Weekly articles and projects.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

The Real Python Podcast – Episode #246: Learning Intermediate Python With a Deep Dive Course

2025-04-11T12:00:00+00:00

Do you want to learn deeper concepts in Python? Would the accountability of scheduled group classes help you get past the basics? This week, five Real Python Intermediate Deep Dive workshop members discuss their experiences.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Real Python

The Real Python Podcast – Episode #255: Structuring Python Scripts & Exciting Non-LLM Software Trends

Your Guide to the Python print() Function

Printing in a Nutshell

Producing Blank Lines

Dealing With Newlines

Quiz: The Python print() Function

Starting With DuckDB and Python

Python enumerate(): Simplify Loops That Need Counters

Using Python’s enumerate()

Practicing With Python enumerate()

The Real Python Podcast – Episode #254: Scaling Python Web Applications With Kubernetes and Karpenter

Python Project: Build a Word Count Command-Line App

Exploring Python's list Data Type With Examples

Write Pythonic and Clean Code With namedtuple

Getting to Know namedtuple in Python

Creating Tuple-Like Classes With the namedtuple() Function

The Real Python Podcast – Episode #253: Starting With marimo Notebooks & Python App Config Management

Defining Your Own Python Function

Getting to Know Functions in Python

Quiz: Defining Your Own Python Function

Python Continuous Integration and Deployment Using GitHub Actions

Python Hits the Big Screen and Other Python News for June 2025

Python Documentary Trailer Released

Python 3.14.0 Beta Feature Freeze Begins

Three Accepted PEPs Tackle Typing, Installation, and Compression

The Real Python Podcast – Episode #252: Rodrigo Girão Serrão: Python Training, itertools, and Idioms

How to Find an Absolute Value in Python

Defining the Absolute Value

Quiz: How to Find an Absolute Value in Python

Execute Your Python Scripts With a Shebang

How Can You Structure Your Python Script?

Setting the Stage for Scripting

Using the Shebang Line

Organizing the Import Statements

Quiz: How Can You Structure Your Python Script?

The Real Python Podcast – Episode #251: Python Thread Safety & Managing Projects With uv

Control Flow Structures in Python

Getting to Know Control Flow in Python

Using Conditional Statements

Quiz: Control Flow Structures in Python

The LEGB Rule & Understanding Python Scope

marimo: A Reactive, Reproducible Notebook

How to Get Started in a marimo Notebook

Adding Code and Markdown Content

Quiz: marimo: A Reactive, Reproducible Notebook

The Real Python Podcast – Episode #250: DjangoCon Europe 2025: Live Recording From Dublin

Nested Loops in Python

Getting Started With Nested Loops in Python

Exploring Practical Examples of Nested Loops

Printing Patterns With Nested Loops

Quiz: Nested Loops in Python

First Steps With LangChain

Quiz: How to Group Data Using Polars .group_by()

The Real Python Podcast – Episode #249: Going Beyond requirements.txt With pylock.toml and PEP 751

Working With Missing Data in Polars

Quiz: Getting Started With Python IDLE

The Real Python Podcast – Episode #248: Experiments With Gen AI, Knowledge Graphs, Workflows, and Python

Using the Python subprocess Module

Quiz: Python Logging With the Loguru Library

Thread Safety in Python: Locks and Other Techniques

The Real Python Podcast – Episode #247: Exploring DuckDB & Comparing Python Expressions vs Statements

The Real Python Podcast – Episode #246: Learning Intermediate Python With a Deep Dive Course

Using Python’s `enumerate()`

Practicing With Python `enumerate()`

Getting to Know `namedtuple` in Python

Creating Tuple-Like Classes With the `namedtuple()` Function