Real Python

Iterators and Iterables in Python: Run Efficient Iterations

2023-03-01T14:00:00+00:00

Python’s iterators and iterables are two different but related tools that come in handy when you need to iterate over a data stream or container. Iterators power and control the iteration process, while iterables typically hold data that you want to iterate over one value at a time.

Iterators and iterables are fundamental components of Python programming, and you’ll have to deal with them in almost all your programs. Learning how they work and how to create them is key for you as a Python developer.

In this tutorial, you’ll learn how to:

Create iterators using the iterator protocol in Python
Understand the differences between iterators and iterables
Work with iterators and iterables in your Python code
Use generator functions and the yield statement to create generator iterators
Build your own iterables using different techniques, such as the iterable protocol
Use the asyncio module and the await and async keywords to create asynchronous iterators

Before diving deeper into these topics, you should be familiar with some core concepts like loops and iteration, object-oriented programming, inheritance, special methods, and asynchronous programming in Python.

Free Sample Code: Click here to download the free sample code that shows you how to use and create iterators and iterables for more efficient data processing.

Understanding Iteration in Python

When writing computer programs, you often need to repeat a given piece of code multiple times. To do this, you can follow one of the following approaches:

Repeating the target code as many times as you need in a sequence
Putting the target code in a loop that runs as many times as you need

The first approach has a few drawbacks. The most troublesome issue is the repetitive code itself, which is hard to maintain and not scalable. For example, the following code will print a greeting message on your screen three times:

# greeting.py

print("Hello!")
print("Hello!")
print("Hello!")

If you run this script, then you’ll get 'Hello!' printed on your screen three times. This code works. However, what if you decide to update your code to print 'Hello, World!' instead of just 'Hello!'? In that case, you’ll have to update the greeting message three times, which is a maintenance burden.

Now imagine a similar situation but with a larger and more complex piece of code. It can become a nightmare for maintainers.

Using a loop will be a much better way to solve the problem and avoid the maintainability issue. Loops allow you to run a piece of code as often as you need. Consider how you’d write the above example using a while loop:

>>>

>>> times = 0

>>> while times < 3:
...     print("Hello!")
...     times += 1
...
Hello!
Hello!
Hello!

This while loop runs as long as the loop-continuation condition (times < 3) remains true. In each iteration, the loop prints your greeting message and increments the control variable, times. Now, if you decide to update your message, then you just have to modify one line, which makes your code way more maintainable.

Python’s while loop supports what’s known as indefinite iteration, which means executing the same block of code over and over again, a potentially undefined number of times.

You’ll also find a different but similar type of iteration known as definite iteration, which means going through the same code a predefined number of times. This kind of iteration is especially useful when you need to iterate over the items of a data stream one by one in a loop.

To run an iteration like this, you typically use a for loop in Python:

>>>

>>> numbers = [1, 2, 3, 4, 5]

>>> for number in numbers:
...     print(number)
...
1
2
3
4
5

In this example, the numbers list represents your stream of data, which you’ll generically refer to as an iterable because you can iterate over it, as you’ll learn later in this tutorial. The loop goes over each value in numbers and prints it to your screen.

When you use a while or for loop to repeat a piece of code several times, you’re actually running an iteration. That’s the name given to the process itself.

In Python, if your iteration process requires going through the values or items in a data collection one item at a time, then you’ll need another piece to complete the puzzle. You’ll need an iterator.

Getting to Know Python Iterators

Iterators were added to Python 2.2 through PEP 234. They were a significant addition to the language because they unified the iteration process and abstracted it away from the actual implementation of collection or container data types. This abstraction allows iteration over unordered collections, such as sets, ensuring every element is visited exactly once.

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

[ 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 ]

Writing Clean, Pythonic Code With namedtuple

2023-02-28T14:00:00+00:00

Python’s collections module provides a factory function called namedtuple(), which is specially designed to make your code more Pythonic when you’re working with tuples. With namedtuple(), you can create immutable sequence types that allow you to access their values using descriptive field names and the dot notation instead of unclear integer indices.

If you have some experience using Python, then you know that writing Pythonic code is a core skill for Python developers. In this video course, you’ll level up that skill using namedtuple.

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

Create namedtuple classes using namedtuple()
Identify and take advantage of cool features of namedtuple
Use namedtuple instances to write Pythonic code
Decide whether to use a namedtuple or a similar data structure
Subclass a namedtuple to provide new features

To get the most out of this course, you need to have a general understanding of Python’s philosophy related to writing Pythonic and readable code. You also need to know the basics of working with:

If you don’t have all the required knowledge before starting this video course, then that’s okay! You can stop and review the above resources as needed.

[ 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 NumPy reshape() to Change the Shape of an Array

2023-02-27T14:00:00+00:00

The main data structure that you’ll use in NumPy is the N-dimensional array. An array can have one or more dimensions to structure your data. In some programs, you may need to change how you organize your data within a NumPy array. You can use NumPy’s reshape() to rearrange the data.

The shape of an array describes the number of dimensions in the array and the length of each dimension. In this tutorial, you’ll learn how to change the shape of a NumPy array to place all its data in a different configuration. When you complete this tutorial, you’ll be able to alter the shape of any array to suit your application’s needs.

In this tutorial, you’ll learn how to:

Change the shape of a NumPy array without changing its number of dimensions
Add and remove dimensions in a NumPy array
Control how data is rearranged when reshaping an array with the order parameter
Use a wildcard value of -1 for one of the dimensions in reshape()

For this tutorial, you should be familiar with the basics of NumPy and N-dimensional arrays. You can read NumPy Tutorial: Your First Steps Into Data Science in Python to learn more about NumPy before diving in.

Supplemental Material: Click here to download the image repository that you’ll use with NumPy reshape().

Install NumPy

You’ll need to install NumPy to your environment to run the code in this tutorial and explore reshape(). You can install the package using pip within a virtual environment. Select either the Windows or Linux + macOS tab below to see instructions for your operating system:

It’s a convention to use the alias np when you import NumPy. To get started, you can import NumPy in the Python REPL:

>>>

>>> import numpy as np

Now that you’ve installed NumPy and imported the package in a REPL environment, you’re ready to start working with NumPy arrays.

Understand the Shape of NumPy Arrays

You’ll use NumPy’s ndarray in this tutorial. In this section, you’ll review the key features of this data structure, including an array’s overall shape and number of dimensions.

You can create an array from a list of lists:

>>>

>>> import numpy as np
>>> numbers = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
>>> numbers
array([[1, 2, 3, 4],
       [5, 6, 7, 8]])

The function np.array() returns an object of type np.ndarray. This data structure is the main data type in NumPy.

You can describe the shape of an array using the length of each dimension of the array. NumPy represents this as a tuple of integers. The array numbers has two rows and four columns. Therefore, this array has a (2, 4) shape:

>>>

>>> numbers.shape
(2, 4)

You can represent the same data using a different shape:

Both of these arrays contain the same data. The array with the shape (2, 4) has two rows and four columns and the array with the shape (4, 2) has four rows and two columns. You can check the number of dimensions of an array using .ndim:

>>>

>>> numbers.ndim
2

The array numbers is two-dimensional (2D). You can arrange the same data contained in numbers in arrays with a different number of dimensions:

Read the full article at https://realpython.com/numpy-reshape/ »

[ 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 #146: Using NumPy and Linear Algebra for Faster Python Code

2023-02-24T12:00:00+00:00

Are you still using loops and lists to process your data in Python? Have you heard of a Python library with optimized data structures and built-in operations that can speed up your data science code? This week on the show, Jodie Burchell, developer advocate for data science at JetBrains, returns to share secrets for harnessing linear algebra and NumPy for your 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 Terminal: First Steps and Useful Commands

2023-02-22T14:00:00+00:00

The terminal can be intimidating to work with when you’re used to working with graphical user interfaces (GUIs). However, it’s an important tool that you need to get used to in your journey as a Python developer. And once you level up your skill of using the terminal, it becomes an extremely powerful tool in your repertoire. With just a few commands in the terminal, you can do tasks that are impossible or at least very tedious to do in a GUI.

In this tutorial, you’ll learn how to:

Find the terminal on your operating system
Open the terminal for the first time
Navigate your file system with basic commans
Create files and folders with the terminal
Manage packages with pip commands
Keep track of your files with Git in the terminal

If you’re new to working with the terminal, or you’re looking to expand your understanding of its capabilities, then this tutorial is a great starting point. In it, you’ll get an introduction to some of the basic commands and learn how to use pip and Git to manage your projects in the terminal.

Understanding how to integrate the terminal, pip, and Git into your workflows is essential for you as a Python developer. However, it’s important to note that you’ll only scratch the surface of what the terminal can do, and there’s much more to learn as you continue to explore the terminal as an essential development tool.

Free Download: Click here to get a free cheat sheet of useful commands to get you started working with the terminal.

Install and Open the Terminal

Back in the day, the term terminal referred to some clunky hardware that you used to enter data into a computer. Nowadays, people are usually talking about a terminal emulator when they say terminal, and they mean some kind of terminal software that you can find on most modern computers.

Note: There are two other terms that you might hear now and then in combination with the terminal:

A shell is the program that you interact with when running commands in a terminal.
A command-line interface (CLI) is a program designed to run in a shell inside the terminal.

In other words, the shell provides the commands that you use in a command-line interface, and the terminal is the application that you run to access the shell.

If you’re using a Linux or macOS machine, then the terminal is already built in. You can start using it right away.

On Windows, you also have access to command-line applications like the Command Prompt. However, for this tutorial and terminal work in general, you should use the Windows terminal application instead.

Read on to learn how to install and open the terminal on Windows and how to find the terminal on Linux and macOS.

Windows

The Windows terminal is a modern and feature-rich application that gives you access to the command line, multiple shells, and advanced customization options. If you have Windows 11 or above, chances are that the Windows terminal is already present on your machine. Otherwise, you can download the application from the Microsoft Store or from the official GitHub repository.

Before continuing with this tutorial, you need to get the terminal working on your Windows computer. You can follow the Your Python Coding Environment on Windows: Setup Guide to learn how to install the Windows terminal.

After you install the Windows terminal, you can find it in the Start menu under Terminal. When you start the application, you should see a window that looks like this:

It can be handy to create a desktop shortcut for the terminal or pin the application to your task bar for easier access.

Linux

You can find the terminal application in the application menu of your Linux distribution. Alternatively, you can press Ctrl+Alt+T on your keyboard or use the application launcher and search for the word Terminal.

After opening the terminal, you should see a window similar to the screenshot below:

How you open the terminal may also depend on which Linux distribution you’re using. Each one has a different way of doing it. If you have trouble opening the terminal on Linux, then the Real Python community will help you out in the comments below.

macOS

A common way to open the terminal application on macOS is by opening the Spotlight Search and searching for Terminal. You can also find the terminal app in the application folder inside Finder.

Read the full article at https://realpython.com/terminal-commands/ »

[ 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 Terminal on Windows

2023-02-21T14:00:00+00:00

The terminal can be intimidating to work with when you’re used to working with graphical user interfaces. However, it’s an important tool that you need to get used to in your journey as a Python developer. Even though you can substitute some workflows in the terminal with apps that contain a graphical user interface (GUI), you may need to open the terminal at some point in your life as a Python developer.

In this Code Conversation, you’ll follow a chat between Philipp and Ian as they perform common tasks in the terminal on Windows, such as:

Showing the current working directory
Listing the contents of a folder
Adding text to files without opening them
Displaying the content of a file

Along the way, you’ll learn how to:

Find the terminal on your operating system
Open the terminal for the first time
Navigate your file system with basic commands
Create files and folders with the terminal
Run Python files on Windows

If you’ve never worked with the terminal on Windows before or you want to see some interesting use cases to incorporate the terminal into your workflow, then this video course is the perfect start for you.

[ 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 ]

Develop Data Visualization Interfaces in Python With Dash

2023-02-20T14:00:00+00:00

In the past, creating analytical web applications was a task for seasoned developers that required knowledge of multiple programming languages and frameworks. That’s no longer the case. Nowadays, you can make data visualization interfaces using pure Python. One popular tool for this is Dash.

Dash gives data scientists the ability to showcase their results in interactive web applications. You don’t need to be an expert in web development. In an afternoon, you can build and deploy a Dash app to share with others.

In this tutorial, you’ll learn how to:

Create a Dash application
Use Dash core components and HTML components
Customize the style of your Dash application
Use callbacks to build interactive applications
Deploy your application on PythonAnywhere

You can download the source code, data, and resources for the sample application that you’ll make in this tutorial by clicking the link below:

Get the Source Code: Click here to get the source code you’ll use to learn about creating data visualization interfaces in Python with Dash in this tutorial.

What Is Dash?

Dash is an open-source framework for building data visualization interfaces. Released in 2017 as a Python library, it’s grown to include implementations for R, Julia, and F#. Dash helps data scientists build analytical web applications without requiring advanced web development knowledge.

Three technologies constitute the core of Dash:

Flask supplies the web server functionality.
React.js renders the user interface of the web page.
Plotly.js generates the charts used in your application.

But you don’t have to worry about making all these technologies work together. Dash will do that for you. You just need to write Python, R, Julia, or F# and sprinkle in a bit of CSS.

Plotly, a Canada-based company, built Dash and supports its development. You may know the company from the popular graphing libraries that share its name. The company released Dash as open source under an MIT license, so you can use Dash at no cost.

Plotly also offers a commercial companion to Dash called Dash Enterprise. This paid service provides companies with support services such as hosting, deploying, and handling authentication on Dash applications. But these features live outside of Dash’s open-source ecosystem.

Dash will help you build dashboards quickly. If you’re used to analyzing data or building data visualizations using Python, then Dash will be a useful addition to your toolbox. Here are a few examples of what you can make with Dash:

This is just a tiny sample. If you’d like to see other interesting use cases, then go check out the Dash App Gallery.

Note: You don’t need advanced knowledge of web development to follow this tutorial, but some familiarity with HTML and CSS won’t hurt.

You should know the basics of the following topics, though:

Python graphing libraries such as Plotly, Bokeh, and Matplotlib
HTML and the structure of an HTML file
CSS and style sheets

If you feel comfortable with the requirements and want to learn how to use Dash in your next project, then continue to the following section!

Get Started With Dash in Python

In this tutorial, you’ll go through the end-to-end process of building a dashboard using Dash. If you follow along with the examples, then you’ll go from a bare-bones dashboard on your local machine to a styled dashboard deployed on PythonAnywhere.

To build the dashboard, you’ll use a dataset of sales and prices of avocados in the United States between 2015 and 2018. Justin Kiggins compiled this dataset using data from the Hass Avocado Board.

How to Set Up Your Local Environment

To develop your app, you’ll need a new directory to store your code and data. You’ll also need a clean Python virtual environment. To create those, execute the commands below, choosing the version that matches your operating system:

PS> mkdir avocado_analytics
PS> cd avocado_analytics
PS> python -m venv venv
PS> venv\Scripts\activate

$ mkdir avocado_analytics
$ cd avocado_analytics
$ python -m venv venv
$ source venv/bin/activate

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

[ 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 #145: Creating a Python Wordle Clone & Testing Environments With Nox

2023-02-17T12:00:00+00:00

Would you like to practice your Python skills while building a challenging word game? Have you been wanting to learn more about creating command-line interfaces and making them colorful and interactive? This week on the show, Christopher Trudeau is here, 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 ]

How to Flush the Output of the Python Print Function

2023-02-15T14:00:00+00:00

Do you want to build a compact visual progress indicator for your Python script using print(), but your output doesn’t show up when you’d expect it to? Or are you piping the logs of your script to another application, but you can’t manage to access them in real time? In both cases, data buffering is the culprit, and you can solve your troubles by flushing the output of print().

In this tutorial, you’ll learn how to:

Flush the output data buffer explicitly using the flush parameter of print()
Change data buffering for a single function, the whole script, and even your entire Python environment
Determine when you need to flush the data buffer explicitly and when that isn’t necessary

By repeatedly running a short code snippet that you change only slightly, you’ll see that if you run print() with its default arguments, then its execution is line-buffered in interactive mode, and block-buffered otherwise.

You’ll get a feel for what all of that means by exploring the code practically. But before you dive into changing output stream buffering in Python, it’s helpful to revisit how it happens by default, and understand why you might want to change it.

Free Sample Code: Click here to download the free sample code that you’ll use to dive deep into flushing the output of the Python print function.

Understand How Python Buffers Output

When you make a write call to a file-like object, Python buffers the call by default—and that’s a good idea! Disk write and read operations are slow in comparison to random-access memory (RAM) access. When your script makes fewer system calls for write operations by batching characters in a RAM data buffer and writing them all at once to disk with a single system call, then you can save a lot of time.

To put the use case for buffering into a real-world context, think of traffic lights as buffers for car traffic. If every car crossed an intersection immediately upon arrival, it would end in gridlock. That’s why the traffic lights buffer traffic from one direction while the other direction flushes.

Note: Data buffers are generally size-based, not time-based, which is where the traffic analogy breaks down. In the context of a data buffer, the traffic lights would switch if a certain number of cars were queued up and waiting.

However, there are situations when you don’t want to wait for a data buffer to fill up before it flushes. Imagine that there’s an ambulance that needs to get past the crossroads as quickly as possible. You don’t want it to wait at the traffic lights until there’s a certain number of cars queued up.

In your program, you usually want to flush the data buffer right away when you need real-time feedback on code that has executed. Here are a couple of use cases for immediate flushing:

Instant feedback: In an interactive environment, such as a Python REPL or a situation where your Python script writes to a terminal
File monitoring: In a situation where you’re writing to a file-like object, and the output of the write operation gets read by another program while your script is still executing—for example, when you’re monitoring a log file

In both cases, you need to read the generated output as soon as it generates, and not only when enough output has assembled to flush the data buffer.

There are many situations where buffering is helpful, and there are some situations where too much buffering can be a disadvantage. Therefore, there are different types of data buffering that you can implement where they fit best:

Unbuffered means that there’s no data buffer. Every byte creates a new system call and gets written independently.
Line-buffered means that there’s a data buffer that collects information in memory, and once it encounters a newline character (\n), the data buffer flushes and writes the whole line in one system call.
Fully-buffered (block-buffered) means that there’s a data buffer of a specific size, which collects all the information that you want to write. Once it’s full, it flushes and sends all its contents onward in a single system call.

Python uses block buffering as a default when writing to file-like objects. However, it executes line-buffered if you’re writing to an interactive environment.

To better understand what that means, write a Python script that simulates a countdown:

# countdown.py

from time import sleep

for second in range(3, 0, -1):
    print(second)
    sleep(1)
print("Go!")

By default, each number shows up right when print() is called in the script. But as you develop and tweak your countdown timer, you might run into a situation where all your output gets buffered. Buffering the whole countdown and printing it all at once when the script finishes would lead to a lot of confusion for the athletes waiting at the start line!

So how can you make sure that you won’t run into data buffering issues as you develop your Python script?

Add a Newline for Python to Flush Print Output

If you’re running a code snippet in a Python REPL or executing it as a script directly with your Python interpreter, then you won’t run into any issues with the script shown above.

In an interactive environment, the standard output stream is line-buffered. This is the output stream that print() writes to by default. You’re working with an interactive environment any time that your output will display in a terminal. In this case, the data buffer flushes automatically when it encounters a newline character ("\n"):

When interactive, the stdout stream is line-buffered. (Source)

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

[ 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 ]

Getters and Setters in Python

2023-02-14T14:00:00+00:00

If you come from a language like Java or C++, then you’re probably used to writing getter and setter methods for every attribute in your classes. These methods allow you to access and mutate private attributes while maintaining encapsulation. In Python, you’ll typically expose attributes as part of your public API and use properties when you need attributes with functional behavior.

Even though properties are the Pythonic way to go, they can have some practical drawbacks. Because of this, you’ll find some situations where getters and setters are preferable over properties.

In this video course, you’ll:

Write getter and setter methods in your classes
Replace getter and setter methods with properties
Explore other tools to replace getter and setter methods in Python
Decide when setter and getter methods can be the right tool for the job

To get the most out of this course, you should be familiar with Python object-oriented programming. It’ll also be a plus if you have basic knowledge of Python properties and descriptors.

[ 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 News: What's New From January 2023

2023-02-13T14:00:00+00:00

The new year has arrived, and January brought a flurry of new and interesting Python enhancement proposals (PEPs). Topics range from f-string formalization and no-GIL Python to packaging. There’s been ample discussion on the Python Discourse forum about the implications of these PEPs, and if you’re still a bit wary of diving deeper into the discussions, then you can get a softer introduction here.

There have also been a couple of noteworthy new releases, first and foremost the fourth alpha release of Python 3.12. And finally, there’s a new job posting out for a security developer in residence sponsored by the Python Software Foundation (PSF).

Let’s dive into the biggest Python news from the past month!

Join Now: Click here to join the Real Python Newsletter and you'll never miss another Python tutorial, course update, or post.

PEP 701 Attempts to Formalize f-Strings

Python’s f-strings are great, but there are currently a few edge cases that might make you scratch your head.

For example, maybe you wanted to greet the new year with a carefully constructed f-string, but you ran into unexpected troubles:

>>>

>>> f"happy {"\n".join(["twenty", "three", "🥳"]) # it's 2023!}!!"
File "<stdin>", line 1
  f"happy {"\n".join(["twenty", "three", "🥳"]) # it's 2023!}!!"
             ^
SyntaxError: unexpected character after line continuation character

You used some double quotes (") inside the curly braces ({}). It looks like Python isn’t happy with that and considers the f-string closed, even though the quotes appear inside the f-string expression part.

The new year is still fresh, so you won’t let this get you down! You just change the double quotes to single quotes:

>>>

>>> f"Happy {'\n'.join(['twenty', 'three', '🥳']) # Yes! 2023!}!!"
File "<stdin>", line 1
  f"Happy {'\n'.join(['twenty', 'three', '🥳']) # Yes! 2023!}!!"
                                                               ^
SyntaxError: f-string expression part cannot include a backslash

Oh! There’s another issue with your new year’s greeting f-string. It looks like you can’t include the backslash (\) character in an f-string expression. Well, maybe 2023 is more about expanding in breadth than in depth, you think to yourself. So you replace the newline character (\n) with a whitespace character (' ') and try again:

>>>

>>> f"Happy {' '.join(['twenty', 'three', '🥳']) # Yes! 2023!}!!"
File "<stdin>", line 1
  f"Happy {' '.join(['twenty', 'three', '🥳']) # Yes! 2023!}!!"
                                                              ^
SyntaxError: f-string expression part cannot include '#'

Argh! Yet another problem! It seems like you can’t include comments in the f-string expression part—not even when they’re full of joy and optimism!

Python 3.6 introduced f-strings, and the LL(1) parser that Python used back then wasn’t able to handle these edge cases.

Maybe running into the limitations of f-strings has slightly dampened your optimistic beginning of 2023. But don’t write this year off quite yet, because these limitations may go away soon.

Pablo Galindo Salgado authored PEP 701 – Syntactic formalization of f-strings at the end of last year. The PEP proposes a formalized grammar for f-strings, which could be directly integrated into the parsing expression grammar (PEG) parser that Python’s been using since version 3.9.

Read the full article at https://realpython.com/python-news-january-2023/ »

[ 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 #144: Wrangling Business Process Models With Python and SpiffWorkflow

2023-02-10T12:00:00+00:00

Can you describe your business processes with flowcharts? What if you could define the steps in a standard notation and implement the workflows in pure Python? This week on the show, Dan Funk from Sartography is here to discuss SpiffWorkflow.

[ 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 Split a Python List or Iterable Into Chunks

2023-02-08T14:00:00+00:00

Splitting a Python list into chunks is a common way of distributing the workload across multiple workers that can process them in parallel for faster results. Working with smaller pieces of data at a time may be the only way to fit a large dataset into computer memory. Sometimes, the very nature of the problem requires you to split the list into chunks.

In this tutorial, you’ll explore the range of options for splitting a Python list—or another iterable—into chunks. You’ll look at using Python’s standard modules and a few third-party libraries, as well as manually looping through the list and slicing it up with custom code. Along the way, you’ll learn how to handle edge cases and apply these techniques to multidimensional data by synthesizing chunks of an image in parallel.

In this tutorial, you’ll learn how to:

Split a Python list into fixed-size chunks
Split a Python list into a fixed number of chunks of roughly equal size
Split finite lists as well as infinite data streams
Perform the splitting in a greedy or lazy manner
Produce lightweight slices without allocating memory for the chunks
Split multidimensional data, such as an array of pixels

Throughout the tutorial, you’ll encounter a few technical terms, such as sequence, iterable, iterator, and generator. If these are new to you, then check out the linked resources before diving in. Additionally, familiarity with Python’s itertools module can be helpful in understanding some of the code snippets that you’ll find later.

To download the complete source code of the examples presented in this tutorial, click the link below:

Free Sample Code: Click here to download the free source code that you’ll use to split a Python list or iterable into chunks.

Split a Python List Into Fixed-Size Chunks

There are many real-world scenarios that involve splitting a long list of items into smaller pieces of equal size. The whole list may be too large to fit in your computer’s memory. Perhaps it’s more convenient or efficient to process the individual chunks separately rather than all at once. But there could be other reasons for splitting.

For example, when you search for something online, the results are usually presented to you in chunks, called pages, containing an equal number of items. This technique, known as content pagination, is common in web development because it helps improve the website’s performance by reducing the amount of data to transfer from the database at a time. It can also benefit the user by improving their browsing experience.

Most computer networks use packet switching to transfer data in packets or datagrams, which can be individually routed from the source to the destination address. This approach doesn’t require a dedicated physical connection between the two points, allowing the packets to bypass a damaged part of the network. The packets can be of variable length, but some low-level protocols require the data to be split into fixed-size packets.

Note: When splitting sequential data, you need to consider its size while keeping a few details in mind.

Specifically, if the total number of elements to split is an exact multiple of the desired chunk’s length, then you’ll end up with all the chunks having the same number of items. Otherwise, the last chunk will contain fewer items, and you may need extra padding to compensate for that.

Additionally, your data may have a known size up front when it’s loaded from a file in one go, or it can consist of an indefinite stream of bytes—while live streaming a teleconference, for example. Some solutions that you learn in this tutorial will only work when the number of elements is known before the splitting begins.

Most web frameworks, such as Django, will handle content pagination for you. Also, you don’t typically have to worry about some low-level network protocols. That being said, there are times when you’ll need to have more granular control and do the splitting yourself. In this section, you’ll take a look at how to split a list into smaller lists of equal size using different tools in Python.

Standard Library in Python 3.12: `itertools.batched()`

Using the standard library is almost always your best choice because it requires no external dependencies. The standard library provides concise, well-documented code that’s been tested by millions of users in production, making it less likely to contain bugs. Besides that, the standard library’s code is portable across different platforms and typically much more performant than a pure-Python equivalent, as most of it is implemented in C.

Unfortunately, the Python standard library hasn’t traditionally had built-in support for splitting iterable objects like Python lists. At the time of writing, Python 3.11 is the most recent version of the interpreter. But you can put yourself on the cutting edge by downloading a pre-release version of Python 3.12, which gives you access to the new itertools.batched(). Here’s an example demonstrating its use:

>>>

>>> from itertools import batched
>>> for batch in batched("ABCDEFGHIJ", 4):
...     print(batch)
...
('A', 'B', 'C', 'D')
('E', 'F', 'G', 'H')
('I', 'J')

The function accepts any iterable object, such as a string, as its first argument. The chunk size is its second argument. Regardless of the input data type, the function always yields chunks or batches of elements as Python tuples, which you may need to convert to something else if you prefer working with a different sequence type. For example, you might want to join the characters in the resulting tuples to form strings again.

Note: The underlying implementation of itertools.batched() could’ve changed since the publishing of this tutorial, which was written against an alpha release of Python 3.12. For example, the function may now yield lists instead of tuples, so be sure to check the official documentation for the most up-to-date information.

Also, notice that the last chunk will be shorter than its predecessors unless the iterable’s length is divisible by the desired chunk size. To ensure that all the chunks have an equal length at all times, you can pad the last chunk with empty values, such as None, when necessary:

>>>

>>> def batched_with_padding(iterable, batch_size, fill_value=None):
...     for batch in batched(iterable, batch_size):
...         yield batch + (fill_value,) * (batch_size - len(batch))

>>> for batch in batched_with_padding("ABCDEFGHIJ", 4):
...     print(batch)
...
('A', 'B', 'C', 'D')
('E', 'F', 'G', 'H')
('I', 'J', None, None)

This adapted version of itertools.batched() takes an optional argument named fill_value, which defaults to None. If a chunk’s length happens to be less than size, then the function appends additional elements to that chunk’s end using fill_value as padding.

You can supply either a finite sequence of values to the batched() function or an infinite iterator yielding values without end:

>>>

>>> from itertools import count

>>> finite = batched([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 4)
>>> infinite = batched(count(1), 4)

>>> finite
<itertools.batched object at 0x7f4e0e2ee830>

>>> infinite
<itertools.batched object at 0x7f4b4e5fbf10>

>>> list(finite)
[(1, 2, 3, 4), (5, 6, 7, 8), (9, 10)]

>>> next(infinite)
(1, 2, 3, 4)

>>> next(infinite)
(5, 6, 7, 8)

>>> next(infinite)
(9, 10, 11, 12)

In both cases, the function returns an iterator that consumes the input iterable using lazy evaluation by accumulating just enough elements to fill the next chunk. The finite iterator will eventually reach the end of the sequence and stop yielding chunks. Conversely, the infinite one will continue to produce chunks as long as you keep requesting them—for instance, by calling the built-in next() function on it.

Read the full article at https://realpython.com/how-to-split-a-python-list-into-chunks/ »

[ 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 Basics: Building Systems With Classes

2023-02-07T14:00:00+00:00

In the previous course in the Python Basics series, you learned how to use classes to create new objects. Now that you understand the basics of object-oriented programming (OOP), it’s time to put those classes to work.

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

Compose classes together to create layers of functionality
Inherit and override behavior from other classes to create variations
Creatively mix and match these approaches

With these capabilities, you’ll be able to build more complex systems and write readable, reusable code.

This video course is part of the Python Basics series, which accompanies Python Basics: A Practical Introduction to Python 3.

Note that you’ll be using IDLE to interact with Python throughout this course. If you’re just getting started, then you might want to check out Python Basics: Setting Up Python before diving into this course.

[ 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 ]

Build a Wordle Clone With Python and Rich

2023-02-06T14:00:00+00:00

In this tutorial, you’ll build your own Wordle clone for the terminal. Since Josh Wardle launched Wordle in October 2021, millions of people have played it. While you can play the original game on the Web, you’ll create your version as a command-line application and then use the Rich library to make it look good.

As you follow along in this step-by-step project, you’ll practice how to set up a simple prototype game before iteratively developing it into a solid application.

In this tutorial, you’ll learn how to:

Build out a command-line application from a prototype to a polished game
Read and validate user input
Use Rich’s console to create an attractive user interface in the terminal
Organize your code into functions
Provide your users with actionable feedback

You’ll create Wyrdl, your own Wordle clone in Python. This project is for anyone getting comfortable with Python who wants to build a terminal application from the ground up. Throughout the tutorial, you’ll build your code step-by-step while focusing on having a game that you can play from the start. You can download all the code by clicking below:

Free Source Code: Click here to download the free source code that you’ll use to build a Wordle clone with Python and Rich.

Read on to see what you’ll be building.

Demo: Your Python Wordle Clone

In Wordle, you have six attempts to guess a secret five-letter word. After each guess, you’ll get feedback about which letters are correctly placed, which are misplaced, and which are wrong.

The New York Times bought the original Wordle in early 2022, and you can now play the game on their website. The game has a social aspect that you won’t re-create in this project. There’s one secret word per day, and all players are guessing the same word.

Your version of the game will look like the following:

After you make a guess, each letter is categorized. Correct letters are marked in green, misplaced letters are marked in yellow, and wrong letters are marked in gray.

If you make any mistakes, like guessing a word with six letters, then the game will give you appropriate feedback and let you take another guess.

Project Overview

An important part of this project is bootstrapping the application early. You want to have code that runs so that you can test that your code works, and you can experiment with different ways of implementing the features that you need in your game.

You’ll build your Wordle clone iteratively, going through the following steps:

Create a simple prototype that allows you to guess a secret word and gives you feedback on the individual letters.
Make the game more interesting by including a list of words that the game randomly chooses from.
Refactor the code to use functions.
Add color and style to the game using the Rich library.
Provide actionable feedback to your users when they play the game.
Improve the user interface by adding the status of all the letters in the alphabet.

As you work through the tutorial, you’ll see how you can start with a small idea and grow it into a full-featured application. After all, that was Wordle’s journey!

Prerequisites

In this tutorial, you’ll build a Wordle clone using Python and Rich. While working through the steps, it’s helpful if you’re comfortable with the following concepts:

Reading input from the user at the terminal
Using if statements to check different conditions
Repeating actions with for and while loops
Organizing data in structures like lists and dictionaries
Encapsulating code with functions

If you’re not confident in your knowledge of these prerequisites, then that’s okay too! In fact, going through this tutorial will help you practice these concepts. You can always stop and review the resources linked above if you get stuck.

It’s time to dive in!

Step 1: Guess a Word

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

[ 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 #143: Create Interactive Maps & Geospatial Data Visualizations With Python

2023-02-03T12:00:00+00:00

Would you like to quickly add data to a map with Python? Have you wanted to create beautiful interactive maps and export them as a stand-alone static web page? This week on the show, Christopher Trudeau is here, 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 ]

Build a JavaScript Front End for a Flask API

2023-02-01T14:00:00+00:00

Most modern web applications are powered by a REST API under the hood. That way, developers can separate JavaScript front-end code from the back-end logic that a web framework like Flask provides.

Following this step-by-step project, you’ll create an interactive single-page application with HTML, CSS, and JavaScript. The foundation is an existing Flask project with a REST API and a connected SQLite database, which you’ll grab in just a moment.

In this tutorial, you’ll learn how to:

Navigate a full-stack web development workflow
Structure an HTML file to act as the template for a single-page web application
Leverage the Jinja templating engine to render dynamic HTML
Use CSS to style the presentation of an application
Write JavaScript to add interactivity to an application
Leverage Ajax to make HTTP requests to the REST API

As a Python developer, you’re probably more comfortable working on the back end of an application. This tutorial will guide you through a full-stack experience from the back end to the front end. You may write less Python code than usual, but you’ll learn a whole bunch about HTML, CSS, and JavaScript.

In the JavaScript world, it’s very common to reach for one of many frameworks and libraries. However, you won’t be using any frameworks in this tutorial. That way, you’ll get to know core JavaScript before using tools that build on top of that foundation in your future projects.

You can download the final code for this project by clicking the link below:

Free Source Code: Click here to download the free source code that you’ll use to build a front end for your Flask REST API single-page web application.

Demo

In this tutorial, you’ll fix some back-end shortcomings and move on to build the front end on top of an existing REST API that you’ll download in a moment. The API already provides several API endpoints to keep track of notes for people who may visit you throughout the year. You’ll initiate the database with people like the Tooth Fairy, the Easter Bunny, and Knecht Ruprecht.

Ideally, you want to be on good terms with all three of them. That’s why you’ll send them notes, to increase your chances of getting valuable gifts from them.

At the end of this tutorial, you’ll be able to interact with your API from the convenience of your application’s front end:

At the end of this tutorial, you can put your earned knowledge into action and continue to build a fully functional single-page application that works seamlessly with the REST API that you’ll get to know over the following few sections.

Throughout the tutorial, you’ll adjust everything from the data model of the database all the way to the client-side experience. This will give you a good idea of what full-stack web development means for you as a Python developer.

Project Overview

In this tutorial, you’ll build upon an existing Flask REST API with several endpoints. You’ll start by grabbing the materials for the Flask project and making sure that the API connects to the database.

Note: The tutorial you’re currently reading will guide you through all the steps that you need to create a JavaScript front end for a Flask REST API. However, if you’re curious, you can follow the Python REST APIs With Flask, Connexion, and SQLAlchemy tutorial series to build the Flask REST API that you’ll use in this tutorial.

Part 1 of this series guides you through building a REST API, and Part 2 shows you how to connect that REST API to a database. In Part 3, you add relationships to the REST API and the supporting database.

If you’re interested in Python back-end development, then it’s a good idea to check out these three parts first. Either way, before you continue with this tutorial, follow the steps below to collect all the prerequisites.

After you’ve verified that the Flask project works, you’ll get to know the back end by investigating some shortcomings that the REST API currently has. This part will give you a good impression of the app’s back-end structure before you move on to the front end.

For most of this step-by-step project, you’ll be iterating over HTML, CSS, and JavaScript code. Piece by piece, you’ll make your single-page web application more maintainable and better looking.

In the end, you’ll be able to communicate with your Flask back end from the convenience of your JavaScript-powered front end.

Prerequisites

In this project, you’ll focus on writing the front-end code. Still, you need a back end to work with. In this case, it’s a Flask project that provides a REST API with several endpoints.

Read on and download the code that you need to create the Flask project. Additionally, you’ll use a bootstrap script to build the database with some sample datasets.

Grab the Back-End Code

Read the full article at https://realpython.com/flask-javascript-frontend-for-rest-api/ »

[ 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 Terminal on Linux

2023-01-31T14:00:00+00:00

In this Code Conversation, you’ll follow a chat between Philipp and Geir Arne as they perform common tasks in the terminal on Linux, such as:

Showing the current working directory
Listing the contents of a folder
Adding text to files without opening them
Displaying the content of a file

Along the way, you’ll learn how to:

Find the terminal on your operating system
Open the terminal for the first time
Navigate your file system with basic commands
Create files and folders with the terminal
Run Python files on Linux

If you’ve never worked with the terminal on Linux before or you want to see some interesting use cases to incorporate the terminal into your workflow, then this video course is the perfect start for you.

[ 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 Iterate Over Rows in pandas, and Why You Shouldn't

2023-01-30T14:00:00+00:00

One of the most common questions you might have when entering the world of pandas is how to iterate over rows in a pandas DataFrame. If you’ve gotten comfortable using loops in core Python, then this is a perfectly natural question to ask.

While iterating over rows is relatively straightforward with .itertuples() or .iterrows(), that doesn’t necessarily mean iteration is the best way to work with DataFrames. In fact, while iteration may be a quick way to make progress, relying on iteration can become a significant roadblock when it comes to being effective with pandas.

In this tutorial, you’ll learn how to iterate over the rows in a pandas DataFrame, but you’ll also learn why you probably don’t want to. Generally, you’ll want to avoid iteration because it comes with a performance penalty and goes against the way of the panda.

To follow along with this tutorial, you can download the datasets and code samples from the following link:

Free Sample Code: Click here to download the free sample code and datasets that you’ll use to explore iterating over rows in a pandas DataFrame vs using vectorized methods.

The last bit of prep work is to spin up a virtual environment and install a few packages:

PS> python -m venv venv
PS> venv\Scripts\activate
(venv) PS> python -m pip install pandas httpx codetiming

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install pandas httpx codetiming

The pandas installation won’t come as a surprise, but you may wonder about the others. You’ll use the httpx package to carry out some HTTP requests as part of one example, and the codetiming package to make some quick performance comparisons.

With that, you’re ready to get stuck in and learn how to iterate over rows, why you probably don’t want to, and what other options to rule out before resorting to iteration.

How to Iterate Over DataFrame Rows in pandas

While uncommon, there are some situations in which you can get away with iterating over a DataFrame. These situations are typically ones where you:

Need to feed the information from a pandas DataFrame sequentially into another API
Need the operation on each row to produce a side effect, such as an HTTP request
Have complex operations to carry out involving various columns in the DataFrame
Don’t mind the performance penalty of iteration, maybe because working with the data isn’t the bottleneck, the dataset is very small, or it’s just a personal project

A common use case for using loops in pandas is when you’re interactively exploring and experimenting with data. In these cases, performance is usually less of a concern. By iterating over the data rows, you can display and get to know individual rows. Based on this experience, you can implement more effective approaches later.

As an example of a more permanent use case, imagine you have a list of URLs in a DataFrame, and you want to check which URLs are online. In the downloadable materials, you’ll find a CSV file with some data on the most popular websites, which you can load into a DataFrame:

>>>

>>> import pandas as pd
>>> websites = pd.read_csv("resources/popular_websites.csv", index_col=0)
>>> websites
         name                              url   total_views
0      Google           https://www.google.com  5.207268e+11
1     YouTube          https://www.youtube.com  2.358132e+11
2    Facebook         https://www.facebook.com  2.230157e+11
3       Yahoo            https://www.yahoo.com  1.256544e+11
4   Wikipedia        https://www.wikipedia.org  4.467364e+10
5       Baidu            https://www.baidu.com  4.409759e+10
6     Twitter              https://twitter.com  3.098676e+10
7      Yandex               https://yandex.com  2.857980e+10
8   Instagram        https://www.instagram.com  2.621520e+10
9         AOL              https://www.aol.com  2.321232e+10
10   Netscape         https://www.netscape.com  5.750000e+06
11       Nope  https://alwaysfails.example.com  0.000000e+00

This data contains the website’s name, its URL, and the total number of views over an unspecified time period. In the example, pandas shows the number of views in scientific notation. You’ve also got a dummy website in there for testing purposes.

You want to write a connectivity checker to test the URLs and provide a human-readable message indicating whether the website is online or whether it’s being redirected to another URL:

>>>

>>> import httpx
>>> def check_connection(name, url):
...     try:
...         response = httpx.get(url)
...         location = response.headers.get("location")
...         if location is None or location.startswith(url):
...             print(f"{name} is online!")
...         else:
...             print(f"{name} is online! But redirects to {location}")
...         return True
...     except httpx.ConnectError:
...         print(f"Failed to establish a connection with {url}")
...         return False
...

Here, you’ve defined a check_connection() function to make the request and print out messages for a given name and URL.

With this function, you’ll use both the url and the name columns. You don’t care much about the performance of reading the values from the DataFrame for two reasons—partly because the data is so small, but mainly because the real time sink is making HTTP requests, not reading from a DataFrame.

Additionally, you’re interested in inspecting whether any of the websites are down. That is, you’re interested in the side effect and not in adding information to the DataFrame.

For these reasons, you can get away with using .itertuples():

>>>

>>> for website in websites.itertuples():
...     check_connection(website.name, website.url)
...
Google is online!
YouTube is online!
Facebook is online!
Yahoo is online!
Wikipedia is online!
Baidu is online!
Twitter is online!
Yandex is online!
Instagram is online!
AOL is online!
Netscape is online! But redirects to https://www.aol.com/
Failed to establish a connection with https://alwaysfails.example.com

Read the full article at https://realpython.com/pandas-iterate-over-rows/ »

[ 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 #142: Orchestrating Large and Small Projects With Apache Airflow

2023-01-27T12:00:00+00:00

Have you worked on a project that needed an orchestration tool? How do you define the workflow of an entire data pipeline or a messaging system with Python? This week on the show, Calvin Hendryx-Parker is back to talk about using Apache Airflow and orchestrating Python 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 ]

Python Basics: Object-Oriented Programming

2023-01-24T14:00:00+00:00

OOP, or object-oriented programming, is a method of structuring a program by bundling related properties and behaviors into individual objects.

Conceptually, objects are like the components of a system. Think of a program as a factory assembly line of sorts. At each step of the assembly line, a system component processes some material, ultimately transforming raw material into a finished product.

An object contains both data, like the raw or preprocessed materials at each step on an assembly line, and behavior, like the action that each assembly line component performs.

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

Create a class, which is like a blueprint for creating an object
Use classes to create new objects
Instantiate classes with attributes and methods

This video course is part of the Python Basics series, which accompanies Python Basics: A Practical Introduction to Python 3. You can also check out the other Python Basics courses.

[ 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 #141: Exploring Python With bpython & Formalizing f-String Grammar

2023-01-20T12:00:00+00:00

Have you used the Python Read-Eval-Print Loop (REPL) to explore the language and learn about how it operates? Would it help if it provided syntax highlighting, definitions, and code completion and behaved more like an IDE? This week on the show, Christopher Trudeau is here, 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 ]

Python Basics Exercises: File System Operations

2023-01-17T14:00:00+00:00

In Python Basics: File System Operations, you learned how to use Python to work with files and folders. As a programmer, you’ll use the pathlib and shutil modules to complete file system operations without relying on your graphical user interface (GUI).

While you already got lots of hands-on practice with file system operations, programmers never stop training! The more you use your new skills, the more comfortable you’ll be when it’s time to put them to work in your own coding. That’s why it’s a great idea to complete exercises to reinforce and test your knowledge of the file system.

In this video course, you’ll practice:

Creating a directory
Iterating over the contents of a directory
Searching for files using wildcards
Moving and deleting files and folders

Along the way, you’ll also get some insight into how to tackle coding challenges in general, which can be a great way to level up as a developer.

This video course is part of the Python Basics series, which accompanies Python Basics: A Practical Introduction to Python 3. You can also check out the other Python Basics courses.

[ 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 #140: Speeding Up Your DataFrames With Polars

2023-01-13T12:00:00+00:00

How can you get more performance from your existing data science infrastructure? What if a DataFrame library could take advantage of your machine's available cores and provide built-in methods for handling larger-than-RAM datasets? This week on the show, Liam Brannigan is here to discuss Polars.

[ 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 Terminal on macOS

2023-01-10T14:00:00+00:00

In this Code Conversation, you’ll follow a chat between Philipp and Martin as they perform common tasks in the terminal on macOS, such as:

Showing the current working directory
Listing the contents of a folder
Adding text to files without opening them
Displaying the content of a file

Along the way, you’ll learn how to:

Find the terminal on your operating system
Open the terminal for the first time
Navigate your filesystem with basic commands
Create files and folders with the terminal
Run Python files on macOS

If you’ve never worked with the terminal on macOS before or you want to see some interesting use cases to incorporate the terminal into your workflow, then this video course is the perfect start for you.

[ 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 #139: Surveying Comprehension Constructs & Python Parallelism Infighting

2023-01-06T12:00:00+00:00

Have you embraced the use of comprehensions in your Python journey? Are you familiar with all the varieties of comprehension constructs? This week on the show, Christopher Trudeau is here, 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 ]

Build Cross-Platform GUI Apps With Kivy

2023-01-03T14:00:00+00:00

These days, developers are highly likely to be working on a mobile or web application. Python doesn’t have built-in mobile development capabilities, but you can create mobile applications by using libraries like Kivy, PyQt, or even Beeware’s Toga library.

These libraries are all major players in the Python mobile space. However, there are some benefits that you’ll enjoy if you choose to create mobile applications with Kivy. Not only will your application look the same on all platforms, but you also won’t need to compile your code after every change. What’s more, you’ll be able to use Python’s clear syntax to build your applications.

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

Work with Kivy widgets
Lay out the user interface (UI)
Add events
Use the KV language
Create a calculator application
Package your application for Windows, Linux, and macOS
Research the tools to package for iOS and Android

To complete this video course, you’ll need to be familiar with object-oriented programming. If you’re not, then check out Object-Oriented Programming (OOP) in Python 3 as either a written tutorial or a video course.

[ 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 #138: 2022 Real Python Tutorial & Video Course Wrap Up

2022-12-23T12:00:00+00:00

It's been another year of changes at Real Python! The Real Python team has written, edited, curated, illustrated, and produced a mountain of Python material this year. We added some new members to the team, updated the site's features, and created new styles of tutorials and video courses.

[ 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 Basics: File System Operations

2022-12-20T14:00:00+00:00

So far, you’ve written programs that get their input from one of two sources: the user or the program itself. Program output has been limited to displaying some text in IDLE’s interactive window.

These input and output strategies aren’t useful in several common scenarios, such as when:

The input values are unknown while writing the program.
The program requires more data than a user can be expected to type in by themselves.
Output must be shared with others after the program runs.

This is where files come in. You’ve likely been working with computer files for a long time. Even so, there are some things that programmers need to know about files that general users do not. Specifically, you’ll want to master some file system operations using the pathlib and shutil modules.

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

Create files and directories
Iterate over the contents of a directory
Search for files and folders using wildcards
Move and delete files and folders

This video course is part of the Python Basics series, which accompanies Python Basics: A Practical Introduction to Python 3. You can also check out the other Python Basics courses.

[ 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 #137: Start Using a Build System & Continuous Integration in Python

2022-12-16T12:00:00+00:00

What advantages can a build system provide for a Python developer? What new skills are required when working with a team of developers? This week on the show, Benjy Weinberger from Toolchain is here to discuss the Pants build system and getting started with continuous integration (CI).

[ 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

Iterators and Iterables in Python: Run Efficient Iterations

Understanding Iteration in Python

Getting to Know Python Iterators

Writing Clean, Pythonic Code With namedtuple

Using NumPy reshape() to Change the Shape of an Array

Install NumPy

Understand the Shape of NumPy Arrays

The Real Python Podcast – Episode #146: Using NumPy and Linear Algebra for Faster Python Code

The Terminal: First Steps and Useful Commands

Install and Open the Terminal

Windows

Linux

macOS

Using the Terminal on Windows

Develop Data Visualization Interfaces in Python With Dash

What Is Dash?

Get Started With Dash in Python

How to Set Up Your Local Environment

The Real Python Podcast – Episode #145: Creating a Python Wordle Clone & Testing Environments With Nox

How to Flush the Output of the Python Print Function

Understand How Python Buffers Output

Add a Newline for Python to Flush Print Output

Getters and Setters in Python

Python News: What's New From January 2023

PEP 701 Attempts to Formalize f-Strings

The Real Python Podcast – Episode #144: Wrangling Business Process Models With Python and SpiffWorkflow

How to Split a Python List or Iterable Into Chunks

Split a Python List Into Fixed-Size Chunks

Standard Library in Python 3.12: itertools.batched()

Python Basics: Building Systems With Classes

Build a Wordle Clone With Python and Rich

Demo: Your Python Wordle Clone

Project Overview

Prerequisites

Step 1: Guess a Word

The Real Python Podcast – Episode #143: Create Interactive Maps & Geospatial Data Visualizations With Python

Build a JavaScript Front End for a Flask API

Demo

Project Overview

Prerequisites

Grab the Back-End Code

Using the Terminal on Linux

How to Iterate Over Rows in pandas, and Why You Shouldn't

How to Iterate Over DataFrame Rows in pandas

The Real Python Podcast – Episode #142: Orchestrating Large and Small Projects With Apache Airflow

Python Basics: Object-Oriented Programming

The Real Python Podcast – Episode #141: Exploring Python With bpython & Formalizing f-String Grammar

Python Basics Exercises: File System Operations

The Real Python Podcast – Episode #140: Speeding Up Your DataFrames With Polars

Using the Terminal on macOS

The Real Python Podcast – Episode #139: Surveying Comprehension Constructs & Python Parallelism Infighting

Build Cross-Platform GUI Apps With Kivy

The Real Python Podcast – Episode #138: 2022 Real Python Tutorial & Video Course Wrap Up

Python Basics: File System Operations

The Real Python Podcast – Episode #137: Start Using a Build System & Continuous Integration in Python

Standard Library in Python 3.12: `itertools.batched()`